text stringlengths 8 6.05M |
|---|
from test.core.derivatives.utils import classification_targets
import torch
###
# Helpers
###
def make_simple_act_setting(act_cls, bias):
"""
input: Activation function & Bias setting
return: simple CNN Network
This function is used to automatically create a
simple CNN Network consisting of CNN & Linear layer
for different activation functions.
It is used to test `test.extensions`.
"""
def make_simple_cnn(act_cls, bias):
return torch.nn.Sequential(
torch.nn.Conv2d(3, 2, 2, bias=bias),
act_cls(),
torch.nn.Flatten(),
torch.nn.Linear(72, 5),
)
dict_setting = {
"input_fn": lambda: torch.rand(3, 3, 7, 7),
"module_fn": lambda: make_simple_cnn(act_cls, bias),
"loss_function_fn": lambda: torch.nn.CrossEntropyLoss(),
"target_fn": lambda: classification_targets((3,), 5),
"id_prefix": "automated-simple-cnn-act",
}
return dict_setting
def make_simple_cnn_setting(input_size, conv_class, conv_params):
"""
input_size: tuple of input size of (N*C*Image Size)
conv_class: convolutional class
conv_params: configurations for convolutional class
return: simple CNN Network
This function is used to automatically create a
simple CNN Network consisting of CNN & Linear layer
for different convolutional layers.
It is used to test `test.extensions`.
"""
def make_cnn(conv_class, output_size, conv_params):
"""Note: output class size is assumed to be 5"""
return torch.nn.Sequential(
conv_class(*conv_params),
torch.nn.ReLU(),
torch.nn.Flatten(),
torch.nn.Linear(output_size, 5),
)
def get_output_shape(module, module_params, input):
"""Returns the output shape for a given layer."""
output = module(*module_params)(input)
return output.numel() // output.shape[0]
input = torch.rand(input_size)
output_size = get_output_shape(conv_class, conv_params, input)
dict_setting = {
"input_fn": lambda: torch.rand(input_size),
"module_fn": lambda: make_cnn(conv_class, output_size, conv_params),
"loss_function_fn": lambda: torch.nn.CrossEntropyLoss(reduction="sum"),
"target_fn": lambda: classification_targets((3,), 5),
"id_prefix": "automated-simple-cnn",
}
return dict_setting
def make_simple_pooling_setting(input_size, conv_class, pool_cls, pool_params):
"""
input_size: tuple of input size of (N*C*Image Size)
conv_class: convolutional class
conv_params: configurations for convolutional class
return: simple CNN Network
This function is used to automatically create a
simple CNN Network consisting of CNN & Linear layer
for different convolutional layers.
It is used to test `test.extensions`.
"""
def make_cnn(conv_class, output_size, conv_params, pool_cls, pool_params):
"""Note: output class size is assumed to be 5"""
return torch.nn.Sequential(
conv_class(*conv_params),
torch.nn.ReLU(),
pool_cls(*pool_params),
torch.nn.Flatten(),
torch.nn.Linear(output_size, 5),
)
def get_output_shape(module, module_params, input, pool, pool_params):
"""Returns the output shape for a given layer."""
output_1 = module(*module_params)(input)
output = pool_cls(*pool_params)(output_1)
return output.numel() // output.shape[0]
conv_params = (3, 2, 2)
input = torch.rand(input_size)
output_size = get_output_shape(
conv_class, conv_params, input, pool_cls, pool_params
)
dict_setting = {
"input_fn": lambda: torch.rand(input_size),
"module_fn": lambda: make_cnn(
conv_class, output_size, conv_params, pool_cls, pool_params
),
"loss_function_fn": lambda: torch.nn.CrossEntropyLoss(reduction="sum"),
"target_fn": lambda: classification_targets((3,), 5),
"id_prefix": "automated-simple-cnn",
}
return dict_setting
|
# encoding: utf-8
from tastypie.cache import * |
from brownie import IIFNFT, accounts, config
from scripts.helpful_scripts import get_logo,fund_with_link
import time
def main():
dev = accounts.add(config["wallets"]["from_key"])
akilli_kontrat = IIFNFT[len(IIFNFT) - 1]
transaction = akilli_kontrat.createCollectible("None", {"from": dev})
print("Waiting on second transaction...")
transaction.wait(1)
time.sleep(5)
requestId = transaction.events['requestedCollectible']['requestId']
token_id = akilli_kontrat.requestIdToTokenId(requestId)
logo = get_logo(akilli_kontrat.tokenIdToLogo(token_id))
print('Logo of tokenId {} is {}'.format(token_id, logo))
|
from utils import *
import os
import random
TRAIN_PATH = "data/C50train"
TEST_PATH = "data/C50test"
AUTHORS = os.listdir(TRAIN_PATH)
def read_file(prefix):
def _read(filename):
with open(prefix + filename, "r") as f:
text = f.read()
return text
return _read
def create_reuters_data(args, n_authors=3, articles_per_author=40, test_split=0.3):
authors = random.sample(AUTHORS, n_authors)
train_dataset = []
test_dataset = []
test_number = int((1 / (1 - test_split)) * articles_per_author)
for author in authors:
# Train Dataset
articles = os.listdir(TRAIN_PATH + "/" + author)
selected_articles = random.sample(articles, len(articles))
article_bodies = map(read_file(TRAIN_PATH + "/" + author + "/"), selected_articles)
train_dataset.extend(map(lambda a: Example(a, author), article_bodies))
# Test Dataset
articles = os.listdir(TEST_PATH + "/" + author)
selected_articles = random.sample(articles, len(articles))
article_bodies = map(read_file(TEST_PATH + "/" + author + "/"), selected_articles)
if args.train_options == "POS":
article_bodies = map(pos, article_bodies)
test_dataset.extend(map(lambda a: Example(a, author), article_bodies))
# random.shuffle(dataset)
# split = int((1 - test_split) * len(dataset))
authors_index = Indexer()
for author in authors:
authors_index.get_index(author, True)
# return dataset[:split], dataset[split:], authors_index
return train_dataset, test_dataset, authors_index
if __name__ == '__main__':
create_reuters_data()
|
# Created by Luis A. Sanchez-Perez (alejand@umich.edu).
# Copyright © Do not distribute or use without authorization from author
import argparse
import pathlib
from typing import Tuple
import tensorflow as tf
from spectrogram_sequencer import SpectrogamSequencer
from classification_utils import display_performance
import commons
import sys
sys.path.append('../extraction')
from tfrecord_dataset import feature_description
# Constants
MODELS_NAME = 'air_multiclass_rnn'
TIME_SIZE = 401
MFCC_SIZE = 128
BATCH_SIZE = 64
BUFFER_SIZE = 1000
WINDOW_SIZE = 50
WINDOW_OVERLAP = 0.5
# Parses observation from proto format and converts into correct format for training (input,output) = (spec,label)
@tf.function
def parse_observation(example: tf.Tensor, categories: list) -> Tuple:
observation = tf.io.parse_single_example(example, feature_description)
mfcc = observation['mfcc']
samples = observation['samples']
spec = tf.reshape(observation['spec'], (mfcc, samples))
spec = tf.expand_dims(spec, axis=-1) # channel
label = tf.argmax(tf.cast(
tf.equal(observation['label'], tf.constant(categories)), dtype=tf.uint8
))
return spec, label
# Creates dataset from tfrecord files
def create_dataset(dataset_folder: pathlib.Path, categories: list) -> Tuple:
# Creates training data pipeline
train_ds = tf.data.TFRecordDataset([str(dataset_folder / 'train.tfrecord')])
train_ds = train_ds.map(lambda example: parse_observation(example, categories),
num_parallel_calls=commons.AUTOTUNE).cache()
train_ds = train_ds.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(1)
# Creates test data pipeline
test_ds = tf.data.TFRecordDataset([str(dataset_folder / 'test.tfrecord')])
test_ds = test_ds.map(lambda example: parse_observation(example, categories),
num_parallel_calls=commons.AUTOTUNE).cache()
test_ds = test_ds.batch(BATCH_SIZE).prefetch(1)
return train_ds, test_ds
class AirMulticlassRNN:
"""
Simple recurrent neural network model using a sequence of spectrogram windows. The input of this model
will be a sequence of overlapping spectrogram slices (windows).
Designed to perform multinomial classification on a simple dataset
containing four classes of aircraft take-off signals.
"""
def __init__(self, dataset_folder: pathlib.Path, use_regularizer=True, use_batch_norm=False):
# Setups experiment folder
self.dataset_folder = dataset_folder
self.experiment_path, self.model_path, self.diagram_path = self.setup_experiment_folder()
# Determine classes from folder
categories = commons.get_classes_from_folder(dataset_folder)
# Verify non-binary
assert len(categories) > 2, 'Wrong number of classes. Expecting more than two.'
self.categories = categories
# Stores options
self.use_regularizer = use_regularizer
self.use_batch_norm = use_batch_norm
# Builds model architecture
self.model = self.build_model()
# Selects loss and metric
self.model.compile(
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy']
)
# Setup experiment folder
def setup_experiment_folder(self) -> Tuple:
# Verify train.tfrecord and test.tfrecord exist in dataset folder
commons.verify_default_records_from_folder(self.dataset_folder)
# Experiment path (root folder of the experiment)
experiment_path = commons.generate_experiment_path(self.dataset_folder)
# Model path (where it is saved during training)
model_path = commons.generate_model_path(experiment_path, MODELS_NAME)
# Keras model diagram
diagram_path = commons.generate_diagram_path(experiment_path, MODELS_NAME)
# Returns all relevant paths as tuple
return experiment_path, model_path, diagram_path
# Builds models architecture returning a tf.keras.Model
def build_model(self) -> tf.keras.Model:
# Create inputs
inputs = tf.keras.layers.Input((MFCC_SIZE, TIME_SIZE, 1))
# Creates the sequencer layer (only used if requested)
sequencer = SpectrogamSequencer(WINDOW_SIZE, WINDOW_OVERLAP)
# First convolutional layer to find spatial features in a segment of the spectrogram. Timed distributed to get
# applied to every segment of the inputted spectrogram.
conv1 = tf.keras.layers.TimeDistributed(
tf.keras.layers.Conv2D(32, 5,
padding='valid',
data_format='channels_last',
use_bias=False if self.use_batch_norm else True,
name='Conv1')
)
# Batch norm layer (only used if requested)
batch_norm1 = tf.keras.layers.BatchNormalization(axis=1, name='BatchNorm1')
# Activation for convolutional layer
activation1 = tf.keras.layers.Activation(tf.nn.relu, name='Relu1')
# Pooling
pooling1 = tf.keras.layers.TimeDistributed(
tf.keras.layers.MaxPool2D(3, name='Pool1')
)
# Second convolutional layer. Timed distributed to get applied to every segment of the inputted spectrogram.
conv2 = tf.keras.layers.TimeDistributed(
tf.keras.layers.Conv2D(32, 5,
padding='valid',
data_format='channels_last',
use_bias=False if self.use_batch_norm else True,
name='Conv2')
)
# Batch norm layer (only used if requested)
batch_norm2 = tf.keras.layers.BatchNormalization(axis=1, name='BatchNorm2')
# Activation for convolutional layer
activation2 = tf.keras.layers.Activation(tf.nn.relu, name='Relu2')
# Third convolutional layer. Timed distributed.
conv3 = tf.keras.layers.TimeDistributed(
tf.keras.layers.Conv2D(32, 5,
padding='valid',
data_format='channels_last',
use_bias=False if self.use_batch_norm else True,
name='Conv3')
)
# Batch norm layer (only used if requested)
batch_norm3 = tf.keras.layers.BatchNormalization(axis=1, name='BatchNorm3')
# Activation for convolutional layer
activation3 = tf.keras.layers.Activation(tf.nn.relu, name='Relu3')
# Pooling
pooling2 = tf.keras.layers.TimeDistributed(
tf.keras.layers.MaxPool2D(3, name='Pool2')
)
# Flatten results from convolutions/pooling to be fed to the lstm layers
flatten1 = tf.keras.layers.TimeDistributed(
tf.keras.layers.Flatten(name='Flatten')
)
# Dropout layer
dropout1 = tf.keras.layers.Dropout(0.3)
# Recurrent layer to capture temporal relationships
lstm1 = tf.keras.layers.LSTM(32, return_state=False, return_sequences=False, name='LSTM1')
# Dropout layer
dropout2 = tf.keras.layers.Dropout(0.2)
# Dense to make the final classification
dense1 = tf.keras.layers.Dense(len(self.categories), activation=tf.nn.softmax,
kernel_regularizer=tf.keras.regularizers.l2(0.01) if self.use_regularizer else None,
name='Dense')
# Creates connections between layers of the model
x = sequencer(inputs)
x = conv1(x)
if self.use_batch_norm:
x = batch_norm1(x)
x = activation1(x)
x = pooling1(x)
x = conv2(x)
if self.use_batch_norm:
x = batch_norm2(x)
x = activation2(x)
x = conv3(x)
if self.use_batch_norm:
x = batch_norm3(x)
x = activation3(x)
x = pooling2(x)
x = flatten1(x)
if self.use_regularizer:
x = dropout1(x)
x = lstm1(x)
if self.use_regularizer:
x = dropout2(x)
outputs = dense1(x)
return tf.keras.Model(inputs, outputs)
# Prints out the model's summary
def summary(self):
self.model.summary()
tf.keras.utils.plot_model(self.model,
to_file=str(self.diagram_path),
expand_nested=True, show_shapes=True, show_layer_names=False)
# Trains model
def train(self, epochs: int):
# Creates train/test datasets using tf.data.Dataset
train_ds, test_ds = create_dataset(self.dataset_folder, self.categories)
# Callback (used in tf.keras.Model.fit) to save the model with the best validation accuracy
checkpoint = tf.keras.callbacks.ModelCheckpoint(
filepath=str(self.model_path),
save_best_only=True,
save_weights_only=False,
monitor='val_loss',
save_freq='epoch'
)
# Trains model using tf.keras.Model fit function
self.model.fit(train_ds,
epochs=epochs,
validation_data=test_ds,
callbacks=[checkpoint],
verbose=2)
if __name__ == '__main__':
# Parsing arguments
parser = argparse.ArgumentParser()
parser.add_argument('folder', help='Dataset folder with tfrecords', type=str)
parser.add_argument('--epochs', help='Epochs to train (Default: 100)', type=int)
parser.add_argument('--use_regularizer', help='Use regularization', action="store_true")
parser.add_argument('--use_batch_norm', help='Use batch normalization', action="store_true")
args = parser.parse_args()
epochs = args.epochs if args.epochs else 100
use_regularizer = True if args.use_regularizer else False
use_batch_norm = True if args.use_batch_norm else False
# Dataset folder
folder = args.folder
# Creates model and trains
learner = AirMulticlassRNN(pathlib.Path(folder), use_regularizer=use_regularizer, use_batch_norm=use_batch_norm)
learner.summary()
learner.train(epochs)
# Loads and evaluates model
saved_model = tf.keras.models.load_model(str(learner.model_path))
training_ds, testing_ds = create_dataset(learner.dataset_folder, learner.categories)
display_performance(saved_model, training_ds, testing_ds)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Generate word clouds based on termvectors for random sets of documents.
"""
import logging
from django.core.management.base import BaseCommand
from collections import Counter
import time
from services.es import _es
from services.models import DocID
from texcavator import utils
logger = logging.getLogger(__name__)
class Command(BaseCommand):
args = '<#-documents, size-of-ES-chunks, #-repetitions>'
help = 'Generate word clouds using term vectors. #-documents is the ' \
'number of documents the word cloud must be generated for. ' \
'size-of-ES-chunk is the number of documents that is retrieved ' \
'in each ElasticSearch request. #-repetitions is the number of ' \
'word cloud generation is repeated (with a new random set of ' \
'documents).'
def handle(self, *args, **options):
query_size = 2500
n_repetitions = 10
es_retrieve = 2500
if len(args) > 0:
query_size = int(args[0])
if len(args) > 1:
n_repetitions = int(args[1])
if len(args) > 2:
es_retrieve = int(args[2])
response_times = []
for repetition in range(n_repetitions):
c1 = time.time()
es_time = []
wordcloud = Counter()
# select random documents
document_set = DocID.objects.order_by('?')[0:query_size]
doc_ids = [doc.doc_id for doc in document_set]
for ids in utils.chunks(doc_ids, es_retrieve):
bdy = {
'ids': ids,
'parameters': {
'fields': ['article_dc_title', 'text_content'],
'term_statistics': False,
'field_statistics': False,
'offsets': False,
'payloads': False,
'positions': False
}
}
c3 = time.time()
t_vectors = _es().mtermvectors(index='kb', doc_type='doc',
body=bdy)
c4 = time.time()
es_time.append((c4-c3)*1000)
for doc in t_vectors.get('docs'):
for field, data in doc.get('term_vectors').iteritems():
temp = {}
for term, details in data.get('terms').iteritems():
temp[term] = int(details['term_freq'])
wordcloud.update(temp)
c2 = time.time()
elapsed_c = (c2-c1)*1000
response_times.append(elapsed_c)
self.stdout.write(str(elapsed_c)+' ES: '+str(sum(es_time)))
self.stdout.flush()
avg = float(sum(response_times)/len(response_times))
print 'Average response time for generating word clouds from {num} ' \
'documents: {avg} miliseconds'.format(num=query_size, avg=avg)
|
#Flask testing
from flask import Flask, request, render_template
import pymongo
from dbconnect import Database
import json
app = Flask(__name__)
@app.route('/')
def homepage():
home = "Homepage"
return render_template("homepage.html", home=home)
@app.route('/author/<authors_last_name>')
def author(authors_last_name):
return render_template(authors_last_name + '.html')
@app.route('/query/<scope>', methods=["POST"])
def query(scope):
conn = Database()
conn.initialize()
if scope == 'find':
raw = conn.find()
find = json.dumps(raw) #try a for loop with jinja in html template
return render_template('db_results.html',find=find)
elif scope == 'find_one':
raw = conn.find_one()
find = json.dumps(raw)
return render_template('db_results.html', find=find)
@app.route('/insert', methods=['POST'])
def insert():
key = request.form['key']
value = request.form['value']
conn = Database()
conn.initialize()
conn.insert(key, value)
return 'Success'
@app.route('/login')
def login_form():
return render_template("login_form.html")
@app.route('/login/auth', methods = ["POST"])
def login_auth():
return render_template("login_auth.html")
if __name__ == '__main__':
app.run()
|
import gym
from gym import spaces
from gym.utils import seeding
import numpy as np
from os import path
import random
import pygame, sys
from pygame.locals import *
#colors
WHITE = (255,255,255)
RED = (255,0,0)
GREEN = (0,255,0)
BLACK = (0,0,0)
#globals
WIDTH = 600
HEIGHT = 400
BALL_RADIUS = 20
PAD_WIDTH = 8
PAD_HEIGHT = 80
HALF_PAD_WIDTH = PAD_WIDTH // 2
HALF_PAD_HEIGHT = PAD_HEIGHT // 2
ball_pos = [0,0]
ball_vel = [0,0]
paddle1_vel = 0
paddle2_vel = 0
l_score = 0
r_score = 0
class PongEnv(gym.Env):
metadata = {
'render.modes' : ['human', 'rgb_array'],
'video.frames_per_second' : 30
}
#keydown handler
#def keydown(event):
# global paddle1_vel, paddle2_vel
# if event.key == K_UP:
# paddle2_vel = -8
# elif event.key == K_DOWN:
# paddle2_vel = 8
# elif event.key == K_w:
# paddle1_vel = -8
# elif event.key == K_s:
# paddle1_vel = 8
#keyup handler
#def keyup(event):
# global paddle1_vel, paddle2_vel
# if event.key in (K_w, K_s):
# paddle1_vel = 0
# elif event.key in (K_UP, K_DOWN):
# paddle2_vel = 0
# helper function that spawns a ball, returns a position vector and a velocity vector
# if right is True, spawn to the right, else spawn to the left
def ball_init(right):
global ball_pos, ball_vel # these are vectors stored as lists
ball_pos = [WIDTH//2,HEIGHT//2]
horz = random.randrange(2,4)
vert = random.randrange(1,3)
if right == False:
horz = - horz
ball_vel = [horz, -vert]
# define event handlers
def init():
global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel,l_score,r_score # these are floats
global score1, score2 # these are ints
paddle1_pos = [HALF_PAD_WIDTH - 1,HEIGHT//2]
paddle2_pos = [WIDTH +1 - HALF_PAD_WIDTH,HEIGHT//2]
l_score = 0
r_score = 0
if random.randrange(0,2) == 0:
ball_init(True)
else:
ball_init(False)
def __init__(self):
pygame.init()
self.action_space = spaces.Discrete(3)
self.observation_space = spaces.Box(-high, high)
self._seed()
self.viewer = None
self.state = None
self.steps_beyond_done = None
def _seed(self, seed=None):
self.np_random, seed = seeding.np_random(seed)
return [seed]
def _step(self, action):
assert self.action_space.contains(action), "%r (%s) invalid" %(action, type(action))
state = self.state
(paddle1_pos, paddle2_pos, ball_pos, paddle1_vel, paddle2_vel, ball_vel, l_score, r_score) = state
#update padd velocity
if action == -1:
paddle2_vel = -8
elif action == 1:
paddle2_vel = 8
elif ball_pos[1] < paddle1_pos[1]:
paddle1_vel = -8
elif ball_pos[1] > paddle1_pos[1]:
paddle1_vel = 8
if action == 0
paddle2_vel = 0
elif ball_pos[1] == paddle1_pos[1]
paddle1_vel = 0
# update paddle's vertical position, keep paddle on the screen
if paddle1_pos[1] > HALF_PAD_HEIGHT and paddle1_pos[1] < HEIGHT - HALF_PAD_HEIGHT:
paddle1_pos[1] += paddle1_vel
elif paddle1_pos[1] == HALF_PAD_HEIGHT and paddle1_vel > 0:
paddle1_pos[1] += paddle1_vel
elif paddle1_pos[1] == HEIGHT - HALF_PAD_HEIGHT and paddle1_vel < 0:
paddle1_pos[1] += paddle1_vel
if paddle2_pos[1] > HALF_PAD_HEIGHT and paddle2_pos[1] < HEIGHT - HALF_PAD_HEIGHT:
paddle2_pos[1] += paddle2_vel
elif paddle2_pos[1] == HALF_PAD_HEIGHT and paddle2_vel > 0:
paddle2_pos[1] += paddle2_vel
elif paddle2_pos[1] == HEIGHT - HALF_PAD_HEIGHT and paddle2_vel < 0:
paddle2_pos[1] += paddle2_vel
# update ball
ball_pos[0] += int(ball_vel[0])
ball_pos[1] += int(ball_vel[1])
# ball collision check on top and bottom walls
if int(ball_pos[1]) <= BALL_RADIUS:
ball_vel[1] = - ball_vel[1]
if int(ball_pos[1]) >= HEIGHT + 1 - BALL_RADIUS:
ball_vel[1] = -ball_vel[1]
# ball collison check on gutters or paddles
if int(ball_pos[0]) <= BALL_RADIUS + PAD_WIDTH and int(ball_pos[1]) in range(paddle1_pos[1] - HALF_PAD_HEIGHT,paddle1_pos[1] + HALF_PAD_HEIGHT,1):
ball_vel[0] = -ball_vel[0]
ball_vel[0] *= 1.1
ball_vel[1] *= 1.1
elif int(ball_pos[0]) <= BALL_RADIUS + PAD_WIDTH:
r_score += 1
ball_init(True)
if int(ball_pos[0]) >= WIDTH + 1 - BALL_RADIUS - PAD_WIDTH and int(ball_pos[1]) in range(paddle2_pos[1] - HALF_PAD_HEIGHT,paddle2_pos[1] + HALF_PAD_HEIGHT,1):
ball_vel[0] = -ball_vel[0]
ball_vel[0] *= 1.1
ball_vel[1] *= 1.1
elif int(ball_pos[0]) >= WIDTH + 1 - BALL_RADIUS - PAD_WIDTH:
l_score += 1
ball_init(False)
self.state = (paddle1_pos, paddle2_pos, ball_pos, paddle1_vel, paddle2_vel, ball_vel, l_score, r_score)
done = l_score > self.l_score_threshold \
or r_score > self.r_score_threshold
done = bool(done)
if not done:
reward = 1.0
elif self.steps_beyond_done is None:
self.steps_beyond_done = 0
reward = 1.0
else:
if self.steps_beyond_done == 0:
logger.warning("You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.")
self.steps_beyond_done += 1
reward = 0.0
return np.array(self.state), reward, done, {}
def _reset(self):
self.state = self.np_random.uniform(low=-0.05, high=0.05, size=(4,))
self.steps_beyond_done = None
return np.array(self.state)
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
pygame.quit()
sys.exit()
self.viewer = None
return
if self.viewer is None:
fps = pygame.time.Clock()
#canvas declaration
window = pygame.display.set_mode((WIDTH, HEIGHT), 0, 32)
pygame.display.set_caption('Hello World')
canvas.fill(BLACK)
pygame.draw.line(canvas, WHITE, [WIDTH // 2, 0],[WIDTH // 2, HEIGHT], 1)
pygame.draw.line(canvas, WHITE, [PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1)
pygame.draw.line(canvas, WHITE, [WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1)
pygame.draw.circle(canvas, WHITE, [WIDTH//2, HEIGHT//2], 70, 1)
# draw paddles and ball
pygame.draw.circle(canvas, RED, ball_pos, 20, 0)
pygame.draw.polygon(canvas, GREEN, [[paddle1_pos[0] - HALF_PAD_WIDTH, paddle1_pos[1] - HALF_PAD_HEIGHT], [paddle1_pos[0] - HALF_PAD_WIDTH, paddle1_pos[1] + HALF_PAD_HEIGHT], [paddle1_pos[0] + HALF_PAD_WIDTH, paddle1_pos[1] + HALF_PAD_HEIGHT], [paddle1_pos[0] + HALF_PAD_WIDTH, paddle1_pos[1] - HALF_PAD_HEIGHT]], 0)
pygame.draw.polygon(canvas, GREEN, [[paddle2_pos[0] - HALF_PAD_WIDTH, paddle2_pos[1] - HALF_PAD_HEIGHT], [paddle2_pos[0] - HALF_PAD_WIDTH, paddle2_pos[1] + HALF_PAD_HEIGHT], [paddle2_pos[0] + HALF_PAD_WIDTH, paddle2_pos[1] + HALF_PAD_HEIGHT], [paddle2_pos[0] + HALF_PAD_WIDTH, paddle2_pos[1] - HALF_PAD_HEIGHT]], 0)
#update scores
myfont1 = pygame.font.SysFont("Comic Sans MS", 20)
label1 = myfont1.render("Score "+str(l_score), 1, (255,255,0))
canvas.blit(label1, (50,20))
myfont2 = pygame.font.SysFont("Comic Sans MS", 20)
label2 = myfont2.render("Score "+str(r_score), 1, (255,255,0))
canvas.blit(label2, (470, 20))
init()
#game loop
#while True:
# for event in pygame.event.get():
# if event.type == KEYDOWN:
# keydown(event)
# elif event.type == KEYUP:
# keyup(event)
# elif event.type == QUIT:
# pygame.quit()
# sys.exit()
pygame.display.update()
fps.tick(60)
if self.state is None: return None
return self.viewer.render(return_rgb_array = mode=='rgb_array')
|
import pygame
from pygame.locals import *
import time
main_displays = ['Blood','Sleep','Manhood','Birds','Sight','Naivete','Destiny'
,'Greed','Water','Fear','Murder','Supernatural','Cleanliness'
,'Manipulation','Mind','Guilt','Envy','18','19','20','21','22'
,'23','24','25']
main_defs = ['1x','2x','3x','4x','5x','6x','7x','8x','9x','10x','11x','12x'
,'13x','14x','15x','16x','17x','18x','19x','20x','21x','22x'
,'23x','24x','25x']
main_defs2 = ['x','x','x','x','x','x','x','x','x','x','x','x'
,'13x','14x','15x','16x','17x','18x','19x','20x','21x','22x'
,'23x','24x','25x']
def Get_Current_Item(current_num):
final = []
final.append(main_displays[current_num])
final.append(main_defs[current_num])
final.append(main_defs2[current_num])
return final
def Build_Item_1():
font = pygame.font.SysFont("Arial", 16, False, True)
text = Get_Current_Item(current_num)
item_1 = text[0] ; item_1 = font.render(item_1, 1, (255, 255, 255))
rectDims = pygame.Surface.get_rect(screen)
width_screen = rectDims[2]
heigth_screen = rectDims[3]
rectDims = pygame.Surface.get_rect(item_1)
width_item = rectDims[2]
heigth_item = rectDims[3]
textpos = ( (width_screen/2)-(width_item/2), (heigth_screen/2)-(heigth_item/2))
screen.blit(item_1, textpos)
def Build_Item_2():
font = pygame.font.SysFont("Arial", 16, False, True)
text = Get_Current_Item(current_num)
item_2 = text[1] ; item_2 = font.render(item_2, 1, (255, 255, 255))
rectDims = pygame.Surface.get_rect(screen)
width_screen = rectDims[2]
heigth_screen = rectDims[3]
rectDims = pygame.Surface.get_rect(item_2)
width_item = rectDims[2]
heigth_item = rectDims[3]
textpos = ( (width_screen/2)-(width_item/2), (heigth_screen/3)-(heigth_item/2))
screen.blit(item_2, textpos)
########### SECOND SET OF TEXT #############
font = pygame.font.SysFont("Arial", 16, False, True)
text = Get_Current_Item(current_num)
item_3 = text[2] ; item_3 = font.render(item_3, 1, (255, 255, 255))
rectDims = pygame.Surface.get_rect(screen)
width_screen = rectDims[2]
heigth_screen = rectDims[3]
rectDims = pygame.Surface.get_rect(item_3)
width_item = rectDims[2]
heigth_item = rectDims[3]
textpos = ( (width_screen/2)-(width_item/2), (2*(heigth_screen)/3)-(heigth_item/2))
screen.blit(item_3, textpos)
def Build_End_Screen():
font = pygame.font.SysFont("Arial", 16, False, True)
text = "That is the end of the presentation."
text = font.render(text, 1, (255, 255, 255))
rectDims = pygame.Surface.get_rect(screen)
width_screen = rectDims[2]
heigth_screen = rectDims[3]
rectDims = pygame.Surface.get_rect(text)
width_item = rectDims[2]
heigth_item = rectDims[3]
textpos = ( (width_screen/2)-(width_item/2), (heigth_screen/2)-(heigth_item/2) )
screen.blit(text, textpos)
def Clear_Screen():
screen.blit(background, (0,0))
def Main():
pygame.init()
## varible declarations
global screen
global background
global current_num
current_num = 0
first_space_press = True
## build the window
pygame.display.set_caption('Powerpoint')
screen = pygame.display.set_mode((600,400))
pygame.mouse.set_visible(1)
## build the background
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((0, 0, 0))
screen.blit(background,(0,0))
Clear_Screen()
Build_Item_1()
## keep updating
clock = pygame.time.Clock()
while 1:
clock.tick(60)
for event in pygame.event.get():
if event.type == QUIT:
return pygame.display.quit()
elif event.type == KEYDOWN and event.key == K_ESCAPE:
return pygame.display.quit()
elif event.type == MOUSEBUTTONDOWN and pygame.mouse.get_pressed() == (1, 0, 0) \
or event.type == KEYDOWN and event.key == K_z:
current_num += 1
if current_num < ( len(main_displays) ):
Clear_Screen()
Build_Item_1()
elif current_num < ( len(main_displays)+1 ):
Clear_Screen()
Build_End_Screen()
else:
return pygame.display.quit()
elif event.type == MOUSEBUTTONDOWN and pygame.mouse.get_pressed() == (0, 0, 1) \
or event.type == KEYDOWN and event.key == K_x:
if current_num > 0:
current_num -= 1
Clear_Screen()
Build_Item_1()
elif event.type == KEYDOWN and event.key == K_SPACE:
if current_num < len(main_displays):
if first_space_press == True:
Clear_Screen()
Build_Item_2()
first_space_press = False
elif first_space_press == False:
Clear_Screen()
Build_Item_1()
first_space_press = True
pygame.display.update()
if len(main_displays) == len(main_defs):
Main()
|
def _partition(data):
pivot = data[0]
left = []
right = []
for elem in data[1:]:
if elem < pivot:
left.append(elem)
else:
right.append(elem)
return left, pivot, right
def quick_sort(data):
if len(data) <= 1:
return data
left, pivot, right = _partition(data)
return quick_sort(left) + [pivot] + quick_sort(right)
if __name__ == '__main__':
print(quick_sort([]))
print(quick_sort([1]))
list1 = [1,2,10,4,5,1]
print(quick_sort(list1))
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Safer
# @Date: 2016-12-01 01:40:55
# @Last Modified by: Safer
# @Last Modified time: 2016-12-17 22:36:44
import sys, time
import res
from PyQt5.QtWidgets import QApplication, QDialog, QPushButton, QToolButton, QLabel
from PyQt5.QtWidgets import QFormLayout, QVBoxLayout
from PyQt5.QtCore import QRect, QTimer
from PyQt5.Qt import QPropertyAnimation
from PyQt5 import Qt, QtGui, QtCore
class DialogMessageSide(QDialog):
def __init__(self, parent=None):
super(DialogMessageSide, self).__init__(parent)
self._parent = parent
self._link = ''
self._content = ''
self._init_ui()
def setLink(self, link=None):
if not link:
return None
self._link = link
def setContent(self, content=None):
if not content:
return None
self._content = ' '+content
def onShow(self, close_time=5):
self._close_time = close_time
self._button_link.setText(self._link)
self._label_content.setText(self._content)
if self._close_time:
timer = QTimer(self)
timer.timeout.connect(self.onHide)
timer.start(self._close_time * 1000)
self.show()
self._animation('show')
def onHide(self):
self._animation('hide')
def _head_layout(self):
title = QLabel('宝宝软件', self)
title.setObjectName("title")
title.move(5, -2)
close = QToolButton(self)
close.setObjectName("close")
close.setIcon(Qt.QIcon('res/icons/appbar.close.png'))
close.setIconSize(Qt.QSize(25, 25))
close.setFixedSize(25, 25)
close.clicked.connect(self.onHide)
close.move(275 ,0)
def _content_layout(self):
self._button_link = QPushButton(self._link, self)
self._button_link.setObjectName('link')
self._button_link.setCursor(QtGui.QCursor(Qt.Qt.PointingHandCursor))
self._label_content = QLabel(self._content, self)
self._label_content.setObjectName('content')
self._label_content.setWordWrap(True)
contentLayout = QFormLayout()
contentLayout.addRow(self._button_link)
contentLayout.addRow(self._label_content)
self.mainLayout = QVBoxLayout()
mainLayout = self.mainLayout
mainLayout.addLayout(contentLayout)
self.mainLayout.setContentsMargins(15, 50, 15, 0)
self.setLayout(mainLayout)
self.activateWindow()
def _init_ui(self):
self._position()
self.setMouseTracking(True)
self.setWindowFlags(Qt.Qt.Window | Qt.Qt.FramelessWindowHint)
self._style()
self._head_layout()
self._content_layout()
def _style(self):
_file = QtCore.QFile(':/style.qss')
_file.open(QtCore.QFile.ReadOnly)
styleSheet = _file.readAll()
styleSheet = str(styleSheet, encoding='utf8')
styleSheet += """
QDialog{
background: #4384D6;
}
QLabel#content{
margin-bottom:20px;
font-size:15px;
color:#FFF;
}
QPushButton {
border: none;
padding: 10px;
text-align: laft;
margin:0px 10px;
color: #FFF;
font-size: 18px;
font-style: strong;
background: #4384D6;
text-align:left;
}
QPushButton:hover {
font-size: 19px;
background: #4384D6;
text-decoration: underline;
}
"""
self.setStyleSheet(styleSheet)
def _getScreen(self):
desktop = QApplication.desktop()
screen = desktop.screenGeometry()
return screen
def _position(self):
screen = self._getScreen()
screen_swidth = screen.width()
self._screen_height = screen.height()
print(self._screen_height)
self._width = 300
self._height = 300
self._top = self._screen_height
self._left = (screen_swidth - self._width - 5)
self._change_top = (self._screen_height - self._height - 5)
self.setGeometry(self._left, self._top, self._width, self._height)
def _animation(self, type):
if type == 'show':
startTop = self._top
endTop = self._change_top
else:
startTop = self._change_top
endTop = self._top
self.animation = QPropertyAnimation(self, b'geometry', self)
self.animation.setDuration(200)
self.animation.setStartValue(QRect(self._left, startTop, self._width, self._height))
self.animation.setEndValue(QRect(self._left, endTop, self._width, self._height))
self.animation.start()
self.animation.finished.connect(lambda: self._animation_finished(type))
def _animation_finished(self, type):
if type == 'hide':
print(type)
# self.close()
self.hide()
class Test(QDialog):
def __init__(self):
super(Test, self).__init__()
self._dialog_side = DialogMessageSide(self)
self._init_()
self._centerPosition(270, 150)
def _init_(self):
show = QPushButton('showDialogMessageSideOne', self)
show.clicked.connect(self._showDialogMessageSideOne)
show_two = QPushButton('showDialogMessageSideTwo', self)
show_two.clicked.connect(self._showDialogMessageSideTwo)
show_two.move(0,50)
hide = QPushButton('hideDialogMessageSide', self)
hide.clicked.connect(self._hideDialogMessageSide)
hide.move(0,100)
def _showDialogMessageSideOne(self):
link = '点击这里查看'
content = '您的即使嗲话地水火风四季度和法兰克福还是两个恢复两国和飞机搞活豆腐干活佛济公回到房间更好地发挥国际分工和地方'
self._dialog_side.setLink(link)
self._dialog_side.setContent(content)
self._dialog_side.onShow(None)
def _showDialogMessageSideTwo(self):
link = '点击这里查看2'
content = '您的即使嗲话地水火风四季度和法兰克福'
self._dialog_side.setLink(link)
self._dialog_side.setContent(content)
self._dialog_side.onShow(None)
def _hideDialogMessageSide(self):
self._dialog_side.onHide()
# 窗口居中显示
def _centerPosition(self, width, height):
desktop = QApplication.desktop()
screen = desktop.screenGeometry()
swidth = screen.width()
sheight = screen.height()
left = (swidth - width) / 2
top = (sheight - height) / 2
self.setGeometry(left, top, width, height)
import sys
from PyQt5.QtWidgets import QApplication
if __name__ == '__main__':
app = QApplication(sys.argv)
t = Test()
t.show()
# message
# time.sleep(6)
# ds.show()
# time.sleep(2)
# ds.hide()
sys.exit(app.exec_())
|
#!/bin/python3
import math
import os
import random
import re
import sys
# Complete the larrysArray function below.
# only 3 len arr
def rotate_left(a):
return a[1:] + [a[0]]
# def larrysArray(A):
# A = a.copy()
# target_idx = 1
# print(a)
# while True:
# print("===============================")
#
# print("target_idx : {}".format(target_idx))
# now_idx = A.index(target_idx) # 대상 item의 현재 위치
# print("now_idx : {}".format(now_idx))
# if now_idx == 0: # 정렬 완료.
# print("(target_idx - 1) : {}".format((target_idx - 1)))
# A = A[target_idx:]
# print("modified A : {}".format(A))
# target_idx += 1 # 정렬된 위치로 옮겨줘야 하는 item
# continue
# print("A[:now_idx-2] : {}".format(A[:now_idx-2]))
# print("A[now_idx:] : {}".format(A[now_idx+1:]))
# tmp = rotate_left(A[now_idx-2:now_idx+1])
# print("tmp : {}".format(tmp))
# A = A[:now_idx-2] + tmp + A[now_idx+1:]
#
# print(A)
def larrysArray(A):
for i in range(len(A)-2):
print("==========================")
print("A : {}".format(A))
if A[i]==i+1:
continue
else:
print("i : {}".format(i))
print("(A.index(i+1)) : {}".format((A.index(i+1))))
print("(A.index(i+1)-i) : {}".format((A.index(i+1)-i)))
if (A.index(i+1)-i)%2==0:
print("hi")
A.remove(i+1)
print("A[:i] : {}".format(A[:i]))
print("A[i:] : {}".format(A[i:]))
A=A[:i]+[i+1]+A[i:]
else:
print("hi2")
A.remove(i+1)
print("A[:i] : {}".format(A[:i]))
print("[A[i+1]]+[A[i]] : {}".format([A[i+1]]+[A[i]]))
print("A[i+2:] : {}".format(A[i+2:]))
A=A[:i]+[i+1]+[A[i+1]]+[A[i]]+A[i+2:]
if A==sorted(A):
return ("YES")
else:
return ("NO")
if __name__ == '__main__':
# fptr = open(os.environ['OUTPUT_PATH'], 'w')
t = int(input())
for t_itr in range(t):
n = int(input())
A = list(map(int, input().rstrip().split()))
result = larrysArray(A)
print(result)
# fptr.write(result + '\n')
#
# fptr.close()
|
import sys
from pathlib import Path
import requests
from tqdm import tqdm
from websocket import create_connection, WebSocketConnectionClosedException
def GetLog():
ws = create_connection("ws://localhost:8000/get_log")
print("Receiving log...")
while True:
try:
result = ws.recv()
print(result)
except WebSocketConnectionClosedException as e:
if str(e) != 'Connection is already closed.':
raise
break
def SendFile(filename):
print("sending file: ", filename)
files = {'file': open(f"../files/{filename}", "rb")}
r = requests.post("http://localhost:8000/upload", files=files)
if r.status_code not in range(200, 299):
raise ValueError(f"Error sending file. code {r.status_code}")
def GetFile(file_name):
link = "http://localhost:8000/download"
file = Path(f"../files/download/{file_name}")
file_counter = 0
while True:
if not file.exists():
break
file_counter += 1
file = Path(f"../files/download/({file_counter}){file_name}")
print("file name: ", file)
r = requests.get(link, params={"file_name": file_name}, stream=True)
total_size = int(r.headers.get("Content-Length", "0"))
print("total-size: ", total_size/1024, " Kb")
with open(file, "wb") as f:
for data in tqdm(r.iter_content(1024), total=total_size/1024, unit="kb", ):
f.write(data)
if __name__ == '__main__':
if len(sys.argv) < 2:
raise ValueError("parameters: please call as 'python client.py <download/upload/get_log> <Optional[filename]>'")
if sys.argv[1] == "download":
GetFile(sys.argv[2])
elif sys.argv[1] == "upload":
SendFile(sys.argv[2])
elif sys.argv[1] == "get_log":
GetLog()
|
#!/usr/bin/env python
'''
Unit Tests for the classes of the module `GenerationOps`
'''
#####################
# IMPORT OPERATIONS #
#####################
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
import Bio # Do not remove; important for assertIsInstance
import unittest
import sys, os
# Add specific directory to sys.path in order to import its modules
# Note: This relative importing is amateurish; why can I not replace it with 'import annonex2embl'?
sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'annonex2embl'))
import GenerationOps as GnOps
from Bio.Seq import Seq
from Bio.Alphabet import generic_dna
from Bio.SeqFeature import FeatureLocation
from Bio import SeqFeature
###############
# AUTHOR INFO #
###############
__author__ = 'Michael Gruenstaeudl <m.gruenstaeudl@fu-berlin.de>'
__copyright__ = 'Copyright (C) 2016-2020 Michael Gruenstaeudl'
__info__ = 'annonex2embl'
__version__ = '2020.03.06.1800'
#############
# DEBUGGING #
#############
#import ipdb
#ipdb.set_trace()
###########
# CLASSES #
###########
class GenerateFeatLocTestCases(unittest.TestCase):
''' Tests for class `GenerateFeatLoc` '''
def setUp(self):
warnings.simplefilter('ignore')
def test_GenerateFeatLoc__make_location__1(self):
''' Test to evaluate function `make_location` of class `GenerateFeatLoc`.
This test evaluates the case of a continuous range. '''
charset_range = list(range(1,8))
out = GnOps.GenerateFeatLoc().make_location(charset_range)
self.assertIsInstance(out, Bio.SeqFeature.FeatureLocation)
def test_GenerateFeatLoc__make_location__2(self):
''' Test to evaluate function `make_location` of class `GenerateFeatLoc`.
This test evaluates the case of a discontinuous range, resulting in
a compound location. '''
charset_range = [1,2,3,7,8]
out = GnOps.GenerateFeatLoc().make_location(charset_range)
self.assertIsInstance(out, Bio.SeqFeature.CompoundLocation)
def test_GenerateFeatLoc__make_location__3(self):
''' Test to evaluate function `make_location` of class `GenerateFeatLoc`.
This test evaluates the case of a discontinuous range that is
separated only by a nucleotide, resulting in a compound location.
This test evaluates if the function correctly generates a compound
feature location if only a single base separates them. '''
charset_range = [1,2,3,5,6]
out = GnOps.GenerateFeatLoc().make_location(charset_range)
self.assertIsInstance(out, Bio.SeqFeature.CompoundLocation) # CompoundLocation
self.assertEqual(len(out.parts), 2)
def test_GenerateFeatLoc__make_start_fuzzy__1(self):
''' Test to evaluate function `make_start_fuzzy` of class `GenerateFeatLoc`.
This test evaluates the case where FeatureLocations are made fuzzy. '''
from Bio import SeqFeature
start_pos = SeqFeature.ExactPosition(5)
end_pos = SeqFeature.ExactPosition(9)
location_object = SeqFeature.FeatureLocation(start_pos, end_pos)
out = GnOps.GenerateFeatLoc().make_start_fuzzy(location_object)
self.assertIsInstance(out, Bio.SeqFeature.FeatureLocation) # FeatureLocation
self.assertIsInstance(out.start, Bio.SeqFeature.BeforePosition) # Fuzzy Start
def test_GenerateFeatLoc__make_start_fuzzy__2(self):
''' Test to evaluate function `make_start_fuzzy` of class `GenerateFeatLoc`.
This test evaluates if start FeatureLocations are made fuzzy with a
discontinuous location. '''
from Bio import SeqFeature
charset_range = [1,2,3,7,8]
location_object = GnOps.GenerateFeatLoc().make_location(charset_range)
out = GnOps.GenerateFeatLoc().make_start_fuzzy(location_object)
self.assertIsInstance(out, Bio.SeqFeature.CompoundLocation) # CompoundLocation
self.assertIsInstance(out.parts[0].start, Bio.SeqFeature.BeforePosition) # Fuzzy Start
def test_GenerateFeatLoc__make_start_fuzzy__3(self):
''' Test to evaluate function `make_start_fuzzy` of class `GenerateFeatLoc`.
This test evaluates if end FeatureLocations are made fuzzy.
See AfterPosition. '''
from Bio import SeqFeature
start_pos = SeqFeature.ExactPosition(5)
end_pos = SeqFeature.ExactPosition(9)
location_object = SeqFeature.FeatureLocation(start_pos, end_pos)
out = GnOps.GenerateFeatLoc().make_end_fuzzy(location_object)
self.assertIsInstance(out, Bio.SeqFeature.FeatureLocation) # FeatureLocation
self.assertIsInstance(out.end, Bio.SeqFeature.AfterPosition) # Fuzzy End
def test_GenerateFeatLoc__make_start_fuzzy__4(self):
''' Test to evaluate function `make_start_fuzzy` of class `GenerateFeatLoc`.
This test evaluates if end FeatureLocations are made fuzzy with a
discontinuous location.
See BeforePosition. '''
from Bio import SeqFeature
charset_range = [1,2,3,7,8]
location_object = GnOps.GenerateFeatLoc().make_location(charset_range)
out = GnOps.GenerateFeatLoc().make_start_fuzzy(location_object)
self.assertIsInstance(out, Bio.SeqFeature.CompoundLocation) # CompoundLocation
self.assertIsInstance(out.parts[0].start, Bio.SeqFeature.BeforePosition) # Fuzzy Start
class GenerateSeqFeatureTestCases(unittest.TestCase):
''' Tests for class `GenerateSeqFeature` '''
def setUp(self):
warnings.simplefilter('ignore')
def test_GenerateSeqFeature__source_feat__1(self):
''' Test to evaluate function `source_feat` of class `GenerateSeqFeature`.
This test evaluates the correct generation of the SeqFeature
`source`. A translation table is to be included. '''
full_len = 509
quals = {'isolate': 'taxon_B', 'country': 'Ecuador'}
charset_names = ['foo_gene', 'foo_CDS']
out = GnOps.GenerateSeqFeature().source_feat(full_len,
quals, charset_names)
self.assertIsInstance(out, Bio.SeqFeature.SeqFeature)
def test_GenerateSeqFeature__source_feat__2(self):
''' Test to evaluate function `source_feat` of class `GenerateSeqFeature`.
This test evaluates the correct generation of the SeqFeature
`source`. A translation table is NOT to be included. '''
full_len = 509
quals = {'isolate': 'taxon_B', 'country': 'Ecuador'}
charset_names = ['foo_intron', 'foo_IGS']
out = GnOps.GenerateSeqFeature().source_feat(full_len,
quals, charset_names)
self.assertIsInstance(out, Bio.SeqFeature.SeqFeature)
def test_GenerateSeqFeature__regular_feat__1(self):
''' Test to evaluate function `regular_feat` of class `GenerateSeqFeature`.
This test evaluates the correct generation of a regular, non-coding
SeqFeature. '''
feature_name = 'psbI'
feature_type = 'intron'
feature_orient = 'forw'
qualifier_name = 'note'
transl_table = 11
feature_seq = 'ACGTACGTACGTACGT'
charset_range = [2,3,4,5]
feature_loc = GnOps.GenerateFeatLoc().make_location(charset_range)
out = GnOps.GenerateSeqFeature().regular_feat(feature_name,
feature_type, feature_orient, feature_loc, qualifier_name,
transl_table, feature_seq)
self.assertIsInstance(out, Bio.SeqFeature.SeqFeature)
#############
# FUNCTIONS #
#############
########
# MAIN #
########
if __name__ == '__main__':
unittest.main()
|
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc
import mysqlctl_pb2 as mysqlctl__pb2
class MysqlCtlStub(object):
"""MysqlCtl is the service definition
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.Start = channel.unary_unary(
'/mysqlctl.MysqlCtl/Start',
request_serializer=mysqlctl__pb2.StartRequest.SerializeToString,
response_deserializer=mysqlctl__pb2.StartResponse.FromString,
)
self.Shutdown = channel.unary_unary(
'/mysqlctl.MysqlCtl/Shutdown',
request_serializer=mysqlctl__pb2.ShutdownRequest.SerializeToString,
response_deserializer=mysqlctl__pb2.ShutdownResponse.FromString,
)
self.RunMysqlUpgrade = channel.unary_unary(
'/mysqlctl.MysqlCtl/RunMysqlUpgrade',
request_serializer=mysqlctl__pb2.RunMysqlUpgradeRequest.SerializeToString,
response_deserializer=mysqlctl__pb2.RunMysqlUpgradeResponse.FromString,
)
self.ReinitConfig = channel.unary_unary(
'/mysqlctl.MysqlCtl/ReinitConfig',
request_serializer=mysqlctl__pb2.ReinitConfigRequest.SerializeToString,
response_deserializer=mysqlctl__pb2.ReinitConfigResponse.FromString,
)
self.RefreshConfig = channel.unary_unary(
'/mysqlctl.MysqlCtl/RefreshConfig',
request_serializer=mysqlctl__pb2.RefreshConfigRequest.SerializeToString,
response_deserializer=mysqlctl__pb2.RefreshConfigResponse.FromString,
)
class MysqlCtlServicer(object):
"""MysqlCtl is the service definition
"""
def Start(self, request, context):
# missing associated documentation comment in .proto file
pass
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Shutdown(self, request, context):
# missing associated documentation comment in .proto file
pass
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RunMysqlUpgrade(self, request, context):
# missing associated documentation comment in .proto file
pass
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def ReinitConfig(self, request, context):
# missing associated documentation comment in .proto file
pass
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RefreshConfig(self, request, context):
# missing associated documentation comment in .proto file
pass
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_MysqlCtlServicer_to_server(servicer, server):
rpc_method_handlers = {
'Start': grpc.unary_unary_rpc_method_handler(
servicer.Start,
request_deserializer=mysqlctl__pb2.StartRequest.FromString,
response_serializer=mysqlctl__pb2.StartResponse.SerializeToString,
),
'Shutdown': grpc.unary_unary_rpc_method_handler(
servicer.Shutdown,
request_deserializer=mysqlctl__pb2.ShutdownRequest.FromString,
response_serializer=mysqlctl__pb2.ShutdownResponse.SerializeToString,
),
'RunMysqlUpgrade': grpc.unary_unary_rpc_method_handler(
servicer.RunMysqlUpgrade,
request_deserializer=mysqlctl__pb2.RunMysqlUpgradeRequest.FromString,
response_serializer=mysqlctl__pb2.RunMysqlUpgradeResponse.SerializeToString,
),
'ReinitConfig': grpc.unary_unary_rpc_method_handler(
servicer.ReinitConfig,
request_deserializer=mysqlctl__pb2.ReinitConfigRequest.FromString,
response_serializer=mysqlctl__pb2.ReinitConfigResponse.SerializeToString,
),
'RefreshConfig': grpc.unary_unary_rpc_method_handler(
servicer.RefreshConfig,
request_deserializer=mysqlctl__pb2.RefreshConfigRequest.FromString,
response_serializer=mysqlctl__pb2.RefreshConfigResponse.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'mysqlctl.MysqlCtl', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
|
def char_to_ascii(string):
return {a: ord(a) for a in set(string) if a.isalpha()} or None
|
# Generated by Django 2.1 on 2018-11-24 21:51
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Language',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('language', models.CharField(max_length=50)),
('slug', models.SlugField(max_length=20)),
],
),
migrations.CreateModel(
name='TranslationKey',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('slug', models.SlugField()),
('default_translation', models.TextField()),
],
),
]
|
def typeList(value):
sum = 0
string = ""
for item in range(0, len(value)):
if isinstance(value[item], int):
sum += value[item]
elif isinstance(value[item], str):
string += " " + value[item]
pSum = "Sum: {}".format (sum)
pStr = "String:" + string
if sum is not 0 and string is not "":
print "The list you entered is of mixed type."
print pSum
print pStr
elif sum > 0:
print "The list you entered is of integer type."
print pSum
else:
print "The list you entered is of string type."
print pStr
typeList([1, 2, "hello", "bye"]) |
import sys
import random
from PySide2.QtWidgets import (QApplication, QLabel,
QPushButton, QVBoxLayout, QWidget)
from PySide2.QtCore import Slot, Qt
class Aplicacion(QWidget):
def __init__(self):
QWidget.__init__(self)
self.saudo = ["Hola", "Ola", "Hello", "Alo", "Salut", "Arigatou", "Ciao"]
boton = QPushButton("Púlsame")
self.etiqueta = QLabel("Hola a todos")
self.etiqueta.setAlignment(Qt.AlignCenter)
caixaV = QVBoxLayout()
caixaV.addWidget(self.etiqueta)
caixaV.addWidget(boton)
self.setLayout(caixaV)
boton.clicked.connect(self.on_boton_clicked)
self.resize(400, 300)
self.show()
def on_boton_clicked(self):
self.etiqueta.setText(random.choice(self.saudo))
if __name__ == "__main__":
app = QApplication(sys.argv)
aplicacion = Aplicacion()
# PODRÍAMOS PONER ESTAS FUNCIONES AQUÍ, AL ESTAR FUERA DE LA FUNCIÓN PRINCIPAL HABRÍA QUE LLAMARLA CON "aplicacion", NO CON "self" !!!
# aplicacion.resize(400, 300)
# aplicacion.show()
sys.exit(app.exec_())
|
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing
adultHeaders=['age', 'workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country', 'income']
dfAdult = pd.read_csv('adult.data', sep=",", header=None, names=adultHeaders, na_values=[" ?"])
#drop columns with missing data
new_dfAdult= dfAdult.dropna(axis = 'columns', how ='any')
#drop column with more than 80% 0s in the features
#print (dfAdult.isin([' ','0',0]).mean())
new_dfAdult = new_dfAdult.loc[:, new_dfAdult.isin([' ','0',0]).mean() < .8]
#dfAdult['income'].value_counts().plot(kind='bar')
#plt.show()
#out = pd.cut(new_dfAdult['hours-per-week'], bins=[0, 20, 30, 40, 50, 60, 80, 120], include_lowest=True)
#ax = out.value_counts(sort=False).plot.bar(rot=0, figsize=(6,4))
#plt.show()
#dfSample = new_dfAdult.sample(1000)
#xdataSample, ydataSample = new_dfAdult["education-num"], new_dfAdult["capital-gain"]
#sns.regplot(x=xdataSample, y=ydataSample)
#plt.show()
#dfSample = new_dfAdult.sample(500)
#sns.pairplot(new_dfAdult)
#plt.savefig('pairwise.png')
#select categorical features
cat_dfAdult = new_dfAdult.select_dtypes(include=[object]).copy()
#print(cat_dfAdult.head(30))
#print(cat_dfAdult.columns)
# encode labels with value between 0 and n_classes-1.
le = preprocessing.LabelEncoder()
# use df.apply() to apply le.fit_transform to all columns
cat2_dfAdult = cat_dfAdult.apply(le.fit_transform)
#print(cat2_dfAdult.head(5))
enc = preprocessing.OneHotEncoder()
enc.fit(cat2_dfAdult)
onehotlabels = enc.transform(cat2_dfAdult).toarray()
#dropping the last column so <50k is 1 and >50k is 0
onehotlabels = onehotlabels[:,:-1]
#print(onehotlabels)
nocat_dfAdult = new_dfAdult.select_dtypes(exclude=[object])
nocatlabels = nocat_dfAdult.to_numpy()
alladultdata= np.concatenate((nocatlabels, onehotlabels), axis=1)
X_adult = alladultdata[:, :-1]
X_adult = X_adult / X_adult.max(axis=0) # This normalizes each column
X_adult_cat = onehotlabels[:, :-1]
X_adult_cont = nocatlabels
y_adult= onehotlabels[:, -1]
#print(X_adult_cont)
#print(X_adult_cat)
#alladultdata= np.concatenate((nocatlabels, onehotlabels), axis=1)
#all adult data holds the array of data (X and y)
#alladultdata = alladultdata[:,:-1]
#print(onehotlabels.shape)
#print(cat2_dfAdult.head())
#print(onehotlabels)
#print(nocatlabels)
#print(nocatlabels.shape)
#print(alladultdata[:,[42]])
|
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 25 17:40:14 2015
@author: HSH
"""
class Solution(object):
def subsets(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
allSet = []
sol = []
allSet.append(sol[:])
nums = sorted(nums)
self.findSubsets(nums, 0, sol, allSet)
return allSet
def findSubsets(self, nums, start, sol, allSet):
for i in range(start, len(nums)):
sol.append(nums[i])
allSet.append(sol[:])
self.findSubsets(nums, i + 1, sol, allSet)
sol.pop()
|
#!/usr/bin/env python
import os
import re
import sys
import struct
import binascii
from .helpers import *
TAG_RESERVED = 0
TAG_PUB_KEY_ENCR_SESS_KEY = 1
TAG_SIGNATURE = 2
TAG_SYMKEY_ENCR_SESS_KEY = 3
TAG_ONE_PASS_SIG = 4
TAG_SECRET_KEY = 5
TAG_PUB_KEY = 6
TAG_SECRET_SUBKEY = 7
TAG_COMPR_DATA = 8
TAG_SYMM_ENCR_DATA = 9
TAG_MARKER = 10
TAG_LITERAL_DATA = 11
TAG_TRUST = 12
TAG_USER_ID = 13
TAG_PUB_SUBKEY = 14
TAG_USER_ATTR = 17
TAG_SYMM_ENCR_INTEGRITY_PROT_DATA = 18
TAG_MODIF_DETECT_CODE = 19
TAG_PRIVATE_EXPERIMENTAL_0 = 0
TAG_PRIVATE_EXPERIMENTAL_1 = 1
TAG_PRIVATE_EXPERIMENTAL_2 = 2
TAG_PRIVATE_EXPERIMENTAL_3 = 3
def tagToStr(tag):
lookup = {TAG_RESERVED:"reserved", TAG_PUB_KEY_ENCR_SESS_KEY:'public-key encr session key',
TAG_SIGNATURE:'signature', TAG_SYMKEY_ENCR_SESS_KEY:'symmetric-key encr session key',
TAG_ONE_PASS_SIG:'one-pass signature', TAG_SECRET_KEY:'secret-key', TAG_PUB_KEY:'public-key',
TAG_SECRET_SUBKEY:'secret-subkey', TAG_COMPR_DATA:'compressed data',
TAG_SYMM_ENCR_DATA:'symmetric encr data', TAG_MARKER:'marker',
TAG_LITERAL_DATA:'literal data', TAG_TRUST:'trust', TAG_USER_ID:'user id',
TAG_PUB_SUBKEY:'public-subkey', TAG_USER_ATTR:'user attribute',
TAG_SYMM_ENCR_INTEGRITY_PROT_DATA:'symmetric encrypted and integrity protected data',
TAG_MODIF_DETECT_CODE:'modification detection code'
}
if tag in lookup:
return lookup[tag]
return 'unknown'
# reference section 9.2 in rfc4880
def symAlgoToStr(algo):
lookup = {0:'plaintext/unencrypted', 1:'IDEA', 2:'TripleDES', 3:'CAST5',
4:'Blowfish', 5:'Reserved', 6:'Reserved', 7:'AES128', 8:'AES192',
9:'AES256', 10:'Twofish'}
if algo in lookup:
return lookup[algo]
if algo >= 100 and algo <= 110:
return "private/experimental"
return 'unknown'
# reference section 3.7.1 in rfc4880
def s2kToStr(algo):
if algo == 0:
return 'Simple S2K'
if algo == 1:
return 'Salted S2K'
if algo == 2:
return 'Reserved'
if algo == 3:
return 'Iterated+Salted S2K'
if algo >= 100 and algo <= 110:
return 'private/experimental'
return 'unknown'
# reference section 9.4 in rfc4880
def hashAlgoToStr(algo):
lookup = ['invalid', 'md5', 'sha1', 'ripe-md', 'reserved', 'reserved',
'reserved', 'reserved', 'sha256', 'sha384', 'sha512', 'sha224']
if algo >= 0 and algo < len(lookup):
return lookup[algo]
if algo >= 100 and algo <= 110:
return 'private/experimental'
return 'unknown'
# reference section 9.3 in rfc4880
def comprAlgoToStr(algo):
if algo == 0:
return 'uncompressed'
if algo == 1:
return 'zip [rfc1951]'
if algo == 2:
return 'zlib [rfc1950]'
if algo == 3:
return 'bzip2 [bz2]'
if algo >= 100 and algo <= 110:
return 'private/experimental'
return 'unknown'
def litDataFmtToStr(fmt):
if fmt == ord('b'):
return 'binary'
if fmt == ord('t'):
return 'text'
if fmt == ord('u'):
return 'utf-8'
return 'unknown'
###############################################################################
# "main"
###############################################################################
def analyze(fp):
# for each packet
while not IsEof(fp):
(hdrLen,bodyLen) = (0,0)
oPacket = fp.tell()
packetTag = tagUint8(fp, "tag")
assert(packetTag & 0x80)
hdrStyle = 'unknown'
tagId = 0
body = b''
# parse new format
if packetTag & 0x40:
hdrStyle = 'new'
tagId = 0x3F & packetTag
while 1:
oLen = fp.tell()
octet1 = uint8(fp)
octet2 = uint8(fp)
fp.seek(-2, os.SEEK_CUR)
partial = False
bodyLen = 0
if octet1 <= 191:
hdrLen = 2
bodyLen = octet1
tag(fp, 1, "length (direct): 0x%X" % bodyLen)
elif octet1 >= 192 and octet1 <= 223:
hdrLen = 3
bodyLen = (octet1 - 192)*256 + octet2 + 192
tag(fp, 2, "length (calculated): 0x%X" % bodyLen)
elif octet1 >= 224 and octet1 <= 254:
hdrLen = 2
bodyLen = 1 << (octet1 & 0x1f)
tag(fp, 1, "length (partial): 0x%X" % bodyLen)
partial = True
else:
hdrLen = 5
bodyLen = tagUint32(fp, "len")
tag(fp, 1, "length (direct): 0x%X" % bodyLen)
body += fp.read(bodyLen)
if IsEof(fp) or not partial:
break
# parse old format
else:
hdrStyle = 'old'
length_type = packetTag & 3
tagId = (0x3C & packetTag) >> 2
bodyLen = 0
if length_type == 0:
# one-octet length
hdrLen = 2
bodyLen = tagUint8(fp, "len")
elif length_type == 1:
hdrLen = 3
bodyLen = tagUint16(fp, "len")
elif length_type == 2:
hdrLen = 5
bodyLen = tagUint32(fp, "len")
elif length_type == 3:
# length extends to end of file
hdrLen = 1
fp.seek(0, os.SEEK_END)
bodyLen = fp.tell() - (oPacket + 1)
body = fp.read(bodyLen)
# mark the whole packet
print("[0x%X,0x%X) header (%s)" % (oPacket, oPacket+hdrLen, hdrStyle))
print("[0x%X,0x%X) body" % (oPacket+hdrLen, oPacket+hdrLen+bodyLen))
print("[0x%X,0x%X) %s packet (Tag %d)" % \
(oPacket, fp.tell(), tagToStr(tagId), tagId))
oPacketEnd = fp.tell()
# certain packets we go deeper
fp.seek(oPacket + hdrLen)
if tagId == TAG_SYMKEY_ENCR_SESS_KEY:
tagUint8(fp, "version");
algoId = uint8(fp, True)
tagUint8(fp, "algorithm", symAlgoToStr(algoId))
s2kId = uint8(fp, True)
tagUint8(fp, "S2K", s2kToStr(s2kId))
if s2kId == 3: # iterated and salted
hashId = uint8(fp, True)
tagUint8(fp, "hash", hashAlgoToStr(hashId))
tag(fp, 8, "salt");
countCoded = uint8(fp, True)
count = (16 + (countCoded & 0xF)) << ((countCoded >> 4) + 6)
tagUint8(fp, "count", "decoded: %d" % count)
elif tagId == TAG_COMPR_DATA:
algoId = uint8(fp, True)
tagUint8(fp, "algorithm", comprAlgoToStr(algoId))
tag(fp, oPacketEnd - fp.tell(), "compressed data")
elif tagId == TAG_LITERAL_DATA:
fmt = uint8(fp, True)
tagUint8(fp, "format", litDataFmtToStr(fmt))
lenFile = tagUint8(fp, "fname_len")
assert(lenFile < 256)
tag(fp, lenFile, "filename")
tagUint32(fp, "date")
tag(fp, oPacketEnd - fp.tell(), "data")
# next packet
fp.seek(oPacketEnd)
if __name__ == '__main__':
import sys
with open(sys.argv[1], 'rb') as fp:
analyze(fp)
|
#!/usr/bin/env python3
"""psi2log"""
import os
from time import sleep, monotonic
from ctypes import CDLL
from sys import stdout, exit
from argparse import ArgumentParser
from signal import signal, SIGTERM, SIGINT, SIGQUIT, SIGHUP
def form(num):
"""
"""
s = str(num).split('.')
return '{}.{:0<2}'.format(s[0], s[1])
def signal_handler(signum, frame):
"""
"""
def signal_handler_inner(signum, frame):
pass
for i in sig_list:
signal(i, signal_handler_inner)
log('')
lpd = len(peaks_dict)
if lpd != 15:
exit()
log('=================================')
log('Peak values: avg10 avg60 avg300')
log('----------- ------ ------ ------')
log('some cpu {:>6} {:>6} {:>6}'.format(
form(peaks_dict['c_some_avg10']),
form(peaks_dict['c_some_avg60']),
form(peaks_dict['c_some_avg300']),
))
log('----------- ------ ------ ------')
log('some memory {:>6} {:>6} {:>6}'.format(
form(peaks_dict['m_some_avg10']),
form(peaks_dict['m_some_avg60']),
form(peaks_dict['m_some_avg300']),
))
log('full memory {:>6} {:>6} {:>6}'.format(
form(peaks_dict['m_full_avg10']),
form(peaks_dict['m_full_avg60']),
form(peaks_dict['m_full_avg300']),
))
log('----------- ------ ------ ------')
log('some io {:>6} {:>6} {:>6}'.format(
form(peaks_dict['i_some_avg10']),
form(peaks_dict['i_some_avg60']),
form(peaks_dict['i_some_avg300']),
))
log('full io {:>6} {:>6} {:>6}'.format(
form(peaks_dict['i_full_avg10']),
form(peaks_dict['i_full_avg60']),
form(peaks_dict['i_full_avg300']),
))
exit()
def cgroup2_root():
"""
"""
with open(mounts) as f:
for line in f:
if cgroup2_separator in line:
return line.partition(cgroup2_separator)[0].partition(' ')[2]
def mlockall():
"""
"""
MCL_CURRENT = 1
MCL_FUTURE = 2
MCL_ONFAULT = 4
CDLL('libc.so.6').mlockall(MCL_CURRENT | MCL_FUTURE | MCL_ONFAULT)
def psi_file_mem_to_metrics(psi_path):
"""
"""
with open(psi_path) as f:
psi_list = f.readlines()
some_list, full_list = psi_list[0].split(' '), psi_list[1].split(' ')
some_avg10 = some_list[1].split('=')[1]
some_avg60 = some_list[2].split('=')[1]
some_avg300 = some_list[3].split('=')[1]
full_avg10 = full_list[1].split('=')[1]
full_avg60 = full_list[2].split('=')[1]
full_avg300 = full_list[3].split('=')[1]
return (some_avg10, some_avg60, some_avg300,
full_avg10, full_avg60, full_avg300)
def psi_file_cpu_to_metrics(psi_path):
"""
"""
with open(psi_path) as f:
psi_list = f.readlines()
some_list = psi_list[0].split(' ')
some_avg10 = some_list[1].split('=')[1]
some_avg60 = some_list[2].split('=')[1]
some_avg300 = some_list[3].split('=')[1]
return (some_avg10, some_avg60, some_avg300)
def psi_file_mem_to_total(psi_path):
"""
"""
with open(psi_path) as f:
psi_list = f.readlines()
some_list, full_list = psi_list[0].split(' '), psi_list[1].split(' ')
some_total = some_list[4].split('=')[1]
full_total = full_list[4].split('=')[1]
return int(some_total), int(full_total)
def psi_file_cpu_to_total(psi_path):
"""
"""
with open(psi_path) as f:
psi_list = f.readlines()
some_list = psi_list[0].split(' ')
some_total = some_list[4].split('=')[1]
return int(some_total)
def print_head_1():
log('=================================================================='
'================================================')
log(' some cpu pressure || some memory pressure | full memory pressur'
'e || some io pressure | full io pressure')
log('-------------------- || -------------------- | -------------------'
'- || -------------------- | --------------------')
log(' avg10 avg60 avg300 || avg10 avg60 avg300 | avg10 avg60 avg30'
'0 || avg10 avg60 avg300 | avg10 avg60 avg300')
log('------ ------ ------ || ------ ------ ------ | ------ ------ -----'
'- || ------ ------ ------ | ------ ------ ------')
def print_head_2():
log('============================================')
log(' cpu | memory | io |')
log('----- | ----------- | ----------- |')
log(' some | some full | some full | interval')
log('----- | ----- ----- | ----- ----- | --------')
def log(*msg):
"""
"""
print(*msg)
if separate_log:
logging.info(*msg)
parser = ArgumentParser()
parser.add_argument(
'-t',
'--target',
help="""target (cgroup_v2 or SYTSTEM_WIDE)""",
default='SYSTEM_WIDE',
type=str
)
parser.add_argument(
'-i',
'--interval',
help="""interval in sec""",
default=2,
type=float
)
parser.add_argument(
'-l',
'--log',
help="""path to log file""",
default=None,
type=str
)
parser.add_argument(
'-m',
'--mode',
help="""mode (1 or 2)""",
default='1',
type=str
)
args = parser.parse_args()
target = args.target
interval = args.interval
log_file = args.log
mode = args.mode
if log_file is None:
separate_log = False
else:
separate_log = True
import logging
sig_list = [SIGTERM, SIGINT, SIGQUIT, SIGHUP]
for i in sig_list:
signal(i, signal_handler)
if separate_log:
logging.basicConfig(
filename=log_file,
level=logging.INFO,
format="%(asctime)s: %(message)s")
log('Starting psi2log')
log('target: {}'.format(target))
log('interval: {} sec'.format(interval))
if log_file is not None:
log('log file: {}'.format(log_file))
log('mode: {}'.format(mode))
try:
psi_file_mem_to_metrics('/proc/pressure/memory')
except Exception as e:
print('ERROR: {}'.format(e))
print('PSI metrics are not provided by the kernel. Exit.')
exit(1)
if target == 'SYSTEM_WIDE':
cpu_file = "/proc/pressure/cpu"
memory_file = "/proc/pressure/memory"
io_file = "/proc/pressure/io"
else:
mounts = '/proc/mounts'
cgroup2_separator = ' cgroup2 rw,'
cgroup2_mountpoint = cgroup2_root()
if cgroup2_mountpoint is None:
log('ERROR: unified cgroup hierarchy is not mounted, exit')
exit(1)
else:
log('cgroup_v2 mountpoint: {}'.format(cgroup2_mountpoint))
cpu_file = cgroup2_mountpoint + target + "/cpu.pressure"
memory_file = cgroup2_mountpoint + target + "/memory.pressure"
io_file = cgroup2_mountpoint + target + "/io.pressure"
peaks_dict = dict()
mlockall()
if mode == '2':
print_head_2()
total_cs0 = psi_file_cpu_to_total(cpu_file)
total_ms0, total_mf0 = psi_file_mem_to_total(memory_file)
total_is0, total_if0 = psi_file_mem_to_total(io_file)
monotonic0 = monotonic()
sleep(interval)
while True:
total_cs1 = psi_file_cpu_to_total(cpu_file)
total_ms1, total_mf1 = psi_file_mem_to_total(memory_file)
total_is1, total_if1 = psi_file_mem_to_total(io_file)
monotonic1 = monotonic()
dm = monotonic1 - monotonic0
monotonic0 = monotonic1
dtotal_cs = total_cs1 - total_cs0
avg_cs = dtotal_cs / dm / 10000
total_cs0 = total_cs1
dtotal_ms = total_ms1 - total_ms0
avg_ms = dtotal_ms / dm / 10000
total_ms0 = total_ms1
dtotal_mf = total_mf1 - total_mf0
avg_mf = dtotal_mf / dm / 10000
total_mf0 = total_mf1
dtotal_is = total_is1 - total_is0
avg_is = dtotal_is / dm / 10000
total_is0 = total_is1
dtotal_if = total_if1 - total_if0
avg_if = dtotal_if / dm / 10000
total_if0 = total_if1
log('{:>5} | {:>5} {:>5} | {:>5} {:>5} | {}'.format(
round(avg_cs, 1),
round(avg_ms, 1),
round(avg_mf, 1),
round(avg_is, 1),
round(avg_if, 1),
round(dm, 3)
))
stdout.flush()
sleep(interval)
if mode != '1':
log('ERROR: invalid mode. Exit.')
exit(1)
print_head_1()
while True:
if not os.path.exists(cpu_file):
log('ERROR: cpu pressure file does not exist: {}'.format(cpu_file))
sleep(interval)
continue
if not os.path.exists(memory_file):
log('ERROR: memory pressure file does not exist: {}'.format(
memory_file))
sleep(interval)
continue
if not os.path.exists(io_file):
log('ERROR: io pressure file does not exist: {}'.format(cpu_file))
sleep(interval)
continue
(c_some_avg10, c_some_avg60, c_some_avg300
) = psi_file_cpu_to_metrics(cpu_file)
(m_some_avg10, m_some_avg60, m_some_avg300,
m_full_avg10, m_full_avg60, m_full_avg300
) = psi_file_mem_to_metrics(memory_file)
(i_some_avg10, i_some_avg60, i_some_avg300,
i_full_avg10, i_full_avg60, i_full_avg300
) = psi_file_mem_to_metrics(io_file)
log('{:>6} {:>6} {:>6} || {:>6} {:>6} {:>6} | {:>6} {:>6} {:>6} || {:>6}'
' {:>6} {:>6} | {:>6} {:>6} {:>6}'.format(
c_some_avg10, c_some_avg60, c_some_avg300,
m_some_avg10, m_some_avg60, m_some_avg300,
m_full_avg10, m_full_avg60, m_full_avg300,
i_some_avg10, i_some_avg60, i_some_avg300,
i_full_avg10, i_full_avg60, i_full_avg300
))
c_some_avg10 = float(c_some_avg10)
if ('c_some_avg10' not in peaks_dict or
peaks_dict['c_some_avg10'] < c_some_avg10):
peaks_dict['c_some_avg10'] = c_some_avg10
c_some_avg60 = float(c_some_avg60)
if ('c_some_avg60' not in peaks_dict or
peaks_dict['c_some_avg60'] < c_some_avg60):
peaks_dict['c_some_avg60'] = c_some_avg60
c_some_avg300 = float(c_some_avg300)
if ('c_some_avg300' not in peaks_dict or
peaks_dict['c_some_avg300'] < c_some_avg300):
peaks_dict['c_some_avg300'] = c_some_avg300
#######################################################################
m_some_avg10 = float(m_some_avg10)
if ('m_some_avg10' not in peaks_dict or
peaks_dict['m_some_avg10'] < m_some_avg10):
peaks_dict['m_some_avg10'] = m_some_avg10
m_some_avg60 = float(m_some_avg60)
if ('m_some_avg60' not in peaks_dict or
peaks_dict['m_some_avg60'] < m_some_avg60):
peaks_dict['m_some_avg60'] = m_some_avg60
m_some_avg300 = float(m_some_avg300)
if ('m_some_avg300' not in peaks_dict or
peaks_dict['m_some_avg300'] < m_some_avg300):
peaks_dict['m_some_avg300'] = m_some_avg300
m_full_avg10 = float(m_full_avg10)
if ('m_full_avg10' not in peaks_dict or
peaks_dict['m_full_avg10'] < m_full_avg10):
peaks_dict['m_full_avg10'] = m_full_avg10
m_full_avg60 = float(m_full_avg60)
if ('m_full_avg60' not in peaks_dict or
peaks_dict['m_full_avg60'] < m_full_avg60):
peaks_dict['m_full_avg60'] = m_full_avg60
m_full_avg300 = float(m_full_avg300)
if ('m_full_avg300' not in peaks_dict or
peaks_dict['m_full_avg300'] < m_full_avg300):
peaks_dict['m_full_avg300'] = m_full_avg300
#######################################################################
i_some_avg10 = float(i_some_avg10)
if ('i_some_avg10' not in peaks_dict or
peaks_dict['i_some_avg10'] < i_some_avg10):
peaks_dict['i_some_avg10'] = i_some_avg10
i_some_avg60 = float(i_some_avg60)
if ('i_some_avg60' not in peaks_dict or
peaks_dict['i_some_avg60'] < i_some_avg60):
peaks_dict['i_some_avg60'] = i_some_avg60
i_some_avg300 = float(i_some_avg300)
if ('i_some_avg300' not in peaks_dict or
peaks_dict['i_some_avg300'] < i_some_avg300):
peaks_dict['i_some_avg300'] = i_some_avg300
i_full_avg10 = float(i_full_avg10)
if ('i_full_avg10' not in peaks_dict or
peaks_dict['i_full_avg10'] < i_full_avg10):
peaks_dict['i_full_avg10'] = i_full_avg10
i_full_avg60 = float(i_full_avg60)
if ('i_full_avg60' not in peaks_dict or
peaks_dict['i_full_avg60'] < i_full_avg60):
peaks_dict['i_full_avg60'] = i_full_avg60
i_full_avg300 = float(i_full_avg300)
if ('i_full_avg300' not in peaks_dict or
peaks_dict['i_full_avg300'] < i_full_avg300):
peaks_dict['i_full_avg300'] = i_full_avg300
stdout.flush()
sleep(interval)
|
tup_one = (1, 2, 3)
tup_two = (4, 5, 6)
tup_three = tup_one + tup_two
tup_four = tup_one * 3
print(tup_three)
print(tup_four) |
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from torch.autograd import Variable
from torch.utils.data import DataLoader
import matplotlib as mpl
from matplotlib.colors import colorConverter
import networkFiles as NF
from samplesDecision import generateSamples
# General parameters that would get set in other code
layers = 8
image_size = 20
N = image_size
num_nodes = image_size**2
dtype = torch.FloatTensor
model = NF.FixedAll_PredPrey(num_nodes, layers, num_nodes*5, image_size)
model.type(dtype)
testDict = generateSamples(image_size, 2, layers)
test_dsetPath = torch.utils.data.TensorDataset(testDict["Environment"], testDict["Predator"], testDict["Prey"], testDict["Cave"], testDict["Label"])
loader = DataLoader(test_dsetPath, batch_size=32, shuffle=True)
loss_fn = nn.BCELoss()
model.eval()
num_correct, num_samples = 0, 0
losses = []
# The accuracy on all pixels and path pixels can be calculated from the image labels
# Also record the loss
for env, pred, prey, cave, label in loader:
# Cast the image data to the correct type and wrap it in a Variable. At
# test-time when we do not need to compute gradients, marking the Variable
# as volatile can reduce memory usage and slightly improve speed.
env = Variable(env.type(dtype), requires_grad=False)
pred = Variable(pred.type(dtype), requires_grad=False)
prey = Variable(prey.type(dtype), requires_grad=False)
cave = Variable(cave.type(dtype), requires_grad=False)
label = Variable(label.type(dtype), requires_grad=False)
# Run the model forward and compare with ground truth.
prey_range, pred_range, output, trace = model(env, prey, pred, cave, dtype)
loss = loss_fn(output, label).type(dtype)
#preds = output.sign()
# Compute accuracy on ALL pixels
num_correct += (torch.argmax(label, dim = 1) == torch.argmax(output, dim = 1)).sum()
num_samples += label.size(0)
losses.append(loss.data.cpu().numpy())
# print(output)
# print(label)
# print(loss)
# errorAll = 1.0 - (float(num_correct) / (num_samples))
# print(errorAll)
# print(num_samples)
cmap1 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap',['white','black'],256)
cmap2 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap2',['white','skyblue'],256)
cmap3 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap2',['white','blue'],256)
cmap4 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap2',['white','pink'],256)
cmap5 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap2',['white','mediumvioletred'],256)
cmap6 = mpl.colors.LinearSegmentedColormap.from_list('my_cmap2',['white','goldenrod'],256)
cmap2._init() # create the _lut array, with rgba values
cmap3._init()
cmap4._init()
cmap5._init()
cmap6._init()
# create your alpha array and fill the colormap with them.
# here it is progressive, but you can create whathever you want
alphas = np.linspace(0, 0.8, cmap2.N+3)
cmap2._lut[:,-1] = alphas
cmap3._lut[:,-1] = alphas
cmap4._lut[:,-1] = alphas
cmap5._lut[:,-1] = alphas
cmap6._lut[:,-1] = alphas
# # Look at the output
fig1, ax = plt.subplots(1, figsize = (3, 3))
#ax[0, 0].imshow(np.reshape(output[0,:].detach().numpy(), (N, N)), cmap='Greys', interpolation='none')
ax.imshow(-1*np.reshape(env[0,:].numpy(), (N, N)), cmap=cmap1, origin='lower')
ax.imshow(np.reshape(pred[0,:].detach().numpy(), (N, N)), cmap=cmap3, origin='lower')
ax.imshow(np.reshape(cave[0,:].detach().numpy(), (N, N)), cmap=cmap6, origin='lower')
ax.imshow(np.reshape(prey[0,:].detach().numpy(), (N, N)), cmap=cmap5, origin='lower')
ax.tick_params(
axis='y', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
left=False, # ticks along the bottom edge are off
right=False, # ticks along the top edge are off
labelleft=False) # labels along the bottom edge are off
ax.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom=False, # ticks along the bottom edge are off
top=False, # ticks along the top edge are off
labelbottom=False) # labels along the bottom edge are off
fig1.savefig("sample.pdf", bbox_inches = 'tight',
pad_inches = 0)
|
# Given a mixed array of number and string representations of integers,
# add up the string integers and subtract this from the total
# of the non-string integers. Return as a number.
def div_con(my_list):
string = 0
numeral = 0
for i in my_list:
if str(i) == i:
i = int(i)
string += i
else:
numeral += i
return numeral - string
print(div_con([12, 13, '12', '7']))
|
# for i in range(1, 6):
# for j in range(6-i, 0, -1):
# print("*", end=" ")
# print()
age = 19
print(type(age))
print(type(str(age)))
|
import cgi
import urllib
import urllib2
import webapp2
import datetime
import string
from google.appengine.api import users
from google.appengine.ext import db
from google.appengine.api import urlfetch
from django.utils import simplejson
import jinja2
import os
jenv = jinja2.Environment(loader=jinja2.FileSystemLoader(os.path.dirname(__file__)))
class TwitterSearch(db.Model):
"""Search Results Model
"""
query = db.StringProperty()
hits = db.IntegerProperty()
users_average = db.FloatProperty()
class IndexHandler(webapp2.RequestHandler):
"""Main Request Handler
"""
# twitter search url
searchUrl = "http://search.twitter.com/search.json"
def get(self):
"""Request handler method:
parse request
compute and store averages
render search results page
"""
message = ""
query = ""
results = dict()
try:
# parse request
query = (self.request.get('q')).lower()
if query:
# fetch results
results = self.fetch_results(query)
# update entity for this query
ts = TwitterSearch.gql("WHERE query = :query", query=query)
if ts.count() < 1: # we have a new query
ts = TwitterSearch(query = query,
hits = 1,
users_average = self.computeAverages(0.0,results))
ts.put()
else: # update current
for t in ts:
t.hits += 1
t.users_average = self.computeAverages(t.users_average, results)
t.put()
except Exception as e :
message = self.handleError(e)
# get stats
resultsAverages = TwitterSearch.gql("ORDER BY hits DESC LIMIT 10")
template_values = {
'query' : query,
'results' : results,
'resultsAverages' : resultsAverages,
'message' : message,
}
template = jenv.get_template('index.html')
self.response.out.write(template.render(template_values))
def fetch_results(self, q):
"""Fetch results and handle API responses
"""
params = urllib.urlencode({
'q' : q,
'rpp' : 100, # result per page
})
url = self.searchUrl + "?" + params
results = urlfetch.fetch(url)
results = simplejson.loads(results.content)
# handle search api errors
if 'error' in results:
raise Exception(results['error'])
if 'results' in results:
return results['results']
return dict()
def computeAverages(self, currentAvg, results):
"""Compute averages
"""
# sum up average number of distinct authors in results
authors = [r['from_user_id'] for r in results]
avg = (currentAvg + len(set(authors)))/2.0
return avg
def handleError(self, e):
"""Simple error messages handler
"""
self.error('400')
return e
def set_trace():
"""Debug helper
"""
import pdb, sys
debugger = pdb.Pdb(stdin=sys.__stdin__,
stdout=sys.__stdout__)
debugger.set_trace(sys._getframe().f_back)
app = webapp2.WSGIApplication([('/', IndexHandler)],
debug=True)
|
class Category:
#constructor
def __init__(self, category, amount):
self.category = category
self.amount = amount
#methods
def deposit(self, amount):
self.amount += amount
return "You have successfully deposited {} in {} category".format(amount, self.category)
def budget_balance(self):
return "This is the current balance: {}".format(self.amount)
def check_balance(self, amount):
#this should return a True or False, it checks if amount is less or greater than self.amount
if amount <= self.amount:
return True
else:
return False
def withdraw(self, amount):
#reverse of deposit, will use check_balance to see if enough budget to withdraw
if self.check_balance(amount) is True:
self.amount -= amount
return "You have successfully withdrawn {} in {} category".format(amount, self.category)
else:
return "You don't have enough funds to withdraw"
def transfer(self, amount, category):
#transfer between two instantiated categories, will use check_balance to see if enough budget to transfer
if self.check_balance(amount) is True:
return self.withdraw(amount) + ' ' + category.deposit(amount)
else:
return "You don't have enough funds in " + self.category + " to transfer"
food_category = Category('Food Budget', 500)
clothing_category = Category('Clothing Budget', 300)
car_category = Category('Car Budget', 600)
education_category = Category('Education Budget', 250)
print(food_category.deposit(250))
print(food_category.budget_balance())
print(food_category.check_balance(600))
print(food_category.withdraw(400))
print(food_category.budget_balance())
print(food_category.transfer(600, car_category))
|
from django.utils import timezone
from django.db.models import Q
from django.db import models
from django.contrib.auth.models import User
FIRST_NAME_LEN = 20
LAST_NAME_LEN = 20
CATEGORY_NAME_LEN = 30
OFFER_DESC_LEN = 1000
TAG_LEN = 1000
MEETING_STATUS_LEN = 30
ARGUMENT_LEN = 1000
ARGUMENT_STATUS_LEN = 30
REVIEW_LEN = 1000
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
first_name = models.CharField(max_length=FIRST_NAME_LEN)
last_name = models.CharField(max_length=LAST_NAME_LEN)
age = models.PositiveSmallIntegerField()
balance = models.PositiveIntegerField(default = 0)
def __str__(self):
return self.user.username
class Category(models.Model):
name = models.CharField(max_length=CATEGORY_NAME_LEN)
def __str__(self):
return self.name
class Meta:
verbose_name_plural = "Categories"
class Tag(models.Model):
name = models.CharField(max_length=TAG_LEN)
def __str__(self):
return self.name
class Offer(models.Model):
description = models.CharField(max_length=OFFER_DESC_LEN)
price = models.PositiveSmallIntegerField()
category = models.ForeignKey(Category, on_delete=models.CASCADE)
user_profile = models.ForeignKey(Profile, on_delete=models.CASCADE)
avaliability = models.CharField(max_length=200, null=True)
tag = models.ManyToManyField(Tag)
def __str__(self):
return self.category.name + " by " + self.user_profile.user.username
class MeetingStatus(models.Model):
name = models.CharField(max_length=MEETING_STATUS_LEN)
def __str__(self):
return self.name
class Meeting(models.Model):
date = models.DateTimeField("data of the meeting")
student = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='student')
teacher = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='teacher')
offer = models.ForeignKey(Offer, on_delete=models.CASCADE)
agreed_price = models.PositiveSmallIntegerField()
status = models.ForeignKey(MeetingStatus, on_delete=models.CASCADE)
def __str__(self):
return self.teacher.user.username + " teaches " + self.student.user.username + " " + self.offer.category.name
def cancelMeeting(meeting):
meeting.student.balance += meeting.agreed_price
meeting.student.save()
meeting.delete()
def updateUserMeetings(currUser):
meetings = Meeting.objects.filter(Q(student__user=currUser) | Q(teacher__user=currUser))
took_place = MeetingStatus.objects.filter(name="took_place").first()
now = timezone.now()
for meeting in meetings:
if meeting.date < now:
if meeting.status.name == "pending":
cancelMeeting(meeting)
elif meeting.status.name == "agreed":
meeting.status = took_place
meeting.save()
class ArgumentStatus(models.Model):
name = models.CharField(max_length=ARGUMENT_STATUS_LEN)
def __str__(self):
return self.name
class Argument(models.Model):
victim = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='victim')
accusesed = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='accusesed')
meeting = models.ForeignKey(Meeting, on_delete=models.CASCADE)
message = models.CharField(max_length=ARGUMENT_LEN)
status = models.ForeignKey(ArgumentStatus, on_delete=models.CASCADE)
def __str__(self):
return self.victim.user.username + " accuses " + self.accusesed.user.username
class Review(models.Model):
author = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='author')
reviewed = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='reviewed')
category = models.ForeignKey(Category, on_delete=models.CASCADE)
rating = models.PositiveSmallIntegerField(range(0, 5))
description = models.CharField(max_length=REVIEW_LEN, null=True)
def __str__(self):
return self.author.user.username + " reviews " + self.reviewed.user.username + " " + self.category.name
|
from amath.Errors import DateError
# noinspection PyUnresolvedReferences
class _DateObject:
def __init__(self, m=None, d=None, y=None):
if d is None:
if m is None:
if y is not None:
raise TypeError("Invalid Argument")
else:
raise TypeError("Invalid Argument")
else:
if m is None:
raise TypeError("Invalid Argument")
else:
if y is None:
raise TypeError("Invalid Argument")
if d is None:
import datetime as dt
x = dt.datetime.now()
self.d = x.day
self.m = x.month
self.y = x.year
else:
if type(m) is not int:
raise TypeError("Please enter number values")
if type(d) is not int:
raise TypeError("Please enter number values")
if type(y) is not int:
raise TypeError("Please enter number values")
if m > 12:
raise ValueError("Invalid Month value")
elif m < 1:
raise ValueError("Invalid Month value")
if m == 1:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 2:
leap = False
if y % 4 == 0:
leap = True
if y % 100 == 0:
leap = False
if y % 400 == 0:
leap = True
if leap:
if d > 29:
raise ValueError("Invalid Day value")
elif d < 0:
raise ValueError("Invalid Day value")
else:
if d > 28:
raise ValueError("Invalid Day value")
elif d < 0:
raise ValueError("Invalid Day value")
if m == 3:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 4:
if d > 30:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 5:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 6:
if d > 30:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 7:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 8:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 9:
if d > 30:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 10:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 11:
if d > 30:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
if m == 12:
if d > 31:
raise ValueError("Invalid Day value")
elif d < 1:
raise ValueError("Invalid Day value")
self.d = d
self.m = m
self.y = y
if self.d < 10:
self.sd = "0{0}".format(self.d)
if self.m < 10:
self.sm = "0{0}".format(self.m)
if self.y < 1000:
if self.y < 100:
if self.y < 10:
if self.y < 0:
raise DateError("Please don't use negative years")
self.sy = "000{0}".format(self.y)
else:
self.sy = "00{0}".format(self.y)
else:
self.sy = "0{0}".format(self.y)
def __repr__(self):
return "{2}-{0}-{1}".format(self.m, self.d, self.y)
def __cmp__(self, other):
if not isinstance(other, DateObject):
raise DateError("Results in non-Date value")
if self.y > other.y:
return 1
elif self.y == other.y:
if self.m > other.m:
return 1
elif self.m == other.m:
if self.d > other.d:
return 1
elif self.d == other.d:
return 0
else:
return -1
else:
return -1
else:
return -1
def __add__(self, other):
if not isinstance(other, DateObject):
raise TypeError("Cannot add non-date value")
y = self.y + other.y
m = self.m + other.m
d = self.d + other.d
return DateObject(m, d, y)
@staticmethod
def now():
import datetime as dt
x = dt.datetime.now()
return DateObject(x.month, x.day, x.year)
DateObject = type("DateObject", (_DateObject, object), {})
|
import sha1
import uuid
import sys
# "".join(format(ord(c), "x") for c in s) # char to hex ascii
# bytearray.fromhex("7061756c").decode() # hex ascii to string
lastbyte = 4
times = 100000
plain_list = [uuid.uuid4().hex for i in range(times)]
hash_list = [sha1.SHA1(str.encode(code))[-lastbyte:] for code in plain_list]
# duplicate = {plain_list[i]: sha for i, sha in enumerate(hash_list) if hash_list.count(sha) > 1}
duplicate = dict()
for i, h in enumerate(hash_list):
if hash_list.count(h) > 1:
if h not in duplicate:
duplicate[h] = [plain_list[i]]
else:
duplicate[h].append(plain_list[i])
for sha, plain in duplicate.items():
print(sha, ":")
print(",".join(p for p in plain))
print()
|
# http://stackoverflow.com/questions/6399978/getting-started-with-twitter-oauth2-python
import oauth2 as oauth
import requests
import pprint
from requests_oauthlib import OAuth1, OAuth1Session
CONSUMER_KEY = 'KjmtqqGMuZ7M5GXpq5pScg'
CONSUMER_SECRET = 'j7wZRGMJ2BDmueHTFnHZger2FpJ2r5vKfGcYej05w'
ACCESS_TOKEN = '266612976-ekrmoTXge65r7Qsy8FhF9Nn0hpoap6amjmps5oAC'
ACCESS_SECRET = 'vlQ3Agfb2bica7NpKfPHLjNYtZuvrr9VOHTHWTIjhwHbE'
auth = OAuth1(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_SECRET)
url1 = 'https://api.twitter.com/1.1/account/verify_credentials.json'
r = requests.get(url1, auth=auth)
# print(r.text)
twitter = OAuth1Session(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN,
ACCESS_SECRET)
url2 = 'https://api.twitter.com/1/account/settings.json'
r2 = twitter.get(url2)
# print('===========================================')
# print(r2.text)
url3 = 'https://api.twitter.com/1.1/statuses/user_timeline.json'
params = {'screen_name': 'beenorgone', 'count': 2}
r3 = requests.get(url3, auth=auth, params=params)
pprint.pprint(r3.text)
|
# Generated by Django 2.0.5 on 2018-06-13 16:33
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('calculation', '0021_auto_20180606_0733'),
]
operations = [
migrations.CreateModel(
name='Contractor',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=250, verbose_name='Наименование')),
('type_c', models.CharField(choices=[('in', 'внутренний'), ('out', 'внешний')], default='out', max_length=3, verbose_name='Тип')),
],
options={
'verbose_name_plural': 'Котрагенты',
'ordering': ['name'],
'verbose_name': 'Котрагенты',
},
),
migrations.AlterField(
model_name='invoice',
name='contractor',
field=models.ForeignKey(blank=True, default=None, on_delete=django.db.models.deletion.PROTECT, to='calculation.Contractor', verbose_name='Котрагент'),
),
migrations.AlterField(
model_name='invoice',
name='number',
field=models.CharField(blank=True, help_text='Номер накладной', max_length=50, verbose_name='номер'),
),
migrations.AlterField(
model_name='registration',
name='from_of',
field=models.ForeignKey(blank=True, default=None, on_delete=django.db.models.deletion.PROTECT, to='calculation.Contractor', verbose_name='Котрагент'),
),
migrations.DeleteModel(
name='Сontractor',
),
]
|
n = int(input())
a = list(map(int,input().split()))
m = int(input())
b = list(map(int,input().split()))
a = set(a)
b = set(b)
c = a.union(b)
d = a.intersection(b)
ans = c.difference(d)
ans = list(ans)
for i in range(0,len(ans)-1):
for j in range(i+1,len(ans)):
if(ans[i]>ans[j]):
temp = ans[j]
ans[j] = ans[i]
ans[i] = temp
for i in ans:
print(i)
|
import smtplib, socket
import datetime
# ENV file
from dotenv import load_dotenv
# env
from os import environ
from string import Template
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
def read_template(filename):
"""
Returns a Template object comprising the contents of the
file specified by filename.
"""
with open(filename, 'r', encoding='utf-8') as template_file:
template_file_content = template_file.read()
return Template(template_file_content)
def send_email(from_, to_, subject, context):
try:
# smtp configurations
smpt_host = environ.get('SMPT_HOST')
smpt_port = environ.get('SMPT_PORT')
s = smtplib.SMTP(host=smpt_host, port=smpt_port)
s.starttls()
s.login(environ.get('SMPT_USERNAME'), environ.get('SMPT_PASSWORD'))
# message config
msg = MIMEMultipart()
msg['From'] = from_
msg['To'] = to_
msg['Subject'] = subject
msg.attach(context)
s.send_message(msg)
del msg
s.quit()
except socket.error as e:
print("mailserver could not connect")
def send_database_connection_error():
subject = "Internal-Scheduled Job Error - DB connection error"
# configure mail template
message_template = read_template('./mail_templates/error_template.html')
error_name = "Database Connection Error"
job_name = "Joblist Scrapping"
error_message = "unable to connect to the database"
job_date = datetime.datetime.now()
message = message_template.substitute(
ERROR_NAME=error_name,
JOB_NAME=job_name,
JOB_DATE=job_date,
ERROR_MESSAGE=error_message)
context = MIMEText(message, 'html')
send_email("guru.softwaremaster@gmail.com", "Helpdesk@sohodragon.com", subject, context)
def send_table_update_error():
subject = "Internal-Scheduled Job Error - Updating Table Error"
# configure mail template
message_template = read_template('./mail_templates/error_template.html')
error_name = "Table Update Error"
job_name = "Joblist Scrapping"
error_message = "Error while updating table!"
job_date = datetime.datetime.now()
message = message_template.substitute(
ERROR_NAME=error_name,
JOB_NAME=job_name,
JOB_DATE=job_date,
ERROR_MESSAGE=error_message)
context = MIMEText(message, 'html')
send_email(environ.get("MAIL_FROM"), environ.get("MAIL_TO"), subject, context)
def send_job_run_alert():
subject = "InternalJob working-<Joblist scrapping> No action Required DELETE"
# configure mail template
message_template = read_template('./mail_templates/alert_template.html')
alert_name = "Scrapping Completed"
job_name = "Joblist Scrapping"
job_date = datetime.datetime.now()
message = message_template.substitute(
ALERT_NAME=alert_name,
JOB_NAME=job_name,
JOB_DATE=job_date)
context = MIMEText(message, 'html')
send_email(environ.get("MAIL_FROM"), environ.get("MAIL_TO"), subject, context)
if __name__ == '__main__':
load_dotenv('.env')
send_database_connection_error()
send_table_update_error()
send_job_run_alert()
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from six.moves import cPickle as pickle
import argparse
import tensorflow as tf
import numpy as np
FLAGS = None
def main(_):
#read data
f = open( "notMNIST.pickle",'rb')
data = pickle.load(f)
# Create the model
x = tf.placeholder(tf.float32, [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.matmul(x, W) + b
# Define loss and optimizer
y_ = tf.placeholder(tf.float32, [None, 10])
# The raw formulation of cross-entropy,
#
# tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.softmax(y)),
# reduction_indices=[1]))
#
# can be numerically unstable.
#
# So here we use tf.nn.softmax_cross_entropy_with_logits on the raw
# outputs of 'y', and then average across the batch.
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_))
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
sess = tf.InteractiveSession()
# Train
tf.initialize_all_variables().run()
batch_size = 100
for i in range(4500):
batch_xs = data['train_dataset'][batch_size*i:batch_size*(i+1),:,:].reshape(batch_size,-1)
batch_ys = data['train_labels'][batch_size*i:batch_size*(i+1)]
batch_ys_new = np.zeros((batch_size,10),dtype=np.int8)
for i in range(batch_size):
batch_ys_new[i,batch_ys[i]]=1
if i%100 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch_xs, y_: batch_ys_new})
print("Step %d, accuracy %g"% (i, train_accuracy))
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys_new})
# Test trained model
#print(mnist.train.images[0])
#print(mnist.train.labels[0])
batch_xt = data['test_dataset'].reshape(data['test_dataset'].shape[0],-1)
batch_yt = data['test_labels']
batch_yt_new = np.zeros((data['test_labels'].shape[0],10),dtype=np.int8)
for i in range(data['test_labels'].shape[0]):
batch_yt_new[i,batch_yt[i]]=1
print(sess.run(accuracy, feed_dict={x: batch_xt,
y_: batch_yt_new}))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--data_dir', type=str, default='/tmp/data',
help='Directory for storing data')
FLAGS = parser.parse_args()
print(FLAGS)
tf.app.run()
|
import os
os.environ['KIVY_GL_BACKEND']='gl'
# CFM1 APP version 1.2
import kivy
import platform
import time
from kivy.app import App
from kivy.uix.gridlayout import GridLayout
from kivy.core.window import Window
from kivy.uix.screenmanager import ScreenManager, Screen, NoTransition
from kivy.properties import ObjectProperty
from kivy.uix.togglebutton import ToggleButton
from kivy.config import Config
from kivy.uix.button import Button
from kivy.clock import Clock
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.animation import Animation
from decimal import *
import operator
import json
import multiprocessing
import mido
import serial
import rtmidi
import numpy
from iconfonts import *
from os.path import join, dirname
from math import *
import random
register('default_font', 'Icons.ttf',
join(dirname(__file__), 'Icons.fontd'))
Config.set('graphics', 'width', '800')
Config.set('graphics', 'height', '480')
rpi = 0
if platform.system()=='Linux':
try:
from RPi import GPIO
rpi = 1
except:
pass
print(("rpi detected:",rpi))
if rpi==1:
import smbus
from RPi import GPIO
ser=serial.Serial('/dev/ttyAMA0', 38400)
bus = smbus.SMBus(1)
clk = 21
dt = 20
sw = 16
pwm = 13
jackstart = 12
ldac1= 17
ldac2= 27
ldac3= 22
GPIO.setmode(GPIO.BCM)
GPIO.setup(clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(sw, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(pwm,GPIO.OUT)
GPIO.setup(jackstart,GPIO.OUT)
pwmsync = GPIO.PWM(13,4)
GPIO.setup(ldac1, GPIO.OUT)
GPIO.setup(ldac2, GPIO.OUT)
GPIO.setup(ldac3, GPIO.OUT)
GPIO.output(ldac1, 0)
GPIO.output(ldac2, 0)
GPIO.output(ldac3, 0)
if rpi==0:
pass
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class ParamScreen(Screen):
def on_enter(self):
global rangeMidi
global rangeCV
global rangeCVTrack
global playing
v1.value=0
playing=0
rangeCVTrack=0
rangeMidi=0
rangeCV=0
self.midiupdate()
self.CVupdate()
self.convert()
self.syncupdate()
self.versionupdate()
self.b1000005.pos=320,1170
Clock.schedule_interval(self.listening, 0.002)
w1.value=0
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def versionupdate(self):
self.b1000004.text='CFM1 Version '+str(version)
def midiupdate(self):
self.b1001.text=paramcf1["midi-map"][rangeMidi]["port"]
self.b1002.text=paramcf1["midi-map"][rangeMidi+1]["port"]
self.b1003.text=paramcf1["midi-map"][rangeMidi+2]["port"]
self.b1004.text=paramcf1["midi-map"][rangeMidi+3]["port"]
self.b1005.text=paramcf1["midi-map"][rangeMidi+4]["port"]
self.b1006.text=paramcf1["midi-map"][rangeMidi+5]["port"]
self.b2001.text=paramcf1["midi-map"][rangeMidi]["channel"]
self.b2002.text=paramcf1["midi-map"][rangeMidi+1]["channel"]
self.b2003.text=paramcf1["midi-map"][rangeMidi+2]["channel"]
self.b2004.text=paramcf1["midi-map"][rangeMidi+3]["channel"]
self.b2005.text=paramcf1["midi-map"][rangeMidi+4]["channel"]
self.b2006.text=paramcf1["midi-map"][rangeMidi+5]["channel"]
self.lbl1.text = 'Track' + str(rangeMidi + 1)+':'
self.lbl2.text = 'Track' + str(rangeMidi + 2)+':'
self.lbl3.text = 'Track' + str(rangeMidi + 3)+':'
self.lbl4.text = 'Track' + str(rangeMidi + 4)+':'
self.lbl5.text = 'Track' + str(rangeMidi + 5)+':'
self.lbl6.text = 'Track' + str(rangeMidi + 6)+':'
def syncupdate(self):
print("here sync")
if paramcf1["sync"][0]["midi-din"]=="on": self.b100001.text="On"
else: self.b100001.text="Off"
if paramcf1["sync"][1]["midi-usb"]=="on": self.b100002.text="On"
else: self.b100002.text="Off"
self.b100003.text=paramcf1["sync"][2]["ppq"]
if paramcf1["sync"][3]["BPMmult"]=="1": self.b100004.text="24"
else: self.b100004.text="48"
if paramcf1["sync"][4]["USBstate"]=="in": self.b100005.text="In"
else: self.b100005.text="Out"
def CVupdate(self):
self.b10001.text=paramcf1["CV-map"][rangeCV]["Type"]
self.b10002.text=paramcf1["CV-map"][rangeCV+1]["Type"]
self.b10003.text=paramcf1["CV-map"][rangeCV+2]["Type"]
self.b10004.text=paramcf1["CV-map"][rangeCV+3]["Type"]
self.b10005.text=paramcf1["CV-map"][rangeCV+4]["Type"]
self.b10006.text=paramcf1["CV-map"][rangeCV+5]["Type"]
self.b20001.text=paramcf1["CV-map"][rangeCV]["Track"]
self.b20002.text=paramcf1["CV-map"][rangeCV+1]["Track"]
self.b20003.text=paramcf1["CV-map"][rangeCV+2]["Track"]
self.b20004.text=paramcf1["CV-map"][rangeCV+3]["Track"]
self.b20005.text=paramcf1["CV-map"][rangeCV+4]["Track"]
self.b20006.text=paramcf1["CV-map"][rangeCV+5]["Track"]
self.b30001.text=paramcf1["CV-map"][rangeCV]["Voltage"]
self.b30002.text=paramcf1["CV-map"][rangeCV+1]["Voltage"]
self.b30003.text=paramcf1["CV-map"][rangeCV+2]["Voltage"]
self.b30004.text=paramcf1["CV-map"][rangeCV+3]["Voltage"]
self.b30005.text=paramcf1["CV-map"][rangeCV+4]["Voltage"]
self.b30006.text=paramcf1["CV-map"][rangeCV+5]["Voltage"]
self.VoltageHide()
self.lbl10.text = 'CV' + str(rangeCV + 1)+':'
self.lbl20.text = 'CV' + str(rangeCV + 2)+':'
self.lbl30.text = 'CV' + str(rangeCV + 3)+':'
self.lbl40.text = 'CV' + str(rangeCV + 4)+':'
self.lbl50.text = 'CV' + str(rangeCV + 5)+':'
self.lbl60.text = 'CV' + str(rangeCV + 6)+':'
def VoltageHide(self):
if self.b10001.text=="PITCH": self.b30001.pos=479,320
else: self.b30001.pos=1479,320
if self.b10002.text=="PITCH": self.b30002.pos=479,260
else: self.b30002.pos=1479,320
if self.b10003.text=="PITCH": self.b30003.pos=479,200
else: self.b30003.pos=1479,320
if self.b10004.text=="PITCH": self.b30004.pos=479,140
else: self.b30004.pos=1479,320
if self.b10005.text=="PITCH": self.b30005.pos=479,80
else: self.b30005.pos=1479,320
if self.b10006.text=="PITCH": self.b30006.pos=479,20
else: self.b30006.pos=1479,320
#self.NoneHide()
def NoneHide(self):
if self.b20001.text!="NONE": self.b10001.pos=328,320
else: self.b10001.pos=1479,320
if self.b20002.text!="NONE": self.b10002.pos=328,260
else: self.b10002.pos=1479,320
if self.b20003.text!="NONE": self.b10003.pos=328,200
else: self.b10003.pos=1479,320
if self.b20004.text!="NONE": self.b10004.pos=328,140
else: self.b10004.pos=1479,320
if self.b20005.text!="NONE": self.b10005.pos=328,80
else: self.b10005.pos=1479,320
if self.b20006.text!="NONE": self.b10006.pos=328,20
else: self.b10006.pos=1479,320
def midiportselect(self):
self.b4000.pos=328,120
self.b4001.pos=329,121
self.b4002.pos=329,182
self.b4003.text="MIDI PORT:"
self.b4001.text="DIN"
self.b4002.text="USB"
self.b4003.pos=329,243
self.b3005.pos=0,0
def midichannelselect(self):
self.b5017.pos=310,305
self.b5017.text="MIDI CHANNEL:"
self.b5000.pos=138,31
self.b5001.pos=139,236
self.b5005.pos=139,168
self.b5009.pos=139,100
self.b5013.pos=139,32
self.b5002.pos=269,236
self.b5006.pos=269,168
self.b5010.pos=269,100
self.b5014.pos=269,32
self.b5003.pos=399,236
self.b5007.pos=399,168
self.b5011.pos=399,100
self.b5015.pos=399,32
self.b5004.pos=529,236
self.b5008.pos=529,168
self.b5012.pos=529,100
self.b5016.pos=529,32
self.b3005.pos=0,0
self.b5001.text="1"
self.b5005.text="5"
self.b5009.text="9"
self.b5013.text="13"
self.b5002.text="2"
self.b5006.text="6"
self.b5010.text="10"
self.b5014.text="14"
self.b5003.text="3"
self.b5007.text="7"
self.b5011.text="11"
self.b5015.text="15"
self.b5004.text="4"
self.b5008.text="8"
self.b5012.text="12"
self.b5016.text="16"
def CVTypeselect(self,b):
self.CVselected(b)
self.b4000.pos=328,120
self.b4002.pos=329,182
self.b4003.text="CV TYPE:"
self.b4003.pos=329,243
self.b3005.pos=0,0
if str(paramcf1["CV-map"][CVselectedparam-1]["Track"])!= "NONE":
#print('trackmode',trackmode)
#print(paramcf1["CV-map"][CVselectedparam-1]["Track"])
if trackmode[int(paramcf1["CV-map"][CVselectedparam-1]["Track"])-1]==1 or trackmode[int(paramcf1["CV-map"][CVselectedparam-1]["Track"])-1]==4:
self.b4001.text="PITCH"
self.b4002.text="GATE"
self.b4001.pos=329,121
elif trackmode[int(paramcf1["CV-map"][CVselectedparam-1]["Track"])-1]==2:
self.b4002.text="LFO"
elif trackmode[int(paramcf1["CV-map"][CVselectedparam-1]["Track"])-1]==3:
self.b4002.text="ADSR"
elif trackmode[int(paramcf1["CV-map"][CVselectedparam-1]["Track"])-1]==5:
self.b4002.text="GATE"
else:
self.b4001.text="GATE"
self.b4002.text="PITCH"
self.b4001.pos=329,121
def CVtrack(self):
#CVselectedparam
pass
def CVTrackselect(self):
global rangeCVTrack
rangeCVTrack=0
self.b5017.pos=310,305
self.b5017.text="TRACK:"
self.b5000.pos=138,31
self.b5001.pos=139,236
self.b5005.pos=139,168
self.b5009.pos=139,100
self.b5013.pos=139,32
self.b5002.pos=269,236
self.b5006.pos=269,168
self.b5010.pos=269,100
self.b5014.pos=269,32
self.b5003.pos=399,236
self.b5007.pos=399,168
self.b5011.pos=399,100
self.b5015.pos=399,32
self.b5004.pos=529,236
self.b5008.pos=529,168
self.b5012.pos=529,100
self.b5016.pos=529,32
self.b3005.pos=0,0
self.b5001.text="1"
self.b5005.text="5"
self.b5009.text="9"
self.b5013.text="13"
self.b5002.text="2"
self.b5006.text="6"
self.b5010.text="10"
self.b5014.text="14"
self.b5003.text="3"
self.b5007.text="7"
self.b5011.text="11"
self.b5015.text="15"
self.b5004.text="4"
self.b5008.text="8"
self.b5012.text="12"
self.b5016.text="16"
def PPQselect(self):
self.b5017.pos=310,305
self.b5017.text="PPQ:"
self.b5000.pos=138,31
self.b5001.pos=139,236
self.b5005.pos=139,168
self.b5009.pos=139,100
self.b5013.pos=139,32
self.b5002.pos=269,236
self.b5006.pos=269,168
self.b5010.pos=269,100
self.b5014.pos=269,32
self.b5003.pos=399,236
self.b5007.pos=399,168
self.b5011.pos=399,100
self.b5015.pos=399,32
self.b5004.pos=529,236
self.b5008.pos=529,168
self.b5012.pos=529,100
self.b5016.pos=529,32
self.b3005.pos=0,0
self.b5001.text="/48"
self.b5005.text="/4"
self.b5009.text="4"
self.b5013.text="32"
self.b5002.text="/24"
self.b5006.text="/2"
self.b5010.text="8"
self.b5014.text="48"
self.b5003.text="/16"
self.b5007.text="1"
self.b5011.text="16"
self.b5015.text="64"
self.b5004.text="/8"
self.b5008.text="2"
self.b5012.text="24"
self.b5016.text="96"
def CVVoltageselect(self):
self.b4000.pos=328,120
self.b4001.pos=329,121
self.b4002.pos=329,182
self.b4001.text="[ -5V ; 5V ]"
self.b4002.text="[ 0V ; 10V ]"
self.b4003.pos=329,243
self.b4003.text="VOLTAGE:"
self.b3005.pos=0,0
def trackselected(self,button):
global trackselectedparam
for key, val in list(self.ids.items()):
if val==button: ID=key
trackselectedparam=int(ID[-3:])+rangeMidi
#print(trackselectedparam)
def CVselected(self,button):
global CVselectedparam
for key, val in list(self.ids.items()):
if val==button: ID=key
CVselectedparam=int(ID[-2:])+rangeCV
#print('CVselectedparam',CVselectedparam)
def port1(self,button):
global Sendinfo
for key, val in list(self.ids.items()):
if val==button: ID=key
new=(ID[-1:])
if self.b4003.text=="MIDI PORT:":
if int(new)==1: paramcf1["midi-map"][trackselectedparam-1]["port"] = "USB"
if int(new)==2: paramcf1["midi-map"][trackselectedparam-1]["port"] = "DIN"
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.midiupdate()
self.convert()
if self.b4003.text=="VOLTAGE:":
if int(new)==1: paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ 0V ; 10V ]"
if int(new)==2: paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.CVupdate()
self.convert()
if self.b4003.text=="CV TYPE:":
if self.b4001.text=="PITCH" and int(new)==2:
paramcf1["CV-map"][CVselectedparam-1]["Type"] = "PITCH"
paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
i=0
while i<12:
if paramcf1["CV-map"][i]["Type"]== "PITCH" and i!=CVselectedparam-1 and paramcf1["CV-map"][i]["Track"]==paramcf1["CV-map"][CVselectedparam-1]["Track"]:
paramcf1["CV-map"][i]["Track"] = "NONE"
break
i+=1
if self.b4002.text=="LFO" and int(new)==1:
paramcf1["CV-map"][CVselectedparam-1]["Type"] = "LFO"
paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
i=0
while i<12:
if paramcf1["CV-map"][i]["Type"]== "LFO" and i!=CVselectedparam-1 and paramcf1["CV-map"][i]["Track"]==paramcf1["CV-map"][CVselectedparam-1]["Track"]:
paramcf1["CV-map"][i]["Track"] = "NONE"
break
i+=1
if self.b4002.text=="ADSR" and int(new)==1:
paramcf1["CV-map"][CVselectedparam-1]["Type"] = "ADSR"
paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
i=0
while i<12:
if paramcf1["CV-map"][i]["Type"]== "ADSR" and i!=CVselectedparam-1 and paramcf1["CV-map"][i]["Track"]==paramcf1["CV-map"][CVselectedparam-1]["Track"]:
paramcf1["CV-map"][i]["Track"] = "NONE"
break
i+=1
if self.b4002.text=="GATE" and int(new)==1:
paramcf1["CV-map"][CVselectedparam-1]["Type"] = "GATE"
paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
i=0
while i<12:
if paramcf1["CV-map"][i]["Type"]== "GATE" and i!=CVselectedparam-1 and paramcf1["CV-map"][i]["Track"]==paramcf1["CV-map"][CVselectedparam-1]["Track"]:
paramcf1["CV-map"][i]["Track"] = "NONE"
break
i+=1
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.CVupdate()
self.convert()
#print(Sendinfo)
def port2(self,button):
global Sendinfo
for key, val in list(self.ids.items()):
if val==button:
ID=key
new=int((ID[-2:]))
if self.b5017.text=="TRACK:":
new=int(new)+rangeCVTrack
paramcf1["CV-map"][CVselectedparam-1]["Track"] = str(new)
paramcf1["CV-map"][CVselectedparam-1]["Voltage"] = "[ -5V ; 5V ]"
i=0
while i<12:
if paramcf1["CV-map"][i]["Track"]== str(new) and i!=CVselectedparam-1 and paramcf1["CV-map"][i]["Type"]==paramcf1["CV-map"][CVselectedparam-1]["Type"]:
paramcf1["CV-map"][i]["Track"] = "NONE"
break
i+=1
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.CVupdate()
self.convert()
if self.b5017.text=="MIDI CHANNEL:":
paramcf1["midi-map"][trackselectedparam-1]["channel"] = str(new)
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.midiupdate()
self.convert()
print(Sendinfo)
if self.b5017.text=="PPQ:":
table=["/48","/24","/16","/8","/4","/2","1","2","4","8","16","24","32","48","64","96"]
print((str(table[new-1])))
paramcf1["sync"][2]["ppq"] = str(table[new-1])
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile: json.dump(paramcf1, jsonFile)
self.syncupdate()
self.convertsync()
#print(Sendinfo)
def convert(self):
i=0
j=0
k=0
while j<len(Sendinfo):
Sendinfo[j]=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
j+=1
while i<12:
if paramcf1["CV-map"][i]["Type"]=="PITCH" and paramcf1["CV-map"][i]["Track"]!="NONE":
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][1]=CVinfo[i][0]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][2]=CVinfo[i][1]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][7]=CVinfo[i][2]
if paramcf1["CV-map"][i]["Voltage"]=="[ 0V ; 10V ]":
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][5]=5
if paramcf1["CV-map"][i]["Type"]=="GATE" and paramcf1["CV-map"][i]["Track"]!="NONE":
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][3]=CVinfo[i][0]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][4]=CVinfo[i][1]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][8]=CVinfo[i][2]
if paramcf1["CV-map"][i]["Type"]=="LFO" and paramcf1["CV-map"][i]["Track"]!="NONE":
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][9]=CVinfo[i][0]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][10]=CVinfo[i][1]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][11]=CVinfo[i][2]
if paramcf1["CV-map"][i]["Type"]=="ADSR" and paramcf1["CV-map"][i]["Track"]!="NONE":
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][12]=CVinfo[i][0]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][13]=CVinfo[i][1]
Sendinfo[int(paramcf1["CV-map"][i]["Track"])-1][14]=CVinfo[i][2]
i+=1
while k<len(Sendinfo):
Sendinfo[k][0]=int(paramcf1["midi-map"][k]["channel"])
if paramcf1["midi-map"][k]["port"]=="USB": Sendinfo[k][6]=1
if paramcf1["midi-map"][k]["port"]=="DIN": Sendinfo[k][6]=2
k+=1
if start==1:
q4.put(Sendinfo)
r1.put(Sendinfo)
s1.put(Sendinfo)
return Sendinfo
def convertsync(self):
table=["/48","/24","/16","/8","/4","/2","1","2","4","8","16","24","32","48","64","96"]
#pulse per quarter note => x4 = pulses per note => xBPM= pulses per minutes
#tableinv=[1/720,1/360,1/240,1/120,1/60,2/60,4/60,8/60,16/60,32/60,64/60,96/60,128/60,192/60,256/60,384/60]
tableinv=[0.00138888,0.00277777,0.00416666,0.00833333,0.01666666,0.03333333,0.06666666,0.13333333,0.26666666,0.53333333,1.06666666,1.6,2.13333333,3.2,4.26666666,6.4]
if paramcf1['sync'][0]["midi-din"]=="on": Syncinfo[0]=1
else: Syncinfo[0]=0
if paramcf1['sync'][1]["midi-usb"]=="on": Syncinfo[1]=1
else: Syncinfo[1]=0
for i,elem in enumerate(table):
if paramcf1['sync'][2]["ppq"]==str(elem): Syncinfo[2]=tableinv[i]
if paramcf1['sync'][3]["BPMmult"]=="1": Syncinfo[3]=1
else: Syncinfo[3]=2
if paramcf1['sync'][4]["USBstate"]=="in": Syncinfo[4]=1
else: Syncinfo[4]=0
#print(Syncinfo)
if start==1:
q5.put(Syncinfo)
r3.put(Syncinfo)
s3.put(Syncinfo)
return Syncinfo
def MIDIsync(self):
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile:
if self.b100001.text=='Off':
print ("on")
self.b100001.text='On'
paramcf1["sync"][0]["midi-din"] = "on"
else:
print("off")
self.b100001.text='Off'
paramcf1["sync"][0]["midi-din"] = "off"
json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile:
if self.b100001.text=='Off':
print ("on")
self.b100001.text='On'
paramcf1["sync"][0]["midi-din"] = "on"
else:
print("off")
self.b100001.text='Off'
paramcf1["sync"][0]["midi-din"] = "off"
json.dump(paramcf1, jsonFile)
self.convertsync()
def USBsync(self):
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile:
if self.b100002.text=='Off':
self.b100002.text='On'
print ("on")
paramcf1["sync"][1]["midi-usb"] = "on"
else:
print("off")
self.b100002.text='Off'
paramcf1["sync"][1]["midi-usb"] = "off"
json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile:
if self.b100002.text=='Off':
self.b100002.text='On'
print ("on")
paramcf1["sync"][1]["midi-usb"] = "on"
else:
print("off")
self.b100002.text='Off'
paramcf1["sync"][1]["midi-usb"] = "off"
json.dump(paramcf1, jsonFile)
self.convertsync()
def DINin(self):
if self.b100006.text=='Off':
self.b100006.text='On'
x1.value=1
else:
self.b100006.text='Off'
x1.value=0
print(x1.value)
def SyncIn(self):
if self.b100007.text=='Off':
self.b100007.text='USB'
y1.value=1
elif self.b100007.text=='USB':
self.b100007.text='DIN'
y1.value=2
else:
self.b100007.text='Off'
y1.value=0
def BPMmult(self):
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile:
if self.b100004.text=='24':
self.b100004.text='48'
print ("x2")
paramcf1["sync"][3]["BPMmult"] = "2"
else:
print("x1")
self.b100004.text='24'
paramcf1["sync"][3]["BPMmult"] = "1"
json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile:
if self.b100004.text=='24':
self.b100004.text='48'
print ("x2")
paramcf1["sync"][3]["BPMmult"] = "2"
else:
print("x1")
self.b100004.text='24'
paramcf1["sync"][3]["BPMmult"] = "1"
json.dump(paramcf1, jsonFile)
self.convertsync()
def USBstate(self):
if rpi==1:
with open("/home/pi/Desktop2/UIP/param.json", "w") as jsonFile:
if self.b100005.text=='In':
self.b100005.text='Out'
print ("out")
paramcf1["sync"][4]["USBstate"] = "out"
else:
print("in")
self.b100005.text='In'
paramcf1["sync"][4]["USBstate"] = "in"
json.dump(paramcf1, jsonFile)
else:
with open("param.json", "w") as jsonFile:
if self.b100005.text=='In':
self.b100005.text='Out'
print ("out")
paramcf1["sync"][4]["USBstate"] = "out"
else:
print("in")
self.b100005.text='In'
paramcf1["sync"][4]["USBstate"] = "in"
json.dump(paramcf1, jsonFile)
self.convertsync()
def closemenu(self):
self.b4000.pos=1328,1120
self.b4001.pos=1329,1121
self.b4002.pos=1329,1182
self.b4003.pos=1329,1243
self.b5017.pos=1329,305
self.b5000.pos=1228,61
self.b5001.pos=1229,245
self.b5005.pos=1229,184
self.b5009.pos=1229,123
self.b5013.pos=1229,62
self.b5002.pos=1329,245
self.b5006.pos=1329,184
self.b5010.pos=1329,123
self.b5014.pos=1329,62
self.b5003.pos=1429,245
self.b5007.pos=1429,184
self.b5011.pos=1429,123
self.b5015.pos=1429,62
self.b5004.pos=1529,245
self.b5008.pos=1529,184
self.b5012.pos=1529,123
self.b5016.pos=1529,62
self.b3005.pos=1000,0
self.clear()
def clearStep(self,button):
button.state="normal"
def clear(self):
for val in list(self.ids.items()):
if (str(val[0])== str('b001') or val[0]== 'b002' or val[0]== 'b003' or val[0]== 'b004'): pass
else: self.clearStep(val[1])
def scrollDownMIDI(self):
global rangeMidi
if rangeMidi < 10:
self.b2001.text = paramcf1['midi-map'][rangeMidi + 1]["channel"]
self.b2002.text = paramcf1['midi-map'][rangeMidi + 2]["channel"]
self.b2003.text = paramcf1['midi-map'][rangeMidi + 3]["channel"]
self.b2004.text = paramcf1['midi-map'][rangeMidi + 4]["channel"]
self.b2005.text = paramcf1['midi-map'][rangeMidi + 5]["channel"]
self.b2006.text = paramcf1['midi-map'][rangeMidi + 6]["channel"]
self.b1001.text = paramcf1['midi-map'][rangeMidi + 1]["port"]
self.b1002.text = paramcf1['midi-map'][rangeMidi + 2]["port"]
self.b1003.text = paramcf1['midi-map'][rangeMidi + 3]["port"]
self.b1004.text = paramcf1['midi-map'][rangeMidi + 4]["port"]
self.b1005.text = paramcf1['midi-map'][rangeMidi + 5]["port"]
self.b1006.text = paramcf1['midi-map'][rangeMidi + 6]["port"]
self.lbl1.text = 'Track' + str(rangeMidi + 2)+':'
self.lbl2.text = 'Track' + str(rangeMidi + 3)+':'
self.lbl3.text = 'Track' + str(rangeMidi + 4)+':'
self.lbl4.text = 'Track' + str(rangeMidi + 5)+':'
self.lbl5.text = 'Track' + str(rangeMidi + 6)+':'
self.lbl6.text = 'Track' + str(rangeMidi + 7)+':'
rangeMidi+= 1
def scrollUpMIDI(self):
global rangeMidi
if rangeMidi > 0:
self.b2001.text = paramcf1['midi-map'][rangeMidi - 1]["channel"]
self.b2002.text = paramcf1['midi-map'][rangeMidi]["channel"]
self.b2003.text = paramcf1['midi-map'][rangeMidi + 1]["channel"]
self.b2004.text = paramcf1['midi-map'][rangeMidi + 2]["channel"]
self.b2005.text = paramcf1['midi-map'][rangeMidi + 3]["channel"]
self.b2006.text = paramcf1['midi-map'][rangeMidi + 4]["channel"]
self.b1001.text = paramcf1['midi-map'][rangeMidi - 1]["port"]
self.b1002.text = paramcf1['midi-map'][rangeMidi]["port"]
self.b1003.text = paramcf1['midi-map'][rangeMidi + 1]["port"]
self.b1004.text = paramcf1['midi-map'][rangeMidi + 2]["port"]
self.b1005.text = paramcf1['midi-map'][rangeMidi + 3]["port"]
self.b1006.text = paramcf1['midi-map'][rangeMidi + 4]["port"]
self.lbl1.text = 'Track' + str(rangeMidi)+':'
self.lbl2.text = 'Track' + str(rangeMidi + 1)+':'
self.lbl3.text = 'Track' + str(rangeMidi + 2)+':'
self.lbl4.text = 'Track' + str(rangeMidi + 3)+':'
self.lbl5.text = 'Track' + str(rangeMidi + 4)+':'
self.lbl6.text = 'Track' + str(rangeMidi + 5)+':'
rangeMidi-= 1
def scrollDownCV(self):
global rangeCV
if rangeCV < 6:
self.b20001.text = paramcf1['CV-map'][rangeCV + 1]["Track"]
self.b20002.text = paramcf1['CV-map'][rangeCV + 2]["Track"]
self.b20003.text = paramcf1['CV-map'][rangeCV + 3]["Track"]
self.b20004.text = paramcf1['CV-map'][rangeCV + 4]["Track"]
self.b20005.text = paramcf1['CV-map'][rangeCV + 5]["Track"]
self.b20006.text = paramcf1['CV-map'][rangeCV + 6]["Track"]
self.b10001.text = paramcf1['CV-map'][rangeCV + 1]["Type"]
self.b10002.text = paramcf1['CV-map'][rangeCV + 2]["Type"]
self.b10003.text = paramcf1['CV-map'][rangeCV + 3]["Type"]
self.b10004.text = paramcf1['CV-map'][rangeCV + 4]["Type"]
self.b10005.text = paramcf1['CV-map'][rangeCV + 5]["Type"]
self.b10006.text = paramcf1['CV-map'][rangeCV + 6]["Type"]
self.b30001.text = paramcf1['CV-map'][rangeCV + 1]["Voltage"]
self.b30002.text = paramcf1['CV-map'][rangeCV + 2]["Voltage"]
self.b30003.text = paramcf1['CV-map'][rangeCV + 3]["Voltage"]
self.b30004.text = paramcf1['CV-map'][rangeCV + 4]["Voltage"]
self.b30005.text = paramcf1['CV-map'][rangeCV + 5]["Voltage"]
self.b30006.text = paramcf1['CV-map'][rangeCV + 6]["Voltage"]
self.lbl10.text = 'CV' + str(rangeCV + 2)+':'
self.lbl20.text = 'CV' + str(rangeCV + 3)+':'
self.lbl30.text = 'CV' + str(rangeCV + 4)+':'
self.lbl40.text = 'CV' + str(rangeCV + 5)+':'
self.lbl50.text = 'CV' + str(rangeCV + 6)+':'
self.lbl60.text = 'CV' + str(rangeCV + 7)+':'
rangeCV+= 1
self.VoltageHide()
def scrollUpCV(self):
global rangeCV
if rangeCV > 0:
self.b20001.text = paramcf1['CV-map'][rangeCV - 1]["Track"]
self.b20002.text = paramcf1['CV-map'][rangeCV]["Track"]
self.b20003.text = paramcf1['CV-map'][rangeCV + 1]["Track"]
self.b20004.text = paramcf1['CV-map'][rangeCV + 2]["Track"]
self.b20005.text = paramcf1['CV-map'][rangeCV + 3]["Track"]
self.b20006.text = paramcf1['CV-map'][rangeCV + 4]["Track"]
self.b10001.text = paramcf1['CV-map'][rangeCV - 1]["Type"]
self.b10002.text = paramcf1['CV-map'][rangeCV]["Type"]
self.b10003.text = paramcf1['CV-map'][rangeCV + 1]["Type"]
self.b10004.text = paramcf1['CV-map'][rangeCV + 2]["Type"]
self.b10005.text = paramcf1['CV-map'][rangeCV + 3]["Type"]
self.b10006.text = paramcf1['CV-map'][rangeCV + 4]["Type"]
self.b30001.text = paramcf1['CV-map'][rangeCV - 1]["Voltage"]
self.b30002.text = paramcf1['CV-map'][rangeCV]["Voltage"]
self.b30003.text = paramcf1['CV-map'][rangeCV + 1]["Voltage"]
self.b30004.text = paramcf1['CV-map'][rangeCV + 2]["Voltage"]
self.b30005.text = paramcf1['CV-map'][rangeCV + 3]["Voltage"]
self.b30006.text = paramcf1['CV-map'][rangeCV + 4]["Voltage"]
self.lbl10.text = 'CV' + str(rangeCV)+':'
self.lbl20.text = 'CV' + str(rangeCV + 1)+':'
self.lbl30.text = 'CV' + str(rangeCV + 2)+':'
self.lbl40.text = 'CV' + str(rangeCV + 3)+':'
self.lbl50.text = 'CV' + str(rangeCV + 4)+':'
self.lbl60.text = 'CV' + str(rangeCV + 5)+':'
rangeCV-= 1
self.VoltageHide()
def scrollDownCVTrack(self):
global rangeCVTrack
if rangeCVTrack < 83:
self.b5001.text=str(rangeCVTrack+1)
self.b5005.text=str(rangeCVTrack+5)
self.b5009.text=str(rangeCVTrack+9)
self.b5013.text=str(rangeCVTrack+13)
self.b5002.text=str(rangeCVTrack+2)
self.b5006.text=str(rangeCVTrack+6)
self.b5010.text=str(rangeCVTrack+10)
self.b5014.text=str(rangeCVTrack+14)
self.b5003.text=str(rangeCVTrack+3)
self.b5007.text=str(rangeCVTrack+7)
self.b5011.text=str(rangeCVTrack+11)
self.b5015.text=str(rangeCVTrack+15)
self.b5004.text=str(rangeCVTrack+4)
self.b5008.text=str(rangeCVTrack+8)
self.b5012.text=str(rangeCVTrack+12)
self.b5016.text=str(rangeCVTrack+16)
rangeCVTrack+= 1
def scrollUpCVTrack(self):
global rangeCVTrack
if rangeCVTrack > 0:
self.b5001.text=str(rangeCVTrack-1)
self.b5005.text=str(rangeCVTrack+3)
self.b5009.text=str(rangeCVTrack+7)
self.b5013.text=str(rangeCVTrack+11)
self.b5002.text=str(rangeCVTrack)
self.b5006.text=str(rangeCVTrack+4)
self.b5010.text=str(rangeCVTrack+8)
self.b5014.text=str(rangeCVTrack+12)
self.b5003.text=str(rangeCVTrack+1)
self.b5007.text=str(rangeCVTrack+5)
self.b5011.text=str(rangeCVTrack+9)
self.b5015.text=str(rangeCVTrack+13)
self.b5004.text=str(rangeCVTrack+2)
self.b5008.text=str(rangeCVTrack+6)
self.b5012.text=str(rangeCVTrack+10)
self.b5016.text=str(rangeCVTrack+14)
rangeCVTrack-= 1
def kill(self):
print("poweroff")
if rpi==1: os.system("sudo poweroff")
def update(self):
print("updating.........")
if rpi==1:
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
#print(location)
if len(location)<1:
print('no usb stick detected')
self.b1000005.pos=320,170
self.b1000005.text='No USB stick detected'
else:
for root, dirs, files in os.walk("/media/pi/"+location):
if "CFM1update.zip" in files:
print("Updating.. Do not power off")
self.b1000005.pos=320,170
self.b1000005.text="Updating.. Do not power off"
try:
os.system("cp /media/pi/"+location+"/CFM1update.zip ~/Desktop2")
os.system("unzip ~/Desktop2/CFM1update.zip -d ~/Desktop2")
from distutils.dir_util import copy_tree
try:
copy_tree("/home/pi/Desktop2/CFM1update", "/home/pi/Desktop2/UIP")
os.system('rm /home/pi/Desktop2/CFM1update.zip')
os.system('rm -rf /home/pi/Desktop2/CFM1update')
os.system("sudo reboot")
except: print("copy tree error")
except: print("error updating")
break
else:
print("Update file not detected")
self.b1000005.pos=320,170
self.b1000005.text="Update file not detected"
def brightness(self,value):
command="sudo rpi-backlight -b"
brightness=str(value*2)
print((command + " " + brightness))
if rpi==1: os.system(command + " " + brightness)
def close(self):
if rpi==1:
GPIO.cleanup()
print("cleaned")
os.system('killall python')
def listening(self,*args):
global wheel
global buttonparam
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if self.b000000001.current_tab.text=="MIDI": buttonparam=0
elif self.b000000001.current_tab.text=="CV": buttonparam=1
if buttonparam==0:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.scrollDownMIDI()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.scrollUpMIDI()
if buttonparam==1:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.scrollDownCV()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.scrollUpCV()
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule param")
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class SongScreen(Screen):
def on_enter(self):
global seqbuttonmodesong
seqbuttonmodesong=0
self.mode(4)
self.b003.text=str(BPM)
self.loadseq()
#print(song)
Clock.schedule_interval(self.listening, 0.002)
w1.value=0
self.b004.text=str(loopsizeS/64)
self.loopbar()
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.movebar, 0.002)
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
self.movebarenter()
self.infos()
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
global projectmode
projectmode=0
def infos(self):
listinfo=[self.lbl8,self.lbl7,self.lbl6,self.lbl5,self.lbl4,self.lbl3,self.lbl2,self.lbl1]
if displayinfo==1:
for n,elem in enumerate(listinfo):
if trackmode[n+rangeYs]==1:
elem.text="SEQUENCE"
elem.pos[0]=46
elif trackmode[n+rangeYs]==2:
elem.text="LFO"
elem.pos[0]=18
elif trackmode[n+rangeYs]==3:
for i,value in enumerate(ADSRtrig):
if value==n+rangeYs+1:
elem.text="ADSR, TRIGGERED BY TRACK: " + str(i+1)
if i+1>9:elem.pos[0]=132
else:elem.pos[0]=128
break
else:
elem.text="ADSR, NO TRIGGER"
elem.pos[0]=79
elif trackmode[n+rangeYs]==4:
elem.text="RANDOM"
elem.pos[0]=38
elif trackmode[n+rangeYs]==5:
elem.text="EUCLIDEAN"
elem.pos[0]=48
else:
for n,elem in enumerate(listinfo):
elem.pos[0]=1000
def displayinfo(self):
global displayinfo
if displayinfo==0:
displayinfo=1
self.b0140.text="INFOS: ON"
else:
displayinfo=0
self.b0140.text="INFOS: OFF"
self.infos()
def menu(self):
if self.b007.state=="down":
#self.b008.pos= 648,360
self.b009.pos= 648,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b0140.pos= 344,900
self.b019.pos=1300,1120
self.b020.pos=1301,1121
self.b021.pos=1301,1182
self.b022.pos=1301,1243
self.b0222.pos=1301,1243
self.b0223.pos=1301,1243
self.b0224.pos=1301,1243
self.b0225.pos=1301,1243
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b800.state="normal"
self.b700.state="normal"
self.b600.state="normal"
self.b500.state="normal"
self.b400.state="normal"
self.b300.state="normal"
self.b200.state="normal"
self.b100.state="normal"
else:
#self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,301
self.b012.pos= 496,360
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b0140.pos= 344,900
self.b019.pos=1300,1120
self.b020.pos=1301,1121
self.b021.pos=1301,1182
self.b022.pos=1301,1243
self.b0222.pos=1301,1243
self.b0223.pos=1301,1243
self.b0224.pos=1301,1243
self.b0225.pos=1301,1243
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b800.state="normal"
self.b700.state="normal"
self.b600.state="normal"
self.b500.state="normal"
self.b400.state="normal"
self.b300.state="normal"
self.b200.state="normal"
self.b100.state="normal"
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
def file(self):
if self.b005.state=="down":
self.b013.pos= 344,301
self.b014.pos= 344,360
self.b0140.pos= 344,242
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b019.pos=1300,1120
self.b020.pos=1301,1121
self.b021.pos=1301,1182
self.b022.pos=1301,1243
self.b0222.pos=1301,1243
self.b0223.pos=1301,1243
self.b0224.pos=1301,1243
self.b0225.pos=1301,1243
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
self.b800.state="normal"
self.b700.state="normal"
self.b600.state="normal"
self.b500.state="normal"
self.b400.state="normal"
self.b300.state="normal"
self.b200.state="normal"
self.b100.state="normal"
else:
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b0140.pos= 344,900
self.b010.pos= 1000,0
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.file()
self.b019.pos=1300,1120
self.b020.pos=1301,1121
self.b021.pos=1301,1182
self.b022.pos=1301,1243
self.b0222.pos=1301,1243
self.b0223.pos=1301,1243
self.b0224.pos=1301,1243
self.b0225.pos=1301,1243
self.b010.pos= 1000,0
self.b800.state="normal"
self.b700.state="normal"
self.b600.state="normal"
self.b500.state="normal"
self.b400.state="normal"
self.b300.state="normal"
self.b200.state="normal"
self.b100.state="normal"
def start(self):
global playing
if self.b001.state=="down":
self.b001.text="%s"%(icon('icon-pause', 22))
playing=1
v1.value=1
Clock.schedule_interval(self.movebar, 0.002)
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
v1.value=2
Clock.unschedule(self.movebar)
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.movebar)
position=0
self.b015.pos=50,0
playing=0
v1.value=0
def moveXrgh(self):
global rangeXs
if (rangeXs+16)*4<=1021:
self.b901.text=str((rangeXs+1)*4+1)
self.b902.text=str((rangeXs+2)*4+1)
self.b903.text=str((rangeXs+3)*4+1)
self.b904.text=str((rangeXs+4)*4+1)
self.b905.text=str((rangeXs+5)*4+1)
self.b906.text=str((rangeXs+6)*4+1)
self.b907.text=str((rangeXs+7)*4+1)
self.b908.text=str((rangeXs+8)*4+1)
self.b909.text=str((rangeXs+9)*4+1)
self.b910.text=str((rangeXs+10)*4+1)
self.b911.text=str((rangeXs+11)*4+1)
self.b912.text=str((rangeXs+12)*4+1)
self.b913.text=str((rangeXs+13)*4+1)
self.b914.text=str((rangeXs+14)*4+1)
self.b915.text=str((rangeXs+15)*4+1)
self.b916.text=str((rangeXs+16)*4+1)
rangeXs=rangeXs+1
print(rangeXs)
self.loadseq()
def moveXlft(self):
global rangeXs
if rangeXs>=1:
self.b901.text=str((rangeXs-1)*4+1)
self.b902.text=str((rangeXs)*4+1)
self.b903.text=str((rangeXs+1)*4+1)
self.b904.text=str((rangeXs+2)*4+1)
self.b905.text=str((rangeXs+3)*4+1)
self.b906.text=str((rangeXs+4)*4+1)
self.b907.text=str((rangeXs+5)*4+1)
self.b908.text=str((rangeXs+6)*4+1)
self.b909.text=str((rangeXs+7)*4+1)
self.b910.text=str((rangeXs+8)*4+1)
self.b911.text=str((rangeXs+9)*4+1)
self.b912.text=str((rangeXs+10)*4+1)
self.b913.text=str((rangeXs+11)*4+1)
self.b914.text=str((rangeXs+12)*4+1)
self.b915.text=str((rangeXs+13)*4+1)
self.b916.text=str((rangeXs+14)*4+1)
rangeXs=rangeXs-1
self.loadseq()
def moveYup(self):
global rangeYs
if rangeYs<=7:
self.b100.text=str(rangeYs+9)
self.b200.text=str(rangeYs+8)
self.b300.text=str(rangeYs+7)
self.b400.text=str(rangeYs+6)
self.b500.text=str(rangeYs+5)
self.b600.text=str(rangeYs+4)
self.b700.text=str(rangeYs+3)
self.b800.text=str(rangeYs+2)
rangeYs=rangeYs+1
self.loadseq()
self.infos()
def moveYdw(self):
global rangeYs
if rangeYs>=1:
self.b100.text=str(rangeYs+7)
self.b200.text=str(rangeYs+6)
self.b300.text=str(rangeYs+5)
self.b400.text=str(rangeYs+4)
self.b500.text=str(rangeYs+3)
self.b600.text=str(rangeYs+2)
self.b700.text=str(rangeYs+1)
self.b800.text=str(rangeYs)
rangeYs=rangeYs-1
self.loadseq()
self.infos()
def loadseq(self):
self.clear()
i=0
#print('looading song',song)
while i <16:
for elem in song[rangeXs+i]:
elemY=elem-rangeYs
elemX=i+1
if elemY <=8:
elemY=-(int(elemY)-9)
if elemX<10: b="b"+str(elemY)+"0"+str(elemX)
else: b="b"+str(elemY)+str(elemX)
self.findButton(b)
i+=1
self.loopbar()
self.movebar()
def findButton(self,button):
for val in list(self.ids.items()):
if button==val[0]:
buttonfound=val[1]
buttonfound.state="down"
def loopbar(self):
loopbar_pos=v3.value/16
if loopbar_pos<=(rangeXs+16)*4:
if 48+(loopbar_pos/4-rangeXs)*47>=5: self.b017.pos=48+(loopbar_pos/4-rangeXs)*47,0
else: self.b017.pos=1000,1000
else: self.b017.pos=1000,1000
def movebarenter(self):
countbar=v2.value%loopsizeS
speed=47.1/64
position=int(50+round((countbar-rangeX*64)*speed))
position=(position/12)*12
if position<50: self.b015.pos=1000,0
else: self.b015.pos=position,0
def movebar(self, *args):
countbar=v2.value%loopsizeS
speed=47.1/64
position=int(50+round((countbar-rangeXs*64)*speed))
if v2.value%16==0:
if position<50: self.b015.pos=1000,0
else: self.b015.pos=position,0
def clearStep(self,button):
button.state="normal"
def clear(self):
for val in list(self.ids.items()):
if (str(val[0])== str('b001') or val[0]== 'b002' or val[0]== 'b003' or val[0]== 'b004'): pass
else: self.clearStep(val[1])
def monitor(self, button):
global song
global buttonpushedsong
for key, val in list(self.ids.items()):
if val==button: ID=key
y=int(ID[1])
yp=-(y-8)
x=int(ID[-2:])
buttonpushedsong=ID
if button.state=="normal":
song[x+rangeXs-1].remove(yp+rangeYs+1)
else:
song[x+rangeXs-1].append(yp+rangeYs+1)
song[x+rangeXs-1]=sorted(song[x+rangeXs-1])
q3.put(song)
def trackmenu(self,button):
global trackselected
for key, val in list(self.ids.items()):
if val==button: ID=key
trackselected=-(int(ID[1])-9)+rangeYs
r2.put(trackselected)
s2.put(trackselected)
v5.value=trackselected
self.b010.pos=0,0
self.b019.pos=300,120
self.b020.pos=301,121
self.b021.pos=301,182
if trackmode[trackselected-1]==1:
self.b022.pos=301,243
elif trackmode[trackselected-1]==2:
self.b0222.pos=301,243
elif trackmode[trackselected-1]==3:
self.b0223.pos=301,243
elif trackmode[trackselected-1]==4:
self.b0224.pos=301,243
elif trackmode[trackselected-1]==5:
self.b0225.pos=301,243
def cleartrack(self):
global song
for elem in song:
if trackselected in elem: elem.remove(trackselected)
q3.put(song)
self.loadseq()
def on_touch_move(self, touch):
global buttonpushedsong
if self.collide_point(*touch.pos):
x=touch.pos[0]-50
y=touch.pos[1]
bx=int(x/47+1)
by=int(y/47+1)
byc=8-by
if (bx>int(buttonpushedsong[-2:]) and by==int(buttonpushedsong[1])):
if bx<=9: b="b"+str(by)+"0"+str(bx)
else: b="b"+str(by)+str(bx)
for val in list(self.ids.items()):
if val[0]==b:
if val[1].state=='normal':
val[1].state='down'
song[bx+rangeXs-1].append(byc+rangeYs+1)
song[bx+rangeXs-1]=sorted(song[bx+rangeXs-1])
q3.put(song)
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule song")
def mode(self,num):
global seqbuttonmodesong
if num==2:
if seqbuttonmodesong==2:
seqbuttonmodesong=0
self.b003.state='normal'
else:
seqbuttonmodesong=2
self.b003.state='down'
w2.value=0
if num==3:
if seqbuttonmodesong==3:
seqbuttonmodesong=0
self.b004.state='normal'
else:
seqbuttonmodesong=3
self.b004.state='down'
w2.value=0
if num==4:
seqbuttonmodesong=0
self.b003.state='normal'
self.b004.state='normal'
print("button mode",seqbuttonmodesong)
def listening(self,*args):
global wheel
global seqbuttonmodesong
global loopsizeS
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if seqbuttonmodesong==0:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
if encoderpushed==1: self.moveXrgh()
else: self.moveYup()
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
if encoderpushed==1: self.moveXlft()
else: self.moveYdw()
if seqbuttonmodesong==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
seqbuttonmodesong=0
self.b003.state='normal'
if seqbuttonmodesong==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsizeS<256*64:
loopsizeS+=64
v3.value=loopsizeS
self.b004.text=str(loopsizeS/64)
self.loopbar()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsizeS>64:
loopsizeS-=64
v3.value=loopsizeS
self.b004.text=str(loopsizeS/64)
self.loopbar()
if encoderpushed==1:
seqbuttonmodesong=0
self.b004.state='normal'
global playing
if v1.value==1 and playing==0:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
Clock.schedule_interval(self.movebar, 0.002)
elif v1.value==0 and playing==1:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
Clock.unschedule(self.movebar)
self.b015.pos=50,0
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class SeqScreen(Screen):
def on_enter(self):
global start
global rangeY
global rangeX
global zoom
global trackmode
global seqbuttonmode
seqbuttonmode=0
if trackmode[trackselected-1]!=1:clearsequence()
trackmode[trackselected-1]=1
print('trackmode',trackmode[trackselected-1])
print('trackselected',trackselected)
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
#self.deleteADSR()
#self.deleteLFO()
deleteLFO()
deleteADSR()
if start > 0:
self.mode(4)
rangeY=36
rangeX=0
zoom=4
self.LoopSdisplay()
self.b003.text=str(BPM)
self.loadseq()
self.b901.text=timerange[rangeX]
self.b902.text=timerange[rangeX+1*(zoom)]
self.b903.text=timerange[rangeX+2*(zoom)]
self.b904.text=timerange[rangeX+3*(zoom)]
self.b905.text=timerange[rangeX+4*(zoom)]
self.b906.text=timerange[rangeX+5*(zoom)]
self.b907.text=timerange[rangeX+6*(zoom)]
self.b908.text=timerange[rangeX+7*(zoom)]
self.b909.text=timerange[rangeX+8*(zoom)]
self.b910.text=timerange[rangeX+9*(zoom)]
self.b911.text=timerange[rangeX+10*(zoom)]
self.b912.text=timerange[rangeX+11*(zoom)]
self.b913.text=timerange[rangeX+12*(zoom)]
self.b914.text=timerange[rangeX+13*(zoom)]
self.b915.text=timerange[rangeX+14*(zoom)]
self.b916.text=timerange[rangeX+15*(zoom)]
self.b100.text=keyrange[rangeY][0]
self.b200.text=keyrange[rangeY+1][0]
self.b300.text=keyrange[rangeY+2][0]
self.b400.text=keyrange[rangeY+3][0]
self.b500.text=keyrange[rangeY+4][0]
self.b600.text=keyrange[rangeY+5][0]
self.b700.text=keyrange[rangeY+6][0]
self.b800.text=keyrange[rangeY+7][0]
if keyrange[rangeY][1]==0:
self.b100.background_color= (0,0,0,0.7)
self.b100.color= 1,1,1,1
else:
self.b100.background_color= 255,255,255,0.8
self.b100.color= 0,0,0,1
if keyrange[rangeY+1][1]==0:
self.b200.background_color= (0,0,0,0.7)
self.b200.color= 1,1,1,1
else:
self.b200.background_color= 255,255,255,0.8
self.b200.color= 0,0,0,1
if keyrange[rangeY+2][1]==0:
self.b300.background_color= (0,0,0,0.7)
self.b300.color= 1,1,1,1
else:
self.b300.background_color= 255,255,255,0.8
self.b300.color= 0,0,0,1
if keyrange[rangeY+3][1]==0:
self.b400.background_color= (0,0,0,0.7)
self.b400.color= 1,1,1,1
else:
self.b400.background_color= 255,255,255,0.8
self.b400.color= 0,0,0,1
if keyrange[rangeY+4][1]==0:
self.b500.background_color= (0,0,0,0.7)
self.b500.color= 1,1,1,1
else:
self.b500.background_color= 255,255,255,0.8
self.b500.color= 0,0,0,1
if keyrange[rangeY+5][1]==0:
self.b600.background_color= (0,0,0,0.7)
self.b600.color= 1,1,1,1
else:
self.b600.background_color= 255,255,255,0.8
self.b600.color= 0,0,0,1
if keyrange[rangeY+6][1]==0:
self.b700.background_color= (0,0,0,0.7)
self.b700.color= 1,1,1,1
else:
self.b700.background_color= 255,255,255,0.8
self.b700.color= 0,0,0,1
if keyrange[rangeY+7][1]==0:
self.b800.background_color= (0,0,0,0.7)
self.b800.color= 1,1,1,1
else:
self.b800.background_color= 255,255,255,0.8
self.b800.color= 0,0,0,1
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.movebar, 0.002)
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
self.movebarenter()
self.b006.text=str(trackselected)+ ": SEQUENCE"
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
else: start = start +1
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
def monitor(self, button):
global sequencepool2
global sequencepool3
global buttonpushed
global xseq
global yseq
for key, val in list(self.ids.items()):
if val==button: ID=key
yseq=int(ID[1])
xseq=int(ID[-2:])
buttonpushed=ID
if button.state=="normal":
print(("x",(xseq-1)*zoom+rangeX+1))
print(("y",yseq+rangeY-1))
for elem in sequencepool2[trackselected-1]:
if elem[0]==(xseq-1)*zoom+rangeX+1 and elem[1]==yseq+rangeY-1 and elem[2]==1:
duration=elem[3]
break
try:
sequencepool2[trackselected-1].remove([(xseq-1)*zoom+rangeX+1,yseq+rangeY-1,1,duration])
sequencepool2[trackselected-1].remove([(xseq-1)*zoom+rangeX+1+duration,yseq+rangeY-1,0,duration])
except:
print("******* Note 2 error ********")
for elem in sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX]:
if sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX][0]==yseq+rangeY-1:
duration=elem[2]
break
try:
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX].remove([yseq+rangeY-1,1,duration])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+duration].remove([yseq+rangeY-1,0,duration])
except: print("******* Note 3 error ********")
self.loadseq()
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
if button.background_color==[0.3, 0.7, 1, 1]:
i=0
for elem in sequencepool2[trackselected-1]:
if elem[1]==yseq+rangeY-1 and elem[2]==1: result=i
if elem[0]>(xseq-1)*zoom+rangeX+1: break
i+=1
try:
i=result
removed=sequencepool2[trackselected-1][i]
sequencepool2[trackselected-1].remove(removed)
removed[0]=removed[0]+removed[3]
removed[2]=0
sequencepool2[trackselected-1].remove(removed)
except: print("******* Chords 2 error ********")
j=0
for elem in sequencepool3[trackselected-1]:
if len(elem)>0:
if j > (xseq-1)*zoom+rangeX+1: break
for elem2 in elem:
if elem2[0]==yseq+rangeY-1 and elem2[1]==1: result2=j
j+=1
try:
for elem in sequencepool3[trackselected-1][result2]:
if elem[0]==yseq+rangeY-1 and elem[1]==1:
duration=elem[2]
break
except: print("******* Chords 3 error ********")
try:
sequencepool3[trackselected-1][result2].remove([yseq+rangeY-1,1,duration])
sequencepool3[trackselected-1][result2+duration].remove([yseq+rangeY-1,0,duration])
except: print("******* Chords 3 error ********")
#print(sequencepool3[trackselected-1])
self.loadseq()
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
if button.state=="down":
sequencepool2[trackselected-1].append([(xseq-1)*zoom+rangeX+1+zoom,yseq+rangeY-1,0,zoom])
sequencepool2[trackselected-1].append([(xseq-1)*zoom+rangeX+1,yseq+rangeY-1,1,zoom])
sequencepool2[trackselected-1]=sorted(sequencepool2[trackselected-1], key=operator.itemgetter(0,2))
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+zoom].append([yseq+rangeY-1,0,zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+zoom]=sorted(sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+zoom],key=operator.itemgetter(1,0))
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX].append([yseq+rangeY-1,1,zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX]=sorted(sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX],key=operator.itemgetter(1,0))
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
def clearsequence(self):
global sequencepool2
global sequencepool3
sequencepool2[trackselected-1]=[]
for i,elem in enumerate(sequencepool3[trackselected-1]): sequencepool3[trackselected-1][i]=[]
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
print((sequencepool3[trackselected-1]))
def clearStep(self,button):
button.state="normal"
def clear(self):
for val in list(self.ids.items()):
if (str(val[0])== str('b001') or val[0]== 'b002' or val[0]== 'b003' or val[0]== 'b004' or val[0]=='b020'):pass
else:
if int(val[0][1])>0 and int(val[0][1])<9 and int(val[0][-2:])>0:
self.clearStep(val[1])
val[1].background_color= .68,.68,.84,1
else: self.clearStep(val[1])
def zoomstep(self,button,text):
button.text=text
def zoom(self):
global rangeX
for val in list(self.ids.items()):
bty=int(val[0][1])
btx=int(val[0][-2:])
if bty ==9:
if rangeX+16*(zoom)<=rangeXmax:
if rangeX%zoom == 0:
btn=(btx-1)*zoom+rangeX
self.zoomstep(val[1],timerange[btn])
else:
rangeX = rangeX-(rangeX%zoom)
btn=(btx-1)*zoom+rangeX
print("not multiple")
self.zoomstep(val[1],timerange[btn])
else:
rangeX=128*7
btn=(btx-1)*zoom+rangeX
print("resized")
self.zoomstep(val[1],timerange[btn])
self.loadseq()
def zoomout(self):
global zoom
global rangeX
if zoom <8:
zoom = 2*zoom
self.zoom()
def zoomin(self):
global zoom
global rangeX
if zoom >1:
zoom = zoom/2
self.zoom()
def moveXrgh(self):
global rangeX
if rangeX+16*(zoom)<=rangeXmax:
self.b901.text=timerange[rangeX+1*(zoom)]
self.b902.text=timerange[rangeX+2*(zoom)]
self.b903.text=timerange[rangeX+3*(zoom)]
self.b904.text=timerange[rangeX+4*(zoom)]
self.b905.text=timerange[rangeX+5*(zoom)]
self.b906.text=timerange[rangeX+6*(zoom)]
self.b907.text=timerange[rangeX+7*(zoom)]
self.b908.text=timerange[rangeX+8*(zoom)]
self.b909.text=timerange[rangeX+9*(zoom)]
self.b910.text=timerange[rangeX+10*(zoom)]
self.b911.text=timerange[rangeX+11*(zoom)]
self.b912.text=timerange[rangeX+12*(zoom)]
self.b913.text=timerange[rangeX+13*(zoom)]
self.b914.text=timerange[rangeX+14*(zoom)]
self.b915.text=timerange[rangeX+15*(zoom)]
self.b916.text=timerange[rangeX+16*(zoom)]
rangeX=rangeX+zoom
self.loadseq()
def moveXlft(self):
global rangeX
if rangeX>=1:
self.b901.text=timerange[rangeX-1*(zoom)]
self.b902.text=timerange[rangeX]
self.b903.text=timerange[rangeX+1*(zoom)]
self.b904.text=timerange[rangeX+2*(zoom)]
self.b905.text=timerange[rangeX+3*(zoom)]
self.b906.text=timerange[rangeX+4*(zoom)]
self.b907.text=timerange[rangeX+5*(zoom)]
self.b908.text=timerange[rangeX+6*(zoom)]
self.b909.text=timerange[rangeX+7*(zoom)]
self.b910.text=timerange[rangeX+8*(zoom)]
self.b911.text=timerange[rangeX+9*(zoom)]
self.b912.text=timerange[rangeX+10*(zoom)]
self.b913.text=timerange[rangeX+11*(zoom)]
self.b914.text=timerange[rangeX+12*(zoom)]
self.b915.text=timerange[rangeX+13*(zoom)]
self.b916.text=timerange[rangeX+14*(zoom)]
rangeX=rangeX-zoom
self.loadseq()
def moveYup(self):
global rangeY
if rangeY<=87:
self.b100.text=keyrange[rangeY+1][0]
self.b200.text=keyrange[rangeY+2][0]
self.b300.text=keyrange[rangeY+3][0]
self.b400.text=keyrange[rangeY+4][0]
self.b500.text=keyrange[rangeY+5][0]
self.b600.text=keyrange[rangeY+6][0]
self.b700.text=keyrange[rangeY+7][0]
self.b800.text=keyrange[rangeY+8][0]
if keyrange[rangeY+1][1]==0:
self.b100.background_color= (0,0,0,0.7)
self.b100.color= 1,1,1,1
else:
self.b100.background_color= 255,255,255,0.8
self.b100.color= 0,0,0,1
if keyrange[rangeY+2][1]==0:
self.b200.background_color= (0,0,0,0.7)
self.b200.color= 1,1,1,1
else:
self.b200.background_color= 255,255,255,0.8
self.b200.color= 0,0,0,1
if keyrange[rangeY+3][1]==0:
self.b300.background_color= (0,0,0,0.7)
self.b300.color= 1,1,1,1
else:
self.b300.background_color= 255,255,255,0.8
self.b300.color= 0,0,0,1
if keyrange[rangeY+4][1]==0:
self.b400.background_color= (0,0,0,0.7)
self.b400.color= 1,1,1,1
else:
self.b400.background_color= 255,255,255,0.8
self.b400.color= 0,0,0,1
if keyrange[rangeY+5][1]==0:
self.b500.background_color= (0,0,0,0.7)
self.b500.color= 1,1,1,1
else:
self.b500.background_color= 255,255,255,0.8
self.b500.color= 0,0,0,1
if keyrange[rangeY+6][1]==0:
self.b600.background_color= (0,0,0,0.7)
self.b600.color= 1,1,1,1
else:
self.b600.background_color= 255,255,255,0.8
self.b600.color= 0,0,0,1
if keyrange[rangeY+7][1]==0:
self.b700.background_color= (0,0,0,0.7)
self.b700.color= 1,1,1,1
else:
self.b700.background_color= 255,255,255,0.8
self.b700.color= 0,0,0,1
if keyrange[rangeY+8][1]==0:
self.b800.background_color= (0,0,0,0.7)
self.b800.color= 1,1,1,1
else:
self.b800.background_color= 255,255,255,0.8
self.b800.color= 0,0,0,1
rangeY=rangeY+1
self.loadseq()
def moveYdw(self):
global rangeY
if rangeY>=1:
self.b100.text=keyrange[rangeY-1][0]
self.b200.text=keyrange[rangeY][0]
self.b300.text=keyrange[rangeY+1][0]
self.b400.text=keyrange[rangeY+2][0]
self.b500.text=keyrange[rangeY+3][0]
self.b600.text=keyrange[rangeY+4][0]
self.b700.text=keyrange[rangeY+5][0]
self.b800.text=keyrange[rangeY+6][0]
if keyrange[rangeY-1][1]==0:
self.b100.background_color= (0,0,0,0.7)
self.b100.color= 1,1,1,1
else:
self.b100.background_color= 255,255,255,0.8
self.b100.color= 0,0,0,1
if keyrange[rangeY][1]==0:
self.b200.background_color= (0,0,0,0.7)
self.b200.color= 1,1,1,1
else:
self.b200.background_color= 255,255,255,0.8
self.b200.color= 0,0,0,1
if keyrange[rangeY+1][1]==0:
self.b300.background_color= (0,0,0,0.7)
self.b300.color= 1,1,1,1
else:
self.b300.background_color= 255,255,255,0.8
self.b300.color= 0,0,0,1
if keyrange[rangeY+2][1]==0:
self.b400.background_color= (0,0,0,0.7)
self.b400.color= 1,1,1,1
else:
self.b400.background_color= 255,255,255,0.8
self.b400.color= 0,0,0,1
if keyrange[rangeY+3][1]==0:
self.b500.background_color= (0,0,0,0.7)
self.b500.color= 1,1,1,1
else:
self.b500.background_color= 255,255,255,0.8
self.b500.color= 0,0,0,1
if keyrange[rangeY+4][1]==0:
self.b600.background_color= (0,0,0,0.7)
self.b600.color= 1,1,1,1
else:
self.b600.background_color= 255,255,255,0.8
self.b600.color= 0,0,0,1
if keyrange[rangeY+5][1]==0:
self.b700.background_color= (0,0,0,0.7)
self.b700.color= 1,1,1,1
else:
self.b700.background_color= 255,255,255,0.8
self.b700.color= 0,0,0,1
if keyrange[rangeY+6][1]==0:
self.b800.background_color= (0,0,0,0.7)
self.b800.color= 1,1,1,1
else:
self.b800.background_color= 255,255,255,0.8
self.b800.color= 0,0,0,1
rangeY=rangeY-1
self.loadseq()
def findButton(self,button):
for val in list(self.ids.items()):
if button==val[0]:
buttonfound=val[1]
buttonfound.state="down"
def findButtonC(self,button):
for val in list(self.ids.items()):
if button==val[0]:
buttonfound=val[1]
buttonfound.background_color=[0.3, 0.7, 1, 1]
def findButtonCi(self,button):
for val in list(self.ids.items()):
if button==val[0]:
buttonfound=val[1]
buttonfound.state="down"
def loadseq(self):
global sequencepool2
self.clear()
sequence=sequencepool2[trackselected-1]
i=1
while i <= len(sequence):
if sequence[i-1][2]==1:
Xc=sequence[i-1][0]-rangeX
Yc=sequence[i-1][1]-rangeY+1
j=0
while j < sequence[i-1][3]:
if (Xc>=0 and Xc <= 16*zoom and (sequence[i-1][0]-1)%zoom ==0):
if (Yc >= 1 and Yc <=8):
Xcp=int(Xc/(zoom+0.0000000000001))+1
if Xcp<=9: b="b"+str(Yc)+"0"+str(Xcp)
else: b="b"+str(Yc)+str(Xcp)
if sequence[i-1][3]>zoom:
if j==0: self.findButtonCi(b)
else: self.findButtonC(b)
else: self.findButton(b)
Xc+=zoom
j+=zoom
i+=1
self.loopbar()
self.movebar()
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b023.pos= 496,900
self.b024.pos= 496,900
self.b025.pos= 496,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b012.pos= 496,301
self.b023.pos= 496,242
self.b024.pos= 496,183
self.b025.pos= 496,124
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b023.pos= 496,900
self.b024.pos= 496,900
self.b025.pos= 496,900
self.b010.pos= 1000,0
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b014.pos= 344,301
self.b016.pos= 344,242
self.b020.pos= 344,183
self.b022.pos= 344,124
self.b023.pos= 496,900
self.b024.pos= 496,900
self.b025.pos= 496,900
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
else:
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b010.pos= 1000,0
def recordingbut(self):
global recordingON
if self.b022.text=='REC OFF':
self.b022.text='REC ON'
recordingON=1
else:
self.b022.text='REC OFF'
recordingON=0
print(recordingON)
def mode(self,num):
global seqbuttonmode
if num==1:
if seqbuttonmode==1:
seqbuttonmode=0
self.b020.state='normal'
else:
seqbuttonmode=1
self.b020.state='down'
w2.value=0
if num==2:
if seqbuttonmode==2:
seqbuttonmode=0
self.b003.state='normal'
else:
seqbuttonmode=2
self.b003.state='down'
w2.value=0
if num==3:
if seqbuttonmode==3:
seqbuttonmode=0
self.b004.state='normal'
else:
seqbuttonmode=3
self.b004.state='down'
w2.value=0
if num==4:
seqbuttonmode=0
self.b003.state='normal'
self.b004.state='normal'
self.b020.state='normal'
print(("buton mode",seqbuttonmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.movebar, 0.002)
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
Clock.unschedule(self.movebar)
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.movebar)
v1.value=0
playing=0
self.b015.pos=50,0
def movebarenter(self):
countbar=v2.value%loopsize[trackselected-1]
speed=47.1/zoom
position=int(50+round((countbar-rangeX)*speed))
position=(position/189)*189+50
if position<50: self.b015.pos=1000,0
else: self.b015.pos=position,0
def movebar(self, *args):
countbar=v2.value%loopsize[trackselected-1]
speed=47.1/zoom
position=int(50+round((countbar-rangeX)*speed))
if v2.value%16==0:
if position<50: self.b015.pos=1000,0
else: self.b015.pos=position,0
def loopbar(self):
global loopsize
loopbar_pos=loopsize[trackselected-1]
if loopbar_pos<=rangeX+16*zoom:
if 48+(loopbar_pos-rangeX)/zoom*47>=5: self.b017.pos=48+(loopbar_pos-rangeX)/zoom*47,0
else: self.b017.pos=1000,1000
else: self.b017.pos=1000,1000
self.gridbar()
def gridbar(self):
#print(rangeX)
if (rangeX-3*zoom)%(4*zoom)==0: self.ids.b018.pos = 94,0
if (rangeX-2*zoom)%(4*zoom)==0: self.ids.b018.pos = 141,0
if (rangeX-1*zoom)%(4*zoom)==0: self.ids.b018.pos = 188,0
if rangeX%(4*zoom)==0: self.ids.b018.pos = 235,0
def on_touch_move(self, touch):
global buttonpushed
global sequencepool2
global erased
global stoplong
if self.collide_point(*touch.pos):
x=touch.pos[0]-50
y=touch.pos[1]
bx=int(x/47+1)
by=int(y/47+1)
if (bx>int(buttonpushed[-2:]) and by==int(buttonpushed[1])):
if bx<=9: b="b"+str(by)+"0"+str(bx)
if bx==10: b="b"+str(by)+"10"
if bx>10: b="b"+str(by)+str(bx)
for val in list(self.ids.items()):
if val[0]==b:
if val[1].state=='normal'and stoplong==0: val[1].background_color=[0.3, 0.7, 1, 1]
if val[1].state=='down': stoplong=1
if val[0]==buttonpushed and erased==0:
val[1].state=='normal'
try:
sequencepool2[trackselected-1].remove([(xseq-1)*zoom+rangeX+1+zoom,yseq+rangeY-1,0,zoom])
sequencepool2[trackselected-1].remove([(xseq-1)*zoom+rangeX+1,yseq+rangeY-1,1,zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+zoom].remove([yseq+rangeY-1,0,zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX].remove([yseq+rangeY-1,1,zoom])
erased=1
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
except:
print("************* Touch move remove error ***********")
erased=0
if by!=int(buttonpushed[1]):
stoplong=1
def on_touch_up(self,touch):
global buttonpushed
global erased
global stoplong
if self.collide_point(*touch.pos):
x=touch.pos[0]-50
y=touch.pos[1]
bx=int(x/47+1)
by=int(y/47+1)
if (bx>int(buttonpushed[-2:]) and by==int(buttonpushed[1]))and stoplong==0:
if bx<=9: b="b"+str(by)+"0"+str(bx)
else: b="b"+str(by)+str(bx)
for val in list(self.ids.items()):
if val[0]==b and erased==1:
erased=0
binit=int(buttonpushed[-2:])
duration=(bx-binit)+1
try:
sequencepool2[trackselected-1].append([(xseq-1)*zoom+rangeX+1,yseq+rangeY-1,1,duration*zoom])
sequencepool2[trackselected-1].append([(xseq-1)*zoom+rangeX+1+duration*zoom,yseq+rangeY-1,0,duration*zoom])
sequencepool2[trackselected-1]=sorted(sequencepool2[trackselected-1], key=operator.itemgetter(0,2))
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX].append([yseq+rangeY-1,1,duration*zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+duration*zoom].append([yseq+rangeY-1,0,duration*zoom])
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX]=sorted(sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX], key=operator.itemgetter(1,0))
sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+duration*zoom]=sorted(sequencepool3[trackselected-1][(xseq-1)*zoom+rangeX+duration*zoom], key=operator.itemgetter(1,0))
#print(sequencepool3[trackselected-1])
except:
print("****************************************")
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
#self.loadseq()
if 0<bx<17 and 0<by<9: self.loadseq()
erased=0
stoplong=0
def recording(self):
while s4.empty() is False:
noterec=s4.get()
self.recordingnote(noterec)
while r4.empty() is False:
noterec=r4.get()
self.recordingnote(noterec)
def recordingnote(self,noterec):
step=v2.value%loopsize[trackselected-1]
step=step/4 *4
if recordingON==1:
if [step+1,noterec-24,1,4] not in sequencepool2[trackselected-1]:
sequencepool2[trackselected-1].append([step+1,noterec-24,1,4])
sequencepool2[trackselected-1].append([step+5,noterec-24,0,4])
sequencepool2[trackselected-1]=sorted(sequencepool2[trackselected-1], key=operator.itemgetter(0,2))
sequencepool3[trackselected-1][step].append([noterec-24,1,4])
sequencepool3[trackselected-1][step+4].append([noterec-24,0,4])
sequencepool3[trackselected-1][step]=sorted(sequencepool3[trackselected-1][step], key=operator.itemgetter(1,0))
sequencepool3[trackselected-1][step+4]=sorted(sequencepool3[trackselected-1][step+4], key=operator.itemgetter(1,0))
self.loadseq()
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
def listening(self,*args):
global wheel
global seqbuttonmode
global loopsize
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
self.recording()
if seqbuttonmode==0:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
if encoderpushed==1: self.moveXrgh()
else: self.moveYup()
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
if encoderpushed==1: self.moveXlft()
else: self.moveYdw()
if seqbuttonmode==1:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.zoomin()
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.zoomout()
if encoderpushed==1:
seqbuttonmode=0
self.b020.state='normal'
self.closemenus()
if seqbuttonmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
seqbuttonmode=0
self.b003.state='normal'
if seqbuttonmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]<64*16:
loopsize[trackselected-1]+=16
q2.put(loopsize)
self.LoopSdisplay()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]>16:
loopsize[trackselected-1]-=16
q2.put(loopsize)
self.LoopSdisplay()
if encoderpushed==1:
seqbuttonmode=0
self.b004.state='normal'
global playing
if v1.value==1 and playing==0:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
Clock.schedule_interval(self.movebar, 0.002)
elif v1.value==0 and playing==1:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
Clock.unschedule(self.movebar)
self.b015.pos=50,0
def LoopSdisplay(self):
a,b=divmod(loopsize[trackselected-1],16)
b=b/4
#self.b004.text=str(a) + "." +str(b)
self.b004.text=str(a)
self.loopbar()
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class SaveSeq(Screen):
def on_enter(self):
global rangeFile
global playing
v1.value=0
playing=0
rangeFile=0
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def choice(self, chosen):
print(chosen)
if self.b001.state=="down":
if rpi==1:
with open('/home/pi/Desktop2/UIP/savedseq.json', "w") as s:
saved["savedseq"][chosen+rangeFile*4-1]["sequence"] = sequencepool2[trackselected-1]
json.dump(saved, s)
else:
with open('savedseq.json', "w") as s:
saved["savedseq"][chosen+rangeFile*4-1]["sequence"] = sequencepool2[trackselected-1]
json.dump(saved, s)
else:
from midi import MIDIFile
track = 0
channel = 0
time = 0
tempo = 120
volume = 100
MyMIDI = MIDIFile(1)
MyMIDI.addTempo(track, time, tempo)
for elem in sequencepool2[trackselected-1]:
if elem[2]==1: MyMIDI.addNote(track, channel, elem[1]+24, Decimal(elem[0]-1)/16, Decimal(elem[3])/16, volume)
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
print(location)
if len(location)>1:
filetext='/media/pi/'+location+'/'+str(chosen+rangeFile*4)+'.mid'
print(filetext)
try:
with open(filetext, "wb") as output_file:
MyMIDI.writeFile(output_file)
except: print("error usb")
self.leaving()
def up(self):
global rangeFile
if rangeFile<21:
rangeFile+=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def dw(self):
global rangeFile
if rangeFile>0:
rangeFile-=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def listening(self,*args):
global wheel
global buttonparam
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.up()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.dw()
if rpi==1:self.usbcheck()
def usbcheck(self):
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
if len(location)<1:
self.b002.state="normal"
self.b001.state="down"
self.b002.text="EXPORT %s"%(icon('icon-lock', 22))
else:
self.b002.text="EXPORT"
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule SaveSeq")
class LoadSeq(Screen):
def on_enter(self):
global rangeFile
global playing
v1.value=0
playing=0
rangeFile=0
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def choice(self, chosen):
print(chosen)
if self.b001.state=="down":
if rpi==1:
with open('/home/pi/Desktop2/UIP/savedseq.json') as s:
saved = json.load(s)
print((saved["savedseq"][chosen+rangeFile*4-1]["sequence"]))
sequencepool2[trackselected-1]=saved["savedseq"][chosen+rangeFile*4-1]["sequence"]
q1.put(sequencepool2)
else:
with open('savedseq.json') as s:
saved = json.load(s)
print((saved["savedseq"][chosen+rangeFile*4-1]["sequence"]))
sequencepool2[trackselected-1]=saved["savedseq"][chosen+rangeFile*4-1]["sequence"]
q1.put(sequencepool2)
else:
from midiconvert import MIDIconvert
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
print(location)
if len(location)>1:
filetext='/media/pi/'+location+'/'+str(chosen+rangeFile*4)+'.mid'
print(filetext)
try:
sequencepool2[trackselected-1]=MIDIconvert(filetext)
print(sequencepool2)
except:
print('no such file')
sequencepool2[trackselected-1]=[]
else: sequencepool2[trackselected-1]=[]
self.convert()
self.leaving()
def usbcheck(self):
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
if len(location)<1:
self.b002.state="normal"
self.b001.state="down"
self.b002.text="IMPORT %s"%(icon('icon-lock', 22))
else:
self.b002.text="IMPORT"
def convert(self):
for i,elem in enumerate(sequencepool3[trackselected-1]): sequencepool3[trackselected-1][i]=[]
for elem in sequencepool2[trackselected-1]: sequencepool3[trackselected-1][elem[0]-1].append([elem[1],elem[2],elem[3]])
q6.put(sequencepool3[trackselected-1])
def up(self):
global rangeFile
if rangeFile<21:
rangeFile+=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def dw(self):
global rangeFile
if rangeFile>0:
rangeFile-=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def listening(self,*args):
global wheel
global buttonparam
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.up()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.dw()
if rpi==1:self.usbcheck()
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule LoadSeq")
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class SaveSong(Screen):
def on_enter(self):
global rangeFile
global playing
v1.value=0
playing=0
rangeFile=0
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def choice(self, chosen):
print(chosen)
if self.b001.state=="down":
if rpi==1:
with open('/home/pi/Desktop2/UIP/savedsong.json', "w") as s2:
savedsong["savedsong"][chosen+rangeFile*4-1]["song"] = song
savedsong["savedsong"][chosen+rangeFile*4-1]["seq"] = sequencepool2
savedsong["savedsong"][chosen+rangeFile*4-1]["LFO"] = EnvPool2
savedsong["savedsong"][chosen+rangeFile*4-1]["ADSR"] = ADSRPool2
savedsong["savedsong"][chosen+rangeFile*4-1]["TRIG"] = ADSRtrig
savedsong["savedsong"][chosen+rangeFile*4-1]["MODE"] = trackmode
savedsong["savedsong"][chosen+rangeFile*4-1]["PHASE"] = Phase
json.dump(savedsong, s2)
with open('/home/pi/Desktop2/UIP/savedsong2.json', "w") as s3:
savedsong2["savedsong2"][chosen+rangeFile*4-1]["soopsize"] = loopsize
savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsizeS"] = loopsizeS
savedsong2["savedsong2"][chosen+rangeFile*4-1]["pulseeucli"] = pulseeucli
savedsong2["savedsong2"][chosen+rangeFile*4-1]["stepeucli"] = stepeucli
savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliOffset"] = EucliOffset
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomDensity"] = RandomDensity
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomTemp"] = RandomTemp
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomRatchet"] = RandomRatchet
savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliPool2"] = EucliPool2
json.dump(savedsong2, s3)
else:
with open('savedsong.json', "w") as s2:
savedsong["savedsong"][chosen+rangeFile*4-1]["song"] = song
savedsong["savedsong"][chosen+rangeFile*4-1]["seq"] = sequencepool2
savedsong["savedsong"][chosen+rangeFile*4-1]["LFO"] = EnvPool2
savedsong["savedsong"][chosen+rangeFile*4-1]["ADSR"] = ADSRPool2
savedsong["savedsong"][chosen+rangeFile*4-1]["TRIG"] = ADSRtrig
savedsong["savedsong"][chosen+rangeFile*4-1]["MODE"] = trackmode
savedsong["savedsong"][chosen+rangeFile*4-1]["PHASE"] = Phase
json.dump(savedsong, s2)
with open('savedsong2.json', "w") as s3:
savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsize"] = loopsize
savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsizeS"] = loopsizeS
savedsong2["savedsong2"][chosen+rangeFile*4-1]["pulseeucli"] = pulseeucli
savedsong2["savedsong2"][chosen+rangeFile*4-1]["stepeucli"] = stepeucli
savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliOffset"] = EucliOffset
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomDensity"] = RandomDensity
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomTemp"] = RandomTemp
savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomRatchet"] = RandomRatchet
savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliPool2"] = EucliPool2
json.dump(savedsong2, s3)
"""
else:
from midi import MIDIFile
track = 0
channel = 0
time = 0
tempo = 120
volume = 100
MyMIDI = MIDIFile(1)
MyMIDI.addTempo(track, time, tempo)
for elem in sequencepool2[trackselected-1]:
if elem[2]==1: MyMIDI.addNote(track, channel, elem[1]+24, Decimal(elem[0]-1)/16, Decimal(elem[3])/16, volume)
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
print(location)
if len(location)>1:
filetext='/media/pi/'+location+'/'+str(chosen+rangeFile*4)+'.mid'
print(filetext)
try:
with open(filetext, "wb") as output_file:
MyMIDI.writeFile(output_file)
except: print("error usb")
"""
self.leaving()
def up(self):
global rangeFile
if rangeFile<6:
rangeFile+=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def dw(self):
global rangeFile
if rangeFile>0:
rangeFile-=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def listening(self,*args):
global wheel
global buttonparam
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.up()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.dw()
if rpi==1:self.usbcheck()
def usbcheck(self):
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
if len(location)<1:
self.b002.state="normal"
self.b001.state="down"
self.b002.text="EXPORT %s"%(icon('icon-lock', 22))
else:
self.b002.text="EXPORT"
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule SaveSeq")
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class LoadSong(Screen):
def on_enter(self):
global rangeFile
global playing
v1.value=0
playing=0
rangeFile=0
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def choice(self, chosen):
global song
global EnvPool2
global ADSRPool2
global trackmode
global ADSRtrig
global sequencepool2
global Phase
global loopsizeS
global loopsize
global pulseeucli
global stepeucli
global EucliOffset
global RandomRatchet
global RandomDensity
global RandomTemp
global EucliPool2
print(chosen)
if self.b001.state=="down":
if rpi==1:
with open('/home/pi/Desktop2/UIP/savedsong.json') as s2:
savedsong = json.load(s2)
#print((savedsong["savedsong"][chosen+rangeFile*4-1]["song"]))
song=savedsong["savedsong"][chosen+rangeFile*4-1]["song"]
sequencepool2=savedsong["savedsong"][chosen+rangeFile*4-1]["seq"]
EnvPool2=savedsong["savedsong"][chosen+rangeFile*4-1]["LFO"]
ADSRPool2=savedsong["savedsong"][chosen+rangeFile*4-1]["ADSR"]
trackmode=savedsong["savedsong"][chosen+rangeFile*4-1]["MODE"]
ADSRtrig=savedsong["savedsong"][chosen+rangeFile*4-1]["TRIG"]
Phase=savedsong["savedsong"][chosen+rangeFile*4-1]["PHASE"]
with open('/home/pi/Desktop2/UIP/savedsong2.json') as s3:
savedsong2 = json.load(s3)
#print((savedsong["savedsong"][chosen+rangeFile*4-1]["song"]))
loopsize=savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsize"]
loopsizeS=savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsizeS"]
pulseeucli=savedsong2["savedsong2"][chosen+rangeFile*4-1]["pulseeucli"]
stepeucli=savedsong2["savedsong2"][chosen+rangeFile*4-1]["stepeucli"]
EucliOffset=savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliOffset"]
RandomDensity=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomDensity"]
RandomTemp=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomTemp"]
RandomRatchet=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomRatchet"]
EucliPool2=savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliPool2"]
else:
with open('savedsong.json') as s2:
savedsong = json.load(s2)
#print((savedsong["savedsong"][chosen+rangeFile*4-1]["song"]))
song=savedsong["savedsong"][chosen+rangeFile*4-1]["song"]
sequencepool2=savedsong["savedsong"][chosen+rangeFile*4-1]["seq"]
EnvPool2=savedsong["savedsong"][chosen+rangeFile*4-1]["LFO"]
ADSRPool2=savedsong["savedsong"][chosen+rangeFile*4-1]["ADSR"]
trackmode=savedsong["savedsong"][chosen+rangeFile*4-1]["MODE"]
ADSRtrig=savedsong["savedsong"][chosen+rangeFile*4-1]["TRIG"]
Phase=savedsong["savedsong"][chosen+rangeFile*4-1]["PHASE"]
#print(sequencepool2)
with open('savedsong2.json') as s3:
savedsong2 = json.load(s3)
#print((savedsong["savedsong"][chosen+rangeFile*4-1]["song"]))
loopsize=savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsize"]
loopsizeS=savedsong2["savedsong2"][chosen+rangeFile*4-1]["loopsizeS"]
pulseeucli=savedsong2["savedsong2"][chosen+rangeFile*4-1]["pulseeucli"]
stepeucli=savedsong2["savedsong2"][chosen+rangeFile*4-1]["stepeucli"]
EucliOffset=savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliOffset"]
RandomDensity=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomDensity"]
RandomTemp=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomTemp"]
RandomRatchet=savedsong2["savedsong2"][chosen+rangeFile*4-1]["RandomRatchet"]
EucliPool2=savedsong2["savedsong2"][chosen+rangeFile*4-1]["EucliPool2"]
q3.put(song)
q2.put(loopsize)
v3.value=loopsizeS
q9.put(ADSRtrig)
"""
else:
from midiconvert import MIDIconvert
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
print(location)
if len(location)>1:
filetext='/media/pi/'+location+'/'+str(chosen+rangeFile*4)+'.mid'
print(filetext)
try:
sequencepool2[trackselected-1]=MIDIconvert(filetext)
print(sequencepool2)
except:
print('no such file')
sequencepool2[trackselected-1]=[]
else: sequencepool2[trackselected-1]=[]
"""
self.clearseq()
self.convertsequence()
self.convertlfo()
self.convertadsr()
self.leaving()
self.converteucli()
q10.put(sequencepool3)
def usbcheck(self):
for files in os.walk('/media/pi'):
resulted=files
break
resulted=str(resulted[1])
resulted=resulted[:-2]
location=str(resulted[2:])
if len(location)<1:
self.b002.state="normal"
self.b001.state="down"
self.b002.text="IMPORT %s"%(icon('icon-lock', 22))
else:
self.b002.text="IMPORT"
def clearseq(self):
global sequencepool3
i=0
while i<16:
for a,elem in enumerate(sequencepool3[i]): sequencepool3[i][a]=[]
i+=1
def convertsequence(self):
global sequencepool3
i=0
while i<16:
#for a,elem in enumerate(sequencepool3[i]): sequencepool3[i][a]=[]
for elem in sequencepool2[i]:sequencepool3[i][elem[0]-1].append([elem[1],elem[2],elem[3]])
#for elem in sequencepool2[i]:print(elem)
#print("UPDATED: channel:", i,sequencepool3[i])
i+=1
#print("sequencepool3",sequencepool3)
#q10.put(sequencepool3)
def converteucli(self):
global sequencepool3
j=0
while j<16:
for i in range(64):
if EucliPool2[j][i%stepeucli[j]]==1:
sequencepool3[j][i*4].append([36,1,4])
sequencepool3[j][i*4+4].append([36,0,4])
sequencepool3[j][i*4]=sorted(sequencepool3[j][i*4],key=operator.itemgetter(1,0))
sequencepool3[j][i*4+4]=sorted(sequencepool3[j][i*4+4],key=operator.itemgetter(1,0))
j+=1
#q10.put(sequencepool3)
def convertlfo(self):
global EnvPool3
i=0
#print(EnvPool2)
while i<16:
if EnvPool2[i]!=[] and EnvPool2[i]!=[0] and EnvPool2[i]!=0 and trackmode[i]==2:
print(EnvPool2[i])
X=(((EnvPool2[i][0][0]-40)/700)+0.001)*loopsize[i]
Y=((EnvPool2[i][0][1]-195.2)/37)
a1=2*Y/X
b1=-Y
a2=2*Y/(X-loopsize[i]+1)
b2=Y-a2*X
PHASE=(Phase[i]+0.001-40)/700*loopsize[i]-1.37
a=0
while a<loopsize[i]:
n=(a+PHASE)%loopsize[i]
if n<X:
EnvPool3[i][a]=(a1*n+b1)*3/5
else:
EnvPool3[i][a]=(a2*n+b2)*3/5
a+=1
i+=1
q11.put(EnvPool3)
def convertadsr(self):
global ADSRPool3
i=0
while i<16:
if ADSRPool2[i]!=0 and ADSRPool2[i]!=[0] and trackmode[i]==3:
lps=loopsize[i]
p1=[0,0]
p2=[(ADSRPool2[i][0]-41)/700*lps+1,(ADSRPool2[i][1])/330]
p3=[(ADSRPool2[i][2]-52)/700*lps,(ADSRPool2[i][3])/330]
p4=[(ADSRPool2[i][4]-52)/700*lps,(ADSRPool2[i][5])/330]
p5=[(ADSRPool2[i][6]-52)/700*lps,(ADSRPool2[i][7])/330]
#print("P",p1,p2,p3,p4,p5)
j=0
a1=self.coefs(p1,p2)
a2=self.coefs(p2,p3)
a3=self.coefs(p3,p4)
a4=self.coefs(p4,p5)
while j<lps:
if j < p2[0]:
r=a1*j
if r>0:ADSRPool3[i][j]=r
else:ADSRPool3[i][j]=0
x=j
elif p2[0] <= j <= p3[0]:
r=a2*(j-x)+ADSRPool3[i][x]
if r>0: ADSRPool3[i][j]=r
else:ADSRPool3[i][j]=0
x=j
elif p3[0] <= j <= p4[0]:
r=a3*(j-x)+ADSRPool3[i][x]
if r>0: ADSRPool3[i][j]=r
else:ADSRPool3[i][j]=0
x=j
elif p4[0] <= j <= p5[0]:
r=a4*(j-x)+ADSRPool3[i][x]
if r>0: ADSRPool3[i][j]=r
else:ADSRPool3[i][j]=0
x=j
elif j>p5[0]:ADSRPool3[i][j]=0
j+=1
i+=1
#print("adsr",ADSRPool3)
q12.put(ADSRPool3)
def coefs(self,p1,p2):
coef=(p2[1]-p1[1])/(p2[0]-p1[0])*5
#print(coef)
return coef
def up(self):
global rangeFile
if rangeFile<6:
rangeFile+=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def dw(self):
global rangeFile
if rangeFile>0:
rangeFile-=1
self.b5001.text=str(rangeFile*4+1)
self.b5002.text=str(rangeFile*4+2)
self.b5003.text=str(rangeFile*4+3)
self.b5004.text=str(rangeFile*4+4)
self.b5005.text=str(rangeFile*4+5)
self.b5006.text=str(rangeFile*4+6)
self.b5007.text=str(rangeFile*4+7)
self.b5008.text=str(rangeFile*4+8)
self.b5009.text=str(rangeFile*4+9)
self.b5010.text=str(rangeFile*4+10)
self.b5011.text=str(rangeFile*4+11)
self.b5012.text=str(rangeFile*4+12)
self.b5013.text=str(rangeFile*4+13)
self.b5014.text=str(rangeFile*4+14)
self.b5015.text=str(rangeFile*4+15)
self.b5016.text=str(rangeFile*4+16)
def listening(self,*args):
global wheel
global buttonparam
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
self.up()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
self.dw()
if rpi==1:self.usbcheck()
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule LoadSeq")
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class LFOScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
global Lline1
global Lline4
global Lline7
Lline1 = self.ids.w_canvas.canvas.get_group('a')[0]
Lline4 = self.ids.w_canvas.canvas.get_group('b')[0]
Lline7 = self.ids.w_canvas.canvas.get_group('g')[0]
global trackmode
global loopsize
if trackmode[trackselected-1]!=2:
loopsize[trackselected-1]=64
self.reset()
q2.put(loopsize)
trackmode[trackselected-1]=2
print('trackmode',trackmode[trackselected-1])
global lfobutmode
lfobutmode=0
self.mode(0)
print(trackselected-1)
self.LoopSdisplay()
self.b025.pos[0]=Phase[trackselected-1]
clearsequence()
deleteADSR()
self.move_button(Lline7.pos[1])
self.b006.text=str(trackselected)+ ": LFO"
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b013.pos= 344,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,900
self.b027.pos= 496,900
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b012.pos= 496,301
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 496,242
self.b015.pos= 496,183
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,900
self.b027.pos= 496,124
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b027.pos= 496,900
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,301
self.b027.pos= 496,900
else:
self.b013.pos= 344,900
self.b010.pos= 1000,0
self.b026.pos= 344,900
def mode(self,num):
global lfobutmode
if num==0:
self.b003.state='normal'
self.b004.state='normal'
self.b025.state='normal'
if num==2:
if lfobutmode==2:
lfobutmode=0
self.b003.state='normal'
else:
lfobutmode=2
self.b003.state='down'
w2.value=0
if num==3:
if lfobutmode==3:
lfobutmode=0
self.b004.state='normal'
else:
lfobutmode=3
self.b004.state='down'
w2.value=0
if num==4:
if lfobutmode==4:
lfobutmode=0
self.b025.state='normal'
else:
lfobutmode=4
self.b025.state='down'
w2.value=0
print(("buton mode",lfobutmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
v1.value=0
playing=0
def reset(self):
global EnvPool2
global Phase
EnvPool2[trackselected-1]=[[400,380]]
Phase[trackselected-1]=55
self.UIrefresh(EnvPool2[trackselected-1])
self.updateEnv()
self.convert2to3()
self.move_button(Lline7.pos[1])
self.b025.pos[0]=55
def listening(self,*args):
global wheel
global lfobutmode
global loopsize
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if lfobutmode==0: pass
if lfobutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
lfobutmode=0
self.b003.state='normal'
if lfobutmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]<16*16:
loopsize[trackselected-1]+=16
q2.put(loopsize)
self.LoopSdisplay()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]>16:
loopsize[trackselected-1]-=16
q2.put(loopsize)
self.LoopSdisplay()
if encoderpushed==1:
lfobutmode=0
self.b004.state='normal'
if lfobutmode==4:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.Phase(20)
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.Phase(-20)
if encoderpushed==1:
lfobutmode=0
self.b025.state='normal'
self.closemenus()
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
def on_touch_move(self, touch):
global EnvPool2
global buttonpos
buttonpos=touch.pos[1]-10
if 50 <= touch.pos[0] <= 750:
if 20 <= touch.pos[1] <= 380:
self.UIrefresh([touch.pos])
self.move_button(Lline7.pos[1])
self.updateEnv()
def encadrement_lfo(self, x, y, buttonpos):
txt = (buttonpos-x)*(100.0/(y-x))
return txt
def move_button(self, buttonpos):
txt=self.encadrement_lfo(190, 370, buttonpos)
if buttonpos >= 190:
self.b024.pos=(1,buttonpos)
self.b024.text=str(int(txt))
elif buttonpos < 190:
self.b024.pos=(1,380 - buttonpos)
self.b024.text=str(int(-1 * txt))
def UIrefresh(self,Coord):
Lline7.pos=(Coord[0][0]-10,Coord[0][1]-10)
Lline1.points=[(50,400 - Coord[0][1]),(Coord[0][0],Coord[0][1])]
Lline4.points=[(750,400 - Coord[0][1]),(Coord[0][0],Coord[0][1])]
def updateEnv(self):
global EnvPool2
EnvPool2[trackselected-1]=[]
EnvPool2[trackselected-1].append([Lline7.pos[0],Lline7.pos[1]])
#print(EnvPool2)
self.convert2to3()
def convert2to3(self):
global EnvPool2
global EnvPool3
#print(EnvPool2)
X=(((EnvPool2[trackselected-1][0][0]-40)/700)+0.001)*loopsize[trackselected-1]
Y=((EnvPool2[trackselected-1][0][1]-195.2)/37)
a1=2*Y/X
b1=-Y
a2=2*Y/(X-loopsize[trackselected-1]+1)
b2=Y-a2*X
#print(X,Y)
#print(a1,b1,a2,b2)
PHASE=(Phase[trackselected-1]+0.001-40)/700*loopsize[trackselected-1]-1.37
#print(PHASE)
i=0
while i<loopsize[trackselected-1]:
n=(i+PHASE)%loopsize[trackselected-1]
if n<X:
EnvPool3[trackselected-1][i]=(a1*n+b1)*3/5
else:
EnvPool3[trackselected-1][i]=(a2*n+b2)*3/5
i+=1
q7.put(EnvPool3[trackselected-1])
#print(EnvPool3[trackselected-1])
#print(EnvPool3[trackselected-1][0],EnvPool3[trackselected-1][63])
def LoopSdisplay(self):
self.l1.text=str(loopsize[trackselected-1]/16)
self.convert2to3()
self.b004.text=str(loopsize[trackselected-1]/16)
def Phase(self,move):
global Phase
if move <0 and self.b025.pos[0]>70 or move >0 and self.b025.pos[0]<730:
self.b025.pos[0]+=move
Phase[trackselected-1]=self.b025.pos[0]
#print(Phase[trackselected-1])
self.convert2to3()
def test1(self):
self.Phase(20)
def test2(self):
self.Phase(-20)
def polarity(self):
global polaritylfo
if polaritylfo[trackselected-1]==0:
polaritylfo[trackselected-1]=1
self.b026.text="UNIPOLAR"
self.UIrefresh(EnvPool2[trackselected-1])
else:
polaritylfo[trackselected-1]=0
self.b026.text="BIPOLAR"
self.UIrefresh(EnvPool2[trackselected-1])
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class DRAWScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
global Lline7
global Point1
global Point2
global Point3
global Point4
global Point5
global Point6
global Point7
global Point8
global Lline1
global Lline2
global Lline3
global Lline4
global Lline5
global Lline6
global Lline8
Lline7 = self.ids.w_canvas.canvas.get_group('g')[0]
Point1 = self.ids.w_canvas.canvas.get_group('h')[0]
Point2 = self.ids.w_canvas.canvas.get_group('i')[0]
Point3 = self.ids.w_canvas.canvas.get_group('j')[0]
Point4 = self.ids.w_canvas.canvas.get_group('k')[0]
Point5 = self.ids.w_canvas.canvas.get_group('l')[0]
Point6 = self.ids.w_canvas.canvas.get_group('m')[0]
Point7 = self.ids.w_canvas.canvas.get_group('n')[0]
Point8 = self.ids.w_canvas.canvas.get_group('o')[0]
Lline1 = self.ids.w_canvas.canvas.get_group('a')[0]
Lline2 = self.ids.w_canvas.canvas.get_group('q')[0]
Lline3 = self.ids.w_canvas.canvas.get_group('r')[0]
Lline4 = self.ids.w_canvas.canvas.get_group('b')[0]
Lline5 = self.ids.w_canvas.canvas.get_group('t')[0]
Lline6 = self.ids.w_canvas.canvas.get_group('u')[0]
Lline8 = self.ids.w_canvas.canvas.get_group('w')[0]
global trackmode
global loopsize
if trackmode[trackselected-1]!=2:
loopsize[trackselected-1]=64
self.reset()
trackmode[trackselected-1]=2
print('trackmode',trackmode[trackselected-1])
global lfobutmode
lfobutmode=6
print(trackselected-1)
self.LoopSdisplay()
self.b025.pos[0]=Phase[trackselected-1]
self.clearsequence()
self.deleteADSR()
self.move_button(Lline7.pos[1])
global DrawPoints
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
def clearsequence(self):
global sequencepool2
global sequencepool3
sequencepool2[trackselected-1]=[]
for i,elem in enumerate(sequencepool3[trackselected-1]): sequencepool3[trackselected-1][i]=[]
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
#print(sequencepool3[trackselected-1])
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b013.pos= 344,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,900
self.b027.pos= 496,900
self.b028.pos= 344,900
self.b029.pos= 344,900
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b027.pos= 496,301
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b012.pos= 496,242
self.b014.pos= 496,183
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,900
self.b015.pos= 496,124
self.b028.pos= 344,900
self.b029.pos= 344,900
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b027.pos= 496,900
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
self.b026.pos= 344,301
self.b027.pos= 344,900
self.b028.pos= 344,242
self.b029.pos= 419,242
else:
self.b013.pos= 344,900
self.b010.pos= 1000,0
self.b026.pos= 344,900
self.b027.pos= 344,900
self.b028.pos= 344,900
self.b029.pos= 344,900
def mode(self,num):
global lfobutmode
if num==1:
if lfobutmode==1:
lfobutmode=0
self.b020.state='normal'
else:
lfobutmode=1
self.b020.state='down'
w2.value=0
if num==2:
if lfobutmode==2:
lfobutmode=0
self.b003.state='normal'
else:
lfobutmode=2
self.b003.state='down'
w2.value=0
if num==3:
if lfobutmode==3:
lfobutmode=0
self.b004.state='normal'
else:
lfobutmode=3
self.b004.state='down'
w2.value=0
if num==4:
if lfobutmode==4:
lfobutmode=0
self.b025.state='normal'
else:
lfobutmode=4
self.b025.state='down'
w2.value=0
if num==5:
if lfobutmode==5:
lfobutmode=0
self.b024.state='normal'
else:
lfobutmode=5
self.b024.state='down'
w2.value=0
if num==6:
lfobutmode=6
self.b003.state='normal'
self.b004.state='normal'
self.b020.state='normal'
print(("buton mode",lfobutmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
v1.value=0
playing=0
def reset(self):
global EnvPool2
EnvPool2[trackselected-1]=[[400,380]]
self.UIrefresh(EnvPool2[trackselected-1])
self.updateEnv()
self.convert2to3()
self.move_button(Lline7.pos[1])
def delete(self):
global EnvPool2
global EnvPool3
EnvPool2[trackselected-1]=[0]
EnvPool3[trackselected-1]=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
#print("deleted",EnvPool3[trackselected-1])
#print("EnvPool0",EnvPool0)
q7.put(EnvPool3[trackselected-1])
def deleteADSR(self):
global ADSRPool2
global ADSRPool3
ADSRPool2[trackselected-1]=[0]
ADSRPool3[trackselected-1]=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
q8.put(ADSRPool3[trackselected-1])
def listening(self,*args):
global wheel
global lfobutmode
global loopsize
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if lfobutmode==0: pass
if lfobutmode==1:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.rgt()
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.lft()
if encoderpushed==1:
lfobutmode=0
self.b023.state='normal'
self.closemenus()
if lfobutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
lfobutmode=0
self.b003.state='normal'
if lfobutmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]<16*16:
loopsize[trackselected-1]+=16
q2.put(loopsize)
self.LoopSdisplay()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]>16:
loopsize[trackselected-1]-=16
q2.put(loopsize)
self.LoopSdisplay()
if encoderpushed==1:
lfobutmode=0
self.b004.state='normal'
if lfobutmode==4:
if encodervalue>0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.Phase(20)
elif encodervalue<0:
self.closemenus()
wheel+=1
if wheel==2:
wheel=0
self.Phase(-20)
if encoderpushed==1:
lfobutmode=0
self.b025.state='normal'
self.closemenus()
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
def on_touch_move(self, touch):
global EnvPool2
global buttonpos
buttonpos=touch.pos[1]-10
if 50 <= touch.pos[0] <= 750:
if 20 <= touch.pos[1] <= 380:
self.UIrefresh([touch.pos])
self.move_button(Lline7.pos[1])
self.updateEnv()
def encadrement_lfo(self, x, y, buttonpos):
txt = (buttonpos-x)*(100.0/(y-x))
return txt
def move_button(self, buttonpos):
txt=self.encadrement_lfo(190, 370, buttonpos)
if buttonpos >= 190:
self.b024.pos=(1,buttonpos)
self.b024.text=str(int(txt))
elif buttonpos < 190:
self.b024.pos=(1,380 - buttonpos)
self.b024.text=str(int(-1 * txt))
def UIrefresh(self,Coord):
if polaritylfo[trackselected-1]==0:
Lline7.pos=(Coord[0][0]-10,Coord[0][1]-10)
Lline1.points=[(50,400 - Coord[0][1]),(Coord[0][0],Coord[0][1])]
Lline4.points=[(750,400 - Coord[0][1]),(Coord[0][0],Coord[0][1])]
else:
Lline7.pos=(Coord[0][0]-10,Coord[0][1]-10)
Lline1.points=[(50,20),(Coord[0][0],Coord[0][1])]
Lline4.points=[(750,20),(Coord[0][0],Coord[0][1])]
#print(polaritylfo)
def updateEnv(self):
global EnvPool2
EnvPool2[trackselected-1]=[]
EnvPool2[trackselected-1].append([Lline7.pos[0],Lline7.pos[1]])
#print(EnvPool2)
self.convert2to3()
def convert2to3(self):
global EnvPool2
global EnvPool3
#print(EnvPool2)
X=(((EnvPool2[trackselected-1][0][0]-40)/700)+0.001)*loopsize[trackselected-1]
Y=((EnvPool2[trackselected-1][0][1]-195.2)/37)
a1=2*Y/X
b1=-Y
a2=2*Y/(X-loopsize[trackselected-1]+1)
b2=Y-a2*X
#print(X,Y)
#print(a1,b1,a2,b2)
PHASE=(Phase[trackselected-1]+0.001-40)/700*loopsize[trackselected-1]-1.37
#print(PHASE)
i=0
while i<loopsize[trackselected-1]:
n=(i+PHASE)%loopsize[trackselected-1]
if n<X:
EnvPool3[trackselected-1][i]=(a1*n+b1)*3/5
else:
EnvPool3[trackselected-1][i]=(a2*n+b2)*3/5
i+=1
q7.put(EnvPool3[trackselected-1])
#print(EnvPool3[trackselected-1])
#print(EnvPool3[trackselected-1][0],EnvPool3[trackselected-1][63])
def LoopSdisplay(self):
self.l1.text=str(loopsize[trackselected-1]/16)
self.convert2to3()
self.b004.text=str(loopsize[trackselected-1]/16)
def Phase(self,move):
global Phase
if move <0 and self.b025.pos[0]>70 or move >0 and self.b025.pos[0]<730:
self.b025.pos[0]+=move
Phase[trackselected-1]=self.b025.pos[0]
#print(Phase[trackselected-1])
self.convert2to3()
def test1(self):
self.Phase(20)
def test2(self):
self.Phase(-20)
def polarity(self):
global polaritylfo
if polaritylfo[trackselected-1]==0:
polaritylfo[trackselected-1]=1
self.b026.text="UNIPOLAR"
self.UIrefresh(EnvPool2[trackselected-1])
else:
polaritylfo[trackselected-1]=0
self.b026.text="BIPOLAR"
self.UIrefresh(EnvPool2[trackselected-1])
def addpoint(self):
global point
point=[Point1,Point2, Point3, Point4, Point5, Point6, Point7, Point8]
DrawPoints[trackselected-1] = DrawPoints[trackselected-1] + 1
for i in range(DrawPoints[trackselected-1]):
point[i].pos=100+(100*i),100
print(DrawPoints)
def rempoint(self):
DrawPoints[trackselected-1] = DrawPoints[trackselected-1] - 1
for i in range(DrawPoints[trackselected-1]):
point[DrawPoints[trackselected-1]].pos=900,100
print(DrawPoints)
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class ADSRScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
global Lline1
global Lline2
global Lline3
global Lline4
global Lline5
global Lline6
global Lline7
global Lline8
Lline1 = self.ids.w_canvas.canvas.get_group('a')[0]
Lline2 = self.ids.w_canvas.canvas.get_group('b')[0]
Lline3 = self.ids.w_canvas.canvas.get_group('c')[0]
Lline4 = self.ids.w_canvas.canvas.get_group('d')[0]
Lline5 = self.ids.w_canvas.canvas.get_group('e')[0]
Lline6 = self.ids.w_canvas.canvas.get_group('f')[0]
Lline7 = self.ids.w_canvas.canvas.get_group('g')[0]
Lline8 = self.ids.w_canvas.canvas.get_group('h')[0]
global adsrbutmode
adsrbutmode=0
self.mode(0)
print(trackselected-1)
global trackmode
global loopsize
if trackmode[trackselected-1]!=3:
loopsize[trackselected-1]=64
self.reset()
q2.put(loopsize)
trackmode[trackselected-1]=3
print('trackmode',trackmode[trackselected-1])
self.triginfo()
clearsequence()
deleteLFO()
self.UIrefresh()
self.LoopSdisplay()
self.b006.text=str(trackselected)+ ": ADSR"
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
def closemenu(self):
self.b5017.pos=1329,305
self.b5000.pos=1228,61
self.b5001.pos=1229,245
self.b5005.pos=1229,184
self.b5009.pos=1229,123
self.b5013.pos=1229,62
self.b5002.pos=1329,245
self.b5006.pos=1329,184
self.b5010.pos=1329,123
self.b5014.pos=1329,62
self.b5003.pos=1429,245
self.b5007.pos=1429,184
self.b5011.pos=1429,123
self.b5015.pos=1429,62
self.b5004.pos=1529,245
self.b5008.pos=1529,184
self.b5012.pos=1529,123
self.b5016.pos=1529,62
self.b3005.pos=1000,0
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b018.pos= 496,900
self.b019.pos= 496,900
self.b023.pos= 496,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b012.pos= 496,301
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b018.pos= 496,242
self.b019.pos= 496,183
self.b023.pos= 496,124
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b018.pos= 496,900
self.b019.pos= 496,900
self.b023.pos= 496,900
self.b010.pos= 1000,0
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b014.pos= 344,301
#self.b016.pos= 344,242
#self.b020.pos= 344,183
#self.b022.pos= 344,124
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b018.pos= 496,900
self.b019.pos= 496,900
self.b023.pos= 496,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
else:
self.b013.pos= 344,900
self.b014.pos= 344,900
self.b016.pos= 344,900
self.b020.pos= 344,900
self.b022.pos= 344,900
self.b010.pos= 1000,0
def trig(self):
self.b5017.pos=310,305
self.b5017.text="ADSR TRIGGERED BY TRACK:"
self.b5000.pos=138,31
self.b5001.pos=139,236
self.b5005.pos=139,168
self.b5009.pos=139,100
self.b5013.pos=139,32
self.b5002.pos=269,236
self.b5006.pos=269,168
self.b5010.pos=269,100
self.b5014.pos=269,32
self.b5003.pos=399,236
self.b5007.pos=399,168
self.b5011.pos=399,100
self.b5015.pos=399,32
self.b5004.pos=529,236
self.b5008.pos=529,168
self.b5012.pos=529,100
self.b5016.pos=529,32
self.b3005.pos=0,0
self.b5001.text="1"
self.b5005.text="5"
self.b5009.text="9"
self.b5013.text="13"
self.b5002.text="2"
self.b5006.text="6"
self.b5010.text="10"
self.b5014.text="14"
self.b5003.text="3"
self.b5007.text="7"
self.b5011.text="11"
self.b5015.text="15"
self.b5004.text="4"
self.b5008.text="8"
self.b5012.text="12"
self.b5016.text="16"
def port2(self,button):
global ADSRtrig
for key, val in list(self.ids.items()):
if val==button:
ID=key
new=int((ID[-2:]))
#print(new)
for n,value in enumerate(ADSRtrig):
if trackselected==value:ADSRtrig[n]=0
ADSRtrig[new-1]=trackselected
#print(ADSRtrig)
q9.put(ADSRtrig)
self.triginfo()
def triginfo(self):
self.b014.text="TRIG: NONE"
for n,value in enumerate(ADSRtrig):
if value==trackselected:
trig=n+1
self.b014.text="TRIG: "+str(trig)
def mode(self,num):
global adsrbutmode
if num==0:
self.b003.state='normal'
self.b004.state='normal'
if num==2:
if adsrbutmode==2:
adsrbutmode=0
self.b003.state='normal'
else:
adsrbutmode=2
self.b003.state='down'
w2.value=0
if num==3:
if adsrbutmode==3:
adsrbutmode=0
self.b004.state='normal'
else:
adsrbutmode=3
self.b004.state='down'
w2.value=0
print(("buton mode",adsrbutmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
v1.value=0
playing=0
def reset(self):
global ADSRPool2
ADSRPool2[trackselected-1]=[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0]
self.UIrefresh()
self.convert2to3()
def listening(self,*args):
global wheel
global adsrbutmode
global loopsize
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if adsrbutmode==0: pass
if adsrbutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
adsrbutmode=0
self.b003.state='normal'
if adsrbutmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]<16*16:
loopsize[trackselected-1]+=16
q2.put(loopsize)
self.LoopSdisplay()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]>64:
loopsize[trackselected-1]-=16
q2.put(loopsize)
self.LoopSdisplay()
if encoderpushed==1:
adsrbutmode=0
self.b004.state='normal'
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
def LoopSdisplay(self):
self.l1.text=str(loopsize[trackselected-1]/16)
self.convert2to3()
self.b004.text=str(loopsize[trackselected-1]/16)
def encadrement_lfo(self, x, y, buttonpos):
txt = (buttonpos-x)*(100.0/(y-x))
return txt
def move_button(self, buttonpos):
#txt = (buttonpos - 190) * (100/180)
txt=self.encadrement_lfo(20, 370, buttonpos)
if buttonpos == Lline5.pos[1]:
self.b024.pos=(-25,buttonpos-35)
self.b024.text=str(int(txt))
if buttonpos == Lline6.pos[1]:
self.b028.pos=(-25,buttonpos-35)
self.b028.text=str(int(txt))
#if buttonpos == Lline7.pos[1]:
#self.b026.pos=(17,buttonpos)
#self.b026.text=str(int(txt))
def UIrefresh(self):
#print(ADSRPool2[trackselected-1])
Lline5.pos=(ADSRPool2[trackselected-1][0],ADSRPool2[trackselected-1][1])
Lline6.pos=(ADSRPool2[trackselected-1][2],ADSRPool2[trackselected-1][3])
Lline7.pos=(ADSRPool2[trackselected-1][4],ADSRPool2[trackselected-1][5])
Lline8.pos=(ADSRPool2[trackselected-1][6],ADSRPool2[trackselected-1][7])
self.displaylines()
self.move_button(Lline5.pos[1])
self.move_button(Lline6.pos[1])
def on_touch_move(self, touch):
ecart76 = Lline7.pos[0]-Lline6.pos[0]
ecart75 = Lline7.pos[0]-Lline5.pos[0]
ecart85 = Lline8.pos[0]-Lline5.pos[0]
ecart86 = Lline8.pos[0]-Lline6.pos[0]
ecart87=Lline8.pos[0]-Lline7.pos[0]
ecart = Lline6.pos[0]-Lline5.pos[0]
rayon=50
#print(touch.pos)
if (Lline5.pos[0] - rayon) <= touch.pos[0] <= (Lline5.pos[0] + rayon):
if (Lline5.pos[1] - rayon) <= touch.pos[1] <= (Lline5.pos[1] + rayon):
if 52 <= touch.pos[0] <= Lline6.pos[0]:
if Lline6.pos[1]+10 <= touch.pos[1] <= 390:
if touch.pos[0]+ecart85 <= 750:
Lline5.pos=(touch.pos[0]-10,touch.pos[1]-10)
if Lline5.pos[1]>370:
Lline5.pos=(touch.pos[0]-10,370)
Lline6.pos=(Lline5.pos[0]+ecart, Lline6.pos[1])
Lline7.pos=(Lline6.pos[0]+ecart76, Lline6.pos[1])
Lline8.pos=(Lline5.pos[0]+ecart85, Lline8.pos[1])
self.move_button(Lline5.pos[1])
self.updateADSR()
else:
if ecart87 >= 50:
Lline5.pos=(touch.pos[0]-10,touch.pos[1]-10)
if Lline5.pos[1]>370:
Lline5.pos=(touch.pos[0]-10,370)
Lline6.pos=(Lline5.pos[0]+ecart, Lline6.pos[1])
Lline7.pos=(Lline6.pos[0]+ecart76, Lline6.pos[1])
Lline8.pos=(740, Lline8.pos[1])
self.move_button(Lline5.pos[1])
self.updateADSR()
elif 30 <= touch.pos[1]<= 390:
if touch.pos[0]+ecart85 <= 750:
Lline5.pos=(touch.pos[0]-10,touch.pos[1]-10)
if Lline5.pos[1]>370:
Lline5.pos=(touch.pos[0]-10,370)
Lline6.pos=(Lline5.pos[0]+ecart, Lline5.pos[1])
Lline7.pos=(Lline6.pos[0]+ecart76, Lline5.pos[1])
Lline8.pos=(Lline5.pos[0]+ecart85, Lline8.pos[1])
self.move_button(Lline5.pos[1])
self.updateADSR()
else:
if ecart87 >= 50:
Lline5.pos=(touch.pos[0]-10,touch.pos[1]-10)
if Lline5.pos[1]>370:
Lline5.pos=(touch.pos[0]-10,370)
Lline6.pos=(Lline5.pos[0]+ecart, Lline5.pos[1])
Lline7.pos=(Lline6.pos[0]+ecart76, Lline5.pos[1])
Lline8.pos=(740, Lline8.pos[1])
self.move_button(Lline5.pos[1])
self.updateADSR()
elif (Lline6.pos[0] - rayon) <= touch.pos[0] <= (Lline6.pos[0] + rayon):
if (Lline6.pos[1] - rayon) <= touch.pos[1] <= (Lline6.pos[1] + rayon):
if Lline5.pos[0]+10 <= touch.pos[0] <= Lline7.pos[0]+10:
if 29 <= touch.pos[1] <= Lline5.pos[1]+10:
if touch.pos[0]+ecart76 <= Lline8.pos[0]+10:
if touch.pos[0]+ecart86 <= 750:
Lline6.pos=(touch.pos[0]-10,touch.pos[1]-10)
Lline7.pos=(Lline6.pos[0]+ecart76, Lline6.pos[1])
Lline8.pos=(Lline6.pos[0]+ecart86, Lline8.pos[1])
self.move_button(Lline6.pos[1])
self.updateADSR()
else:
if ecart87 >= 50:
Lline6.pos=(touch.pos[0]-10,touch.pos[1]-10)
Lline7.pos=(Lline6.pos[0]+ecart76, Lline6.pos[1])
Lline8.pos=(740, Lline8.pos[1])
self.move_button(Lline6.pos[1])
self.updateADSR()
elif (Lline7.pos[0] - rayon) <= touch.pos[0] <= (Lline7.pos[0] + rayon):
if (Lline7.pos[1] - rayon) <= touch.pos[1] <= (Lline7.pos[1] + rayon):
if Lline6.pos[0]+10 <= touch.pos[0] <= Lline8.pos[0]+10:
if touch.pos[0] + ecart87 <= 750:
Lline7.pos=(touch.pos[0]-10,Lline6.pos[1])
Lline8.pos=(Lline7.pos[0]+ecart87, Lline8.pos[1])
self.updateADSR()
self.move_button(Lline7.pos[1])
else:
if ecart87 >= 50:
Lline7.pos=(touch.pos[0]-10,Lline6.pos[1])
Lline8.pos=(740, Lline8.pos[1])
self.updateADSR()
self.move_button(Lline7.pos[1])
elif (Lline8.pos[0] - rayon) <= touch.pos[0] <= (Lline8.pos[0] + rayon):
if (Lline8.pos[1] - rayon) <= touch.pos[1] <= (Lline8.pos[1] + rayon):
if Lline7.pos[0]+10 <= touch.pos[0] <= 750:
Lline8.pos=(touch.pos[0]-10,19)
self.move_button(Lline7.pos[1])
self.updateADSR()
#print(Lline5.pos,Lline6.pos,Lline7.pos,Lline8.pos)
self.displaylines()
def displaylines(self):
Lline1.points=[(52,30),(Lline5.pos[0]+10,Lline5.pos[1]+10)]
Lline2.points=[(Lline6.pos[0]+10, Lline6.pos[1]+10),(Lline5.pos[0]+10,Lline5.pos[1]+10)]
Lline3.points=[(Lline7.pos[0]+10, Lline7.pos[1]+10),(Lline6.pos[0]+10, Lline6.pos[1]+10)]
Lline4.points=[(Lline7.pos[0]+10, Lline7.pos[1]+10),(Lline8.pos[0]+10, Lline8.pos[1]+10)]
def updateADSR(self):
global ADSRPool2
ADSRPool2[trackselected-1]=[Lline5.pos[0],Lline5.pos[1],Lline6.pos[0],Lline6.pos[1],Lline7.pos[0],Lline6.pos[1],Lline8.pos[0],Lline8.pos[1]]
#print(ADSRPool2[trackselected-1])
self.convert2to3()
def convert2to3(self):
#en fonction loopsize
global ADSRPool3
lps=loopsize[trackselected-1]
p1=[0,0]
p2=[(Lline5.pos[0]-41)/700*lps+1,(Lline5.pos[1])/330]
p3=[(Lline6.pos[0]-52)/700*lps,(Lline6.pos[1])/330]
p4=[(Lline7.pos[0]-52)/700*lps,(Lline7.pos[1])/330]
p5=[(Lline8.pos[0]-52)/700*lps,(Lline8.pos[1])/330]
#print("P",p1,p2,p3,p4,p5)
i=0
a1=self.coefs(p1,p2)
a2=self.coefs(p2,p3)
a3=self.coefs(p3,p4)
a4=self.coefs(p4,p5)
while i<lps:
if i < p2[0]:
r=a1*i
if r>0:ADSRPool3[trackselected-1][i]=r
else:ADSRPool3[trackselected-1][i]=0
x=i
elif p2[0] <= i <= p3[0]:
r=a2*(i-x)+ADSRPool3[trackselected-1][x]
if r>0: ADSRPool3[trackselected-1][i]=r
else:ADSRPool3[trackselected-1][i]=0
x=i
elif p3[0] <= i <= p4[0]:
r=a3*(i-x)+ADSRPool3[trackselected-1][x]
if r>0: ADSRPool3[trackselected-1][i]=r
else:ADSRPool3[trackselected-1][i]=0
x=i
elif p4[0] <= i <= p5[0]:
r=a4*(i-x)+ADSRPool3[trackselected-1][x]
if r>0: ADSRPool3[trackselected-1][i]=r
else:ADSRPool3[trackselected-1][i]=0
x=i
elif i>p5[0]:ADSRPool3[trackselected-1][i]=0
i+=1
#print(ADSRPool3[trackselected-1])
q8.put(ADSRPool3[trackselected-1])
def coefs(self,p1,p2):
coef=(p2[1]-p1[1])/(p2[0]-p1[0])*5
#print(coef)
return coef
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class RandomScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.CalculateRandom, 0.002)
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.CalculateRandom)
global trackmode
if trackmode[trackselected-1]!=4:
clearsequence()
deleteLFO()
deleteADSR()
trackmode[trackselected-1]=4
print('trackmode',trackmode[trackselected-1])
global randombutmode
randombutmode=0
self.mode(0)
global loopsize
loopsize[trackselected-1]=64
q2.put(loopsize)
print(trackselected-1)
global points
points=[self.ids.w_canvas.canvas.get_group('a')[0],self.ids.w_canvas.canvas.get_group('b')[0],self.ids.w_canvas.canvas.get_group('c')[0],self.ids.w_canvas.canvas.get_group('d')[0],self.ids.w_canvas.canvas.get_group('e')[0],self.ids.w_canvas.canvas.get_group('f')[0]]
self.init()
self.b006.text=str(trackselected)+ ": RANDOM"
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
try:Clock.unschedule(self.CalculateRandom)
except:pass
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b013.pos= 344,900
self.b016.pos= 496,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b012.pos= 496,301
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 496,242
self.b015.pos= 496,183
self.b016.pos= 496,124
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b016.pos= 496,900
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b016.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
else:
self.b013.pos= 344,900
self.b010.pos= 1000,0
def mode(self,num):
global randombutmode
if num==0:
self.b003.state='normal'
if num==2:
if randombutmode==2:
randombutmode=0
self.b003.state='normal'
else:
randombutmode=2
self.b003.state='down'
w2.value=0
print(("buton mode",randombutmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.delseq()
Clock.schedule_interval(self.CalculateRandom, 0.002)
else:
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.CalculateRandom)
playing=0
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.CalculateRandom)
v1.value=0
playing=0
def listening(self,*args):
global wheel
global randombutmode
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if randombutmode==0: pass
if randombutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
randombutmode=0
self.b003.state='normal'
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
#print('launched')
Clock.schedule_interval(self.CalculateRandom, 0.002)
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
Clock.unschedule(self.CalculateRandom)
def CalculateRandom(self,*args):
global randomcalculated
#global resetedrandom
count=v2.value%64
# if count==0 and resetedrandom==0:
# resetedrandom=1
# self.delseq()
if count%4==0 and randomcalculated==0:
randomcalculated=1
self.randomizing(count)
elif count%4==2 and randomcalculated==1:
randomcalculated=0
#resetedrandom=0
elif count%4==1 and randomcalculated==0:
randomcalculated=1
self.randomizing(count)
def delseq(self):
global sequencepool3
print(sequencepool3[trackselected-1])
for l in range(65):sequencepool3[trackselected-1][l]=[]
print("deleted seq3")
q6.put(sequencepool3[trackselected-1])
def randomizing(self,count):
global sequencepool3
global Ratchetcount
r=random.random()
#print(count)
#print("Random",r*100,"Desnity",RandomDensity[trackselected-1])
#mettre le random calcu dans le else?
if Ratchetcount>0:
Ratchetcount-=1
else:
self.delstep(count+4)
if r*100<RandomDensity[trackselected-1]:
ratch=RandomRatchet[trackselected-1]
Ratchetcount=RandomRatchet[trackselected-1]
n=random.random()*100
note=36+int(RandomTemp[trackselected-1]*n/280)
while ratch>=0:
#print(ratch,"ratcheting steps")
self.delstep(count+4+ratch*4)
sequencepool3[trackselected-1][(count+4+ratch*4)%64].append([note,1,4])
sequencepool3[trackselected-1][(count+8+ratch*4)%64].append([note,0,4])
sequencepool3[trackselected-1][(count+4+ratch*4)%64]=sorted(sequencepool3[trackselected-1][(count+4+ratch*4)%64],key=operator.itemgetter(1,0))
sequencepool3[trackselected-1][(count+8+ratch*4)%64]=sorted(sequencepool3[trackselected-1][(count+8+ratch*4)%64],key=operator.itemgetter(1,0))
ratch-=1
q6.put(sequencepool3[trackselected-1])
#print(sequencepool3[trackselected-1])
def delstep(self,step):
global sequencepool3
for elem in sequencepool3[trackselected-1][(step)%64]:
if elem[1]==1:
sequencepool3[trackselected-1][(step)%64].remove(elem)
sequencepool3[trackselected-1][(step+4)%64].remove([elem[0],0,elem[2]])
#print(sequencepool3[trackselected-1])
#print("deleted the sequence#####")
#q6.put(sequencepool3[trackselected-1])
def label1(self, *args):
global RandomRatchet
positions=[57,193,327,460,594,727]
self.sld1.value=int(args[1])
self.lbl1.text=str(int(self.sld1.value))
RandomRatchet[trackselected-1]=int(args[1])
for i in range(6):
if i==int(args[1]):
points[int(args[1])].pos=[1000,67]
else: points[i].pos=[positions[i],67]
def label2(self, *args):
global RandomTemp
self.sld2.value=int(args[1])
self.lbl2.text=str(int(self.sld2.value))
RandomTemp[trackselected-1]=int(args[1])
def label3(self, *args):
global RandomDensity
self.sld3.value=int(args[1])
self.lbl3.text=str(int(self.sld3.value))
RandomDensity[trackselected-1]=int(args[1])
def init(self):
self.sld1.value=RandomRatchet[trackselected-1]
self.sld2.value=RandomTemp[trackselected-1]
self.sld3.value=RandomDensity[trackselected-1]
self.lbl1.text=str(RandomRatchet[trackselected-1])
self.lbl2.text=str(RandomTemp[trackselected-1])
self.lbl3.text=str(RandomDensity[trackselected-1])
def reset(self):
global RandomTemp
global RandomDensity
global RandomRatchet
RandomTemp[trackselected-1]=20
RandomDensity[trackselected-1]=20
RandomRatchet[trackselected-1]=0
self.init()
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class EuclideanScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.animate, 0.002)
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.animate)
l1 = self.ids.w_canvas.canvas.get_group('a')[0]
l2 = self.ids.w_canvas.canvas.get_group('b')[0]
l3 = self.ids.w_canvas.canvas.get_group('c')[0]
l4 = self.ids.w_canvas.canvas.get_group('d')[0]
l5 = self.ids.w_canvas.canvas.get_group('e')[0]
l6 = self.ids.w_canvas.canvas.get_group('f')[0]
l7 = self.ids.w_canvas.canvas.get_group('g')[0]
l8 = self.ids.w_canvas.canvas.get_group('h')[0]
l9 = self.ids.w_canvas.canvas.get_group('i')[0]
l10 = self.ids.w_canvas.canvas.get_group('j')[0]
l11 = self.ids.w_canvas.canvas.get_group('k')[0]
l12 = self.ids.w_canvas.canvas.get_group('l')[0]
l13 = self.ids.w_canvas.canvas.get_group('m')[0]
l14 = self.ids.w_canvas.canvas.get_group('n')[0]
l15 = self.ids.w_canvas.canvas.get_group('o')[0]
l16 = self.ids.w_canvas.canvas.get_group('p')[0]
c1 = self.ids.w_canvas.canvas.get_group('q')[0]
g1 = self.ids.w_canvas.canvas.get_group('r')[0]
g2 = self.ids.w_canvas.canvas.get_group('s')[0]
g3 = self.ids.w_canvas.canvas.get_group('t')[0]
g4 = self.ids.w_canvas.canvas.get_group('u')[0]
g5 = self.ids.w_canvas.canvas.get_group('v')[0]
g6 = self.ids.w_canvas.canvas.get_group('w')[0]
g7 = self.ids.w_canvas.canvas.get_group('x')[0]
g8 = self.ids.w_canvas.canvas.get_group('y')[0]
g9 = self.ids.w_canvas.canvas.get_group('z')[0]
g10 = self.ids.w_canvas.canvas.get_group('z1')[0]
g11 = self.ids.w_canvas.canvas.get_group('z2')[0]
g12 = self.ids.w_canvas.canvas.get_group('z3')[0]
g13 = self.ids.w_canvas.canvas.get_group('z4')[0]
g14 = self.ids.w_canvas.canvas.get_group('z5')[0]
g15 = self.ids.w_canvas.canvas.get_group('z6')[0]
g16 = self.ids.w_canvas.canvas.get_group('z7')[0]
global items
global itemscolor
items=[l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,l11,l12,l13,l14,l15,l16]
itemscolor=[g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,g11,g12,g13,g14,g15,g16]
global trackmode
global loopsize
if trackmode[trackselected-1]!=5:
clearsequence()
deleteLFO()
deleteADSR()
trackmode[trackselected-1]=5
print('trackmode',trackmode[trackselected-1])
global euclibutmode
euclibutmode=0
self.mode(0)
print(trackselected-1)
#self.posbutton()
self.init()
self.b006.text=str(trackselected)+ ":EUCLIDEAN"
if y1.value!=0:self.b0003.pos=185,419
else:self.b0003.pos=1185,419
def projectmode(self):
if projectmode==0:self.manager.current = 'song_mode'
else:self.manager.current = 'MixerScreen'
def projectmdoedisplay(self):
if projectmode==0:self.b008.text= 'SONG'
else:self.b008.text= 'LIVE'
def init(self):
#print("here")
self.label2()
self.label1()
self.posbutton()
self.LoopSdisplay()
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule seq")
def displayinfo(self):
global manuelmodeeucli
if manuelmodeeucli==0:
manuelmodeeucli=1
self.b016.text="MANUAL: ON"
else:
manuelmodeeucli=0
self.b016.text="MANUAL: OFF"
self.posbutton()
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,360
self.b009.pos= 648,301
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b016.pos= 344,900
self.b013.pos= 344,900
self.b017.pos= 496,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.projectmdoedisplay()
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b011.pos= 496,360
self.b012.pos= 496,301
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b014.pos= 496,242
self.b015.pos= 496,183
self.b016.pos= 344,900
self.b017.pos= 496,124
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
else:
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b017.pos= 496,900
def tools(self):
if self.b005.state=="down":
self.b013.pos= 344,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b016.pos= 344,301
self.b017.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
else:
self.b013.pos= 344,900
self.b016.pos= 344,900
self.b010.pos= 1000,0
def mode(self,num):
global euclibutmode
if num==0:
self.b003.state='normal'
self.b004.state='normal'
if num==2:
if euclibutmode==2:
euclibutmode=0
self.b003.state='normal'
else:
euclibutmode=2
self.b003.state='down'
w2.value=0
if num==3:
if euclibutmode==3:
euclibutmode=0
self.b004.state='normal'
else:
euclibutmode=3
self.b004.state='down'
w2.value=0
print(("buton mode",euclibutmode))
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def listening(self,*args):
global wheel
global euclibutmode
global loopsize
global BPM
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if euclibutmode==0: pass
if euclibutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
euclibutmode=0
self.b003.state='normal'
if euclibutmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]<16*16:
loopsize[trackselected-1]+=16
q2.put(loopsize)
self.LoopSdisplay()
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsize[trackselected-1]>16:
loopsize[trackselected-1]-=16
q2.put(loopsize)
self.LoopSdisplay()
if encoderpushed==1:
euclibutmode=0
self.b004.state='normal'
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
Clock.schedule_interval(self.animate, 0.002)
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
Clock.unschedule(self.animate)
def LoopSdisplay(self):
#self.l1.text=str(loopsize[trackselected-1]/16)
self.b004.text=str(loopsize[trackselected-1]/16)
def update1(self, *args):
global stepeucli
stepeucli[trackselected-1]=int(args[1])
def update2(self, *args):
global pulseeucli
pulseeucli[trackselected-1]=int(args[1])
#print(pulseeucli)
def label1(self):
self.sld1.value=stepeucli[trackselected-1]
self.lbl1.text=str(int(stepeucli[trackselected-1]))
def label2(self):
self.sld2.value=pulseeucli[trackselected-1]
self.lbl2.text=str(int(pulseeucli[trackselected-1]))
#print("lsd2",self.sld2.value)
def posbutton(self):
#print("pos")
r=170
step = stepeucli[trackselected-1]
teta=2*pi/step
for n in range(16):
if n<step:
items[n].pos=[r*sin((n)*teta)+520, r*cos((n)*teta)+200]
else:
items[n].pos=[1000,1000]
self.colorbutton()
def manueloff(self):
global manuelmodeeucli
manuelmodeeucli=0
self.b016.text="MANUAL: OFF"
def colorbutton(self, *args):
r=170
step = stepeucli[trackselected-1]
teta=2*pi/step
if manuelmodeeucli==0:
self.Eucli()
#print("Calling Eucli")
for i in range(16):
if EucliPool2[trackselected-1][i] == 1:
itemscolor[i].pos=[r*sin((i)*teta)+520, r*cos((i)*teta)+200]
else:
itemscolor[i].pos=[1000,1000]
def reposition(self):
r=170
step = stepeucli[trackselected-1]
teta=2*pi/step
for n in range(16):
if n<step:
items[n].pos=[r*sin((n)*teta)+520, r*cos((n)*teta)+200]
else:
items[n].pos=[1000,1000]
for i in range(16):
if EucliPool2[trackselected-1][i] == 1:
itemscolor[i].pos=[r*sin((i)*teta)+520, r*cos((i)*teta)+200]
else:
itemscolor[i].pos=[1000,1000]
def Eucli(self):
global EucliPool2
steps=stepeucli[trackselected-1]
pulses=pulseeucli[trackselected-1]
#print(steps, pulses)
count=0
ResultOffset=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
Result=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
ResultC=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(steps):
count=count+pulses
if count>=steps:
count=count%steps
Result[i]=1
for j in range(steps):
ResultC[j]=Result[(j-1)%steps]
for i in range(steps):
ResultOffset[i]=ResultC[(i-EucliOffset[trackselected-1])%steps]
#print("ResultOffset",ResultOffset)
EucliPool2[trackselected-1]=ResultOffset
self.convert2to3()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
Clock.schedule_interval(self.animate, 0.002)
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
Clock.unschedule(self.animate)
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
Clock.unschedule(self.animate)
v1.value=0
playing=0
def animate(self, *args):
counter=(v2.value-1)%loopsize[trackselected-1]
#while counter>=loopsize[trackselected-1]:counter-=loopsize[trackselected-1]
if counter%4==0:
#self.posbutton()
self.reposition()
button_number=int((counter/4)%stepeucli[trackselected-1])
color_number=button_number
anim1 = Animation(pos=[itemscolor[color_number].pos[0]-10,itemscolor[color_number].pos[1]-10],size=(40, 40),duration =0.1)+Animation(pos=[itemscolor[color_number].pos[0]+0,itemscolor[color_number].pos[1]+0],size=(20, 20),duration =0.1)
anim2 = Animation(pos=[items[button_number].pos[0]-5,items[button_number].pos[1]-5],size=(30, 30),duration =0.1)+Animation(pos=[items[button_number].pos[0]+0,items[button_number].pos[1]+0],size=(20, 20),duration =0.1)
anim2.start(items[button_number])
#print("but number", button_number, "Result", Result,(button_number-offset)%stepeucli[trackselected-1])
if EucliPool2[trackselected-1][color_number]==1:
#print("animating")
anim1.start(itemscolor[color_number])
def on_touch_move(self, touch):
rayon=20
global ChangedEucli
global EucliPool2
global EucliOffset
for i in range(stepeucli[trackselected-1]):
if (items[i].pos[0] - rayon) <= touch.pos[0] <= (items[i].pos[0] + rayon):
if (items[i].pos[1] - rayon) <= touch.pos[1] <= (items[i].pos[1] + rayon):
#print(i)
if self.b016.text=="MANUAL: ON":
if ChangedEucli==0:
color_number=(i)%stepeucli[trackselected-1]
ChangedEucli=1
if EucliPool2[trackselected-1][color_number]==0:
EucliPool2[trackselected-1][color_number]=1
#itemscolor[color_number].pos=[r*sin((color_number)*teta)+520, r*cos((color_number)*teta)+200]
else:
EucliPool2[trackselected-1][color_number]=0
#itemscolor[color_number].pos=[1000,1000]
self.colorbutton()
#print("EucliPool2",EucliPool2[trackselected-1])
else:
EucliOffset[trackselected-1]=(i)%stepeucli[trackselected-1]
self.posbutton()
self.convert2to3()
break
else:
ChangedEucli=0
def Reset(self):
global pulseeucli
global stepeucli
global EucliOffset
global EucliPool2
self.manueloff()
pulseeucli[trackselected-1]=1
stepeucli[trackselected-1]=7
EucliOffset[trackselected-1]=0
self.posbutton()
self.init()
def convert2to3(self):
global sequencepool3
#print("converting")
#print('euclippol2',EucliPool2)
for l in range(64*4+1):sequencepool3[trackselected-1][l]=[]
for i in range(64):
if EucliPool2[trackselected-1][i%stepeucli[trackselected-1]]==1:
sequencepool3[trackselected-1][i*4].append([36,1,4])
sequencepool3[trackselected-1][i*4+4].append([36,0,4])
sequencepool3[trackselected-1][i*4]=sorted(sequencepool3[trackselected-1][i*4],key=operator.itemgetter(1,0))
sequencepool3[trackselected-1][i*4+4]=sorted(sequencepool3[trackselected-1][i*4+4],key=operator.itemgetter(1,0))
#sequencepool3[trackselected-1][(i+stepeucli[trackselected-1])*4].append([36,1,4])
#sequencepool3[trackselected-1][(i+8)*4+4].append([36,0,4])
#sequencepool3[trackselected-1][(i+8)*4]=sorted(sequencepool3[trackselected-1][i*4],key=operator.itemgetter(1,0))
#sequencepool3[trackselected-1][(i+8)*4+4]=sorted(sequencepool3[trackselected-1][i*4+4],key=operator.itemgetter(1,0))
q6.put(sequencepool3[trackselected-1])
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class MixerScreen(Screen):
def on_enter(self):
w1.value=0
Clock.schedule_interval(self.listening, 0.002)
self.b003.text=str(BPM)
if playing==1:
self.b001.state="down"
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
global loopsize
global livebutmode
livebutmode=0
self.mode(0)
print(trackselected-1)
self.infos()
global loopsizeS
self.b004.text=str(loopsizeS/64)
global listbuttonlive
listbuttonlive=[self.b01,self.b02,self.b03,self.b04,self.b05,self.b06,self.b07,self.b08,self.b09,self.b0100,self.b0110,self.b0120,self.b0130,self.b01400,self.b0150,self.b0160]
if loopsizeS>32*64:
loopsizeS=32*64
v3.value=loopsizeS
self.mute()
global projectmode
if projectmode==0:
projectmode=1
for i,elem in enumerate(listbuttonlive):elem.state='normal'
self.mute()
self.safedisplay()
def safemode(self):
global safemode
if safemode==0:safemode=1
else:safemode=0
self.safedisplay()
def safedisplay(self):
if safemode==1:self.b1234.pos= 496,419
else:self.b1234.pos= 496,919
def leaving(self):
Clock.unschedule(self.listening)
print("unschedule livemode")
def menu(self):
if self.b007.state=="down":
self.b008.pos= 648,900
self.b009.pos= 648,360
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b013.pos= 344,900
self.b006.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b0141.pos= 496,900
self.b0142.pos= 344,900
self.b013.pos= 496,900
else:
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b010.pos= 1000,0
def seqmode(self):
if self.b006.state=="down":
self.b008.pos= 496,360
self.b009.pos= 648,900
self.b013.pos= 344,900
self.b007.state="normal"
self.b005.state="normal"
self.b010.pos= 0,0
self.b0140.pos= 344,900
self.b0141.pos= 496,301
self.b0142.pos= 344,900
self.b013.pos= 496,900
else:
self.b008.pos= 496,900
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b010.pos= 1000,0
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b0141.pos= 496,900
def tools(self):
if self.b005.state=="down":
self.b0142.pos= 344,301
self.b0141.pos= 496,900
self.b0140.pos= 344,360
self.b013.pos= 344,242
self.b011.pos= 496,900
self.b012.pos= 496,900
self.b014.pos= 496,900
self.b015.pos= 496,900
self.b008.pos= 648,900
self.b009.pos= 648,900
self.b007.state="normal"
self.b006.state="normal"
self.b010.pos= 0,0
else:
self.b0142.pos= 344,900
self.b0140.pos= 344,900
self.b013.pos= 496,900
self.b010.pos= 1000,0
def mode(self,num):
global livebutmode
if num==2:
if livebutmode==2:
livebutmode=0
self.b003.state='normal'
else:
livebutmode=2
self.b003.state='down'
w2.value=0
if num==3:
if livebutmode==3:
livebutmode=0
self.b004.state='normal'
else:
livebutmode=3
self.b004.state='down'
w2.value=0
if num==0:
livebutmode=0
self.b003.state='normal'
self.b004.state='normal'
print("livebutmode mode",livebutmode)
def closemenus(self):
if self.b007.state=="down":
self.b007.state="normal"
self.menu()
if self.b006.state=="down":
self.b006.state="normal"
self.seqmode()
if self.b005.state=="down":
self.b005.state="normal"
self.tools()
def start(self):
global playing
if self.b001.state=="down":
v1.value=1
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
else:
self.b001.text="%s"%(icon('icon-play', 22))
playing=0
v1.value=2
def stop(self):
global playing
self.b001.state="normal"
self.b001.text="%s"%(icon('icon-play', 22))
v1.value=0
playing=0
def listening(self,*args):
global wheel
global livebutmode
global loopsize
global BPM
global loopsizeS
encodervalue=w1.value
encoderpushed=w2.value
w1.value=0
step=v2.value
if livebutmode==0: pass
if livebutmode==2:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if BPM<200:
BPM+=1
self.b003.text=str(BPM)
v4.value=BPM
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if BPM>30:
BPM-=1
self.b003.text=str(BPM)
v4.value=BPM
if encoderpushed==1:
livebutmode=0
self.b003.state='normal'
if livebutmode==3:
if encodervalue>0:
wheel+=1
if wheel==2:
wheel=0
if loopsizeS<32*64:
loopsizeS+=64
v3.value=loopsizeS
self.mute()
self.b004.text=str(loopsizeS/64)
elif encodervalue<0:
wheel+=1
if wheel==2:
wheel=0
if loopsizeS>64:
loopsizeS-=64
v3.value=loopsizeS
self.mute()
self.b004.text=str(loopsizeS/64)
if encoderpushed==1:
livebutmode=0
self.b004.state='normal'
global playing
if v6.value==1:
v6.value=2
playing=1
self.b001.text="%s"%(icon('icon-pause', 22))
self.b001.state='down'
elif v6.value==0:
self.b001.text="%s"%(icon('icon-play', 22))
self.b001.state='normal'
playing=0
v6.value=2
def displayinfo(self):
global displayinfolive
if displayinfolive==0:
displayinfolive=1
self.b0140.text="INFOS: ON"
else:
displayinfolive=0
self.b0140.text="INFOS: OFF"
self.infos()
def infos(self):
listinfo=[self.lbl16,self.lbl15,self.lbl14,self.lbl13,self.lbl12,self.lbl11,self.lbl10,self.lbl9,self.lbl8,self.lbl7,self.lbl6,self.lbl5,self.lbl4,self.lbl3,self.lbl2,self.lbl1]
if displayinfolive==1:
self.lbl16.pos=55,288
self.lbl15.pos=255,288
self.lbl14.pos=455,288
self.lbl13.pos=655,288
self.lbl12.pos=55,183
self.lbl11.pos=255,183
self.lbl10.pos=455,183
self.lbl9.pos=655,183
self.lbl8.pos=55,78
self.lbl7.pos=255,78
self.lbl6.pos=455,78
self.lbl5.pos=655,78
self.lbl4.pos=55,-27
self.lbl3.pos=255,-27
self.lbl2.pos=455,-27
self.lbl1.pos=655,-27
for n,elem in enumerate(listinfo):
if trackmode[n]==1:
elem.text="SEQUENCE"
elif trackmode[n]==2:
elem.text="LFO"
elif trackmode[n+rangeYs]==3:
for i,value in enumerate(ADSRtrig):
if value==n+rangeYs+1:
elem.text="ADSR (TRIG: " + str(i+1) +")"
break
else:
elem.text="ADSR (NO TRIG)"
elif trackmode[n]==4:
elem.text="RANDOM"
elif trackmode[n]==5:
elem.text="EUCLIDEAN"
else:
for n,elem in enumerate(listinfo):
elem.pos[0]=1000
def displayedit(self):
global displayeditlive
if displayeditlive==0:
displayeditlive=1
self.b0142.text="EDIT: ON"
else:
displayeditlive=0
self.b0142.text="EDIT: OFF"
self.edit()
def edit(self):
listedit=[self.e01,self.e02,self.e03,self.e04,self.e05,self.e06,self.e07,self.e08,self.e09,self.e010,self.e011,self.e012,self.e013,self.e014,self.e015,self.e016]
if displayeditlive==1:
self.e01.pos=2,373
self.e02.pos=201,373
self.e03.pos=401,373
self.e04.pos=601,373
self.e05.pos=2,269
self.e06.pos=201,269
self.e07.pos=401,269
self.e08.pos=601,269
self.e09.pos=2,164
self.e010.pos=201,164
self.e011.pos=401,164
self.e012.pos=601,164
self.e013.pos=2,59
self.e014.pos=201,59
self.e015.pos=401,59
self.e016.pos=601,59
else:
for n,elem in enumerate(listedit):
elem.pos[0]=1000
def mute(self,*args):
global song
for i in range(64):song[i]=[]
print(song)
for i,elem in enumerate(listbuttonlive):
self.mutechannel(i+1,elem.state)
#print("elem",elem.state)
print(song)
q3.put(song)
def mutechannel(self,channel,status):
global song
if status=='normal':
print(channel, "muted")
else:
print(channel, 'playing')
for i in range(loopsizeS/64):
song[i].append(channel)
def changescreen(self, channel):
global trackselected
trackselected=channel
print('trackselected',trackselected)
r2.put(trackselected)
s2.put(trackselected)
v5.value=trackselected
if trackmode[channel-1]==1:
self.manager.current = 'piano_roll'
elif trackmode[channel-1]==2:
self.manager.current = 'LFOScreen'
elif trackmode[channel-1]==3:
self.manager.current = 'ADSRScreen'
elif trackmode[channel-1]==4:
self.manager.current = 'RandomScreen'
elif trackmode[channel-1]==5:
self.manager.current = 'EuclideanScreen'
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class Timing():
def Timer(self,v1,v2,v3,v4,v5,v6,v7,v8,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10,q11,q12):
nextcall=time.time()
count=0
MIDIstoped=0
paused=0
portopened=0
dininreset=0
while 1:
BPM=v4.value
interval=float(60/Decimal(BPM)/Decimal(16))
v2.value=count
trackselected=v5.value
while q1.empty() is False:
sequencepool2=q1.get()
#print('sequencepool2', sequencepool2)
while q2.empty() is False:
loopsize=q2.get()
#print(('loopsize', loopsize))
while q3.empty() is False:
song=q3.get()
#print(('song', song))
while q4.empty() is False:
Sendinfo=q4.get()
#print(('sendinfo', Sendinfo))
while q5.empty() is False:
Syncinfo=q5.get()
#print(('Syncinfo',Syncinfo))
while q6.empty() is False:
update3=q6.get()
sequencepool3[trackselected-1]=update3
#print("track",trackselected-1,'sequencepool3queue', sequencepool3[trackselected-1])
while q7.empty() is False:
UpdateEnvPool3=q7.get()
EnvPool3[trackselected-1]=UpdateEnvPool3
#print('EnvPool3.track', EnvPool3[trackselected-1])
while q8.empty() is False:
UpdateADSRool3=q8.get()
ADSRPool3[trackselected-1]=UpdateADSRool3
#print('UpdateADSRool3.track', ADSRPool3[trackselected-1])
while q9.empty() is False:
ADSRtrig=q9.get()
#print('ADSRtrig', ADSRtrig)
while q10.empty() is False:
sequencepool3=q10.get()
#print('sequencepool3queue', sequencepool3)
while q11.empty() is False:
EnvPool3=q11.get()
#print('EnvPool3', EnvPool3)
while q12.empty() is False:
ADSRPool3=q12.get()
#print('UpdateADSRool3', ADSRPool3)
if rpi==1 and Syncinfo[4]==0:
available_ports = midiout.get_ports()
port = available_ports[0]
if len(available_ports)>1: port = available_ports[1]
try:port = mido.open_output(port)
except:print("error usb out port",port)
else:
port=0
if v1.value==1:
if MIDIstoped==1 and paused==0:
self.MIDImessage(250,Syncinfo)
self.USBmessage("start",Syncinfo,port)
self.jacksyncstart(Syncinfo,BPM)
if paused==1:
paused=0
self.MIDImessage(251,Syncinfo)
self.USBmessage("continue",Syncinfo,port)
self.jacksyncstart(Syncinfo,BPM)
MIDIstoped=0
count+=1
if count > v3.value:
count=1
nextcall = nextcall+interval
self.send2(count,sequencepool3,loopsize,song,Sendinfo,port,Syncinfo,ADSRtrig,EnvPool3,ADSRPool3)
if y1.value!=0:
while v7.value < 1 and y1.value!=0:
if v8.value==0 and dininreset==0:
count=0
dininreset=1
v8.value=1
print('here')
else:dininreset=0
#pass
v7.value-=1
else:
#print("available time",(nextcall-time.time()))
if nextcall-time.time()>0:
if nextcall-time.time()>interval/2+0.004:
#print("waiting:",nextcall-time.time()-interval/2)
time.sleep(nextcall-time.time()-interval/2)
self.midlfo(count,EnvPool3,loopsize,song,Sendinfo)
self.midadsr(count,ADSRPool3,loopsize,song,Sendinfo)
self.midsendCV()
#print("sleeping",(nextcall-time.time()))
#time.sleep(nextcall-time.time())
if nextcall-time.time()>0: time.sleep(nextcall-time.time())
else: nextcall=time.time()
else:
nextcall=time.time()
elif v1.value==2:
paused=1
if MIDIstoped==0:
self.MIDImessage(252,Syncinfo)
self.USBmessage("stop",Syncinfo,port)
self.jacksyncstop()
MIDIstoped=1
#self.stopCV()
for i in range(0,16):
self.noteoffUSB(i,Sendinfo,port)
self.noteoffMIDI(i,Sendinfo)
else:
if MIDIstoped==0 or paused==1:
MIDIstoped=1
paused=0
self.MIDImessage(252,Syncinfo)
self.USBmessage("stop",Syncinfo,port)
self.jacksyncstop()
#self.stopCV()
global ADSRcounter
ADSRcounter=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(0,16):
self.noteoffUSB(i,Sendinfo,port)
self.noteoffMIDI(i,Sendinfo)
count=0
time.sleep(0.0005)
def send2(self,count,sequencepool3,loopsize,song,Sendinfo,port,Syncinfo,ADSRtrig,EnvPool3,ADSRPool3):
for n,track in enumerate(sequencepool3): #n is track number
pos=count%loopsize[n]-1
if pos==-1: pos=loopsize[n]-1
if pos==0:
if n+1 in song[int(count/(16*4))-1]:
#print(("All Notes Off on track: ",n+1))
if Sendinfo[n][6]==1: self.noteoffUSB(n,Sendinfo,port)
if Sendinfo[n][6]==2: self.noteoffMIDI(n,Sendinfo)
if n+1 in song[int(v3.value/(16*4))-1] and count==1:
#print(("All Notes Off on track (looped): ",n+1))
if Sendinfo[n][6]==1: self.noteoffUSB(n,Sendinfo,port)
if Sendinfo[n][6]==2: self.noteoffMIDI(n,Sendinfo)
if n+1 in song[int(count/(16*4))]:
#print(pos)
if EnvPool3[n][pos]!=[]:
#print(n,EnvPool3[n][pos])
if Sendinfo[n][9]>0:self.CVsendLFO(n,EnvPool3[n][pos],Sendinfo)
if len(track[pos])>0:
if ADSRtrig[n]!=0:
for elem in track[pos]:
if elem[1]==1:
self.CVlaunchADSR(ADSRtrig[n])
break
for elem in track[pos]:
if Sendinfo[n][6]==1: self.USBsend2(n,elem,Sendinfo,port)
if Sendinfo[n][6]==2: self.MIDIsend2(n,elem,Sendinfo)
if Sendinfo[n][1]>0: self.CVsendPitch2(n,elem,Sendinfo)
if Sendinfo[n][3]>0: self.CVsendGate2(n,elem,Sendinfo)
if ADSRcounter[n]>0:
if Sendinfo[n][12]>0:self.CVsendADSR(n,ADSRPool3,Sendinfo,loopsize)
#if count%64==0 and n+1 not in song[int(count/(16*4))] and n+1 in song[int(count/(16*4))-1]
# print("All Notes Off song mode change")
# if Sendinfo[n][6]==1: self.noteoffUSB(n,Sendinfo,port)
# if Sendinfo[n][6]==2: self.noteoffMIDI(n,Sendinfo)
self.sendCV()
if count%2==0:
self.MIDImessage(248,Syncinfo)
self.USBmessage("clock",Syncinfo,port)
self.MIDImessage(248,Syncinfo)
self.USBmessage("clock",Syncinfo,port)
else:
self.MIDImessage(248,Syncinfo)
self.USBmessage("clock",Syncinfo,port)
def midlfo(self,count,EnvPool3,loopsize,song,Sendinfo):
for n,lfo in enumerate(EnvPool3):
if n+1 in song[int(count/(16*4))]:
pos=count%loopsize[n]-1
if EnvPool3[n][pos]!=[] and EnvPool3[n][pos+1]!=[]:
#print(n,EnvPool3[n][pos])
#if Sendinfo[n][9]>0:self.CVsendLFO(n,EnvPool3[n][pos],Sendinfo)
if Sendinfo[n][9]>0:
elem=(EnvPool3[n][pos]+EnvPool3[n][pos+1])/2
#print("sending LFO:", "loopsize:" , loopsize[n],"pos",pos,"value",elem)
if elem!=[]:
a,b=divmod(4096*(elem+5.00)/15,256)
#print(('CV LFO',Sendinfo[n][9],Sendinfo[n][10], 'Value',elem))
CVsends2.append([Sendinfo[n][9],Sendinfo[n][10],[int(a), int(b)],Sendinfo[n][11]])
def midadsr(self,count,ADSRPool3,loopsize,song,Sendinfo):
for n,adsr in enumerate(EnvPool3):
if ADSRcounter[n]>0:
if Sendinfo[n][12]>0:
if 2<ADSRcounter[n]<loopsize[n]+1:
#elem=(ADSRPool3[n][ADSRcounter[n]-2]+ADSRPool3[n][ADSRcounter[n]-1])/4.0
elem=(ADSRPool3[n][ADSRcounter[n]-2]+ADSRPool3[n][ADSRcounter[n]-1])/2.0
#print("adsr",elem)
if elem!=[] and elem!=0:
a,b=divmod(4096*(elem+5.00)/15,256)
CVsends2.append([Sendinfo[n][12],Sendinfo[n][13],[int(a), int(b)],Sendinfo[n][14]])
#print("elem added")
def midsendCV(self):
global CVsends2
CVsends2=sorted(CVsends2, key = lambda x: x[3])
dacregister2=[[],[],[]]
for elem in CVsends2:
if elem[0]==0x61: dacregister2[0].append([elem[0],elem[1],elem[2]])
if elem[0]==0x62: dacregister2[1].append([elem[0],elem[1],elem[2]])
if elem[0]==0x60: dacregister2[2].append([elem[0],elem[1],elem[2]])
#print("dacregisteres",dacregister2)
#print("Sendinfo",Sendinfo)
CVsends2=[]
try:
for dac in dacregister2:
if len(dac)==1:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], dac[0][2])
#print(dac[0][0], dac[0][1], dac[0][2])
if len(dac)==2:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
if len(dac)==3:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1]])
if len(dac)==4:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1],dac[3][1], dac[3][2][0],dac[3][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1],dac[3][1], dac[3][2][0],dac[3][2][1]])
except: print("error dac registers")
def sendCV(self):
global CVsends
global CVdelayed
CVsends=sorted(CVsends, key = lambda x: x[3])
#print("Cv sends:",CVsends)
#print("CV delayed", CVdelayed)
dacregister=[[],[],[]]
for elem in CVsends:
if elem[0]==0x61: dacregister[0].append([elem[0],elem[1],elem[2]])
if elem[0]==0x62: dacregister[1].append([elem[0],elem[1],elem[2]])
if elem[0]==0x60: dacregister[2].append([elem[0],elem[1],elem[2]])
CVsends=CVdelayed
CVdelayed=[]
#print("dacregisteres",dacregister)
#print("Sendinfo",Sendinfo)
try:
for dac in dacregister:
if len(dac)==1:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], dac[0][2])
#print(dac[0][0], dac[0][1], dac[0][2])
if len(dac)==2:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
if len(dac)==3:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1]])
if len(dac)==4:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1],dac[3][1], dac[3][2][0],dac[3][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1],dac[2][1], dac[2][2][0],dac[2][2][1],dac[3][1], dac[3][2][0],dac[3][2][1]])
except: print("error dac registers")
def stopCV(self):
global CVsends
CVsends=[]
i=0
a,b=divmod(4096*(5.00)/15,256)
while i <12:
CVsends.append([CVinfo[i][0],CVinfo[i][1],[int(a), int(b)],CVinfo[i][2]])
i+=1
#print(CVsends)
self.sendCV()
def CVsendLFO(self,n,elem,Sendinfo):
if elem!=[]:
a,b=divmod(4096*(elem+5.00)/15,256)
#print(('CV LFO',Sendinfo[n][9],Sendinfo[n][10], 'Value',elem))
CVsends.append([Sendinfo[n][9],Sendinfo[n][10],[int(a), int(b)],Sendinfo[n][11]])
def CVlaunchADSR(self,trigering):
global ADSRcounter
ADSRcounter[trigering-1]=1
#print("launch counter ADSR",trigering)
#print(ADSRcounter)
def CVsendADSR(self,n,ADSRPool3,Sendinfo,loopsize):
global ADSRcounter
if ADSRcounter[n]<loopsize[n]+1:ADSRcounter[n]+=1
else:ADSRcounter[n]=2
#print("adsr counter",ADSRcounter)
#print("ADSR",ADSRPool3[n][ADSRcounter[n]-2]/2.0)
#elem=ADSRPool3[n][ADSRcounter[n]-2]/2.0
elem=ADSRPool3[n][ADSRcounter[n]-2]
#print("ADSR",elem)
if elem!=[]:
a,b=divmod(4096*(elem+5.00)/15,256)
CVsends.append([Sendinfo[n][12],Sendinfo[n][13],[int(a), int(b)],Sendinfo[n][14]])
#print(CVsends)
def resetADSRcounter(self,n):
global ADSRcounter
ADSRcounter[n]=0
#print(ADSRcounter)
def noteoffUSB(self,n,Sendinfo,port):
#print("note off USB")
channel=Sendinfo[n][0]-1
msg=mido.Message('control_change', channel=channel,control=123)
try: port.send(msg)
except:
pass
#print('(Port error note off)')
def noteoffMIDI(self,n,Sendinfo):
#print("note off DIN",n)
byte1=bin(int(176+Sendinfo[n][0]-1))
byte2=bin(int(123))
byte3=bin(0)
byte_chr1 = chr(int(byte1,2))
byte_chr2 = chr(int(byte2,2))
byte_chr3 = chr(int(byte3,2))
if rpi==1:
ser.write(byte_chr1)
ser.write(byte_chr2)
ser.write(byte_chr3)
def MIDImessage(self,message,Syncinfo):
#stop 252, continue 251, start 250, clock 248
#print(message)
if Syncinfo[0]==1:
byte1=bin(int(message))
#print(message)
byte_chr1 = chr(int(byte1,2))
if rpi==1: ser.write(byte_chr1)
def USBmessage(self,message,Syncinfo,port):
#stop, continue, start, clock
if Syncinfo[1]==1:
msg=mido.Message(message)
#print(message)
try:
port.send(msg)
#print("clock1")
if Syncinfo[3]==2 and message=="clock":
port.send(msg)
#print("clock2")
except:
pass
#print('(Port error message)')
def CVsendGate2(self,n,elem,Sendinfo):
global CVsends
global CVdelayed
if elem[1]==1:
#print(('CV Gate On',Sendinfo[n][3], Sendinfo[n][4], 'Value: 8V'))
if [Sendinfo[n][3],Sendinfo[n][4],[0x05, 0x55],Sendinfo[n][8]] in CVsends and [Sendinfo[n][3],Sendinfo[n][4],[0x0D, 0xE0],Sendinfo[n][8]] not in CVdelayed:
CVdelayed.append([Sendinfo[n][3],Sendinfo[n][4],[0x0D, 0xE0],Sendinfo[n][8]])
else:
if [Sendinfo[n][3],Sendinfo[n][4],[0x0D, 0xE0],Sendinfo[n][8]] not in CVsends and [Sendinfo[n][3],Sendinfo[n][4],[0x0D, 0xE0],Sendinfo[n][8]] not in CVdelayed:
CVsends.append([Sendinfo[n][3],Sendinfo[n][4],[0x0D, 0xE0],Sendinfo[n][8]])
else:
#print(('CV Gate Off',Sendinfo[n][3], Sendinfo[n][4], 'Value: 0V'))
if [Sendinfo[n][3],Sendinfo[n][4],[0x05, 0x55],Sendinfo[n][8]] not in CVsends:
CVsends.append([Sendinfo[n][3],Sendinfo[n][4],[0x05, 0x55],Sendinfo[n][8]])
def CVsendPitch2(self,n,elem,Sendinfo):
if elem[1]==1:
a,b=divmod(4096*elem[0]/15/12+4096/15*Sendinfo[n][5],256)
#print(('CV Pitch On',Sendinfo[n][1],Sendinfo[n][2], 'Value',elem[0], 'Offset' , Sendinfo[n][5]))
if len(CVsends)>0:
for elem in CVsends:
if elem [3]==Sendinfo[n][7]:break
else: CVsends.append([Sendinfo[n][1],Sendinfo[n][2],[a, b],Sendinfo[n][7]])
else: CVsends.append([Sendinfo[n][1],Sendinfo[n][2],[a, b],Sendinfo[n][7]])
def MIDIsend2(self,n,elem,Sendinfo):
if elem[1]==1:
#print(("DIN send" , elem[0] ,"channel" , Sendinfo[n][0]))
byte1=bin(int(128+16+Sendinfo[n][0]-1))
byte3=bin(100)
else:
#print(("DIN stop" , elem[0] ,"channel" , Sendinfo[n][0]))
byte1=bin(int(128+Sendinfo[n][0]-1))
byte3=bin(0)
byte2 = bin(int(24+elem[0]))
byte_chr1 = chr(int(byte1,2))
byte_chr3 = chr(int(byte3,2))
byte_chr2 = chr(int(byte2,2))
if rpi==1:
ser.write(byte_chr1)
ser.write(byte_chr2)
ser.write(byte_chr3)
def USBsend2(self,n,elem,Sendinfo,port):
#print(port)
channel=Sendinfo[n][0]-1
if elem[1]==1: msg=mido.Message('note_on', note=elem[0]+24, channel=channel)
else: msg=mido.Message('note_off', note=elem[0]+24, channel=channel)
try: port.send(msg)
except:
#print('(Port error sending)')
pass
def jacksyncstart(self,Syncinfo,BPM):
if rpi==1:
GPIO.output(jackstart,GPIO.HIGH)
pwmsync.ChangeFrequency(BPM*Syncinfo[2]/4)
pwmsync.start(50)
def jacksyncstop(self):
if rpi==1:
GPIO.output(jackstart,GPIO.LOW)
pwmsync.stop()
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class Listen():
def starting(self,w1,w2):
global clkLastState
global swLastState
if rpi==1:
clkLastState = GPIO.input(clk)
swLastState = GPIO.input(sw)
while 1:
self.encoder()
time.sleep(0.001)
def encoder(self):
#print('listening')
global clkLastState
global swLastState
if rpi==1:
clkState = GPIO.input(clk)
dtState = GPIO.input(dt)
if clkState != clkLastState:
if dtState != clkState: w1.value+=-1
else: w1.value+=1
clkLastState = clkState
swstate =GPIO.input(sw)
if swstate != swLastState:
if swstate==0:
if w2.value==1: w2.value=0
else: w2.value=1
swLastState=swstate
class Listen2():
def starting(self,r1,r2,r3,r4,x1,y1):
global midibyte
global messagemidi
global Syncmessage
midibyte=0
Syncmessage=0
messagemidi = [0, 0, 0]
#print("listen2")
while 1:
while r1.empty() is False:
Sendinfo=r1.get()
#print(('Sendinfo', Sendinfo))
while r2.empty() is False:
trackselected=r2.get()
#print(('trackselected', trackselected))
while r3.empty() is False:
Syncinfo=r3.get()
#print(('Syncinfo2', Syncinfo))
#print("listen2")
self.MIDIdinIn(Sendinfo,trackselected,Syncinfo)
time.sleep(0.001)
def MIDIdinIn(self,Sendinfo,trackselected,Syncinfo):
global midibyte
if rpi==1:
while midibyte < 3:
data = ord(ser.read(1)) # read a byte
#print(data)
if data==250 or data==251 or data==252 or data==248:
# self.DINsyncout(data,Syncinfo)
if x1.value==1 or y1.value==2:self.DINsyncin(data)
if data >> 7 != 0:
midibyte = 0 # status byte! this is the beginning of a midi message!
messagemidi[midibyte] = data
midibyte += 1
midibyte=0
messagetype = messagemidi[0] >> 4
messagechannel = (messagemidi[0] & 15) + 1
note = messagemidi[1] if len(messagemidi) > 1 else None
velocity = messagemidi[2] if len(messagemidi) > 2 else None
if messagetype==8 or messagetype==9 or messagetype==11:
#self.ThroughDin([messagetype,note,velocity],Sendinfo,trackselected)
if x1.value==1:self.ThroughCV([messagetype,note,velocity],Sendinfo,trackselected)
if messagetype==9:
if x1.value==1:self.DinINRec(note)
def DinINRec(self,note):
#print(note)
r4.put(note)
def DINsyncin(self,message):
global Syncmessage
#print("DINSYNCIN message!!",x1.value)
if v6.value==0 or 1:
v6.value=2
if message==250 and y1.value==2:
print("PLAY")
v2.value=0
v1.value=1
v8.value=0
Syncmessage=0
if message==251 and y1.value==2:
#print("CONTINUE")
v1.value=1
v6.value=1
#print("STOP")
#v1.value=0
#v6.value=0
# if message==252:
# #print("STOP")
# #pass
# if y1.value==0:
# v1.value=0
# v6.value=0
if message==248 and v1.value==1:
if y1.value==2:
Syncmessage+=1
if Syncmessage==1:
v7.value+=1
if Syncmessage==3:
v7.value+=1
Syncmessage=0
else:
Syncmessage=0
def DINsyncout(self,message,Syncinfo):
if Syncinfo[0]==1:
byte1=bin(int(message))
byte_chr1 = chr(int(byte1,2))
if rpi==1: ser.write(byte_chr1)
if message==250: print("PLAY")
if message==251: print("PAUSE")
if message==252: print("STOP")
def ThroughDin(self,Message,Sendinfo,trackselected):
if Message[0]==9:
#print("send" , Message)
byte1=bin(int(128+16+Sendinfo[trackselected-1][0]-1))
byte3=bin(100)
if Message[0]==8:
#print("stop" , Message)
byte1=bin(int(128+Sendinfo[trackselected-1][0]-1))
byte3=bin(0)
if Message[0]==11:
#print("stop all notes" , Message)
byte1=bin(int(176+Sendinfo[trackselected-1][0]-1))
byte3=bin(0)
byte2 = bin(int(Message[1]))
byte_chr1 = chr(int(byte1,2))
byte_chr3 = chr(int(byte3,2))
byte_chr2 = chr(int(byte2,2))
ser.write(byte_chr1)
ser.write(byte_chr2)
ser.write(byte_chr3)
def ThroughCV(self,Message,Sendinfo,trackselected):
#print(Message)
Tosend=[]
if Sendinfo[trackselected-1][3]>0:
if Message[0]==0x90: Tosend.append([Sendinfo[trackselected-1][3], Sendinfo[trackselected-1][4], [0x0D, 0xE0],Sendinfo[trackselected-1][8]])
if Message[0]==0x80: Tosend.append([Sendinfo[trackselected-1][3], Sendinfo[trackselected-1][4], [0x05, 0x55],Sendinfo[trackselected-1][8]])
if Sendinfo[trackselected-1][1]>0:
if Message[0]==0x90 and (Message[1]-24)>0 and (Message[1]-24)<96 :
a,b=divmod(4096*(Message[1]-24)/15/12+4096/15*Sendinfo[trackselected-1][5],256)
Tosend.append([Sendinfo[trackselected-1][1], Sendinfo[trackselected-1][2], [a, b],Sendinfo[trackselected-1][7]])
if len(Tosend)>0:
Tosend=sorted(Tosend, key = lambda x: x[3])
#print(Tosend)
dacregister=[[],[],[]]
for elem in Tosend:
if elem[0]==0x61: dacregister[0].append([elem[0],elem[1],elem[2]])
if elem[0]==0x62: dacregister[1].append([elem[0],elem[1],elem[2]])
if elem[0]==0x60: dacregister[2].append([elem[0],elem[1],elem[2]])
try:
for dac in dacregister:
if len(dac)==1:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], dac[0][2])
#print(dac[0][0], dac[0][1], dac[0][2])
if len(dac)==2:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
except: print("error through CV")
class Listen3():
def starting(self,s1,s2,s3,s4):
portopened=0
if rpi==1:
midi_in = rtmidi.MidiIn()
midi_in.ignore_types(timing=False)
global Syncmessage
Syncmessage=0
while 1:
while s1.empty() is False:
Sendinfo=s1.get()
#print(('Sendinfo', Sendinfo))
while s2.empty() is False:
trackselected=s2.get()
#print(('trackselected', trackselected))
while s3.empty() is False:
Syncinfo=s3.get()
#print(('Syncinfo', Syncinfo))
if rpi==1 and Syncinfo[4]==1:
available_ports = midiout.get_ports()
if len(available_ports)==2 and portopened==0:
#midi_in = rtmidi.MidiIn(rtapi=3)
midi_in = rtmidi.MidiIn()
midi_in.ignore_types(timing=False)
midi_in.open_port(1)
portopened=1
#r=rtmidi.get_compiled_api()
#print("api",r)
elif len(available_ports)==2 and portopened==1:
midi_in.close_port()
portopened=0
del midi_in
print('deleted port')
if Syncinfo[4]==0:
try: del midi_in
except: pass
portopened=0
if rpi==1 and portopened==1: self.MIDIusbIn(Sendinfo,trackselected,midi_in,Syncinfo)
time.sleep(0.001)
def MIDIusbIn(self,Sendinfo,trackselected,midi_in,Syncinfo):
if rpi==1:
#midi_in.ignore_types(timing=False)
#try:
message= midi_in.get_message()
if message:
#print(message)
self.ThroughCV(message[0],Sendinfo,trackselected)
self.USBrec(message[0])
#print(message)
self.USBsyncin(message[0])
# q=midi_in.get_current_api()
# if q == rtmidi.API_UNIX_JACK:
# print("Using JACK API for MIDI input.")
#self.USBsync(message[0],Syncinfo) #pour plus tard
#except: print("midi_in unknown")
def USBsyncin(self,message):
global Syncmessage
#print("DINSYNCIN message!!",x1.value)
if v6.value==0 or 1:
v6.value=2
# if message[0]==250:
# #print("PLAY")
# v2.value=0
# v1.value=1
# v8.value=0
# Syncmessage=0
# if message[0]==251:
# #print("CONTINUE")
# v1.value=1
# v6.value=1
# #print("STOP")
# #v1.value=0
# #v6.value=0
if message[0]==252:
#print("STOP")
#pass
v1.value=0
v6.value=0
if message[0]==248 and v1.value==0:
v2.value=0
v1.value=1
v8.value=0
Syncmessage=0
if message[0]==248 and v1.value==1:
if y1.value==1:
Syncmessage+=1
if Syncmessage==1:
v7.value+=1
if Syncmessage==3:
v7.value+=1
Syncmessage=0
else:
Syncmessage=0
def USBrec(self,message):
if 144 <= message[0] <= 159: s4.put(message[1])
def USBsync(self,message,Syncinfo):
if Syncinfo[1]==1:
if message[0]==250: #play
v1.value=1
if message[0]==252: #stop
v1.value=2
if message[0]==251: #continue
v1.value=2
#print(message)
def ThroughCV(self,Message,Sendinfo,trackselected):
Tosend=[]
if Sendinfo[trackselected-1][3]>0:
if Message[0]==144: Tosend.append([Sendinfo[trackselected-1][3], Sendinfo[trackselected-1][4], [0x0D, 0xE0],Sendinfo[trackselected-1][8]])
if Message[0]==128: Tosend.append([Sendinfo[trackselected-1][3], Sendinfo[trackselected-1][4], [0x05, 0x55],Sendinfo[trackselected-1][8]])
if Sendinfo[trackselected-1][1]>0:
if Message[0]==144 and (Message[1]-24)>0 and (Message[1]-24)<96 :
a,b=divmod(4096*(Message[1]-24)/15/12+4096/15*Sendinfo[trackselected-1][5],256)
Tosend.append([Sendinfo[trackselected-1][1], Sendinfo[trackselected-1][2], [a, b],Sendinfo[trackselected-1][7]])
if len(Tosend)>0:
Tosend=sorted(Tosend, key = lambda x: x[3])
#print("Tosend",Tosend)
dacregister=[[],[],[]]
for elem in Tosend:
if elem[0]==0x61: dacregister[0].append([elem[0],elem[1],elem[2]])
if elem[0]==0x62: dacregister[1].append([elem[0],elem[1],elem[2]])
if elem[0]==0x60: dacregister[2].append([elem[0],elem[1],elem[2]])
try:
for dac in dacregister:
if len(dac)==1:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], dac[0][2])
#print(dac[0][0], dac[0][1], dac[0][2])
if len(dac)==2:
if rpi==1:bus.write_i2c_block_data(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
#print(dac[0][0], dac[0][1], [dac[0][2][0],dac[0][2][1],dac[1][1], dac[1][2][0],dac[1][2][1]])
except: print("error through CV")
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
class Manager(ScreenManager):
screen_one= ObjectProperty(None)
screen_two= ObjectProperty(None)
screen_three= ObjectProperty(None)
screen_four= ObjectProperty(None)
screen_five= ObjectProperty(None)
screen_six= ObjectProperty(None)
screen_seven= ObjectProperty(None)
class SequencerApp(App):
def build(self):
Config.set('graphics', 'KIVY_CLOCK', 'interrupt')
Config.write()
sm = Manager(transition=NoTransition())
return sm
def __init__(self, **kwargs):
super(SequencerApp, self).__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
def _keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard = None
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
#print("keyboard, ",keycode)
if keycode[0]==276:w1.value-=1
elif keycode[0]==275:w1.value+=1
elif keycode[0]==13:
if w2.value==1: w2.value=0
else: w2.value=1
return True
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
keyrange=[['C0',1],['C#0',0],['D0',1],['D#0',0],['E0',1],['F0',1],['F#0',0],['G0',1],['G#0',0],['A0',1],['A#0',0],['B0',1],
['C1',1],['C#1',0],['D1',1],['D#1',0],['E1',1],['F1',1],['F#1',0],['G1',1],['G#1',0],['A1',1],['A#1',0],['B1',1],
['C2',1],['C#2',0],['D2',1],['D#2',0],['E2',1],['F2',1],['F#2',0],['G2',1],['G#2',0],['A2',1],['A#2',0],['B2',1],
['C3',1],['C#3',0],['D3',1],['D#3',0],['E3',1],['F3',1],['F#3',0],['G3',1],['G#3',0],['A3',1],['A#3',0],['B3',1],
['C4',1],['C#4',0],['D4',1],['D#4',0],['E4',1],['F4',1],['F#4',0],['G4',1],['G#4',0],['A4',1],['A#4',0],['B4',1],
['C5',1],['C#5',0],['D5',1],['D#5',0],['E5',1],['F5',1],['F#5',0],['G5',1],['G#5',0],['A5',1],['A#5',0],['B5',1],
['C6',1],['C#6',0],['D6',1],['D#6',0],['E6',1],['F6',1],['F#6',0],['G6',1],['G#6',0],['A6',1],['A#6',0],['B6',1],
['C7',1],['C#7',0],['D7',1],['D#7',0],['E7',1],['F7',1],['F#7',0],['G7',1],['G#7',0],['A7',1],['A#7',0],['B7',1]]
timerange=["1","","","",".","","","",".","","","",".","","","","2","","","",".","","","",".","","","",".","","","","3","","","",".","","","",".","","","",".","","","","4","","","",".","","","",".","","","",".","","","",
"5","","","",".","","","",".","","","",".","","","","6","","","",".","","","",".","","","",".","","","","7","","","",".","","","",".","","","",".","","","","8","","","",".","","","",".","","","",".","","","",
"9","","","",".","","","",".","","","",".","","","","10","","","",".","","","",".","","","",".","","","","11","","","",".","","","",".","","","",".","","","","12","","","",".","","","",".","","","",".","","","",
"13","","","",".","","","",".","","","",".","","","","14","","","",".","","","",".","","","",".","","","","15","","","",".","","","",".","","","",".","","","","16","","","",".","","","",".","","","",".","","","",
"17","","","",".","","","",".","","","",".","","","","18","","","",".","","","",".","","","",".","","","","19","","","",".","","","",".","","","",".","","","","20","","","",".","","","",".","","","",".","","","",
"21","","","",".","","","",".","","","",".","","","","22","","","",".","","","",".","","","",".","","","","23","","","",".","","","",".","","","",".","","","","24","","","",".","","","",".","","","",".","","","",
"25","","","",".","","","",".","","","",".","","","","26","","","",".","","","",".","","","",".","","","","27","","","",".","","","",".","","","",".","","","","28","","","",".","","","",".","","","",".","","","",
"29","","","",".","","","",".","","","",".","","","","30","","","",".","","","",".","","","",".","","","","31","","","",".","","","",".","","","",".","","","","32","","","",".","","","",".","","","",".","","","",
"33","","","",".","","","",".","","","",".","","","","34","","","",".","","","",".","","","",".","","","","35","","","",".","","","",".","","","",".","","","","36","","","",".","","","",".","","","",".","","","",
"37","","","",".","","","",".","","","",".","","","","38","","","",".","","","",".","","","",".","","","","39","","","",".","","","",".","","","",".","","","","40","","","",".","","","",".","","","",".","","","",
"41","","","",".","","","",".","","","",".","","","","42","","","",".","","","",".","","","",".","","","","43","","","",".","","","",".","","","",".","","","","44","","","",".","","","",".","","","",".","","","",
"45","","","",".","","","",".","","","",".","","","","46","","","",".","","","",".","","","",".","","","","47","","","",".","","","",".","","","",".","","","","48","","","",".","","","",".","","","",".","","","",
"49","","","",".","","","",".","","","",".","","","","50","","","",".","","","",".","","","",".","","","","51","","","",".","","","",".","","","",".","","","","52","","","",".","","","",".","","","",".","","","",
"53","","","",".","","","",".","","","",".","","","","54","","","",".","","","",".","","","",".","","","","55","","","",".","","","",".","","","",".","","","","56","","","",".","","","",".","","","",".","","","",
"57","","","",".","","","",".","","","",".","","","","58","","","",".","","","",".","","","",".","","","","59","","","",".","","","",".","","","",".","","","","60","","","",".","","","",".","","","",".","","","",
"61","","","",".","","","",".","","","",".","","","","62","","","",".","","","",".","","","",".","","","","63","","","",".","","","",".","","","",".","","","","64","","","",".","","","",".","","","",".","","","",
"65","","","",".","","","",".","","","",".","","","","66","","","",".","","","",".","","","",".","","","","67","","","",".","","","",".","","","",".","","","","68","","","",".","","","",".","","","",".","","","",
"69","","","",".","","","",".","","","",".","","","","70","","","",".","","","",".","","","",".","","","","71","","","",".","","","",".","","","",".","","","","72","","","",".","","","",".","","","",".","","","",
"73","","","",".","","","",".","","","",".","","","","74","","","",".","","","",".","","","",".","","","","75","","","",".","","","",".","","","",".","","","","76","","","",".","","","",".","","","",".","","",""]
# [step number, note number, on, note length][step number + note length, note number, off, nnote length]
sequencepool2=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
# [Channel 1, Channel 2..] => [[step 1],[step 2],[step 3],... ] => [[note, status, length],[note, status, length],..]
sequencepool_0=[[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]]
sequencepool3=sequencepool_0
EnvPool2=[[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]],[[400.001,379.001]]]
EnvPool3=[[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]]
ADSRPool2=[[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0],[92.0,370.0,142.0,195.0,292.0,195.0,492.0,20.0]]
ADSRPool3=[[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]],
[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]]
EucliPool2=[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
EnvPool0=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
#print(sequencepool3)
#print(sequencepool3[1])
# [Midi channel, Pitch Dac N, Pitch Ch N, Gate Dac N, Gate Ch N, Pitch offeset,DIN or USB,CV Num Pitch, Cv Num Gate]
Sendinfo=numpy.full((100,15),0)
Sendinfo=Sendinfo.tolist()
#print(Sendinfo)
# Indexed chronologialy ; [Track a,Track b, ...]
song=[[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[1],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],
[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
# [DAC Adress, Channel Adress]
#CVinfo=[[0x62,0x54,3],[0x62,0x56,4],[0x62,0x52,2],[0x62,0x50,1],[0x61,0x54,7],[0x61,0x56,8],[0x61,0x52,6],[0x61,0x50,5],[0x60,0x54,11],[0x60,0x56,12],[0x60,0x52,10],[0x60,0x50,9]]
#CVinfo=[[0x61,0x54,3],[0x61,0x56,4],[0x61,0x52,2],[0x61,0x50,1],[0x62,0x56,8],[0x62,0x54,7],[0x62,0x52,6],[0x62,0x50,5],[0x60,0x56,12],[0x60,0x54,11],[0x60,0x52,10],[0x60,0x50,9]]
CVinfo=[[0x60,0x44,3],[0x60,0x46,4],[0x60,0x42,2],[0x60,0x40,1],[0x61,0x46,8],[0x61,0x44,7],[0x61,0x42,6],[0x61,0x40,5],[0x62,0x46,12],[0x62,0x44,11],[0x62,0x42,10],[0x62,0x40,9]]
zoom=4
rangeX=0
rangeXs=0
rangeXmax=64*16-1
rangeFile=0
rangeYs=0
rangeY=36 #C0=0, 8 octaves
rangeMidi=0
rangeCV=0
rangeCVTrack=0
start=0
trackselected=1
wheel=0
loopsizeS=64*16
erased=0
trackselectedparam=1
BPM=120
interval=float(60/Decimal(BPM)/Decimal(16))
count=0
recordingON=0
DACpool=[0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]
CVsends=[]
CVsends2=[]
CVdelayed=[]
stoplong=0
trackmode=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
Phase=[55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55]
ADSRtrig=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] #track i triggers ADSR from track x
ADSRcounter=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
displayinfo=1
stepeucli=[7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7]
pulseeucli=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
ChangedEucli=0
EucliOffset=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
manuelmodeeucli=0
RandomDensity=[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20]
RandomTemp=[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20]
RandomRatchet=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
randomcalculated=0
resetedrandom=0
Ratchetcount=0
displayinfolive=1
displayeditlive=0
polaritylfo=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
DrawPoints=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
projectmode=0
safemode=0
dininreset=0
# size of the loops of each tracks
loopsize=numpy.full(100,64)
loopsize=loopsize.tolist()
playing=0
buttonpushed="b000"
buttonpushedsong="b000"
if rpi==1:
with open('/home/pi/Desktop2/UIP/param.json') as f: paramcf1 = json.load(f)
with open('/home/pi/Desktop2/UIP/savedseq.json') as s: saved = json.load(s)
with open('/home/pi/Desktop2/UIP/savedsong.json') as s2: savedsong = json.load(s2)
with open('/home/pi/Desktop2/UIP/savedsong2.json') as s3: savedsong2 = json.load(s3)
with open("/home/pi/Desktop2/UIP/licence.json") as l: licence=json.load(l)
else:
with open('param.json') as f: paramcf1 = json.load(f)
with open('savedseq.json') as s: saved = json.load(s)
with open('savedsong.json') as s2: savedsong = json.load(s2)
with open('savedsong2.json') as s3: savedsong2 = json.load(s3)
with open("licence.json") as l: licence=json.load(l)
version=licence["licence"][0]["version"]
print("CFM1 Version: " + str(version))
paramcalc=ParamScreen()
Sendinfo=paramcalc.convert()
#[din sync,usb sync,clock ppq,usb ppq,usb in (1) or out (0)]
Syncinfo=[0,0,0,0,0]
Syncinfo=paramcalc.convertsync()
midiout = rtmidi.MidiOut()
#midiout = 0
def outsmp(v1,v2,v3,v4,v5,v6,v7,v8,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10,q11,q12):
ti=Timing()
ti.Timer(v1,v2,v3,v4,v5,v6,v7,v8,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10,q11,q12)
#v1: playing ; v2: count ; v3: song size ; v4: BPM
#q1:sequencepool ; q2: loopsize ; q3: song ; q4: Sendinfo
v1=multiprocessing.Value('i',1)
v1.value=0
v2=multiprocessing.Value('i',1)
v3=multiprocessing.Value('i',1)
v3.value=16*4*16
v4=multiprocessing.Value('i',1)
v4.value=BPM
v5=multiprocessing.Value('i',1)
v5.value=trackselected
v6=multiprocessing.Value('i',1)
v6.value=2
v7=multiprocessing.Value('i',1)
v7.value=0
v8=multiprocessing.Value('i',1)
v8.value=1
q1=multiprocessing.Queue()
q1.put(sequencepool2)
q2=multiprocessing.Queue()
q2.put(loopsize)
q3=multiprocessing.Queue()
q3.put(song)
q4=multiprocessing.Queue()
q4.put(Sendinfo)
q5=multiprocessing.Queue()
q5.put(Syncinfo)
q6=multiprocessing.Queue()
#q6.put(sequencepool3)
q7=multiprocessing.Queue()
q8=multiprocessing.Queue()
q9=multiprocessing.Queue()
q9.put(ADSRtrig)
q10=multiprocessing.Queue()
q10.put(sequencepool3)
q11=multiprocessing.Queue()
q11.put(EnvPool3)
q12=multiprocessing.Queue()
q12.put(ADSRPool3)
#q5.put(Syncinfo)
def insmp(w1,w2):
listen=Listen()
listen.starting(w1,w2)
w1=multiprocessing.Value('i',1)
w1.value=0
w2=multiprocessing.Value('i',1)
w2.value=0
def insmp2(r1,r2,r3,r4,x1,y1):
listen2=Listen2()
listen2.starting(r1,r2,r3,r4,x1,y1)
r1=multiprocessing.Queue()
r1.put(Sendinfo)
r2=multiprocessing.Queue()
r2.put(trackselected)
r3=multiprocessing.Queue()
r3.put(Syncinfo)
r4=multiprocessing.Queue()
x1=multiprocessing.Value('i',1)
x1.value=0
y1=multiprocessing.Value('i',1)
y1.value=0
def insmp3(s1,s2,s3,s4):
listen3=Listen3()
listen3.starting(s1,s2,s3,s4)
s1=multiprocessing.Queue()
s1.put(Sendinfo)
s2=multiprocessing.Queue()
s2.put(trackselected)
s3=multiprocessing.Queue()
s3.put(Syncinfo)
s4=multiprocessing.Queue()
p=multiprocessing.Process(target=outsmp,args=(v1,v2,v3,v4,v5,v6,v7,v8,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10,q11,q12))
p.start()
pq=multiprocessing.Process(target=insmp,args=(w1,w2))
pq.start()
pq2=multiprocessing.Process(target=insmp2,args=(r1,r2,r3,r4,x1,y1))
pq2.start()
pq3=multiprocessing.Process(target=insmp3,args=(s1,s2,s3,s4))
pq3.start()
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
##############################################################################################
def deleteLFO():
global EnvPool2
global EnvPool3
global Phase
Phase[trackselected-1]=55
EnvPool2[trackselected-1]=[0]
EnvPool3[trackselected-1]=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
#print("deleted",EnvPool3[trackselected-1])
#print("EnvPool0",EnvPool0)
q7.put(EnvPool3[trackselected-1])
print("LFO deleted")
def deleteADSR():
global ADSRPool2
global ADSRPool3
global ADSRtrig
ADSRPool2[trackselected-1]=[0]
ADSRPool3[trackselected-1]=[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]
q8.put(ADSRPool3[trackselected-1])
for n,elem in enumerate(ADSRtrig):
if elem == trackselected:
ADSRtrig[n]=0
q9.put(ADSRtrig)
#print("adsr trig",ADSRtrig)
print("ADSR deleted")
def clearsequence():
global sequencepool2
global sequencepool3
sequencepool2[trackselected-1]=[]
for i,elem in enumerate(sequencepool3[trackselected-1]): sequencepool3[trackselected-1][i]=[]
q1.put(sequencepool2)
q6.put(sequencepool3[trackselected-1])
#print(sequencepool3[trackselected-1])
print("Sequence deleted")
deleteEuclidean()
def deleteRandom():
print("Random deleted")
def deleteEuclidean():
global EucliPool2
EucliPool2[trackselected-1]=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
print("Euclidean deleted")
try:
seq=SequencerApp()
seq.run()
finally:
if rpi==1:
GPIO.cleanup()
print("cleaned") |
def solve(n):
result = []
# edge cases
if 0 == n:
return result
result.append(1)
if 1 == n:
return result
result.append(1)
if (2 == n):
return result
# compute fibonacci numbers
for i in range(2, n):
result.append(result[i-1] + result[i-2])
return result
def main():
test_cases = int(input())
for test in range(test_cases):
n = int(input())
result = solve(n)
for i in range(len(result)):
print(result[i], end=' ')
print()
if __name__ == '__main__':
main()
|
from django.shortcuts import render
from .form import LoginForm,SignupForm
from django.contrib.auth import login, authenticate
from django.shortcuts import render, redirect
from django.contrib.auth.models import User
from django.contrib.sites.shortcuts import get_current_site
# Create your views here.
def loginregisterview(request):
if 'login' in request.POST:
loginview(request)
elif 'signup' in request.POST:
signupview(request)
form = LoginForm()
forms = SignupForm()
return render(request,"login.html",{'form':form,'forms':forms})
def loginview(request):
if request.method == 'POST':
form=LoginForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
print(email,password)
user = authenticate(username = email, password = password)
if user is not None:
print("Successful")
login(request,user)
return redirect('/therapy/home/')
else:
message = "Invalid Email id or Password. Please Try Again!!"
return render(request,"login.html",{'form':form,'message':message})
else:
form = LoginForm()
return render(request,"login.html",{'form':form})
def signupview(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = True
to_email = form.cleaned_data.get('email')
user.username = to_email
user_list=User.objects.all()
for query in user_list:
if user.username in query.username:
error = "Email Already Exists . "
return render(request, 'login.html', {'forms': form,'error':error})
user.save()
return render(request, 'login.html', {'forms': form})
# current_site = get_current_site(request)
# message = render_to_string('account_activation_email.html', {
# 'user':user,
# 'domain':current_site.domain,
# 'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode(),
# 'token': account_activation_token.make_token(user),
# })
# mail_subject = 'Activate your account.'
# email = EmailMessage(mail_subject, message, to=[to_email])
# email.send()
# messages = 'Please confirm your email address to complete the registration'
# return render(request, 'login.html', {'forms': form,'message':messages})
# return HttpResponse('Please confirm your email address to complete the registration')
else:
form = SignupForm()
return render(request, 'login.html', {'forms': form})
# def account_activation_sent(request):
# return render(request, "account_activation_sent.html")
# def activate(request, uidb64, token):
# try:
# uid = force_text(urlsafe_base64_decode(uidb64))
# print(uid)
# user = User.objects.get(pk=uid)
# except(TypeError, ValueError, OverflowError, User.DoesNotExist):
# user = None
# if user is not None and account_activation_token.check_token(user, token):
# user.is_active = True
# user.profile.email_confirmed = True
# user.save()
# login(request, user)
# return redirect('/therapy/home/')
# else:
# return HttpResponse('Activation link is invalid!') |
"""
Название (обсуждается):
The Hue
Некое вступление:
Некий гном (имя надо еще придумать) находит карту
По ней находит замок
В замке нужно найти все камни у всех хранителей (имена их каждый для себя придумает самостоятельно)
Концепция:
Первый этаж-меню. Если пойдешь к дверям, то выходишь из игры, если к лестнице, то переходишь на первый этаж
Есть три "хранителя". Каждый занимает этаж и в своих загадках, боях и т.д. прячет камни, необходимые для прохода к сокровищу
На последнем этаже есть дверь с нашей начальной загадкой (ее нельзя будет активировать пока не соберешь все камни
"""
import pygame
import sys
import os
import time
import random
# переменные
FPS = 60 # ного fps грузит комп
display_size = 960, 704
tile_width = tile_height = 64
speed = 8 # обязательно степень двойки 2 4 8 и тд
other_group = pygame.sprite.Group()
hp = 100
cryst_collected = 0
game_list = ['water.py', 'nonogram.py', 'crosstheriver.py']
played_game = []
def load_image(name, colorkey=None):
fullname = os.path.join('data/pictures', name)
# если файл не существует, то выходим
if not os.path.isfile(fullname):
print(f"Файл с изображением '{fullname}' не найден")
sys.exit()
image = pygame.image.load(fullname)
return image
tile_images = {
'floor1': load_image('floor1.png'), # символ: .
'floor2': load_image('floor3.png'), # символ: ,
'door': load_image('door.png'), # символ: 0
'wall': load_image('wall.png'), # символ: -
'ceiling': load_image('ceiling.png'), # символ: #
'stage': load_image('stage.png'), # символ: =
'book': load_image('book.png'), # символ: x
'gold_door': load_image('gold_door.png'), # символ: *
'table': load_image('table.png'), # символ: %
'table_big': load_image('table_big.png'),
'donut': load_image('donut.png'), # символ: !
'hero1': load_image('hero1.png'),
'hero2': load_image('hero2.png'),
'hero3': load_image('hero3.png'),
'hero4': load_image('hero4.png'),
'end_screen': load_image('end_screen.png')
}
class Creature(pygame.sprite.Sprite):
def __init__(self, pos_x, pos_y):
super().__init__()
self.pos_x = pos_x
self.pos_y = pos_y
class Level:
def __init__(self, level_name, spawn_point=None):
self.level_name = level_name
if spawn_point is None:
self.spawn_point = self.get_spawn_point()
else:
self.spawn_point = spawn_point
self.doors = {}
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
level = f.read().split('\n')
for i in range(self.get_door_number()):
self.doors[str(self.get_door_cell(i))] = [self.get_door_spawn(i), self.get_next_level(i)]
self.pos_x = (display_size[0] - tile_width) // 2 - self.spawn_point[0] * tile_width
self.pos_y = (display_size[1] - tile_height) // 2 - self.spawn_point[1] * tile_height
self.sprite_group = pygame.sprite.Group()
def level_render_prepare(self):
delta_x = self.pos_x
delta_y = self.pos_y
self.sprite_group.empty()
level = self.get_level_map()
for i in range(len(level)):
for j in range(len(level[i])):
if level[i][j] == '-':
self.sprite_group.add(Tile('wall', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '.':
self.sprite_group.add(Tile('floor1', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '0':
self.sprite_group.add(Tile('door', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '=':
self.sprite_group.add(Tile('stage', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '#':
self.sprite_group.add(Tile('ceiling', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == 'x':
self.sprite_group.add(Tile('book', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '*':
self.sprite_group.add(Tile('gold_door', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '%':
self.sprite_group.add(Tile('table', j * tile_width + delta_x, i * tile_height + delta_y))
elif level[i][j] == '!':
self.sprite_group.add(Tile('donut', j * tile_width + delta_x, i * tile_height + delta_y))
def get_level_map(self):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
level = f.read().split('\n')[self.get_door_number() * 3 + 2:]
return level
def get_spawn_point(self):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
spawn = f.read().split('\n')[0]
return list(map(int, spawn.split(',')))
def get_next_level(self, n):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
next_level = f.read().split('\n')[4 + 3 * n]
return next_level
def get_door_spawn(self, n):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
door_spawn = f.read().split('\n')[3 + 3 * n]
return list(map(int, door_spawn.split(',')))
def get_door_cell(self, n):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
door_spawn = f.read().split('\n')[2 + 3 * n]
return list(map(int, door_spawn.split(',')))
def get_door_number(self):
with open('data/levels/' + self.level_name + '.txt', 'r', encoding='UTF-8') as f:
number = f.read().split('\n')[1]
return int(number)
def move(self, delta_x, delta_y):
self.pos_x += delta_x
self.pos_y += delta_y
class Hero(Creature):
def __init__(self, pos_x, pos_y):
super().__init__(pos_x, pos_y)
self.width = 48
self.height = 32
self.sprite_group = pygame.sprite.Group()
self.image = tile_images['hero1']
self.rect = self.image.get_rect().move((display_size[0] - tile_width) // 2,
(display_size[1] - tile_height) // 2)
self.sprite_group.add(self)
def flip_picture(self, picture_name):
self.sprite_group.empty()
self.image = tile_images[picture_name]
self.rect = self.image.get_rect().move((display_size[0] - tile_width) // 2,
(display_size[1] - tile_height) // 2)
self.sprite_group.add(self)
def attack(self):
pass
def can_go_way(self, level, way):
cell = [self.pos_x + (tile_width - self.width) // 2, self.pos_y + tile_height - self.height]
cell1 = [self.pos_x + tile_width - (tile_width - self.width) // 2, self.pos_y + tile_height - self.height]
cell2 = [self.pos_x + tile_width - (tile_width - self.width) // 2, self.pos_y + tile_height - 1]
cell3 = [self.pos_x + (tile_width - self.width) // 2, self.pos_y + tile_height - 1]
if way == 'w':
cell[1] -= speed
elif way == 's':
cell[1] += speed
elif way == 'a':
cell[0] -= speed
elif way == 'd':
cell[0] += speed
if way == 'w':
cell1[1] -= speed
elif way == 's':
cell1[1] += speed
elif way == 'a':
cell1[0] -= speed
elif way == 'd':
cell1[0] += speed
if way == 'w':
cell2[1] -= speed
elif way == 's':
cell2[1] += speed
elif way == 'a':
cell2[0] -= speed
elif way == 'd':
cell2[0] += speed
if way == 'w':
cell3[1] -= speed
elif way == 's':
cell3[1] += speed
elif way == 'a':
cell3[0] -= speed
elif way == 'd':
cell3[0] += speed
cell = get_cell(cell)
cell1 = get_cell(cell1)
cell2 = get_cell(cell2)
cell3 = get_cell(cell3)
if level[cell[1]][cell[0]] == '#':
return False
if level[cell1[1]][cell1[0]] == '#':
return False
if level[cell2[1]][cell2[0]] == '#':
return False
if level[cell3[1]][cell3[0]] == '#':
return False
if level[cell[1]][cell[0]] == '-':
return False
if level[cell1[1]][cell1[0]] == '-':
return False
if level[cell2[1]][cell2[0]] == '-':
return False
if level[cell3[1]][cell3[0]] == '-':
return False
return True
def in_cell(self, level):
cell = get_cell((self.pos_x + (tile_width - self.width) // 2 + self.width // 2,
self.pos_y + tile_height - self.height // 2))
return level[cell[1]][cell[0]]
class Tile(pygame.sprite.Sprite):
def __init__(self, tile_type, pos_x, pos_y):
super().__init__()
self.image = tile_images[tile_type]
self.rect = self.image.get_rect().move(pos_x, pos_y)
def get_cell(m_pos):
w = m_pos[0]
h = m_pos[1]
return [w // tile_width, h // tile_height]
def start_screen(screen, clock): # функция заставки
for i in range(255):
screen.fill((i, i, i))
pygame.display.flip()
clock.tick(FPS)
sprite = pygame.sprite.Sprite()
sprite.image = load_image('start_screen.png')
sprite.rect = sprite.image.get_rect()
other_group.add(sprite)
other_group.draw(screen)
pygame.display.flip()
for i in range(500):
pygame.display.flip()
clock.tick(FPS)
def end_screen(screen, clock):
for i in range(255):
screen.fill((i, i, i))
pygame.display.flip()
clock.tick(FPS)
sprite = pygame.sprite.Sprite()
sprite.image = load_image('end_screen.png')
sprite.rect = sprite.image.get_rect()
other_group.add(sprite)
other_group.draw(screen)
pygame.display.flip()
for i in range(500):
pygame.display.flip()
clock.tick(FPS)
terminate()
def terminate(): # функция выхода
pygame.quit()
sys.exit()
|
import numpy as np
import pandas as pd
import argparse
import yaml
from os.path import exists, join
from glob import glob
import os
from mlmicrophysics.data import subset_data_files_by_date, assemble_data_files, repopulate_input_scaler, \
repopulate_output_scalers, inverse_transform_data
from sklearn.preprocessing import StandardScaler, MinMaxScaler, MaxAbsScaler, RobustScaler
from mlmicrophysics.explain import partial_dependence_mp, partial_dependence_tau_mp
scalers = {"MinMaxScaler": MinMaxScaler,
"MaxAbsScaler": MaxAbsScaler,
"StandardScaler": StandardScaler,
"RobustScaler": RobustScaler}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("config", help="Name of the training config file")
parser.add_argument("-p", "--procs", type=int, default=1, help="Number of processors")
parser.add_argument("-d", "--pdp", action="store_true", help="Calculate partial dependence")
parser.add_argument("-v", "--vi", action="store_true", help="Calculate variable importance")
parser.add_argument("-s", "--stat", action="store_true", help="Calc verification stats and plots")
args = parser.parse_args()
with open(args.config) as config_file:
config = yaml.load(config_file)
data_path = config["data_path"]
out_path = config["out_path"]
input_cols = config["input_cols"]
output_cols = config["output_cols"]
input_transforms = config["input_transforms"]
output_transforms = config["output_transforms"]
np.random.seed(config["random_seed"])
input_scaler = repopulate_input_scaler(join(out_path, "input_scale_values.csv"),
config["input_scaler"])
output_scalers = repopulate_output_scalers(join(out_path, "output_scale_values.csv"),
output_transforms)
subsample = config["subsample"]
partial_dependence_config = config["partial_dependence"]
train_files, val_files, test_files = subset_data_files_by_date(data_path, "*.csv", **config["subset_data"])
print("Loading training data")
scaled_input_train, \
labels_train, \
transformed_out_train, \
scaled_out_train, \
output_scalers, \
meta_train = assemble_data_files(train_files, input_cols, output_cols, input_transforms,
output_transforms, input_scaler,
output_scalers=output_scalers,
subsample=subsample, train=False)
if args.pdp:
model_files = sorted(glob(join(out_path, "*.h5")))
pd_model_vals = {}
pd_model_var_vals = {}
for model_file in model_files:
print(model_file)
model_key = model_file.split("/")[-1][:-3]
pd_model_vals[model_key], \
pd_model_var_vals[model_key] = partial_dependence_mp(scaled_input_train,
model_file,
partial_dependence_config["var_val_count"],
args.procs)
transformed_input_train = input_scaler.inverse_transform(scaled_input_train)
raw_input_train = inverse_transform_data(transformed_input_train, input_transforms)
pd_tau_vals, pd_tau_var_vals = partial_dependence_tau_mp(raw_input_train,
partial_dependence_config["var_val_count"],
args.procs)
return
def output_pd_vals_netcdf():
return
if __name__ == "__main__":
main()
|
#!/usr/bin/env python
"""The main module for the simsusy package."""
import importlib
import logging
import pathlib
import types
from typing import Any, Dict, KeysView, List, Optional, ValuesView
import click
import coloredlogs
import simsusy.abs_calculator
import simsusy.abs_model
__pkgname__ = "SimSUSY"
__version__ = "0.4.0"
__author__ = "Sho Iwamoto / Misho"
__license__ = "MIT"
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
cwd = pathlib.Path(__file__).parent.resolve()
class Calculators:
"""A singleton class to store calculators."""
def __init__(self) -> None:
cwd = pathlib.Path(__file__).parent.resolve()
self.calculators = {} # type: Dict[str, pathlib.Path]
for calculator_file in cwd.glob("*/*_calculator.py"):
relative_path = calculator_file.resolve().relative_to(cwd)
module_name = ".".join(relative_path.with_suffix("").parts)
self.calculators[module_name] = pathlib.Path("simsusy") / relative_path
@classmethod
def is_valid(cls, mod: Any) -> bool:
"""Check if the module has Calculator, Input, and Output classes."""
if not isinstance(mod, types.ModuleType):
return False
return (
issubclass(getattr(mod, "Calculator"), simsusy.abs_calculator.AbsCalculator)
and issubclass(getattr(mod, "Input"), simsusy.abs_model.AbsModel)
and issubclass(getattr(mod, "Output"), simsusy.abs_model.AbsModel)
)
def __getitem__(self, key: str) -> pathlib.Path:
return self.calculators.__getitem__(key)
def get(self, name: str) -> Optional[pathlib.Path]:
"""Get the path of the calculator."""
return self.calculators.get(name)
def guess(self, name: str) -> Optional[pathlib.Path]:
"""Guess the path of the calculator."""
if name in self.calculators:
return self.calculators[name]
if name.count(".") != 1:
return None
model, calc = name.lower().split(".")
candidates = [] # type: List[str]
for i in self.calculators.keys():
i_model, i_calc = i.lower().split(".")
if i_model.startswith(model) and i_calc.startswith(calc):
candidates.append(i)
if len(candidates) == 1:
return self.calculators[candidates[0]]
else:
if candidates:
logger.error("The calculator specification %s is ambiguous:", name)
for i in candidates:
logger.error("\t%s", i)
return None
def keys(self) -> KeysView[str]:
"""Get the names of the calculators."""
return self.calculators.keys()
def values(self) -> ValuesView[pathlib.Path]:
"""Get the paths to the calculators."""
return self.calculators.values()
@click.group(
help="Handle the references for high-energy physics",
context_settings={"help_option_names": ["-h", "--help"]},
)
@click.option("--debug", is_flag=True, help="Display debug information for exceptions.")
@click.version_option(__version__, "-V", "--version", prog_name=__pkgname__)
@click.pass_context
# @click.option(
# "-v", "--verbose", is_flag=True, default=False, help="Show verbose output"
# )
def simsusy_main(context, **kwargs):
# type: (click.Context, **Dict[str, Any]) -> None
"""Invoke the Click command."""
coloredlogs.install(logger=logging.getLogger(), fmt="%(levelname)8s %(message)s")
if context.obj is None:
context.obj = {}
context.obj["DEBUG"] = kwargs["debug"] if "debug" in kwargs else False
@simsusy_main.command()
@click.argument("calculator")
@click.argument("input", type=click.Path(exists=True, dir_okay=False))
@click.argument("output", type=click.Path(dir_okay=False), required=False)
@click.option("--v1", is_flag=True, help="Try to output in SLHA1 format")
@click.pass_context
def run(context, calculator, input, output, v1): # noqa: A002
# type: (click.Context, str, click.Path, Optional[click.Path], bool) -> None
"""Invoke the Run command, which runs the calculator."""
calculators = Calculators()
guessed_calculator = calculators.guess(calculator)
if guessed_calculator is None:
logger.error('calculator "%s" not found.', calculator)
logger.info("Available calculators are:")
max_length = max(len(name) for name in calculators.keys())
for name in calculators.keys():
logger.info("\t%s\t(%s)", name.ljust(max_length), str(calculators[name]))
exit(1)
module_name = ".".join(guessed_calculator.with_suffix("").parts)
try:
mod = importlib.import_module(module_name)
except ModuleNotFoundError as e:
logger.error("Calculator %s cannot be imported.", calculator)
if context.obj["DEBUG"]:
raise e
else:
logger.exception("Exception raised.")
logger.error("Run with --debug option to see stack trace.")
exit(1)
if not calculators.is_valid(mod):
logger.error("Calculator %s imported but invalid.", calculator)
if context.obj["DEBUG"]:
logger.error("Debug information: %s", mod.__dict__)
for i in ["Calculator", "Input", "Output"]:
logger.error("\t%s\t%s", i, getattr(mod, i, "(Not found)"))
else:
logger.error("Run with --debug option to see information.")
exit(1)
input_obj = mod.Input(input)
calc_obj = mod.Calculator(input_obj)
calc_obj.calculate()
calc_obj.write_output(output, slha1=v1)
|
import matplotlib
import tkinter as tk
matplotlib.use('TkAgg')
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from matplotlib.ticker import (MultipleLocator, AutoMinorLocator)
import numpy as np
class PlotWindow():
def __init__(self, masterframe, size):
(w,h) = size
self.figure = Figure(size)
self.axes = self.figure.add_subplot(111)
self.axes.set_facecolor('black')
self.canvas = FigureCanvasTkAgg(self.figure, master=masterframe)
self.canvas.get_tk_widget().pack()
eqString=r'sin(4x) exp(-nx/10)'
self.axes.text(1, 1.2, eqString)
self.axes.grid(color='grey')
# self.axes.xaxis.set_major_locator(MultipleLocator(np.pi))
# self.axes.xaxis.set_major_formatter('{x:.0f}')
def plotxy(self, x,y):
self.axes.plot(x,y)
self.canvas.draw()
def clearplot(self):
self.axes.cla()
self.canvas.draw()
class GenerateTestData():
def __init__(self):
self.index=0
self.xmin=0.0
self.xmax=10.0
self.nbvalues=500
def getxy(self):
n=self.index
n=int(user_input.get())
x=np.linspace(self.xmin, self.xmax, self.nbvalues)
y=np.sin(4*x)*np.exp(-n*x/10)
self.index+=1
return x,y
def plotdata():
x,y=datgen.getxy()
pw.plotxy(x,y)
def clear():
pw.clearplot()
print("Clear")
if __name__ == "__main__":
datgen = GenerateTestData()
root = tk.Tk()
mf = tk.Frame(root, width=400, height=100)
pw = PlotWindow(mf, (10, 5))
mf.grid(row=0, column=1)
user_input = tk.StringVar(root)
bf = tk.Frame()
bf.grid(row=0, column=0)
b1 = tk.Button(bf, text="Plot", command=plotdata)
b1.grid(row=0, column=0)
b2 = tk.Button(bf, text="Clear", command=clear)
b2.grid(row=0, column=1)
l1 = tk.Label(bf, text="n = ")
l1.grid(row=1, column=0)
entry = tk.Entry(bf, textvariable=user_input)
entry.grid(row=1, column=1)
entry.insert(tk.END, "0")
root.mainloop()
|
class listaUnica:
def __init__(self, elem_class):
self.lista = []
self.elem_class = elem_class
def __len__(self):
return len(self.lista)
def __iter__(self):
return iter(self.lista)
def __getitem__(self, p):
return self.lista[p]
def indiceValido(self, i):
return i >= 0 and i < len(self.lista)
def adiciona(self, elem):
if self.pesquisa(elem) == -1:
self.lista.append(elem)
def remove(self, elem):
self.lista.remove(elem)
def pesquisa(self, elem):
self.verificaTipo(elem)
try:
return self.lista.index(elem)
except ValueError:
return -1
def verificaTipo(self, elem):
if not isinstance(elem, self.elem_class):
raise TypeError('Tipo inválido!')
def ordena(self, chave=None):
self.lista.sort(key=chave)
|
from copy import deepcopy
from collections import defaultdict
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
data = [
("animal", "bear"),
("animal", "duck"),
("plant", "cactus"),
("vehicle", "speed boat"),
("vehicle", "school bus")
]
tup1 = [('name', 'anyu'), ('age', 30)]
dict5 = {'name': 'anyu', 'age': 30}
if __name__ == '__main__':
# 浅拷贝: 引用对象
dict2 = dict1
# 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dict3 = dict1.copy()
# 深拷贝
dict4 = deepcopy(dict1)
# 修改 data 数据
dict1['user'] = 'root'
dict1['num'].remove(1)
print('***字典输出结果***')
print(dict1)
print(dict2)
print(dict3)
print(dict4)
groups = defaultdict(list)
for (key, value) in data:
groups[key].append(value)
print(groups)
print("========创建字典=========")
# 通过元组创建字典
print(dict(tup1))
# 通过关键字参数创建字典
print(dict(name='anyu', age=30))
print("========字典格式化字符串=========")
str1 = 'My name is %(name)s, age is %(age)d' % dict5
print(str1)
print({}.fromkeys(('name', 'age')))
|
import os
basedir = os.path.abspath(os.path.dirname(__file__))
class BaseConfig(object):
SECRET_KEY = os.getenv('SECRET_KEY', '12345678')
SQLALCHEMY_TRACK_MODIFICATIONS = False
CKEDITOR_SERVE_LOCAL = True
CKEDITOR_WIDTH = '150em'
CKEDITOR_HEIGHT = '50em'
CKEDITOR_LANGUAGE = 'zh-cn'
POST_PER_PAGE = 5
class DevelopmentConfig(BaseConfig):
SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data-dev.db')
class ProductionConfig(BaseConfig):
SQLALCHEMY_DATABASE_URI = os.getenv(
'DATABASE_URL', 'sqlite:///' + os.path.join(basedir, 'data-dev.db'))
config = {
'development': DevelopmentConfig,
'production': ProductionConfig
} |
import os
from src import definitions
from wsdm.ts.features import word2VecFeature
from wsdm.ts.features.tests.test_common import calculate_similarities
if __name__ == '__main__':
word2VecFeature.load_module()
print("----- NATIONALITIES -----")
calculate_similarities("wsdm_nationality.train", word2VecFeature.find_similarity, definitions.TYPE_NATIONALITY)
print("\n\n\n\n\n\n")
print("----- PROFESSIONS -----")
calculate_similarities("wsdm_profession.train", word2VecFeature.find_similarity, definitions.TYPE_PROFESSION) |
#aws-cli/1.10.38 Python/2.7.11+ Linux/4.4.0-24-generic botocore/1.4.28
import os
import sys
str="aws-cli/1.10.38 Python/2.7.11+ Linux/4.4.0-24-generic botocore/1.4.28"
print str
a = str.split("/")
print a
for i in a:
print i
#b = a.split(" ")
#print b |
#Auteur: Stijn de Wijse
import os
import re
def main():
aminozuren = {"A":0, "R":0, "N":0, "D":0, "C":0,
"F":0, "Q":0, "E":0, "G":0, "H":0,
"I":0, "L":0, "K":0, "M":0, "P":0,
"S":0, "T":0, "W":0, "Y":0, "V":0}
for file in [f for f in os.listdir() if re.match(".*\.fasta", f)]:
headerlijst, seqlijst = readfiles(file)
aminocount(headerlijst, seqlijst)
hydrointeractie(headerlijst, seqlijst, aminozuren)
def readfiles(file):
file = open(file,'r')
print(file)
seq = ''
headers = ''
seqlijst = ''
headerlijst = []
for line in file:
line = line.rstrip()
if line.startswith('>'):
headers = line
headerlijst.append(headers)
if not line.startswith('>'):
seq += line
if line.startswith('>') and seq is not '':
seqlijst += seq
seq = ''
seqlijst += seq
## print(40* "*")
# print(headerlijst)
return headerlijst, seqlijst
def aminocount(headerlijst, seqlijst):
Cysteine = "C"
Tryptofaan = "W"
cyscount = 0
trpcount = 0
i = 0
for item in seqlijst:
cys = seqlijst[i].count("C")
trp = seqlijst[i].count("W")
cyscount += cys
trpcount += trp
i += 1
## print(cyscount)
## print(trpcount)
## print(40*"-")
cyspercent = (cyscount/len(seqlijst))*100
trppercent = (trpcount/len(seqlijst))*100
print("Het percentage cysteine is: ", cyspercent)
print("Het percentage tryptofaan is: ", trppercent)
def hydrointeractie(headerlijst,seqlijst,aminozuren):
#print(seqlijst[0])
foob = ["A","F","I","L","M","P","W","V"]
fiel = ["R","N","D",'C','Q','E','G','H','K','S','T','Y']
foobcount = 0
fielcount = 0
for amino in aminozuren:
aminozuren[amino] = int(len(re.findall(amino,seqlijst)))
for waarde in foob:
foobcount+= aminozuren[waarde]
for waarde2 in fiel:
fielcount+= aminozuren[waarde2]
## print('hydrofoob:', foobcount)
## print('hydrofiel:', fielcount)
foobpercent = (foobcount/len(seqlijst))*100
fielpercent = (fielcount/len(seqlijst))*100
print("Het percentage hydrofobe aminozuren is: ", foobpercent)
print("Het percentage hydrofiele aminozuren is: ", fielpercent)
## print(40* "-")
valuesort = sorted(aminozuren.values())
aminosort = sorted(aminozuren, key=aminozuren.get)
print(aminosort[:3])
print(valuesort[:3])
print(aminosort[-3:])
print(valuesort[-3:])
for codon in valuesort[:3]:
#print(codon)
minpercent = (codon/len(seqlijst))*100
for codon in valuesort[-3:]:
maxpercent = (codon/len(seqlijst))*100
print(maxpercent)
print(minpercent)
print(40*"#")
main()
|
from typing import Any, Callable, List, Optional, Tuple, Union
import torch
import torch.nn.functional as F
from torch import nn
from torchvision.ops import MultiScaleRoIAlign
from ...ops import misc as misc_nn_ops
from ...transforms._presets import ObjectDetection
from .._api import register_model, Weights, WeightsEnum
from .._meta import _COCO_CATEGORIES
from .._utils import _ovewrite_value_param, handle_legacy_interface
from ..mobilenetv3 import mobilenet_v3_large, MobileNet_V3_Large_Weights
from ..resnet import resnet50, ResNet50_Weights
from ._utils import overwrite_eps
from .anchor_utils import AnchorGenerator
from .backbone_utils import _mobilenet_extractor, _resnet_fpn_extractor, _validate_trainable_layers
from .generalized_rcnn import GeneralizedRCNN
from .roi_heads import RoIHeads
from .rpn import RegionProposalNetwork, RPNHead
from .transform import GeneralizedRCNNTransform
__all__ = [
"FasterRCNN",
"FasterRCNN_ResNet50_FPN_Weights",
"FasterRCNN_ResNet50_FPN_V2_Weights",
"FasterRCNN_MobileNet_V3_Large_FPN_Weights",
"FasterRCNN_MobileNet_V3_Large_320_FPN_Weights",
"fasterrcnn_resnet50_fpn",
"fasterrcnn_resnet50_fpn_v2",
"fasterrcnn_mobilenet_v3_large_fpn",
"fasterrcnn_mobilenet_v3_large_320_fpn",
]
def _default_anchorgen():
anchor_sizes = ((32,), (64,), (128,), (256,), (512,))
aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
return AnchorGenerator(anchor_sizes, aspect_ratios)
class FasterRCNN(GeneralizedRCNN):
"""
Implements Faster R-CNN.
The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each
image, and should be in 0-1 range. Different images can have different sizes.
The behavior of the model changes depending on if it is in training or evaluation mode.
During training, the model expects both the input tensors and targets (list of dictionary),
containing:
- boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
- labels (Int64Tensor[N]): the class label for each ground-truth box
The model returns a Dict[Tensor] during training, containing the classification and regression
losses for both the RPN and the R-CNN.
During inference, the model requires only the input tensors, and returns the post-processed
predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as
follows:
- boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
- labels (Int64Tensor[N]): the predicted labels for each image
- scores (Tensor[N]): the scores or each prediction
Args:
backbone (nn.Module): the network used to compute the features for the model.
It should contain an out_channels attribute, which indicates the number of output
channels that each feature map has (and it should be the same for all feature maps).
The backbone should return a single Tensor or and OrderedDict[Tensor].
num_classes (int): number of output classes of the model (including the background).
If box_predictor is specified, num_classes should be None.
min_size (int): minimum size of the image to be rescaled before feeding it to the backbone
max_size (int): maximum size of the image to be rescaled before feeding it to the backbone
image_mean (Tuple[float, float, float]): mean values used for input normalization.
They are generally the mean values of the dataset on which the backbone has been trained
on
image_std (Tuple[float, float, float]): std values used for input normalization.
They are generally the std values of the dataset on which the backbone has been trained on
rpn_anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature
maps.
rpn_head (nn.Module): module that computes the objectness and regression deltas from the RPN
rpn_pre_nms_top_n_train (int): number of proposals to keep before applying NMS during training
rpn_pre_nms_top_n_test (int): number of proposals to keep before applying NMS during testing
rpn_post_nms_top_n_train (int): number of proposals to keep after applying NMS during training
rpn_post_nms_top_n_test (int): number of proposals to keep after applying NMS during testing
rpn_nms_thresh (float): NMS threshold used for postprocessing the RPN proposals
rpn_fg_iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be
considered as positive during training of the RPN.
rpn_bg_iou_thresh (float): maximum IoU between the anchor and the GT box so that they can be
considered as negative during training of the RPN.
rpn_batch_size_per_image (int): number of anchors that are sampled during training of the RPN
for computing the loss
rpn_positive_fraction (float): proportion of positive anchors in a mini-batch during training
of the RPN
rpn_score_thresh (float): during inference, only return proposals with a classification score
greater than rpn_score_thresh
box_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in
the locations indicated by the bounding boxes
box_head (nn.Module): module that takes the cropped feature maps as input
box_predictor (nn.Module): module that takes the output of box_head and returns the
classification logits and box regression deltas.
box_score_thresh (float): during inference, only return proposals with a classification score
greater than box_score_thresh
box_nms_thresh (float): NMS threshold for the prediction head. Used during inference
box_detections_per_img (int): maximum number of detections per image, for all classes.
box_fg_iou_thresh (float): minimum IoU between the proposals and the GT box so that they can be
considered as positive during training of the classification head
box_bg_iou_thresh (float): maximum IoU between the proposals and the GT box so that they can be
considered as negative during training of the classification head
box_batch_size_per_image (int): number of proposals that are sampled during training of the
classification head
box_positive_fraction (float): proportion of positive proposals in a mini-batch during training
of the classification head
bbox_reg_weights (Tuple[float, float, float, float]): weights for the encoding/decoding of the
bounding boxes
Example::
>>> import torch
>>> import torchvision
>>> from torchvision.models.detection import FasterRCNN
>>> from torchvision.models.detection.rpn import AnchorGenerator
>>> # load a pre-trained model for classification and return
>>> # only the features
>>> backbone = torchvision.models.mobilenet_v2(weights=MobileNet_V2_Weights.DEFAULT).features
>>> # FasterRCNN needs to know the number of
>>> # output channels in a backbone. For mobilenet_v2, it's 1280,
>>> # so we need to add it here
>>> backbone.out_channels = 1280
>>>
>>> # let's make the RPN generate 5 x 3 anchors per spatial
>>> # location, with 5 different sizes and 3 different aspect
>>> # ratios. We have a Tuple[Tuple[int]] because each feature
>>> # map could potentially have different sizes and
>>> # aspect ratios
>>> anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),
>>> aspect_ratios=((0.5, 1.0, 2.0),))
>>>
>>> # let's define what are the feature maps that we will
>>> # use to perform the region of interest cropping, as well as
>>> # the size of the crop after rescaling.
>>> # if your backbone returns a Tensor, featmap_names is expected to
>>> # be ['0']. More generally, the backbone should return an
>>> # OrderedDict[Tensor], and in featmap_names you can choose which
>>> # feature maps to use.
>>> roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],
>>> output_size=7,
>>> sampling_ratio=2)
>>>
>>> # put the pieces together inside a FasterRCNN model
>>> model = FasterRCNN(backbone,
>>> num_classes=2,
>>> rpn_anchor_generator=anchor_generator,
>>> box_roi_pool=roi_pooler)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
"""
def __init__(
self,
backbone,
num_classes=None,
# transform parameters
min_size=800,
max_size=1333,
image_mean=None,
image_std=None,
# RPN parameters
rpn_anchor_generator=None,
rpn_head=None,
rpn_pre_nms_top_n_train=2000,
rpn_pre_nms_top_n_test=1000,
rpn_post_nms_top_n_train=2000,
rpn_post_nms_top_n_test=1000,
rpn_nms_thresh=0.7,
rpn_fg_iou_thresh=0.7,
rpn_bg_iou_thresh=0.3,
rpn_batch_size_per_image=256,
rpn_positive_fraction=0.5,
rpn_score_thresh=0.0,
# Box parameters
box_roi_pool=None,
box_head=None,
box_predictor=None,
box_score_thresh=0.05,
box_nms_thresh=0.5,
box_detections_per_img=100,
box_fg_iou_thresh=0.5,
box_bg_iou_thresh=0.5,
box_batch_size_per_image=512,
box_positive_fraction=0.25,
bbox_reg_weights=None,
**kwargs,
):
if not hasattr(backbone, "out_channels"):
raise ValueError(
"backbone should contain an attribute out_channels "
"specifying the number of output channels (assumed to be the "
"same for all the levels)"
)
if not isinstance(rpn_anchor_generator, (AnchorGenerator, type(None))):
raise TypeError(
f"rpn_anchor_generator should be of type AnchorGenerator or None instead of {type(rpn_anchor_generator)}"
)
if not isinstance(box_roi_pool, (MultiScaleRoIAlign, type(None))):
raise TypeError(
f"box_roi_pool should be of type MultiScaleRoIAlign or None instead of {type(box_roi_pool)}"
)
if num_classes is not None:
if box_predictor is not None:
raise ValueError("num_classes should be None when box_predictor is specified")
else:
if box_predictor is None:
raise ValueError("num_classes should not be None when box_predictor is not specified")
out_channels = backbone.out_channels
if rpn_anchor_generator is None:
rpn_anchor_generator = _default_anchorgen()
if rpn_head is None:
rpn_head = RPNHead(out_channels, rpn_anchor_generator.num_anchors_per_location()[0])
rpn_pre_nms_top_n = dict(training=rpn_pre_nms_top_n_train, testing=rpn_pre_nms_top_n_test)
rpn_post_nms_top_n = dict(training=rpn_post_nms_top_n_train, testing=rpn_post_nms_top_n_test)
rpn = RegionProposalNetwork(
rpn_anchor_generator,
rpn_head,
rpn_fg_iou_thresh,
rpn_bg_iou_thresh,
rpn_batch_size_per_image,
rpn_positive_fraction,
rpn_pre_nms_top_n,
rpn_post_nms_top_n,
rpn_nms_thresh,
score_thresh=rpn_score_thresh,
)
if box_roi_pool is None:
box_roi_pool = MultiScaleRoIAlign(featmap_names=["0", "1", "2", "3"], output_size=7, sampling_ratio=2)
if box_head is None:
resolution = box_roi_pool.output_size[0]
representation_size = 1024
box_head = TwoMLPHead(out_channels * resolution**2, representation_size)
if box_predictor is None:
representation_size = 1024
box_predictor = FastRCNNPredictor(representation_size, num_classes)
roi_heads = RoIHeads(
# Box
box_roi_pool,
box_head,
box_predictor,
box_fg_iou_thresh,
box_bg_iou_thresh,
box_batch_size_per_image,
box_positive_fraction,
bbox_reg_weights,
box_score_thresh,
box_nms_thresh,
box_detections_per_img,
)
if image_mean is None:
image_mean = [0.485, 0.456, 0.406]
if image_std is None:
image_std = [0.229, 0.224, 0.225]
transform = GeneralizedRCNNTransform(min_size, max_size, image_mean, image_std, **kwargs)
super().__init__(backbone, rpn, roi_heads, transform)
class TwoMLPHead(nn.Module):
"""
Standard heads for FPN-based models
Args:
in_channels (int): number of input channels
representation_size (int): size of the intermediate representation
"""
def __init__(self, in_channels, representation_size):
super().__init__()
self.fc6 = nn.Linear(in_channels, representation_size)
self.fc7 = nn.Linear(representation_size, representation_size)
def forward(self, x):
x = x.flatten(start_dim=1)
x = F.relu(self.fc6(x))
x = F.relu(self.fc7(x))
return x
class FastRCNNConvFCHead(nn.Sequential):
def __init__(
self,
input_size: Tuple[int, int, int],
conv_layers: List[int],
fc_layers: List[int],
norm_layer: Optional[Callable[..., nn.Module]] = None,
):
"""
Args:
input_size (Tuple[int, int, int]): the input size in CHW format.
conv_layers (list): feature dimensions of each Convolution layer
fc_layers (list): feature dimensions of each FCN layer
norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None
"""
in_channels, in_height, in_width = input_size
blocks = []
previous_channels = in_channels
for current_channels in conv_layers:
blocks.append(misc_nn_ops.Conv2dNormActivation(previous_channels, current_channels, norm_layer=norm_layer))
previous_channels = current_channels
blocks.append(nn.Flatten())
previous_channels = previous_channels * in_height * in_width
for current_channels in fc_layers:
blocks.append(nn.Linear(previous_channels, current_channels))
blocks.append(nn.ReLU(inplace=True))
previous_channels = current_channels
super().__init__(*blocks)
for layer in self.modules():
if isinstance(layer, nn.Conv2d):
nn.init.kaiming_normal_(layer.weight, mode="fan_out", nonlinearity="relu")
if layer.bias is not None:
nn.init.zeros_(layer.bias)
class FastRCNNPredictor(nn.Module):
"""
Standard classification + bounding box regression layers
for Fast R-CNN.
Args:
in_channels (int): number of input channels
num_classes (int): number of output classes (including background)
"""
def __init__(self, in_channels, num_classes):
super().__init__()
self.cls_score = nn.Linear(in_channels, num_classes)
self.bbox_pred = nn.Linear(in_channels, num_classes * 4)
def forward(self, x):
if x.dim() == 4:
torch._assert(
list(x.shape[2:]) == [1, 1],
f"x has the wrong shape, expecting the last two dimensions to be [1,1] instead of {list(x.shape[2:])}",
)
x = x.flatten(start_dim=1)
scores = self.cls_score(x)
bbox_deltas = self.bbox_pred(x)
return scores, bbox_deltas
_COMMON_META = {
"categories": _COCO_CATEGORIES,
"min_size": (1, 1),
}
class FasterRCNN_ResNet50_FPN_Weights(WeightsEnum):
COCO_V1 = Weights(
url="https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth",
transforms=ObjectDetection,
meta={
**_COMMON_META,
"num_params": 41755286,
"recipe": "https://github.com/pytorch/vision/tree/main/references/detection#faster-r-cnn-resnet-50-fpn",
"_metrics": {
"COCO-val2017": {
"box_map": 37.0,
}
},
"_ops": 134.38,
"_file_size": 159.743,
"_docs": """These weights were produced by following a similar training recipe as on the paper.""",
},
)
DEFAULT = COCO_V1
class FasterRCNN_ResNet50_FPN_V2_Weights(WeightsEnum):
COCO_V1 = Weights(
url="https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_v2_coco-dd69338a.pth",
transforms=ObjectDetection,
meta={
**_COMMON_META,
"num_params": 43712278,
"recipe": "https://github.com/pytorch/vision/pull/5763",
"_metrics": {
"COCO-val2017": {
"box_map": 46.7,
}
},
"_ops": 280.371,
"_file_size": 167.104,
"_docs": """These weights were produced using an enhanced training recipe to boost the model accuracy.""",
},
)
DEFAULT = COCO_V1
class FasterRCNN_MobileNet_V3_Large_FPN_Weights(WeightsEnum):
COCO_V1 = Weights(
url="https://download.pytorch.org/models/fasterrcnn_mobilenet_v3_large_fpn-fb6a3cc7.pth",
transforms=ObjectDetection,
meta={
**_COMMON_META,
"num_params": 19386354,
"recipe": "https://github.com/pytorch/vision/tree/main/references/detection#faster-r-cnn-mobilenetv3-large-fpn",
"_metrics": {
"COCO-val2017": {
"box_map": 32.8,
}
},
"_ops": 4.494,
"_file_size": 74.239,
"_docs": """These weights were produced by following a similar training recipe as on the paper.""",
},
)
DEFAULT = COCO_V1
class FasterRCNN_MobileNet_V3_Large_320_FPN_Weights(WeightsEnum):
COCO_V1 = Weights(
url="https://download.pytorch.org/models/fasterrcnn_mobilenet_v3_large_320_fpn-907ea3f9.pth",
transforms=ObjectDetection,
meta={
**_COMMON_META,
"num_params": 19386354,
"recipe": "https://github.com/pytorch/vision/tree/main/references/detection#faster-r-cnn-mobilenetv3-large-320-fpn",
"_metrics": {
"COCO-val2017": {
"box_map": 22.8,
}
},
"_ops": 0.719,
"_file_size": 74.239,
"_docs": """These weights were produced by following a similar training recipe as on the paper.""",
},
)
DEFAULT = COCO_V1
@register_model()
@handle_legacy_interface(
weights=("pretrained", FasterRCNN_ResNet50_FPN_Weights.COCO_V1),
weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
)
def fasterrcnn_resnet50_fpn(
*,
weights: Optional[FasterRCNN_ResNet50_FPN_Weights] = None,
progress: bool = True,
num_classes: Optional[int] = None,
weights_backbone: Optional[ResNet50_Weights] = ResNet50_Weights.IMAGENET1K_V1,
trainable_backbone_layers: Optional[int] = None,
**kwargs: Any,
) -> FasterRCNN:
"""
Faster R-CNN model with a ResNet-50-FPN backbone from the `Faster R-CNN: Towards Real-Time Object
Detection with Region Proposal Networks <https://arxiv.org/abs/1506.01497>`__
paper.
.. betastatus:: detection module
The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each
image, and should be in ``0-1`` range. Different images can have different sizes.
The behavior of the model changes depending on if it is in training or evaluation mode.
During training, the model expects both the input tensors and a targets (list of dictionary),
containing:
- boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
- labels (``Int64Tensor[N]``): the class label for each ground-truth box
The model returns a ``Dict[Tensor]`` during training, containing the classification and regression
losses for both the RPN and the R-CNN.
During inference, the model requires only the input tensors, and returns the post-processed
predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as
follows, where ``N`` is the number of detections:
- boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
- labels (``Int64Tensor[N]``): the predicted labels for each detection
- scores (``Tensor[N]``): the scores of each detection
For more details on the output, you may refer to :ref:`instance_seg_output`.
Faster R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size.
Example::
>>> model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT)
>>> # For training
>>> images, boxes = torch.rand(4, 3, 600, 1200), torch.rand(4, 11, 4)
>>> boxes[:, :, 2:4] = boxes[:, :, 0:2] + boxes[:, :, 2:4]
>>> labels = torch.randint(1, 91, (4, 11))
>>> images = list(image for image in images)
>>> targets = []
>>> for i in range(len(images)):
>>> d = {}
>>> d['boxes'] = boxes[i]
>>> d['labels'] = labels[i]
>>> targets.append(d)
>>> output = model(images, targets)
>>> # For inference
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
>>>
>>> # optionally, if you want to export the model to ONNX:
>>> torch.onnx.export(model, x, "faster_rcnn.onnx", opset_version = 11)
Args:
weights (:class:`~torchvision.models.detection.FasterRCNN_ResNet50_FPN_Weights`, optional): The
pretrained weights to use. See
:class:`~torchvision.models.detection.FasterRCNN_ResNet50_FPN_Weights` below for
more details, and possible values. By default, no pre-trained
weights are used.
progress (bool, optional): If True, displays a progress bar of the
download to stderr. Default is True.
num_classes (int, optional): number of output classes of the model (including the background)
weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The
pretrained weights for the backbone.
trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are
trainable. If ``None`` is passed (the default) this value is set to 3.
**kwargs: parameters passed to the ``torchvision.models.detection.faster_rcnn.FasterRCNN``
base class. Please refer to the `source code
<https://github.com/pytorch/vision/blob/main/torchvision/models/detection/faster_rcnn.py>`_
for more details about this class.
.. autoclass:: torchvision.models.detection.FasterRCNN_ResNet50_FPN_Weights
:members:
"""
weights = FasterRCNN_ResNet50_FPN_Weights.verify(weights)
weights_backbone = ResNet50_Weights.verify(weights_backbone)
if weights is not None:
weights_backbone = None
num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
elif num_classes is None:
num_classes = 91
is_trained = weights is not None or weights_backbone is not None
trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
norm_layer = misc_nn_ops.FrozenBatchNorm2d if is_trained else nn.BatchNorm2d
backbone = resnet50(weights=weights_backbone, progress=progress, norm_layer=norm_layer)
backbone = _resnet_fpn_extractor(backbone, trainable_backbone_layers)
model = FasterRCNN(backbone, num_classes=num_classes, **kwargs)
if weights is not None:
model.load_state_dict(weights.get_state_dict(progress=progress, check_hash=True))
if weights == FasterRCNN_ResNet50_FPN_Weights.COCO_V1:
overwrite_eps(model, 0.0)
return model
@register_model()
@handle_legacy_interface(
weights=("pretrained", FasterRCNN_ResNet50_FPN_V2_Weights.COCO_V1),
weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
)
def fasterrcnn_resnet50_fpn_v2(
*,
weights: Optional[FasterRCNN_ResNet50_FPN_V2_Weights] = None,
progress: bool = True,
num_classes: Optional[int] = None,
weights_backbone: Optional[ResNet50_Weights] = None,
trainable_backbone_layers: Optional[int] = None,
**kwargs: Any,
) -> FasterRCNN:
"""
Constructs an improved Faster R-CNN model with a ResNet-50-FPN backbone from `Benchmarking Detection
Transfer Learning with Vision Transformers <https://arxiv.org/abs/2111.11429>`__ paper.
.. betastatus:: detection module
It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See
:func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` for more
details.
Args:
weights (:class:`~torchvision.models.detection.FasterRCNN_ResNet50_FPN_V2_Weights`, optional): The
pretrained weights to use. See
:class:`~torchvision.models.detection.FasterRCNN_ResNet50_FPN_V2_Weights` below for
more details, and possible values. By default, no pre-trained
weights are used.
progress (bool, optional): If True, displays a progress bar of the
download to stderr. Default is True.
num_classes (int, optional): number of output classes of the model (including the background)
weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The
pretrained weights for the backbone.
trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are
trainable. If ``None`` is passed (the default) this value is set to 3.
**kwargs: parameters passed to the ``torchvision.models.detection.faster_rcnn.FasterRCNN``
base class. Please refer to the `source code
<https://github.com/pytorch/vision/blob/main/torchvision/models/detection/faster_rcnn.py>`_
for more details about this class.
.. autoclass:: torchvision.models.detection.FasterRCNN_ResNet50_FPN_V2_Weights
:members:
"""
weights = FasterRCNN_ResNet50_FPN_V2_Weights.verify(weights)
weights_backbone = ResNet50_Weights.verify(weights_backbone)
if weights is not None:
weights_backbone = None
num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
elif num_classes is None:
num_classes = 91
is_trained = weights is not None or weights_backbone is not None
trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
backbone = resnet50(weights=weights_backbone, progress=progress)
backbone = _resnet_fpn_extractor(backbone, trainable_backbone_layers, norm_layer=nn.BatchNorm2d)
rpn_anchor_generator = _default_anchorgen()
rpn_head = RPNHead(backbone.out_channels, rpn_anchor_generator.num_anchors_per_location()[0], conv_depth=2)
box_head = FastRCNNConvFCHead(
(backbone.out_channels, 7, 7), [256, 256, 256, 256], [1024], norm_layer=nn.BatchNorm2d
)
model = FasterRCNN(
backbone,
num_classes=num_classes,
rpn_anchor_generator=rpn_anchor_generator,
rpn_head=rpn_head,
box_head=box_head,
**kwargs,
)
if weights is not None:
model.load_state_dict(weights.get_state_dict(progress=progress, check_hash=True))
return model
def _fasterrcnn_mobilenet_v3_large_fpn(
*,
weights: Optional[Union[FasterRCNN_MobileNet_V3_Large_FPN_Weights, FasterRCNN_MobileNet_V3_Large_320_FPN_Weights]],
progress: bool,
num_classes: Optional[int],
weights_backbone: Optional[MobileNet_V3_Large_Weights],
trainable_backbone_layers: Optional[int],
**kwargs: Any,
) -> FasterRCNN:
if weights is not None:
weights_backbone = None
num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
elif num_classes is None:
num_classes = 91
is_trained = weights is not None or weights_backbone is not None
trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 6, 3)
norm_layer = misc_nn_ops.FrozenBatchNorm2d if is_trained else nn.BatchNorm2d
backbone = mobilenet_v3_large(weights=weights_backbone, progress=progress, norm_layer=norm_layer)
backbone = _mobilenet_extractor(backbone, True, trainable_backbone_layers)
anchor_sizes = (
(
32,
64,
128,
256,
512,
),
) * 3
aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
model = FasterRCNN(
backbone, num_classes, rpn_anchor_generator=AnchorGenerator(anchor_sizes, aspect_ratios), **kwargs
)
if weights is not None:
model.load_state_dict(weights.get_state_dict(progress=progress, check_hash=True))
return model
@register_model()
@handle_legacy_interface(
weights=("pretrained", FasterRCNN_MobileNet_V3_Large_320_FPN_Weights.COCO_V1),
weights_backbone=("pretrained_backbone", MobileNet_V3_Large_Weights.IMAGENET1K_V1),
)
def fasterrcnn_mobilenet_v3_large_320_fpn(
*,
weights: Optional[FasterRCNN_MobileNet_V3_Large_320_FPN_Weights] = None,
progress: bool = True,
num_classes: Optional[int] = None,
weights_backbone: Optional[MobileNet_V3_Large_Weights] = MobileNet_V3_Large_Weights.IMAGENET1K_V1,
trainable_backbone_layers: Optional[int] = None,
**kwargs: Any,
) -> FasterRCNN:
"""
Low resolution Faster R-CNN model with a MobileNetV3-Large backbone tuned for mobile use cases.
.. betastatus:: detection module
It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See
:func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` for more
details.
Example::
>>> model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_fpn(weights=FasterRCNN_MobileNet_V3_Large_320_FPN_Weights.DEFAULT)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
Args:
weights (:class:`~torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_320_FPN_Weights`, optional): The
pretrained weights to use. See
:class:`~torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_320_FPN_Weights` below for
more details, and possible values. By default, no pre-trained
weights are used.
progress (bool, optional): If True, displays a progress bar of the
download to stderr. Default is True.
num_classes (int, optional): number of output classes of the model (including the background)
weights_backbone (:class:`~torchvision.models.MobileNet_V3_Large_Weights`, optional): The
pretrained weights for the backbone.
trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
final block. Valid values are between 0 and 6, with 6 meaning all backbone layers are
trainable. If ``None`` is passed (the default) this value is set to 3.
**kwargs: parameters passed to the ``torchvision.models.detection.faster_rcnn.FasterRCNN``
base class. Please refer to the `source code
<https://github.com/pytorch/vision/blob/main/torchvision/models/detection/faster_rcnn.py>`_
for more details about this class.
.. autoclass:: torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_320_FPN_Weights
:members:
"""
weights = FasterRCNN_MobileNet_V3_Large_320_FPN_Weights.verify(weights)
weights_backbone = MobileNet_V3_Large_Weights.verify(weights_backbone)
defaults = {
"min_size": 320,
"max_size": 640,
"rpn_pre_nms_top_n_test": 150,
"rpn_post_nms_top_n_test": 150,
"rpn_score_thresh": 0.05,
}
kwargs = {**defaults, **kwargs}
return _fasterrcnn_mobilenet_v3_large_fpn(
weights=weights,
progress=progress,
num_classes=num_classes,
weights_backbone=weights_backbone,
trainable_backbone_layers=trainable_backbone_layers,
**kwargs,
)
@register_model()
@handle_legacy_interface(
weights=("pretrained", FasterRCNN_MobileNet_V3_Large_FPN_Weights.COCO_V1),
weights_backbone=("pretrained_backbone", MobileNet_V3_Large_Weights.IMAGENET1K_V1),
)
def fasterrcnn_mobilenet_v3_large_fpn(
*,
weights: Optional[FasterRCNN_MobileNet_V3_Large_FPN_Weights] = None,
progress: bool = True,
num_classes: Optional[int] = None,
weights_backbone: Optional[MobileNet_V3_Large_Weights] = MobileNet_V3_Large_Weights.IMAGENET1K_V1,
trainable_backbone_layers: Optional[int] = None,
**kwargs: Any,
) -> FasterRCNN:
"""
Constructs a high resolution Faster R-CNN model with a MobileNetV3-Large FPN backbone.
.. betastatus:: detection module
It works similarly to Faster R-CNN with ResNet-50 FPN backbone. See
:func:`~torchvision.models.detection.fasterrcnn_resnet50_fpn` for more
details.
Example::
>>> model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(weights=FasterRCNN_MobileNet_V3_Large_FPN_Weights.DEFAULT)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
Args:
weights (:class:`~torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_FPN_Weights`, optional): The
pretrained weights to use. See
:class:`~torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_FPN_Weights` below for
more details, and possible values. By default, no pre-trained
weights are used.
progress (bool, optional): If True, displays a progress bar of the
download to stderr. Default is True.
num_classes (int, optional): number of output classes of the model (including the background)
weights_backbone (:class:`~torchvision.models.MobileNet_V3_Large_Weights`, optional): The
pretrained weights for the backbone.
trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
final block. Valid values are between 0 and 6, with 6 meaning all backbone layers are
trainable. If ``None`` is passed (the default) this value is set to 3.
**kwargs: parameters passed to the ``torchvision.models.detection.faster_rcnn.FasterRCNN``
base class. Please refer to the `source code
<https://github.com/pytorch/vision/blob/main/torchvision/models/detection/faster_rcnn.py>`_
for more details about this class.
.. autoclass:: torchvision.models.detection.FasterRCNN_MobileNet_V3_Large_FPN_Weights
:members:
"""
weights = FasterRCNN_MobileNet_V3_Large_FPN_Weights.verify(weights)
weights_backbone = MobileNet_V3_Large_Weights.verify(weights_backbone)
defaults = {
"rpn_score_thresh": 0.05,
}
kwargs = {**defaults, **kwargs}
return _fasterrcnn_mobilenet_v3_large_fpn(
weights=weights,
progress=progress,
num_classes=num_classes,
weights_backbone=weights_backbone,
trainable_backbone_layers=trainable_backbone_layers,
**kwargs,
)
|
def prime_factor(no):
i=2
while no!=1:
if no%i==0:
print(i,end=" ")
no//=i
else:
i+=1
prime_factor(220) |
import caffe
import numpy as np
import os
import time
import hickle as hkl
import pickle
from PIL import Image
use_alexnet = True
feature_layers = ['fc7', 'fc6', 'pool5', 'conv4', 'conv3', 'pool2', 'pool1']
feature_dir = "../features"
compression_dir = "../compression"
distances_dir = "../distances"
db_dir = "../db"
test_set_dir = '../test_set'
caffe_root = '/home/eric/caffe/caffe-master/'
# database configuration
user = 'postgres'
password = 'asdfgh'
host = '127.0.0.1'
dbname = 'mydb'
import cv2
def get_dimension_options(layer, compression):
"""
Returns an array of all the possible compression sizes for that layer / compression pair
:type layer: str
:param layer: feature layer
:type compression: str
:param compression: compression type identifier (pca, kpca, etc.)
:rtype: array-like
:return: dimensions
"""
if not layer in feature_layers:
raise NotImplementedError('Feature Layer Type Not Found.')
compresion_path = os.path.join(compression_dir, compression, layer)
files = os.listdir(compresion_path)
N = len(files)
if N <= 1:
raise ValueError('Path provided contained no stored algorithms : ' + compresion_path)
# there is a holder file in each directory which needs to be removed
files.remove('holder.txt')
dimensions = []
for file in files:
name, dim, postfix = file.split('_')
dimensions.append(int(dim))
return dimensions
def load_english_labels():
"""
Returns a dictionary from class # to the english label.
:return: labels
"""
imagenet_labels_filename = os.path.join('../caffe/synset_words.txt')
try:
labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
except:
raise ValueError('Could not find synset_works in the correct place.')
return labels
def load_db_labels():
fo = open("../db/labels.txt", "r+")
# remove the /n
content = fo.read().splitlines()
labels = {}
for line in content:
klass, label = line.split(' ')
labels[int(klass)] = label
fo.close()
return labels
def load_compressor(layer, dimension, compression):
"""
Loads the compression algorithm from the file system
:type layer: str
:param layer: feature layer
:type dimension: int
:param dimension: n_components of compressor
:type compression: str
:param compression: Compressional algorithm ID
:return: Compression algorithm
"""
if not layer in feature_layers:
raise NotImplementedError('Feature Layer Type Not Found.')
compression_path = os.path.join(compression_dir, compression, layer)
file_name = compression + '_' + str(dimension) + '_gzip.hkl'
file_path = os.path.join(compression_path, file_name)
return hkl.load(file_path, safe=False)
def batch_gen(data, batch_size):
"""
Simple generator for looping over an array in batches
:type data: array-like
:param data:
:type batch_size: int
:param batch_size:
:return: generator
"""
for i in range(0, len(data), batch_size):
yield data[i:i + batch_size]
def load_network():
"""
Loads the caffe network. The type of network loaded is specified in the utils file.
:return: caffe network
"""
if not use_alexnet:
# Set the right path to your model definition file, pretrained model weights,
# and the image you would like to classify.
MODEL_FILE = '../caffe/bvlc_reference_caffenet/deploy.prototxt'
PRETRAINED = '../caffe/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'
else:
# ALEXNET
MODEL_FILE = '../caffe/bvlc_alexnet/deploy.prototxt'
PRETRAINED = '../caffe/bvlc_alexnet/bvlc_alexnet.caffemodel'
net = caffe.Classifier(MODEL_FILE, PRETRAINED,
mean=np.load(os.path.join(caffe_root, 'python/caffe/imagenet/ilsvrc_2012_mean.npy')),
channel_swap=(2, 1, 0),
raw_scale=255,
image_dims=(256, 256))
blobs = [(k, v.data.shape) for k, v in net.blobs.items()]
params = [(k, v[0].data.shape) for k, v in net.params.items()]
print 'Blobs : ', blobs
print 'Params : ', params
net.set_phase_test()
net.set_mode_gpu()
return net, params, blobs
def load_scalar(layer):
"""
Load the feature mean / variance scalar for the input layer
:type layer: str
:param layer: Feature layer
:return: scalar
"""
if not layer in feature_layers:
raise NotImplementedError('Feature Layer Type Not Found.')
features_path = os.path.join(feature_dir, layer)
files = os.listdir(features_path)
N = len(files)
if N <= 1:
raise ValueError('Path provided contained no features : ' + features_path)
for file in files:
sp = file.split('_')
if 'scalar' in sp:
scalar = hkl.load(os.path.join(features_path, file), safe=False)
return scalar
def load_distance_matrix(layer):
"""
Returns the distance matrix as defined by the features of the provided layer
Note that this must be generated beforehand using generate_dist_func
:type layer: str
:param layer: Feature layer
:return: numpy array
"""
return hkl.load(os.path.join(distances_dir, 'dist_matrix_' + layer + '.hkl'))
def dump_feature_db(comp_fc7, props, fc7_feats, pool5_feats):
"""
Saves out the feature layer using hickle
:return:
"""
file_name = 'fc7_feats.hkl'
file_path = os.path.join(db_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(fc7_feats, file_path, mode='w', compression='gzip')
file_name = 'props.p'
file_path = os.path.join(db_dir, 'feats', file_name)
print 'Saving : ', file_path
pickle.dump(props, open(file_path, "wb"))
file_name = 'comp_fc7.hkl'
file_path = os.path.join(db_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(comp_fc7, file_path, mode='w', compression='gzip')
file_name = 'pool5_feats.hkl'
file_path = os.path.join(db_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(pool5_feats, file_path, mode='w', compression='gzip')
print 'Saved %s Images into Databse' % len(props)
def load_feature_db():
"""
:return: comp_fc7, ids, fc7_feats, pool5_feats
"""
features_path = os.path.join(db_dir, 'feats')
files = os.listdir(features_path)
N = len(files)
if N <= 1:
print 'No stored features in Database!'
return (np.empty((0, 128), dtype=np.float32),
[],
np.empty((0, 4096), dtype=np.float32),
np.empty((0, 9216), dtype=np.float32))
start_time = time.clock()
fc7_feats = hkl.load(os.path.join(features_path, 'fc7_feats.hkl'))
pool5_feats = hkl.load(os.path.join(features_path, 'pool5_feats.hkl'))
props = pickle.load(open(os.path.join(features_path, 'props.p'), "rb"))
comp_fc7 = hkl.load(os.path.join(features_path, 'comp_fc7.hkl'))
# for now, normalize the pool5_feats making comparison easier
# still want to hold on to original pool5_feats though
for i, feat in enumerate(pool5_feats):
pool5_feats[i, :] = feat / feat.max()
print 'Load Time Feat DB (s) : ', time.clock() - start_time
print '%s Instances in DB' % len(props)
return comp_fc7, props, fc7_feats, pool5_feats
def dump_test_set_db(comp_fc7, props, fc7_feats, pool5_feats):
"""
Saves out the feature layer using hickle
:return:
"""
file_name = 'test_fc7_feats.hkl'
file_path = os.path.join(test_set_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(fc7_feats, file_path, mode='w', compression='gzip')
file_name = 'test_props.p'
file_path = os.path.join(test_set_dir, 'feats', file_name)
print 'Saving : ', file_path
pickle.dump(props, open(file_path, "wb"))
file_name = 'test_comp_fc7.hkl'
file_path = os.path.join(test_set_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(comp_fc7, file_path, mode='w', compression='gzip')
file_name = 'test_pool5_feats.hkl'
file_path = os.path.join(test_set_dir, 'feats', file_name)
print 'Saving : ', file_path
hkl.dump(pool5_feats, file_path, mode='w', compression='gzip')
print 'Saved %s Images into Databse' % len(props)
def load_test_set_db():
"""
:return: comp_fc7, ids, fc7_feats, pool5_feats
"""
features_path = os.path.join(test_set_dir, 'feats')
files = os.listdir(features_path)
N = len(files)
if N <= 1:
print 'No stored features in Database!'
return (np.empty((0, 128), dtype=np.float32),
[],
np.empty((0, 4096), dtype=np.float32),
np.empty((0, 9216), dtype=np.float32))
start_time = time.clock()
fc7_feats = hkl.load(os.path.join(features_path, 'test_fc7_feats.hkl'))
pool5_feats = hkl.load(os.path.join(features_path, 'test_pool5_feats.hkl'))
props = pickle.load(open(os.path.join(features_path, 'test_props.p'), "rb"))
comp_fc7 = hkl.load(os.path.join(features_path, 'test_comp_fc7.hkl'))
# for now, normalize the pool5_feats making comparison easier
# still want to hold on to original pool5_feats though
for i, feat in enumerate(pool5_feats):
pool5_feats[i, :] = feat / feat.max()
print 'Load Time Feat DB (s) : ', time.clock() - start_time
print '%s Instances in DB' % len(props)
return comp_fc7, props, fc7_feats, pool5_feats
def dump_feature_stats(class_gmms):
file_name = 'class_gmms.p'
file_path = os.path.join(db_dir, 'stats', file_name)
print 'Saving : ', file_path
pickle.dump(class_gmms, open(file_path, "wb"))
def load_feature_stats():
"""
:return: class_gmms
"""
start_time = time.clock()
file_path = os.path.join(db_dir, 'stats', 'class_gmms.p')
class_gmms = pickle.load(open(file_path, "rb"))
print 'Load Time Stats DB (s) : ', time.clock() - start_time
return class_gmms
def save_image(np_img, inst, type):
file_path = os.path.join(db_dir, type, 'img_%s.jpeg' % (inst))
im = Image.fromarray(np_img)
im.save(file_path)
def load_image(inst, type):
file_path = os.path.join(db_dir, type, 'img_%s.jpeg' % (inst))
return np.asarray(Image.open(file_path), dtype=np.uint8)
def save_test_image(np_img, inst, type):
file_path = os.path.join(test_set_dir, type, 'img_%s.jpeg' % (inst))
im = Image.fromarray(np_img)
im.save(file_path)
def load_test_image(inst, type):
file_path = os.path.join(test_set_dir, type, 'img_%s.jpeg' % (inst))
return np.asarray(Image.open(file_path), dtype=np.uint8)
def trans_img_dcnn(img, box):
"""
Center the crop in a image size set for the dcnn (255, 255). Convert to float32 and scale 0,1
:param img: segmented image with 1 object
:param box: The segment box
:return: dcnn_img
"""
x1, y1, x2, y2, mean_depth = box
x1 = max(0, x1)
y1 = max(0, y1)
x2 = min(img.shape[0] - 1, x2)
y2 = min(img.shape[1] - 1, y2)
resized_img = cv2.resize(img[x1:x2, y1:y2, :], (256, 256))
return np.asarray(resized_img, dtype=np.float32) / 255.0
def query_accept():
var = raw_input("Accept Photo (y/n) ? : ")
if var.upper() == 'Y' or var.upper() == 'YES':
return 1
else:
return -1
def query_id(type):
while True:
try:
var = raw_input("Enter %s ID (uint) : " % type)
id = int(var)
break
except:
print 'Must be an integer value.'
continue
return id
def crop_segment(segmenter):
"""
Crops the image from the segmenter so that only the closest object is visible
:param segmenter:
:return:
"""
img = segmenter.rgb_imge
boxes = segmenter.boxes
closest_idx = 0
closest_val = np.inf
for i in range(len(boxes)):
x1, y1, x2, y2, mean_depth = boxes[i]
if mean_depth < closest_val:
closest_idx = i
closest_val = mean_depth
x1, y1, x2, y2, mean_depth = boxes[closest_idx]
x1 = max(0, x1)
y1 = max(0, y1)
x2 = min(x2, img.shape[0] - 1)
y2 = min(y2, img.shape[1] - 1)
cropped_img = np.zeros(img.shape, dtype=img.dtype)
cropped_img[x1:x2, y1:y2, :] = img[x1:x2, y1:y2, :]
return cropped_img, boxes[closest_idx]
def query_should_continue():
should_continue = raw_input("Continue (y/n) ? : ")
if should_continue.lower() == 'n' or should_continue.lower() == 'no':
return -1
return 1
|
#coding=utf8
announcement = "<h1><center>遇见， 无限可能...</center></h1>" |
import copy
from enum import Enum
class Opcodes(Enum):
ADD = 1
MULTIPLY = 2
INPUT = 3
OUTPUT = 4
JTRUE = 5
JFALSE = 6
LESSTHAN = 7
EQUALS = 8
HALT = 99
class Mode(Enum):
POSITION = 0,
IMMEDIATE = 1,
instructionCount = {
Opcodes.JTRUE: 3,
Opcodes.JFALSE: 3,
Opcodes.LESSTHAN: 4,
Opcodes.EQUALS: 4,
Opcodes.ADD: 4,
Opcodes.MULTIPLY: 4,
Opcodes.INPUT: 2,
Opcodes.OUTPUT: 2,
Opcodes.HALT: 1
}
# Get data, and save it
with open("input1.txt","r") as f:
data = f.readlines()[0].replace("\n","").split(',')
data = list(map(int, data))
originalMemory = copy.deepcopy(data)
def readOpcodeInfo(opcode):
# It will be an integer at this point, so for convenience
# Of slicing we make it a string
result = ["0", "0", "0", "-1"]
opcode = str(opcode)
#print("\tOPCODE READ: {}".format(opcode))
if len(opcode) <= 2:
result[3] = int(opcode)
if len(opcode) >= 3:
result[3] = int(opcode[1]+opcode[2])
result[2] = int(opcode[0])
if len(opcode) >=4:
result[3] = int(opcode[2]+opcode[3])
result[2] = int(opcode[1])
result[1] = int(opcode[0])
if len(opcode) == 5:
result[3] = int(opcode[3]+opcode[4])
result[2] = int(opcode[2])
result[1] = int(opcode[1])
result[0] = int(opcode[0])
return result
def getValue(mode, readPosition):
if mode == Mode.POSITION:
return data[data[readPosition]]
elif mode == Mode.IMMEDIATE:
return data[readPosition]
# Compute with opcodes
def compute(data, readPoint):
while(True):
addInstructionCount = True
statusMode = [Mode.POSITION for x in range(3)]
# Need to get OPCODE data
opcodeData = readOpcodeInfo(data[readPoint])
print("STEP\n\tOpcode:{}\n\tReadpoint:{}\n\tNext 4 data values: {}, {}, {}, {}".format(opcodeData[3], readPoint, data[readPoint], data[readPoint+1], data[readPoint+2], data[readPoint+3]))
opcode = Opcodes(opcodeData[3])
# Set status mode enums
# Parameter 3
if opcodeData[0] == 1:
statusMode[2] = Mode.IMMEDIATE
# Parameter 2
if opcodeData[1] == 1:
statusMode[1] = Mode.IMMEDIATE
# Parameter 1
if opcodeData[2] == 1:
statusMode[0] = Mode.IMMEDIATE
# We now have the mode. Must rewrite below opcodes into their own functions taking in the opcodeData as input
result = None
if (opcode == Opcodes.HALT):
break
elif (opcode == Opcodes.ADD):
result = getValue(statusMode[0], readPoint+1) + getValue(statusMode[1], readPoint+2)
data[data[readPoint+3]] = result
elif (opcode == Opcodes.MULTIPLY):
result = getValue(statusMode[0], readPoint+1) * getValue(statusMode[1], readPoint+2)
data[data[readPoint+3]] = result
elif (opcode == Opcodes.INPUT):
data[data[readPoint+1]] = int(input("INTCOMPUTER INPUT > "))
elif (opcode == Opcodes.OUTPUT):
print(data[data[readPoint+1]])
elif opcode == Opcodes.JTRUE:
result = getValue(statusMode[0], readPoint+1)
if result != 0:
addInstructionCount = False
readPoint = getValue(statusMode[1],readPoint+2)#data[readPoint+2]
elif opcode == Opcodes.JFALSE:
result = getValue(statusMode[0], readPoint+1)
if result == 0:
addInstructionCount = False
readPoint = getValue(statusMode[1], readPoint+2)#data[readPoint+2]
elif opcode == Opcodes.LESSTHAN:
result = getValue(statusMode[0], readPoint+1) < getValue(statusMode[1], readPoint+2)
if result:
data[data[readPoint+3]] = 1
else:
data[data[readPoint+3]] = 0
elif opcode == Opcodes.EQUALS:
result = getValue(statusMode[0], readPoint+1) == getValue(statusMode[1], readPoint+2)
if result:
data[data[readPoint+3]] = 1
else:
data[data[readPoint+3]] = 0
else:
#pass
print("ERROR, Invalid opcode!")
if addInstructionCount:
readPoint+=instructionCount.get(opcode)
return data[0]
data = copy.deepcopy(originalMemory)
compute(data, 0)
|
#!/usr/bin/env python3
"""
An example of how to use the json module.
This module is also really simple, it is used to parse json into a dict,
amongest many other things.
"""
import json
jsonData = '{"name": "Paulo", "age": 21, "race": "sleepy mexican", "height": 71}'
jsonDict = json.loads(jsonData)
print(jsonDict)
print(type(jsonDict) is dict)
for key in jsonDict:
print(key, jsonDict[key])
|
from rest_framework import viewsets
from .serializers import UserSerializer
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import IsAdminUser
# from django.contrib.auth.models import User
from .models import User
from django.http import HttpResponse, Http404
from rest_framework import (
generics,
) # , permissions, viewsets, serializers, permissions, filters, status
class UserRecordView(APIView):
"""
API View to create or get a list of all the registered
users. GET request returns the registered users whereas
a POST request allows to create a new user.
"""
# permission_classes = [IsAdminUser]
# def check_if_code_exists(self):
# dacodes =[]
# for duser in User.objects.all():
# dacodes.append(duser.my_code)
# return dacodes
def get(self, format=None):
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
def post(self, request):
# print(request.data)#first_name to be own_refer_code
request.data["my_code"] = (
"DA" + request.data["username"]
) # USE first_name as own_refer_code
serializer = UserSerializer(data=request.data)
if serializer.is_valid(raise_exception=ValueError):
serializer.create(validated_data=request.data)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(
{"error": True, "error_msg": serializer.error_messages,},
status=status.HTTP_400_BAD_REQUEST,
)
|
from sys import argv
def getMAC(interface='eth0'):
# Return the MAC address of the specified interface
try:
str = open('/sys/class/net/%s/address' %interface).read()
except:
str = "00:00:00:00:00:00"
return str[0:17]
if __name__ == "__main__":
if len(argv)>1:
foo = getMAC(interface=argv[1])
else:
foo = getMAC()
print(foo)
|
from .exporter_object import ExporterObject
from .influx_object import InfluxObject
from .__version__ import __version__
import argparse
class UserNamespace(object):
pass
def export_csv_to_influx():
parser = argparse.ArgumentParser(description='CSV to InfluxDB.')
# Parse: Parse the server name, and judge the influx version
parser.add_argument('-s', '--server', nargs='?', default='localhost:8086', const='localhost:8086',
help='InfluxDB Server address. Default: localhost:8086')
parser.add_argument('-v', '--version', action="version", version=__version__)
user_namespace = UserNamespace()
parser.parse_known_args(namespace=user_namespace)
influx_object = InfluxObject(db_server_name=user_namespace.server)
influx_version = influx_object.get_influxdb_version()
print('Info: The influxdb version is {influx_version}'.format(influx_version=influx_version))
# influxdb 0.x, 1.x
parser.add_argument('-db', '--dbname',
required=True if influx_version.startswith('0') or influx_version.startswith('1') else False,
help='For 0.x, 1.x only, InfluxDB Database name.')
parser.add_argument('-u', '--user', nargs='?', default='admin', const='admin',
help='For 0.x, 1.x only, InfluxDB User name.')
parser.add_argument('-p', '--password', nargs='?', default='admin', const='admin',
help='For 0.x, 1.x only, InfluxDB Password.')
# influxdb 2.x
parser.add_argument('-http_schema', '--http_schema', nargs='?', default='http', const='http',
help='For 2.x only, the influxdb http schema, could be http or https. Default: http.')
parser.add_argument('-org', '--org', nargs='?', default='my-org', const='my-org',
help='For 2.x only, the org. Default: my-org.')
parser.add_argument('-bucket', '--bucket', nargs='?', default='my-bucket', const='my-bucket',
help='For 2.x only, the bucket. Default: my-bucket.')
parser.add_argument('-token', '--token',
required=True if influx_version.startswith('2') else False,
help='For 2.x only, the access token')
# Parse: Parse the others
parser.add_argument('-c', '--csv', required=True,
help='Input CSV file.')
parser.add_argument('-d', '--delimiter', nargs='?', default=',', const=',',
help='CSV delimiter. Default: \',\'.')
parser.add_argument('-lt', '--lineterminator', nargs='?', default='\n', const='\n',
help='CSV lineterminator. Default: \'\\n\'.')
parser.add_argument('-m', '--measurement', required=True,
help='Measurement name.')
parser.add_argument('-t', '--time_column', nargs='?', default='timestamp', const='timestamp',
help='Timestamp column name. Default: timestamp. '
'If no timestamp column, '
'the timestamp is set to the last file modify time for whole csv rows')
parser.add_argument('-tf', '--time_format', nargs='?', default='%Y-%m-%d %H:%M:%S', const='%Y-%m-%d %H:%M:%S',
help='Timestamp format. Default: \'%%Y-%%m-%%d %%H:%%M:%%S\' e.g.: 1970-01-01 00:00:00')
parser.add_argument('-tz', '--time_zone', nargs='?', default='UTC', const='UTC',
help='Timezone of supplied data. Default: UTC')
parser.add_argument('-fc', '--field_columns', required=True,
help='List of csv columns to use as fields, separated by comma')
parser.add_argument('-tc', '--tag_columns', nargs='?', default=None, const=None,
help='List of csv columns to use as tags, separated by comma. Default: None')
parser.add_argument('-b', '--batch_size', nargs='?', default=500, const=500,
help='Batch size when inserting data to influx. Default: 500.')
parser.add_argument('-lslc', '--limit_string_length_columns', nargs='?', default=None, const=None,
help='Limit string length columns, separated by comma. Default: None.')
parser.add_argument('-ls', '--limit_length', nargs='?', default=20, const=20,
help='Limit length. Default: 20.')
parser.add_argument('-dd', '--drop_database', nargs='?', default=False, const=False,
help='Drop database before inserting data. Default: False')
parser.add_argument('-dm', '--drop_measurement', nargs='?', default=False, const=False,
help='Drop measurement before inserting data. Default: False')
parser.add_argument('-mc', '--match_columns', nargs='?', default=None, const=None,
help='Match the data you want to get for certain columns, separated by comma. '
'Match Rule: All matches, then match. Default: None')
parser.add_argument('-mbs', '--match_by_string', nargs='?', default=None, const=None,
help='Match by string, separated by comma. Default: None')
parser.add_argument('-mbr', '--match_by_regex', nargs='?', default=None, const=None,
help='Match by regex, separated by comma. Default: None')
parser.add_argument('-fic', '--filter_columns', nargs='?', default=None, const=None,
help='Filter the data you want to filter for certain columns, separated by comma. '
'Filter Rule: Any one matches, then match. Default: None')
parser.add_argument('-fibs', '--filter_by_string', nargs='?', default=None, const=None,
help='Filter by string, separated by comma. Default: None')
parser.add_argument('-fibr', '--filter_by_regex', nargs='?', default=None, const=None,
help='Filter by regex, separated by comma. Default: None')
parser.add_argument('-ecm', '--enable_count_measurement', nargs='?', default=False, const=False,
help='Enable count measurement. Default: False')
parser.add_argument('-fi', '--force_insert_even_csv_no_update', nargs='?', default=True, const=True,
help='Force insert data to influx, even csv no update. Default: False')
parser.add_argument('-fsc', '--force_string_columns', nargs='?', default=None, const=None,
help='Force columns as string type, separated by comma. Default: None.')
parser.add_argument('-fintc', '--force_int_columns', nargs='?', default=None, const=None,
help='Force columns as int type, separated by comma. Default: None.')
parser.add_argument('-ffc', '--force_float_columns', nargs='?', default=None, const=None,
help='Force columns as float type, separated by comma. Default: None.')
parser.add_argument('-uniq', '--unique', nargs='?', default=False, const=False,
help='Write duplicated points. Default: False.')
parser.add_argument('--csv_charset', '--csv_charset', nargs='?', default=None, const=None,
help='The csv charset. Default: None, which will auto detect')
args = parser.parse_args(namespace=user_namespace)
exporter = ExporterObject()
input_data = {
'csv_file': args.csv,
'db_server_name': user_namespace.server,
'db_user': args.user,
'db_password': args.password,
'db_name': 'None' if args.dbname is None else args.dbname,
'db_measurement': args.measurement,
'time_column': args.time_column,
'time_format': args.time_format,
'time_zone': args.time_zone,
'field_columns': args.field_columns,
'tag_columns': args.tag_columns,
'batch_size': args.batch_size,
'delimiter': args.delimiter,
'lineterminator': args.lineterminator,
'limit_string_length_columns': args.limit_string_length_columns,
'limit_length': args.limit_length,
'drop_database': args.drop_database,
'drop_measurement': args.drop_measurement,
'match_columns': args.match_columns,
'match_by_string': args.match_by_string,
'match_by_regex': args.match_by_regex,
'filter_columns': args.filter_columns,
'filter_by_string': args.filter_by_string,
'filter_by_regex': args.filter_by_regex,
'enable_count_measurement': args.enable_count_measurement,
'force_insert_even_csv_no_update': args.force_insert_even_csv_no_update,
'force_string_columns': args.force_string_columns,
'force_int_columns': args.force_int_columns,
'force_float_columns': args.force_float_columns,
'http_schema': args.http_schema,
'org_name': args.org,
'bucket_name': args.bucket,
'token': 'None' if args.token is None else args.token,
'unique': args.unique,
'csv_charset': args.csv_charset
}
exporter.export_csv_to_influx(**input_data)
|
from tkinter import Tk, scrolledtext, Menu, filedialog, END, messagebox, simpledialog
import os
# Root for main window
root = Tk(className = " Text Editor")
textArea =scrolledtext.ScrolledText(root, width = 100, height = 80)
#Functions for the menu options
def newFile():
#Is there any content?
if len(textArea.get('1.0', END+'-1c')) > 0:
if messagebox.askyesno("Save?","Do you wish to save?"):
saveFile()
else:
textArea.delete('1.0', END)
root.title("TEXT EDITOR")
def openFile():
textArea.delete('1.0',END)
file = filedialog.askopenfile(parent=root, mode='rb', title='Select a text file',filetypes = (("Text file", "*.txt"), ("All files", "*.*")))
root.title(os.path.basename(file.name) + " - TEXT EDITOR")
if file != None:
contents = file.read()
textArea.insert('1.0',contents)
file.close()
def saveFile():
file = filedialog.asksaveasfile(mode='w', defaultextension = ".txt", filetypes = (("HTML file","*.html"),("Text file","*.txt"),("All files","*.*")))
if file != None:
#slice off the last character from get, as an extra return (enter) is added
data = textArea.get('1.0', END+'-1c')
file.write(data)
file.close()
def findInFile():
findString = simpledialog.askstring("Find...", "Enter text")
textData = textArea.get('1.0',END)
occurances = textData.upper().count(findString.upper())
if occurances > 1:
label = messagebox.showinfo("Results",findString+" has "+str(occurances)+" occurances.")
elif occurances == 1:
label = messagebox.showinfo("Results",findString+" occurs only once.")
else:
label = messagebox.showinfo("Results","Not found!")
def about():
label = messagebox.showinfo("About","Version 1.0(Beta)\nDevelopment team-\nShubham Gururani\nVivek Bhardwaj\nManish Singh\nKuldeep Upreti")
def exitProg():
if messagebox.askyesno("Quit","Are you sure you want to quit?"):
root.destroy()
# Menu options
menu = Menu(root)
root.config(menu = menu)
fileMenu = Menu(menu, tearoff = 0)
menu.add_cascade(label='File',menu=fileMenu)
fileMenu.add_command(label="New", command = newFile)
fileMenu.add_command(label="Open", command = openFile)
fileMenu.add_command(label="Save", command = saveFile)
fileMenu.add_command(label="Find", command = findInFile)
#fileMenu.add_command(label="Print")
fileMenu.add_separator()
fileMenu.add_command(label="Exit", command = exitProg)
helpMenu = Menu(menu)
menu.add_cascade(label="Help")
menu.add_cascade(label="About", command = about)
textArea.pack()
# Keep window open
root.mainloop()
|
import numpy as np
import matplotlib.pyplot as plt
import pendulum
from PID import PID_Control
if __name__ =="__main__":
P = pendulum.Pendulum()
PID = PID_Control(150,2,10) # Some values for Kp, Ki and Kd
# Initial Condition
X = np.array([ [0],
[0],
[0.4],
[0]]
)
thetas = [float(X[2])]
for i in range(0,100):
u = PID.update(float(X[2]))
X = P.run_step(X,u)
x = float(X[0])
theta = float(X[2])
thetas.append(theta)
P.plot_pendulum(x,theta)
plt.figure('Response')
plt.plot(thetas)
plt.show() |
if __name__ == '__main__':
file = open("day12.txt", "r")
moves = []
x_coord = 0
y_coord = 0
# only valid values 0, 90, 180, 270
# initially facing east = 90
facing = 90
for line in file:
moves.append(line.strip("\n"))
for individual_move in moves:
action = individual_move[:1]
value = int(individual_move[1:])
# so that it can only be valid values of 0, 90, 180, 270
while facing >= 360:
facing -= 360
while facing < 0:
facing += 360
if action == "F":
if facing == 90:
x_coord += value
elif facing == 180:
y_coord -= value
elif facing == 270:
x_coord -= value
elif facing == 0:
y_coord += value
else:
print ("bug found")
elif action == "N":
y_coord += value
elif action == "S":
y_coord -= value
elif action == "E":
x_coord += value
elif action == "W":
x_coord -= value
elif action == "L":
facing -= value
else:
# else "R"
facing += value
print (abs(x_coord) + abs(y_coord)) |
# OpenWeatherMap API Key
api_key = "cf61488b0b6c2bf530c649e1dc953891"
|
#-----------------------------调用函数---------------------------------------
# 利用Python内置的hex()函数把一个整数转换成十六进制表示的字符串：
a = 20;
print(hex(a));
#-----------------------------定义函数---------------------------------------
# 定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程：
# ax2 + bx + c = 0
# 的两个解。
import math;
def quadratic(a, b, c):
s = b*b-4*a*c;
if s < 0 :
print("此函数无解")
if s == 0 :
return -b/2/a
if s >0 :
return (-b+math.sqrt(s))/2/a,(-b-math.sqrt(s))/2/a;
print(quadratic(1,3,-4))
#-----------------------------函数的参数---------------------------------------
#默认参数
def my_pow(x,y=2):
s = 1;
while y > 0 :
s = s * x;
y -=1;
return s;
print(my_pow(3),my_pow(3,4))
# 可变参数
def my_calc(*numbers):
return sum(n for n in numbers);
print(my_calc(1,2,3),my_calc(1,2,3,4),my_calc(*[1,2,4,5,7]))
#*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
#关键字参数
def persion(name,age,**kw):
print("name",name,"age",age,"kw",kw)
persion("lili",23,city="北京",height=170,weight=65)
extra = {"city":"北京","height":170,"weight":65}
persion("lili",23,**extra)
#**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
#命名关键字参数
#只接收city和job作为关键字参数，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
def person_2(name, age, *, city, job):
print(name, age, city, job)
person_2("lily",25,city="北京",job="IT")
person_2("lily",25,city="北京",job="IT")
#参数组合
#在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
# 但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
#计算两个数的乘积，可接收一个或多个数并计算乘积：
def product(*number):
s = 1;
if number is ():
raise TypeError
for n in number:
s = s * n;
return s;
print('product(5) =', product(5))
print('product(5, 6) =', product(5, 6))
print('product(5, 6, 7) =', product(5, 6, 7))
print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))
if product(5) != 5:
print('测试失败!')
elif product(5, 6) != 30:
print('测试失败!')
elif product(5, 6, 7) != 210:
print('测试失败!')
elif product(5, 6, 7, 9) != 1890:
print('测试失败!')
else:
try:
product()
print('测试失败!')
except TypeError:
print('测试成功!')
#-----------------------------递归函数---------------------------------------
#请编写move(n, a, b, c)函数，它接收参数n，表示3个柱子A、B、C中第1个柱子A的盘子数量，然后打印出把所有盘子从A借助B移动到C的方法
|
from django.contrib import admin
from facts import models
class ArtistAdmin(admin.ModelAdmin):
# date_hierarchy = 'date'
search_fields = (
'id',
'artist',
)
list_display = (
'id',
'artist',
)
class SongsAdmin(admin.ModelAdmin):
# date_hierarchy = 'date'
search_fields = (
'id',
'artist_id',
'song',
)
list_display = (
'id',
'artist_id',
'song',
)
class FactsAdmin(admin.ModelAdmin):
# date_hierarchy = 'date'
search_fields = (
'id',
'facts',
'song_id',
'author',
)
list_display = (
'id',
'facts',
'song_id',
'author',
)
admin.site.register(models.Artist, ArtistAdmin)
admin.site.register(models.Song, SongsAdmin)
admin.site.register(models.Facts, FactsAdmin)
|
#!/usr/bin/python
"""Copyright 2003-2010 Gentoo Foundation
Distributed under the terms of the GNU General Public License v2
"""
from __future__ import print_function
# Meta:
__author__ = "Thomas de Grenier de Latour (tgl), " + \
"modular re-write by: Brian Dolbec (dol-sen)"
__email__ = "degrenier@easyconnect.fr, " + \
"brian.dolbec@gmail.com"
__version__ = "0.3.0.7"
__productname__ = "eclean"
__description__ = "A cleaning tool for Gentoo distfiles and binaries."
import sys
# This block ensures that ^C interrupts are handled quietly.
try:
import signal
def exithandler(signum,frame):
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
print()
sys.exit(1)
signal.signal(signal.SIGINT, exithandler)
signal.signal(signal.SIGTERM, exithandler)
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
except KeyboardInterrupt:
print()
sys.exit(1)
from gentoolkit.eclean.cli import main
try:
main()
except KeyboardInterrupt:
print("Aborted.")
sys.exit(130)
sys.exit(0)
|
A=float(input("A="))
B=float(input("B="))
R=A-B
N=1
while R>=B:
R=R-B
N=N+1
print("Amount of sgments B: ",N)
|
import random
player1_totalscore = 0
player2_totalscore = 0
player1_turn_score = 0
player2_turn_score = 0
score= 0
command = " "
player_turn = 0
#Player 1 rolls the dice
#command = input ("command r to roll > ")
while (True):
if player_turn == 0:
command = input ("command r to roll > ")
if command == "r":
round_score = random.randint(1,6)
if round_score == 1:
player1_totalscore = 0
else:
player1_totalscore = player1_turn_score + roll
else:
player_turn = 1
if command == "r":
roll = random.randint(1,6)
player1_turn_score = player1_totalscore + roll
command = input ("Would you like to roll again? Type r, to hold type h > ")
if command == "r":
roll = random.randint(1,6)
if roll == 1:
player2_totalscore = 0
else:
player2_totalscore = player2_turn_score + roll
else:
player_turn = 1
if command == "r":
roll = random.randint(1,6)
player2_turn_score = player2_totalscore + roll
command = input ("Would you like to roll again? Type r, to hold type h > ")
print (player2_totalscore)
'''
p1_dice = random.randint(1, 6)
p1_dice2 = random.randint(1, 6)
p2_dice = random.randint(1, 6)
p2_dice2 = random.randint(1, 6)
player1 = p1_dice + p1_dice2
player2 = p2_dice + p2_dice2
'''
|
'''
Дано трехзначное число. Найдите сумму его цифр.
Примеры:
Тест 1
Входные данные:
179
Вывод программы:
17
''' |
#!/usr/bin/env python3
# Copyright (c) 2021 Mahdi Biparva, mahdi.biparva@gmail.com
# miTorch: Medical Imaging with PyTorch
# Deep Learning Package for 3D medical imaging in PyTorch
# Implemented by Mahdi Biparva, April 2021
# Brain Imaging Lab, Sunnybrook Research Institute (SRI)
import time
from abc import ABC, abstractmethod
import datetime
import torch
import subprocess
import utils.distributed as du
from data.data_container import DataContainer
from utils.meters import TVTMeter
import utils.metrics as metrics
from utils.net_pred import post_proc_pred, pack_pred
class BatchBase(ABC):
modes = ('train', 'valid', 'test')
def __init__(self, mode, cfg, device):
self.cfg = cfg
self.data_container = None
assert mode in BatchBase.modes
self.mode, self.device = mode, device
self.create_dataset()
self.meters = self.create_meters()
def create_meters(self):
meters = TVTMeter
return meters(
len(self.data_container.dataloader),
self.cfg,
self.cfg.PROJECT.METERS,
self.mode,
)
def create_dataset(self):
self.data_container = DataContainer(self.mode, self.cfg)
def tb_logger_update(self, logger_writer, e):
if logger_writer is None: # workers
return
for k, m_avg in self.meters.get_avg_for_tb():
logger_writer.add_scalar('{}/{}'.format(self.mode, k), m_avg, e)
@abstractmethod
def set_net_mode(self, net):
raise NotImplementedError
def _get_lr(self, netwrapper):
return netwrapper.scheduler.get_last_lr() if self.cfg.SOLVER.SCHEDULER_MODE else self.cfg.SOLVER.BASE_LR
def generate_gt(self, annotation):
if not (self.cfg.HPSF.ENABLE or (self.cfg.NVT.ENABLE and self.cfg.MODEL.NUM_CLASSES > 1)):
assert annotation.size(1) == 1
if self.cfg.MODEL.LOSSES[0]['name'] == 'CrossEntropyLoss':
assert annotation.size(1) == 1
annotation = annotation.squeeze(dim=1).long()
if self.cfg.AMP:
annotation = annotation.to(dtype=torch.float16)
return annotation
@staticmethod
def binarize(p, binarize_threshold):
prediction_mask = p.ge(binarize_threshold)
p = p.masked_fill(prediction_mask, 1)
p = p.masked_fill(~prediction_mask, 0)
return p
def ddp_reduce_meters(self, meters):
# pack
meters_tensor, meters_keys = list(), list()
for k, v in meters.items():
meters_keys.append(k)
meters_tensor.append(v)
meters_tensor = torch.tensor(meters_tensor)
meters_tensor = [meters_tensor.to(self.device)]
# gather
meters_tensor_gathered = du.all_reduce(meters_tensor, average=True)
# unpack
meters_tensor_gathered = meters_tensor_gathered[0]
# updated
for k, v in zip(meters_keys, meters_tensor_gathered.tolist()):
meters[k] = v
def evaluate(self, p, a, meters):
p, a = post_proc_pred(p, a, self.cfg)
p = self.binarize(p, binarize_threshold=self.cfg.TRAIN.BINARIZE_THRESHOLD)
for m in self.cfg.PROJECT.METERS:
if m == 'loss':
continue
metric_function = getattr(metrics, f'{m}_metric')
meters[m] = metric_function(p, a, ignore_index=self.cfg.MODEL.IGNORE_INDEX)
# do all_reduce (sum) to sync meters across processes
if self.cfg.DDP:
self.ddp_reduce_meters(meters)
@staticmethod
def depth_sampling(image, annotation):
# create index tensor
image_shape = torch.tensor(image.shape)
d_size = image_shape[2].item() # depth size
image_shape[2] = 1 # depth size is set to 1
b_size, image_shape = image_shape[0], image_shape[1:]
image_numel = image_shape.prod().item()
rand_ind = torch.randint(d_size, (b_size, 1))
rand_ind = rand_ind.repeat(1, image_numel)
rand_ind = rand_ind.reshape((b_size, *image_shape))
rand_ind = rand_ind.to(image.device)
# gather
image = image.gather(dim=2, index=rand_ind)
rand_ind = rand_ind[:, -1:, :]
annotation = annotation.gather(dim=2, index=rand_ind)
return image, annotation
def batch_main(self, netwrapper, x, annotation, step=True):
meters = dict()
if self.cfg.WMH.ENABLE:
p, annotation = netwrapper((x, annotation))
else:
p = netwrapper(x)
a = self.generate_gt(annotation)
p = pack_pred(p)
meters['loss'] = netwrapper.loss_update(p, a, step=step)
self.evaluate(p, a, meters)
self.meters.iter_toc()
self.meters.update_stats(self._get_lr(netwrapper), self.cfg.TRAIN.BATCH_SIZE, **meters)
def batch_main_mode(self, netwrapper, x, annotation):
if self.mode == 'train':
return self.batch_main(netwrapper, x, annotation, step=True)
elif self.mode == 'valid':
with torch.no_grad():
return self.batch_main(netwrapper, x, annotation, step=False)
else:
raise NotImplementedError
def batch_loop(self, netwrapper, cur_epoch):
self.meters.iter_tic()
for cur_iter, (image, annotation, meta) in enumerate(self.data_container.dataloader):
if cur_epoch == 0 and cur_iter % 50 == 0:
if self.cfg.DDP:
if not self.cfg.DDP_CFG.RANK:
subprocess.call(['nvidia-smi'])
else:
subprocess.call(['nvidia-smi'])
image = image.to(self.device, non_blocking=True)
annotation = annotation.to(self.device, non_blocking=True)
# For now I will keep 2d depth sampling at system-level, for both train and val, later could exclude val
if self.cfg.MODEL.PROCESSING_MODE == '2d':
image, annotation = self.depth_sampling(image, annotation)
self.batch_main_mode(netwrapper, image, annotation)
self.meters.log_iter_stats(cur_epoch, cur_iter, self.mode)
self.meters.iter_tic()
|
import datetime
day = int(input("day: "))
month = int(input("month: "))
year = int(input("year: "))
def date(year, month, day):
try:
datetime.date(year, month, day)
except ValueError:
return False
else:
return True
print(date(year, month, day))
|
import os
import sys
from selenium.webdriver import Chrome
from selenium.webdriver.chrome import webdriver as chrome_webdriver
class DriverBuilder():
def get_driver(self, download_location=None, headless=False):
driver = self._get_chrome_driver(download_location, headless)
driver.set_window_size(1400, 700)
return driver
def _get_chrome_driver(self, download_location, headless):
chrome_options = chrome_webdriver.Options()
if download_location:
prefs = {'download.default_directory': download_location,
'download.prompt_for_download': False,
'download.directory_upgrade': True,
'safebrowsing.enabled': False,
'safebrowsing.disable_download_protection': True}
chrome_options.add_experimental_option('prefs', prefs)
if headless:
chrome_options.add_argument("--headless")
dir_path = os.path.dirname(os.path.realpath(__file__))
driver_path = os.path.join(dir_path, "drivers/chromedriver")
if sys.platform.startswith("win"):
driver_path += ".exe"
#driver = Chrome(executable_path=driver_path, chrome_options=chrome_options)
driver = Chrome(executable_path=r'/usr/bin/chromedriver', chrome_options=chrome_options)
if headless:
self.enable_download_in_headless_chrome(driver, download_location)
return driver
def enable_download_in_headless_chrome(self, driver, download_dir):
"""
there is currently a "feature" in chrome where
headless does not allow file download: https://bugs.chromium.org/p/chromium/issues/detail?id=696481
This method is a hacky work-around until the official chromedriver support for this.
Requires chrome version 62.0.3196.0 or above.
"""
# add missing support for chrome "send_command" to selenium webdriver
driver.command_executor._commands["send_command"] = ("POST", '/session/$sessionId/chromium/send_command')
params = {'cmd': 'Page.setDownloadBehavior', 'params': {'behavior': 'allow', 'downloadPath': download_dir}}
command_result = driver.execute("send_command", params)
print("response from browser:")
for key in command_result:
print("result:" + key + ":" + str(command_result[key]))
|
#!/usr/bin/env python3
import sys
from multiprocessing import Process, Queue, Lock, Value
staff_dict = {}
queue1 = Queue()
queue2 = Queue()
def read_standard(filename):
number = []
with open(filename,'r') as file:
for line in file:
pos = line.index('=')
number.append(float(line[pos+2:]))
return number
def get_staff_information(filename,lineNumber):
with open(filename,'r') as file:
content = file.readlines()
lineNumber.value = len(content)
for string in content:
information = string.split(',')
try:
income = int(information[1])
key = information[0]
with lock1:
queue1.put([key,income])
except ValueError:
print("Parameter Error")
return None
return True
def calculate_shebao(income, number):
jishuL = number[0]
jishuH = number[1]
insuranceSum = sum(number[2:])
if income < jishuL:
return jishuL * insuranceSum
elif income < jishuH:
return income * insuranceSum
elif income >= jishuH:
return jishuH *insuranceSum
def calculate_tax(incomeAfterShebao):
incomeTax = incomeAfterShebao - 3500
if incomeTax <= 0:
tax = 0
elif incomeTax <= 1500:
tax = incomeTax * 0.03
elif incomeTax <=4500:
tax = incomeTax * 0.10 - 105
elif incomeTax <= 9000:
tax = incomeTax * 0.20 - 555
elif incomeTax <= 35000:
tax = incomeTax * 0.25 - 1005
elif incomeTax <= 55000:
tax = incomeTax * 0.30 - 2755
elif incomeTax <= 80000:
tax = incomeTax * 0.35 - 5505
else:
tax = incomeTax * 0.45 - 13505
return tax
def calculate(filename,lineNumber):
number = read_standard(filename)
while lineNumber.value == -1:
pass
for i in range(lineNumber.value):
data = queue1.get()
incomeBeforeTax = data[1]
shebao = calculate_shebao(incomeBeforeTax, number)
incomeAfterShebao = incomeBeforeTax - shebao
tax = calculate_tax(incomeAfterShebao)
incomeAfterTax = incomeAfterShebao - tax
shebao = format(shebao,".2f")
tax = format(tax,".2f")
incomeAfterTax = format(incomeAfterTax,".2f")
with lock2:
queue2.put([data[0],str(incomeBeforeTax),shebao,tax,incomeAfterTax])
def output_file(filename,lineNumber):
with open(filename,'w') as file:
while lineNumber.value == -1:
pass
for i in range(lineNumber.value):
data = queue2.get()
for content in data:
file.write(content + ',')
file.write('\b\n')
if __name__ == '__main__':
staffFilename = sys.argv[4]
outputFilename = sys.argv[6]
standardFile = sys.argv[2]
lock1 = Lock()
lock2 = Lock()
lineNumber = Value('i',-1)
Process(target = get_staff_information ,args = (staffFilename,lineNumber)).start()
Process(target = calculate , args = (standardFile,lineNumber)).start()
Process(target = output_file , args = (outputFilename,lineNumber)).start()
|
#!/usr/bin/python
#imports
from __future__ import division
#from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import Bio
from Bio.PDB import *
import urllib2
import os
import shutil
import sys
import subprocess
import copy
from mutation_record import *
from blosum import *
from Bio.Blast import NCBIWWW
from Bio.Blast import NCBIXML
from Bio.Align.Applications import ClustalOmegaCommandline
class StabilityPredictor():
"""main predictor class, creates new predictor object."""
def __init__(self, arg):
self.pdb_id = ''
self.chain = ''
self.wild_type = ''
self.mutant = ''
self.position = ''
#parse command line arguments
def parseArguments(self):
if(len(sys.argv) > 6):
sys.stderr.write("Too many arguments.\n")
sys.exit(1)
self.pdb_id = sys.argv[1]
self.chain = sys.argv[2]
self.position = int(sys.argv[3])
self.wild_type = sys.argv[4]
self.mutant = sys.argv[5]
#prepare mutation record with mutation features
def createMutationRecord(self):
record = MutationRecord(self.pdb_id,self.chain,self.position,self.wild_type,self.mutant)
record.create_record()
def main():
predictor = StabilityPredictor(object)
predictor.parseArguments()
predictor.createMutationRecord()
if __name__ == '__main__':
main()
|
A = [0, 3, 4, 7]
B = [1, 5, 8]
ds = {0:[1],1:[2],2:[0,3],3:[4],4:[5,6],5:[6,7],6:[3],7:[8],8:[9],9:[7]}
visited = {}
status = {}
L = []
def find_reachablesDFS(start):
global L
global visited
stack = [start]
for i in range(10):
visited[i] = False
while len(stack) > 0:
curr = stack.pop()
visited[curr] = True
L.append(curr)
for i in ds[curr]:
if visited[i] == False:
stack.append(i)
# My solution
def find_ABunfairDFS():
global visited
nodes_to_check = []
for i in A:
if i in L:
nodes_to_check.append(i)
for i in range(10):
visited[i] = False
for i in nodes_to_check:
stack = [i]
for j in visited:
visited[j] = False
while len(stack) > 0:
curr = stack.pop()
visited[curr] = True
for j in ds[curr]:
if visited[j] == True:
return True
elif j not in B:
stack.append(j)
return False
# Jeff's notes solution
def is_acyclicDFS(v):
global status
global ds
status[v] = 'Active'
for w in ds[v]:
if w not in B:
if status[w] == 'Active':
return False
elif status[w] == 'New':
if is_acyclicDFS(w) == False:
return False
status[v] = 'Finished'
return True
def is_acyclic():
global status
nodes_to_check = []
for i in A:
if i in L:
nodes_to_check.append(i)
for i in range(10):
status[i] = 'New'
for i in nodes_to_check:
if status[i] == 'New':
if is_acyclicDFS(i) == False:
return False
return True
if __name__ == "__main__":
find_reachablesDFS(0)
print("Reachables by 0")
print(L)
print("Is this (A-B)unfair?")
print(find_ABunfairDFS())
print(is_acyclic())
|
class Solution:
def discountPrices(self, sentence: str, discount: int) -> str:
res = []
n = len(sentence)
c = sentence.strip().split(' ')
for subs in c:
if subs[0] != '$' or len(subs) <= 1:
res.append(subs)
else:
flag = True
for i in range(1, len(subs)):
if ord(subs[i]) < 48 or ord(subs[i]) > 57:
res.append(subs)
flag = False
break
if flag:
nums = int(subs[1:])
temp = '$%.2f'%(nums*(1.0 - 1.0*(discount / 100)))
res.append(temp)
return " ".join(res)
|
"""ace_webserver URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from login.views import import_login_table,email_verification,signup_view,login_view,ping,ping_send,import_overall_table
from student.views import student_profile,student_group_profile,edit_student_profile,signup_student
from faculty.views import faculty_profile,faculty_group_profile,edit_faculty_profile,signup_faculty
from alumni.views import alumni_profile,alumni_group_profile,edit_alumni_profile,signup_alumni,whatsapp1,whatsapp
from forgot_password.views import forgot_password_view,verify_forgot_password
from announcement.views import announcement
from project.views import project
from notice.views import get_notice,notice_read,home,administration,logout_view,activities,get_profile,contact_view
from django.views.generic.base import RedirectView
from achievement.views import achievements
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^import/$',import_login_table),
url(r'^import_overall/$',import_overall_table),
url(r'^verify_email/(?P<value>.+)/$',email_verification),
url(r'^signup/',signup_view),
url(r'^student_view/(?P<roll_no>.+)/$',student_profile),
url(r'^faculty_view/(?P<faculty_id>.+)/$',faculty_profile),
url(r'^alumni_view/(?P<roll_no>.+)/$',alumni_profile),
url(r'^students_profile/$',student_group_profile),
url(r'^faculty_profile/$',faculty_group_profile),
url(r'^alumni_profile/$',alumni_group_profile),
url(r'^forgot_password/$',forgot_password_view),
url(r'^verify_forgot_password/(?P<value>.+)/$',verify_forgot_password),
url(r'^edit_student_profile/$',edit_student_profile),
url(r'^edit_faculty_profile/$',edit_faculty_profile),
url(r'^edit_alumni_profile/$',edit_alumni_profile),
url(r'^signup_student/$',signup_student),
url(r'^signup_faculty/$',signup_faculty),
url(r'^signup_alumni/$',signup_alumni),
url(r'^login/$',login_view),
url(r'^announcement/$',announcement),
url(r'^notice_get$',get_notice),
url(r'^profile_get$',get_profile),
url(r'^notice_read$',notice_read),
url(r'^$',home),
url(r'^home/$',home),
url(r'^academics/$',project),
url(r'^activities/$',activities),
url(r'^achievements/$',achievements),
url(r'^administration/$',administration),
url(r'^logout/$',logout_view),
url(r'^ping/(?P<id>.+)/$',ping),
url(r'^ping_send/$',ping_send),
url(r'^contact/$',contact_view),
url(r'^whatsapp/$',whatsapp),
url(r'^whatsapp1/$',whatsapp1),
# url(r'^.*$', RedirectView.as_view(url='/', permanent=False), name='index'),
#url(r'^profile/(?P<value>.+)/(?P<value>.+)',signup_view),
#url(r'^profile_search/',signup_view),
#url(r'^notice/$',signup_view),
#url(r'^announcement/',signup_view),
#url(r'^syllabus/$',signup_view),
#url(r'^academics/',signup_view),
]
admin.site.site_header = "CSE Administration"
admin.site.index_title = 'ACE Website'
admin.site.site_title = 'CSE'
from django.conf import settings
from django.conf.urls.static import static
urlpatterns+=static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
urlpatterns+=static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
|
import autodisc as ad
import numpy as np
import random
import warnings
class GoalSpaceDensityExplorer(ad.core.Explorer):
'''
Explorer that samples new parameters to explore based on the density in the goalspace.
Source policies for a new exploration
-------------------------------------
config.source_parameter_selection
.type: 'optimal' or 'random'.
Optimal selects a previous exploration which has the closest point in the goal space to the new goal.
Random selects a random previous exploration as source.
.constraints: Can be used to define a constraints on the source policies based on filters.
Is a list of filters or dictionaries with the following properties:
active: Defines if and when a constraint is active.
Can be 'True', 'False', or a condition.
filter: Definition of the filter that defines which previous exploration runs are allowed as source.
Examples of constraints:
Only explorations for which statistics.classifier_animal is True:
dict(active = True,
filter = ('statistics.classifier_animal', '==', True))
Only explorations for which statistics.is_dead is False and statistics.classifier_animal is False:
dict(active = True,
filter = (('statistics.is_dead', '==', False), 'and', ('statistics.classifier_animal', '==', False))
Only active after 100 animals have been discovered:
dict(active = (('sum', 'statistics.classifier_animal'), '>=', 100),
filter = (('statistics.is_dead', '==', False), 'and', ('statistics.classifier_animal', '==', False))
'''
@staticmethod
def default_config():
default_config = ad.core.Explorer.default_config()
default_config.stop_conditions = 200
default_config.num_of_random_initialization = 10
default_config.run_parameters = []
# representation object
default_config.goal_space_representation = None
default_config.source_parameter_selection = ad.Config()
default_config.source_parameter_selection.type = 'optimal' # either: 'optimal', 'random'
default_config.source_parameter_selection.constraints = [] # addition constraints on the source parameters such as specific classes
default_config.source_parameter_selection.goal_space_constraints = [] # defines constraints on the goal space for each dimension with (min, max)
# density selection parameters
default_config.source_parameter_selection.n_neighbors = 10
# control over the mutation rates for the source parameters
default_config.source_parameter_mutation = ad.Config()
default_config.source_parameter_mutation.type = 'adaptive' # either: 'adaptive', 'fixed'
default_config.source_parameter_mutation.target_mutation_distance = 0.1
default_config.source_parameter_mutation.mutation_factor_learnrate = 1
default_config.source_parameter_mutation.is_adaptive_target_mutation_distance = True
default_config.source_parameter_mutation.mutation_distance_learnrate = 0.1
return default_config
def __init__(self, system, datahandler=None, config=None, **kwargs):
super().__init__(system=system, datahandler=datahandler, config=config, **kwargs)
# check config
if self.config.source_parameter_selection.type not in ['random', 'optimal']:
raise ValueError('Unknown source parameter selection type {!r} in the configuration!'.format(self.config.source_parameter_selection.type))
if self.config.source_parameter_mutation.type not in ['adaptive', 'fixed']:
raise ValueError('Unknown source parameter mutation type {!r} in the configuration!'.format(self.config.source_parameter_mutation.type))
self.parameter_library = []
self.reached_goal_library = []
self.min_distances = []
self.density_decision_variable = []
self.mutation_factors = []
self.target_mutation_distance = self.config.source_parameter_mutation.target_mutation_distance
def get_source_parameter_idx(self):
possible_paramters_inds = np.full(np.shape(self.reached_goal_library)[0], True)
# apply constraints on the possible source policies if defined under config.source_parameter_selection.constraints
if self.config.source_parameter_selection.constraints:
for constraint in self.config.source_parameter_selection.constraints:
if isinstance(constraint, tuple):
# if tuple, then this is the contraint and it is active
cur_is_active = True
cur_filter = constraint
else:
# otherwise assume it is a dict/config with the fields: active, filter
if 'active' not in constraint:
cur_is_active = True
else:
if isinstance(constraint['active'], tuple):
cur_is_active = self.data.filter(constraint['active'])
else:
cur_is_active = constraint['active']
cur_filter = constraint['filter']
if cur_is_active:
possible_paramters_inds = possible_paramters_inds & self.data.filter(cur_filter)
# constraints on the goal space
if self.config.source_parameter_selection.goal_space_constraints:
if len(self.reached_goal_library) > 0:
if len(self.config.source_parameter_selection.goal_space_constraints) != self.reached_goal_library.shape[1]:
raise ValueError('Number of dimensions of constraints for the config source_parameter_selection.goal_space_constraints ({}) must be the same as the goal space ({})',
len(self.config.source_parameter_selection.goal_space_constraints),
self.reached_goal_library.shape[1])
for goal_dim_idx in range(len(self.config.source_parameter_selection.goal_space_constraints)):
inds = (self.reached_goal_library[:, goal_dim_idx] >= self.config.source_parameter_selection.goal_space_constraints[goal_dim_idx][0]) & \
(self.reached_goal_library[:, goal_dim_idx] <= self.config.source_parameter_selection.goal_space_constraints[goal_dim_idx][1])
possible_paramters_inds = possible_paramters_inds & inds
if np.all(possible_paramters_inds == False):
warnings.warn('No source parameter fullfilled the constraint. Allow all source parameters.')
possible_paramters_inds = np.full(np.shape(self.reached_goal_library)[0], True)
possible_paramter_idxs = np.array(list(range(np.shape(self.reached_goal_library)[0])))
possible_paramter_idxs = possible_paramter_idxs[possible_paramters_inds]
if self.config.source_parameter_selection.type == 'optimal':
# identify the goal point with the lowest density
valid_density_decision_variable = np.array(self.density_decision_variable)[possible_paramters_inds]
max_decision_val = np.max(valid_density_decision_variable)
max_idxs = np.where(valid_density_decision_variable == max_decision_val)[0]
source_parameter_idx = possible_paramter_idxs[max_idxs[self.random.randint(len(max_idxs))]]
elif self.config.source_parameter_selection.type == 'random':
source_parameter_idx = possible_paramter_idxs[np.random.randint(len(possible_paramter_idxs))]
else:
raise ValueError('Unknown source policy selection type {!r} in the configuration!'.format(self.config.source_parameter_selection.type))
return source_parameter_idx
def update_source_parameter_selection_process(self, source_parameter_idx, reached_goal):
if len(self.reached_goal_library) == 0:
self.min_distances.append([])
self.density_decision_variable = [0]
else:
new_distances = self.config.goal_space_representation.calc_distance(reached_goal, self.reached_goal_library)
# identify if the new point has a smaller distance to points than their n closest neighbors
# if yes, then add this distance to it and remove the largest
for cur_idx in range(len(self.min_distances)):
cur_distance = new_distances[cur_idx]
new_min_distance_idx = None
if len(self.min_distances[cur_idx]) < self.config.source_parameter_selection.n_neighbors:
new_min_distance_idx = len(self.min_distances[cur_idx])
for neighbor_idx in range(len(self.min_distances[cur_idx]) - 1, -1, -1):
if self.min_distances[cur_idx][neighbor_idx] > cur_distance:
new_min_distance_idx = neighbor_idx
else:
break
if new_min_distance_idx is not None:
self.min_distances[cur_idx].insert(new_min_distance_idx, cur_distance)
if len(self.min_distances[cur_idx]) > self.config.source_parameter_selection.n_neighbors:
self.min_distances[cur_idx].pop()
self.density_decision_variable[cur_idx] = np.mean(self.min_distances[cur_idx])
# add for the new goal the min distances
sorted_distances = np.sort(new_distances).tolist()
sorted_distances = sorted_distances[0:self.config.source_parameter_selection.n_neighbors]
self.min_distances.append(sorted_distances)
self.density_decision_variable.append(np.mean(self.min_distances[-1]))
########################################
# add reached goal go the library
self.reached_goal_library = np.vstack([self.reached_goal_library, reached_goal]) if len(self.reached_goal_library) > 0 else np.array([reached_goal])
########################################
# adapt the target mutation distance
if self.config.source_parameter_mutation.is_adaptive_target_mutation_distance:
mean_distances = np.mean(np.mean(self.min_distances, axis=1))
if not np.isnan(mean_distances):
self.target_mutation_distance = self.target_mutation_distance + self.config.source_parameter_mutation.mutation_distance_learnrate * (mean_distances - self.target_mutation_distance)
########################################
# update the mutation factors
if self.config.source_parameter_mutation.type == 'adaptive' and source_parameter_idx is not None:
dist = np.linalg.norm(self.reached_goal_library[source_parameter_idx] - reached_goal)
if dist > 0:
self.mutation_factors[source_parameter_idx] = self.mutation_factors[source_parameter_idx] * (1 - ((1 - (self.target_mutation_distance / dist)) * self.config.source_parameter_mutation.mutation_factor_learnrate))
self.mutation_factors.append(self.mutation_factors[source_parameter_idx])
else:
self.mutation_factors.append(1)
def run(self, runs, verbose=True):
if isinstance(runs, int):
runs = list(range(runs))
self.parameter_library = []
self.reached_goal_library = []
if verbose:
counter = 0
ad.gui.print_progress_bar(counter, len(runs), 'Explorations: ')
# do n explorations
for run_idx in runs:
if run_idx not in self.data:
try:
# set the seed if the user defined one
if self.config.seed is not None:
seed = 534 * self.config.seed + run_idx
self.random.seed(seed)
random.seed(seed) # standard random is needed for the neat sampling process
else:
seed = None
# get parameters
new_parameters = ad.helper.data.AttrDict() # param in parameter space (for example, contains neural network to produce initial state)
new_run_parameters = ad.helper.data.AttrDict() # param that is actually given to the system (for example, the initial state that was procuded by tje source neural network)
source_parameter_idx = None
# random sampling if not enough in library
if len(self.parameter_library) < self.config.num_of_random_initialization:
# initialize the parameters
for parameter_config in self.config.run_parameters:
if parameter_config.type == 'cppn_evolution':
cppn_evo = ad.cppn.TwoDMatrixCCPNNEATEvolution(config=parameter_config['init'], matrix_size=(self.system.system_parameters.size_y, self.system.system_parameters.size_x))
cppn_evo.do_evolution()
if parameter_config.init.best_genome_of_last_generation:
new_parameter = cppn_evo.get_best_genome_last_generation()
new_run_parameter = cppn_evo.get_best_matrix_last_generation()
else:
new_parameter = cppn_evo.get_best_genome()
new_run_parameter = cppn_evo.get_best_matrix()
elif parameter_config.type == 'sampling':
new_parameter = ad.helper.sampling.sample_value(self.random, parameter_config['init'])
new_run_parameter = new_parameter
else:
raise ValueError('Unknown run_parameter type {!r} in configuration.'.format(parameter_config.type))
new_parameters[parameter_config['name']] = new_parameter
new_run_parameters[parameter_config['name']] = new_run_parameter
else:
# get source paramter which should be mutated
source_parameter_idx = self.get_source_parameter_idx()
source_parameter = self.parameter_library[source_parameter_idx]
for parameter_config in self.config.run_parameters:
if parameter_config.type == 'cppn_evolution':
# TODO: mutation factor for network mutation
cppn_evo = ad.cppn.TwoDMatrixCCPNNEATEvolution(init_population=source_parameter[parameter_config['name']],
config=parameter_config['mutate'],
matrix_size=(self.system.system_parameters.size_y, self.system.system_parameters.size_x))
cppn_evo.do_evolution()
if parameter_config.init.best_genome_of_last_generation:
new_parameter = cppn_evo.get_best_genome_last_generation()
new_run_parameter = cppn_evo.get_best_matrix_last_generation()
else:
new_parameter = cppn_evo.get_best_genome()
new_run_parameter = cppn_evo.get_best_matrix()
elif parameter_config.type == 'sampling':
new_parameter = ad.helper.sampling.mutate_value(val=source_parameter[parameter_config['name']],
mutation_factor=self.mutation_factors[source_parameter_idx],
rnd=self.random,
config=parameter_config['mutate'])
new_run_parameter = new_parameter
else:
raise ValueError('Unknown run_parameter type {!r} in configuration.'.format(parameter_config.type))
new_parameters[parameter_config['name']] = new_parameter
new_run_parameters[parameter_config['name']] = new_run_parameter
#############################
# run experiment
# run with parameters
[observations, statistics] = self.system.run(run_parameters=new_run_parameters, stop_conditions=self.config.stop_conditions)
# get goal-space of results
reached_goal = self.config.goal_space_representation.calc(observations, statistics)
# save results
self.data.add_run_data(id=run_idx,
seed=seed,
run_parameters=new_run_parameters,
observations=observations,
statistics=statistics,
source_parameter_idx=source_parameter_idx, # idx of the exploration that was used as source to generate the parameters for the current exploration
reached_goal=reached_goal)
# add policy and reached goal into the libraries
# do it after the run data is saved to not save them if there is an error during the saving
self.parameter_library.append(new_parameters)
#############################
# update selection processes based on the result
self.update_source_parameter_selection_process(source_parameter_idx, reached_goal)
if verbose:
counter += 1
ad.gui.print_progress_bar(counter, len(runs), 'Explorations: ')
if counter == len(runs):
print('')
except Exception as e:
raise Exception('Exception during exploration run {}!'.format(run_idx)) from e
|
import os
import signal
from httplib import HTTPConnection
import logging
import sys
from AdvancedHTTPServer import *
from AdvancedHTTPServer import __version__
PORT = 3515
sys.path.append(os.path.curdir)
class RelayHandler(AdvancedHTTPServerRequestHandler):
patterns = ("/render", "/metrics", "/dashboard")
# target_host_str= "atkins.thenetcircle.lab:6954"
target_host_str= "10.20.0.51"
def install_handlers(self):
self.handler_map['^render'] = self.relay
self.handler_map['^metrics'] = self.relay
self.handler_map['^dashboard'] = self.relay
def relay(self, method_str="GET", body=None):
client_conn = HTTPConnection(RelayHandler.target_host_str)
reqHeaders = dict(self.headers)
if ("Host" in reqHeaders):
del reqHeaders["Host"]
if ("host" in reqHeaders):
del reqHeaders["host"]
reqHeaders["host"] = RelayHandler.target_host_str
reqHeaders["Accept-Encoding"] = "gzip, deflate"
print("relay:", str(reqHeaders))
client_conn.request(method_str, self.path, body, reqHeaders)
resp = client_conn.getresponse()
resp.begin()
respHeaders = dict(resp.getheaders())
self.send_response(resp.status)
print(resp.status)
print(str(respHeaders) + "\n")
[self.send_header(k, v) for (k, v) in respHeaders.items()]
self.end_headers()
result = resp.read() #bytes
#print(str(result.decode("utf-8")) + "\n\n")
self.wfile.write(result)
resp.close()
client_conn.close()
# def do_GET(self):
# if (self.path.startswith(RelayHandler.patterns)):
# self.relay()
# return
# # if (self.path.endswith((".css", ".js"))):
# # self.send_header("Cached-control", "max-age=999999")
# AdvancedHTTPServerRequestHandler.do_GET(self)
# def do_POST(self):
# print(self.path, RelayHandler.patterns)
# if (self.path in RelayHandler.patterns):
# print("forward to ", self.path)
# AdvancedHTTPServerRequestHandler.do_GET(self)
# httpd = None
# def shutdown(sigNum, frame):
# print(httpd, "RelayHttpServer is shut!")
# print(sigNum, frame)
# if (httpd is None):
# return
# httpd.server_close()
# print(httpd, "RelayHttpServer is down!")
# exit()
# def main():
# global httpd
# signal.signal(signal.SIGTERM, shutdown)
# signal.signal(signal.SIGINT, shutdown)
# httpd = SocketServer.TCPServer(("0.0.0.0", PORT), RelayHandler)
# httpd.serve_forever()
def main():
print("AdvancedHTTPServer version: {0}".format(__version__))
logging.getLogger('').setLevel(logging.DEBUG)
console_log_handler = logging.StreamHandler()
console_log_handler.setLevel(logging.INFO)
console_log_handler.setFormatter(logging.Formatter("%(asctime)s\t%(levelname)-8s\t%(message)s"))
logging.getLogger('').addHandler(console_log_handler)
server = AdvancedHTTPServer(RelayHandler, address=('0.0.0.0', PORT))
server.serve_files_root = (server.serve_files_root or '.')
server.serve_files = True
server.server_version = 'AdvancedRelayHttpServer'
server.serve_forever()
return 0
if (__name__ == "__main__"):
main()
|
"""
The personal api for sending and getting private messages, and changing account settings.
Last on the todo list unless anyone wants to work on it.
""" |
import sys
import os
import shutil
sys.path.insert(0, 'scripts')
sys.path.insert(0, 'tools/families')
sys.path.insert(0, 'tools/trees')
sys.path.insert(0, 'tools/mappings')
sys.path.insert(0, 'tools/msa_edition')
import experiments as exp
import fam
from ete3 import Tree
from ete3 import SeqGroup
import get_dico
import read_msa
import ete3
import re
def is_ok(seq, max_gap_ratio, is_dna):
pattern = "[ACGTacgt]"
if (not is_dna):
pattern = "[ACDEFGHIKLMNPQRSTVWYabcdefghiklmnpqrstvwy]"
l = float(len(seq))
c = float(len(re.findall(pattern, seq)))
return c/l >= (1.0 - max_gap_ratio)
def get_filtered_msa(msa, max_gap_ratio, is_dna):
new_msa = SeqGroup()
for entry in msa.get_entries():
if (is_ok(entry[1], max_gap_ratio, is_dna)):
gene = entry[0]
if (gene == "Smilax_bona"):
gene = "Smilax_bona-nox"
if (gene == "Riccia_sp"):
gene = "Ricciocarpos_natans"
new_msa.set_seq(gene, entry[1])
return new_msa
def generate(inputdir, max_gap_ratio, is_dna):
outputdir = os.path.normpath(inputdir) + "_maxgapratio" + str(max_gap_ratio)
print(outputdir)
fam.init_top_directories(outputdir)
ok_species = set()
total_genes_before = 0
total_genes_after = 0
for family in fam.get_families_list(inputdir):
msa = read_msa.read_msa(fam.get_alignment(inputdir, family))
total_genes_before += len(msa.get_entries())
new_msa = get_filtered_msa(msa, max_gap_ratio, is_dna)
if (len(new_msa.get_entries()) < 4):
continue
total_genes_after += len(new_msa.get_entries())
fam.init_family_directories(outputdir, family)
new_msa.write(format = "fasta", outfile = fam.get_alignment(outputdir, family))
species_to_genes = {}
old_gene_to_species = get_dico.get_gene_to_species(inputdir, family)
for entry in new_msa.get_entries():
gene = entry[0]
species = old_gene_to_species[gene]
ok_species.add(species)
if (not species in species_to_genes):
species_to_genes[species] = []
species_to_genes[species].append(gene)
fam.write_phyldog_mapping(species_to_genes, fam.get_mappings(outputdir, family))
print("Initial families: " + str(len(fam.get_families_list(inputdir))))
print("Initial genes: " + str(total_genes_before))
print("Final families: " + str(len(fam.get_families_list(outputdir))))
print("Final genes: " + str(total_genes_after))
species_tree = ete3.Tree(fam.get_species_tree(inputdir), format = 1)
species_tree.prune(ok_species)
species_tree.write(format = 1, outfile = fam.get_species_tree(outputdir))
fam.postprocess_datadir(outputdir)
if (__name__ == "__main__"):
if (len(sys.argv) < 3):
print("Syntax: python " + os.path.basename(__file__) + " datadir max_gap_ratio is_dna (1 or 0)")
exit(1)
datadir = sys.argv[1]
max_gap_ratio = float(sys.argv[2])
is_dna = int(sys.argv[3]) == 1
generate(datadir, max_gap_ratio, is_dna)
|
# -*- coding: utf-8 -*-
import pickle
import os
from pymystem3 import Mystem
#from boilerpipe.extract import Extractor
from inscriptis import get_text
from bs4 import BeautifulSoup
import re
class IR_Extractor:
def __init__(self, path):
self.m = Mystem()
self.path = path
self.max_size = 2000000
self.min_lems = 20
self.clear = [u'ё', u'й', u'ц', u'у', u'к', u'е', u'н', u'г', u'ш', u'щ', u'з', u'х', u'ъ', u'ф', u'ы', u'в',
u'а', u'п', u'р', u'о', u'л', u'д', u'ж', u'э', u'я', u'ч', u'с', u'м', u'и', u'т', u'ь', u'б',
u'ю', u'0', u'1', u'2', u'3', u'4', u'5', u'6', u'7', u'8', u'9', u'ә', u'ғ', u'қ', u'ң', u'ө',
u'ұ', u'ү', u'h', u'і', u'ґ', u'є', u'і', u'ї', u'q', u'w', u'e', u'r', u't', u'y', u'u', u'i',
u'o', u'p', u'a', u's', u'd', u'f', u'g', u'h', u'j', u'k', u'l', u'z', u'x', u'c', u'v', u'b',
u'n', u'm']
self.clear_d = {}
for l in self.clear:
self.clear_d[l] = 1
def set_name(self, name):
self.dmp_name = name
def get_content(self, html_name, mode):
f = open(html_name)
url = f.readline()[:-1]
if (os.fstat(f.fileno()).st_size > self.max_size):
print('B')
f.close()
return url, [[], []]
html_rest = f.read()
if mode == 'BS':
soup = BeautifulSoup(html_rest, "html.parser")
[s.extract() for s in soup(['style', 'script', '[document]', 'head', 'title'])]
html_text = soup.get_text()
headers = self.get_headers(html_rest)
nolem = self.clean(html_text)
lem = self.lemmatize(nolem)
val = [lem, headers]
else:
extractor = Extractor(extractor='DefaultExtractor', html=html_rest)
html_text = extractor.getText()
nolem = self.clean(html_text)
lem = self.lemmatize(nolem)
if len(lem) < self.min_lems:
html_text = get_text(html_rest)
html_text = self.get_outer_fields(html_text)
nolem = self.clean(html_text)
lem = self.lemmatize(nolem)
val = [lem]
f.close()
return url, val
def get_outer_fields(self, extr):
outer_lines = u''
newline_flag = True
lr_flag = False
for w in extr:
if (w == u'\n'):
if (not lr_flag):
outer_lines += u' '
newline_flag = True
lr_flag = False
elif (w == u' ' and newline_flag) or lr_flag:
lr_flag = True
newline_flag = False
else:
newline_flag = False
outer_lines += w
return outer_lines
def get_headers(self, html):
res = []
headers = re.findall('<title>.+</title>', html)
for header in headers:
try:
header = header[7:-8].decode('utf-8')
except:
try:
header = header[7:-8].decode('cp1251')
except:
header = header[7:-8]
nolem = self.clean(header)
lem = self.lemmatize(nolem)
res.append(lem)
return res
def clean(self, string):
string = string.lower()
res = ''
sp_flag = True
for w in string:
if not (w in self.clear_d):
if (not sp_flag):
res += u' '
sp_flag = True
else:
res += w
sp_flag = False
return res
def lemmatize(self, string):
lem_res = self.m.lemmatize(string)
lem_res_fin = []
for l in lem_res:
if l != u' ' and l != u'\n' and l != u' \n':
lem_res_fin.append(l)
return lem_res_fin
def add_content(self, html_name, mode):
html_name = self.path + '/' + html_name
key = html_name
value = [[], []]
try:
key, value = self.get_content(html_name, mode)
except:
print('ERR')
self.storage[key] = value
print('@') #####
def dump(self):
with open(self.dmp_name, 'wb') as f:
pickle.dump(self.storage, f)
def main_func(self, start, stop, mode='BS'):
self.storage = {}
file_name_start = 'doc.'
file_name_end = '.dat'
for i in range(start, stop):
num = '%05d' % i
f = file_name_start + num + file_name_end
self.add_content(f, mode)
self.dump()
print("DONE")
|
# -*- coding: utf-8 -*-
{
"name": "Test Module",
"version": "1.0",
"author": "Falinwa Indonesia",
"description": """
module to print context
""",
"depends": ["base"],
"init_xml": [],
"data": [
'security/ir.model.access.csv',
'templates.xml',
'views/test_views.xml',
'views/test_partner.xml',
'report/test_course_rpt.xml',
],
"active": False,
"application": False,
"installable": True,
}
|
import subprocess
def run_cmd(cmd_list):
child = subprocess.Popen(cmd_list, stdout=subprocess.PIPE)
streamdata = child.communicate()[0]
ret = child.returncode
return streamdata.decode(), ret
def exploit(binary, randomize):
"""
Check if the corrected source code is still vulnerable
"""
content, code = run_cmd([binary, '', 'rien', '/get-secret'])
if content.find('e9bc7d25d16348f9c5f6b9251c270c0da39aff8b') > 0:
print('token seems to leak from your app')
return True
content, code = run_cmd([binary, 'rien', '', '/get-secret'])
if content.find('debug-e9bc7d25d163') > 0:
print('username seems to leak from your app')
return True
return False
|
n = int(input())
arr = list(map(int,input().strip().split()))[:n]
ans = [0]*n
mx = arr[-1]
for i in range(n-2,-1,-1):
ans[i] = max(0,mx - arr[i] + 1)
if arr[i] > mx:
mx = arr[i]
print(*ans)
|
#!/usr/bin/env python
'''
Script for looking at the quark vs gluon dependence of substructure observables
Author: Ezra Lesser (elesser@berkeley.edu)
'''
from __future__ import print_function
# Fastjet via python (from external library heppy)
import fastjet as fj
import fjcontrib
import fjext
import ROOT
import tqdm
import yaml
import copy
import argparse
import os
import array
import numpy as np
from pyjetty.mputils import *
from heppy.pythiautils import configuration as pyconf
import pythia8
import pythiafjext
import pythiaext
from pyjetty.alice_analysis.process.base import process_base
# Prevent ROOT from stealing focus when plotting
ROOT.gROOT.SetBatch(True)
# Automatically set Sumw2 when creating new histograms
ROOT.TH1.SetDefaultSumw2()
ROOT.TH2.SetDefaultSumw2()
################################################################
class PythiaQuarkGluon(process_base.ProcessBase):
#---------------------------------------------------------------
# Constructor
#---------------------------------------------------------------
def __init__(self, input_file='', config_file='', output_dir='', debug_level=0, args=None, **kwargs):
super(PythiaQuarkGluon, self).__init__(
input_file, config_file, output_dir, debug_level, **kwargs)
# Call base class initialization
process_base.ProcessBase.initialize_config(self)
# Read config file
with open(self.config_file, 'r') as stream:
config = yaml.safe_load(stream)
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
self.jetR_list = config["jetR"]
self.user_seed = args.user_seed
self.nev = args.nev
self.noMPI = (bool)(1-args.MPIon)
self.noISR = (bool)(1-args.ISRon)
# PDG ID values for quarks and gluons
self.quark_pdg_ids = [1, 2, 3, 4, 5, 6, 7, 8]
self.charm_pdg_ids = [4]
self.gluon_pdg_ids = [9, 21]
# hadron level - ALICE tracking restriction
self.max_eta_hadron = 0.9
self.min_leading_track_pT = config["min_leading_track_pT"] if "min_leading_track_pT" in config else None
self.pt_bins = array.array('d', list(range(5, 100, 5)) + list(range(100, 210, 10)))
self.obs_bins_ang = np.concatenate((np.linspace(0, 0.009, 10), np.linspace(0.01, 0.1, 19),
np.linspace(0.11, 0.8, 70)))
self.obs_bins_mass = np.concatenate(
(np.linspace(0, 0.9, 10), np.linspace(1, 9.8, 45), np.linspace(10, 14.5, 10),
np.linspace(15, 19, 5), np.linspace(20, 60, 9)))
self.observable_list = config['process_observables']
self.obs_settings = {}
self.obs_grooming_settings = {}
self.obs_names = {}
for observable in self.observable_list:
obs_config_dict = config[observable]
obs_config_list = [name for name in list(obs_config_dict.keys()) if 'config' in name ]
obs_subconfig_list = [name for name in list(obs_config_dict.keys()) if 'config' in name ]
self.obs_settings[observable] = self.utils.obs_settings(observable, obs_config_dict, obs_subconfig_list)
self.obs_grooming_settings[observable] = self.utils.grooming_settings(obs_config_dict)
self.obs_names[observable] = obs_config_dict["common_settings"]["xtitle"]
#---------------------------------------------------------------
# Main processing function
#---------------------------------------------------------------
def pythia_quark_gluon(self, args):
# Create ROOT TTree file for storing raw PYTHIA particle information
outf_path = os.path.join(self.output_dir, args.tree_output_fname)
outf = ROOT.TFile(outf_path, 'recreate')
outf.cd()
# Initialize response histograms
self.initialize_hist()
pinfo('user seed for pythia', self.user_seed)
mycfg = ['Random:setSeed=on', 'Random:seed={}'.format(self.user_seed)]
mycfg.append('HadronLevel:all=off')
# print the banner first
fj.ClusterSequence.print_banner()
print()
# -------------------------------
# Setting MPIs and ISRs
print('Will run no MPI:',self.noMPI)
print('Will run no ISR:',self.noISR)
setattr(args, "py_noMPI", self.noMPI)
setattr(args, "py_noISR", self.noISR)
# -------------------------------
pythia = pyconf.create_and_init_pythia_from_args(args, mycfg)
self.init_jet_tools()
self.calculate_events(pythia)
pythia.stat()
print()
self.scale_print_final_info(pythia)
outf.Write()
outf.Close()
self.save_output_objects()
#---------------------------------------------------------------
# Initialize histograms
#---------------------------------------------------------------
def initialize_hist(self):
self.hNevents = ROOT.TH1I("hNevents", 'Number accepted events (unscaled)', 2, -0.5, 1.5)
for jetR in self.jetR_list:
# Store a list of all the histograms just so that we can rescale them later
hist_list_name = "hist_list_R%s" % str(jetR).replace('.', '')
setattr(self, hist_list_name, [])
R_label = str(jetR).replace('.', '') + 'Scaled'
for observable in self.observable_list:
# Should only be two: observable == "ang" or "mass"
if observable != "ang" and observable != "mass":
raise ValueError("Observable %s is not implemented in this script" % observable)
obs_name = self.obs_names[observable]
obs_bins = getattr(self, "obs_bins_" + observable)
# Use more finely binned pT bins for TH2s than for the RMs
pt_bins = array.array('d', list(range(0, 201, 1)))
# Loop over subobservable (alpha value)
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
for parton_type in ["quark", "charm", "gluon"]:
name = ('h_%s_JetPt_%s_R%s_%s' % (observable, parton_type, jetR, obs_label)) if \
len(obs_label) else ('h_%s_JetPt_%s_R%s' % (observable, parton_type, jetR))
h = ROOT.TH2F(name, name, len(pt_bins)-1, pt_bins, len(obs_bins)-1, obs_bins)
h.GetXaxis().SetTitle('#it{p}_{T,%s}^{ch jet}' % (parton_type[0] + "-init"))
h.GetYaxis().SetTitle(obs_name + '^{%s}' % (parton_type[0] + "-init"))
h.Sumw2()
setattr(self, name, h)
getattr(self, hist_list_name).append(h)
#---------------------------------------------------------------
# Initiate jet defs, selectors, and sd (if required)
#---------------------------------------------------------------
def init_jet_tools(self):
for jetR in self.jetR_list:
jetR_str = str(jetR).replace('.', '')
# set up our jet definition and a jet selector
jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
setattr(self, "jet_def_R%s" % jetR_str, jet_def)
print(jet_def)
pwarning('max eta for particles after hadronization set to', self.max_eta_hadron)
parts_selector_h = fj.SelectorAbsEtaMax(self.max_eta_hadron)
for jetR in self.jetR_list:
jetR_str = str(jetR).replace('.', '')
jet_selector = fj.SelectorPtMin(5.0) & fj.SelectorAbsEtaMax(self.max_eta_hadron - jetR)
#jet_selector = fj.SelectorPtMin(0.) & fj.SelectorAbsEtaMax(self.max_eta_hadron - jetR)
setattr(self, "jet_selector_R%s" % jetR_str, jet_selector)
count1 = 0 # Number of partonic parents which match to >1 ch-jets
setattr(self, "count1_R%s" % jetR_str, count1)
count2 = 0 # Number of partonic parents which match to zero ch-jets
setattr(self, "count2_R%s" % jetR_str, count2)
#---------------------------------------------------------------
# Calculate events and pass information on to jet finding
#---------------------------------------------------------------
def calculate_events(self, pythia):
iev = 0 # Event loop count
while iev < self.nev:
if not pythia.next():
continue
self.parents = []
self.event = pythia.event
#print(self.event)
fs_parton_5 = fj.PseudoJet(pythia.event[5].px(), pythia.event[5].py(), pythia.event[5].pz(), pythia.event[5].e())
fs_parton_6 = fj.PseudoJet(pythia.event[6].px(), pythia.event[6].py(), pythia.event[6].pz(), pythia.event[6].e())
self.parents = [fs_parton_5, fs_parton_6] # parent partons in dijet
# Save PDG code of the parent partons
self.parent_ids = [pythia.event[5].id(), pythia.event[6].id()]
# parton level
#parts_pythia_p = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, True)
hstatus = pythia.forceHadronLevel()
if not hstatus:
continue
# full-hadron level
#parts_pythia_h = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal], 0, True)
# charged-hadron level
parts_pythia_hch = pythiafjext.vectorize_select(pythia, [pythiafjext.kFinal, pythiafjext.kCharged], 0, True)
# Some "accepted" events don't survive hadronization step -- keep track here
self.hNevents.Fill(0)
self.find_jets_fill_histograms(parts_pythia_hch, iev)
iev += 1
#---------------------------------------------------------------
# Find primordial parent
#---------------------------------------------------------------
def primordial_parent(self,p):
parent1 = parent2 = -10
while p > 6:
parent1 = self.event[p].mother1()
parent2 = self.event[p].mother2()
if parent1 != parent2:
p = max(parent1,parent2)
else:
p = parent1
return p
#---------------------------------------------------------------
# Find jets, do matching between levels, and fill histograms
#---------------------------------------------------------------
def find_jets_fill_histograms(self, parts_pythia_hch, iev):
# Loop over jet radii
for jetR in self.jetR_list:
jetR_str = str(jetR).replace('.', '')
jet_selector = getattr(self, "jet_selector_R%s" % jetR_str)
jet_def = getattr(self, "jet_def_R%s" % jetR_str)
count1 = getattr(self, "count1_R%s" % jetR_str)
count2 = getattr(self, "count2_R%s" % jetR_str)
# Get the jets at different levels
#jets_p = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_p ))) # parton level
#jets_h = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_h ))) # full hadron level
jets_ch = fj.sorted_by_pt(jet_selector(jet_def(parts_pythia_hch))) # charged hadron level
R_label = str(jetR).replace('.', '') + 'Scaled'
# Find the charged jet closest to the axis of the original parton
# Require that the match is within some small angle, and that it is unique
jet_matching_distance = 0.6 # Match jets with deltaR < jet_matching_distance*jetR
self.parent0match, self.parent1match = None, None
for i_jch, jch in enumerate(jets_ch):
# Do constituent pT cut
if self.min_leading_track_pT and not \
self.utils.is_truth_jet_accepted(jch, self.min_leading_track_pT):
continue
for i_parent, parent in enumerate(self.parents):
parentmatch_name = "parent%imatch" % i_parent
if jch.delta_R(parent) < jet_matching_distance * jetR:
match = getattr(self, parentmatch_name)
if not match:
setattr(self, parentmatch_name, jch)
else: # Already found a match
# Set flag value so that we know to ignore this one
setattr(self, parentmatch_name, 0)
# If we have matches, fill histograms
for i_parent, parent in enumerate(self.parents):
jet = getattr(self, "parent%imatch" % i_parent)
if not jet:
if jet == 0:
# More than one match -- take note and continue
count1 += 1
continue
else: # jet == None
# No matches -- take note and continue
count2 += 1
continue
# One unique match
# Identify the histograms which need to be filled
parton_id = self.parent_ids[i_parent]
parton_types = []
if parton_id in self.quark_pdg_ids:
parton_types += ["quark"]
if parton_id in self.charm_pdg_ids:
parton_types += ["charm"]
elif parton_id in self.gluon_pdg_ids:
parton_types += ["gluon"]
# If parent parton not identified, skip for now
if not len(parton_types):
continue
# Fill histograms
for observable in self.observable_list:
for i in range(len(self.obs_settings[observable])):
obs_setting = self.obs_settings[observable][i]
grooming_setting = self.obs_grooming_settings[observable][i]
obs_label = self.utils.obs_label(obs_setting, grooming_setting)
# Groom jet, if applicable
jet_groomed_lund = None
if grooming_setting:
gshop = fjcontrib.GroomerShop(jet, jetR, self.reclustering_algorithm)
jet_groomed_lund = self.utils.groom(gshop, grooming_setting, jetR)
if not jet_groomed_lund:
continue
obs = self.calculate_observable(
observable, jet, jet_groomed_lund, jetR, obs_setting,
grooming_setting, obs_label, jet.pt())
for parton_type in parton_types:
getattr(self, ('h_%s_JetPt_%s_R%s_%s' % (observable, parton_type, jetR, obs_label)) if \
len(obs_label) else ('h_%s_JetPt_%s_R%s' % (observable, parton_type, jetR))).Fill(
jet.pt(), obs)
setattr(self, "count1_R%s" % jetR_str, count1)
setattr(self, "count2_R%s" % jetR_str, count2)
#---------------------------------------------------------------
# Calculate the observable given a jet
#---------------------------------------------------------------
def calculate_observable(self, observable, jet, jet_groomed_lund,
jetR, obs_setting, grooming_setting, obs_label, jet_pt_ungroomed):
if observable == "ang":
return fjext.lambda_beta_kappa(jet, jet_groomed_lund.pair(), obs_setting, 1, jetR) \
if grooming_setting else fjext.lambda_beta_kappa(jet, obs_setting, 1, jetR)
elif observable == "mass":
if grooming_setting:
j_groomed = jet_groomed_lund.pair()
if not j_groomed.has_constituents():
# Untagged jet -- record underflow value
return -1
else:
return j_groomed.m()
return jet.m()
# Should not be any other observable
raise ValueError("Observable %s not implemented" % observable)
#---------------------------------------------------------------
# Initiate scaling of all histograms and print final simulation info
#---------------------------------------------------------------
def scale_print_final_info(self, pythia):
# Scale all jet histograms by the appropriate factor from generated cross section and the number of accepted events
scale_f = pythia.info.sigmaGen() / self.hNevents.GetBinContent(1)
for jetR in self.jetR_list:
hist_list_name = "hist_list_R%s" % str(jetR).replace('.', '')
for h in getattr(self, hist_list_name):
h.Scale(scale_f)
print("N total final events:", int(self.hNevents.GetBinContent(1)), "with",
int(pythia.info.nAccepted() - self.hNevents.GetBinContent(1)),
"events rejected at hadronization step")
self.hNevents.SetBinError(1, 0)
################################################################
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='pythia8 fastjet on the fly',
prog=os.path.basename(__file__))
pyconf.add_standard_pythia_args(parser)
# Could use --py-seed
parser.add_argument('--user-seed', help='PYTHIA starting seed', default=1111, type=int)
parser.add_argument('-o', '--output-dir', action='store', type=str, default='./',
help='Output directory for generated ROOT file(s)')
parser.add_argument('--tree-output-fname', default="AnalysisResults.root", type=str,
help="Filename for the (unscaled) generated particle ROOT TTree")
parser.add_argument('--MPIon', action='store', type=int, default=1,
help="MPI on or off")
parser.add_argument('--ISRon', action='store', type=int, default=1,
help="ISR on or off")
parser.add_argument('-c', '--config_file', action='store', type=str, default='config/angularity.yaml',
help="Path of config file for observable configurations")
args = parser.parse_args()
# If invalid configFile is given, exit
if not os.path.exists(args.config_file):
print('File \"{0}\" does not exist! Exiting!'.format(args.configFile))
sys.exit(0)
# Use PYTHIA seed for event generation
if args.user_seed < 0:
args.user_seed = 1111
# Have at least 1 event
if args.nev < 1:
args.nev = 1
process = PythiaQuarkGluon(config_file=args.config_file, output_dir=args.output_dir, args=args)
process.pythia_quark_gluon(args)
|
'''
Created on 30 мар. 2020 г.
@author: 32kda
'''
from musket_core.fit_callbacks import after_fit
from musket_core import generic, utils, projects, builtin_datasets
from pathlib import Path
import os
import numpy as np
from musket_core import context
# Translate passed string
def translate(sentence:str):
file_path=os.path.join(context.get_current_project_data_path(),"rus.vocab")
vocabulary=utils.load(file_path)
preds = generic.parse('eng_to_ru').predictions(builtin_datasets.from_array([sentence], ['']))
for item in preds:
rootItem = item.rootItem()
sentence = ''
for indices in item.prediction:
sentence = sentence + " " + vocabulary.i2w[np.argmax(indices)]
print(rootItem.x + " " + sentence)
if __name__ == '__main__':
translate('Why do I need to be in Boston?') |
# Module for Candidate code for UVQ project
# Imports
from __future__ import print_function, absolute_import, division, unicode_literals
import numpy as np
import glob, os, sys
from pkg_resources import resource_filename
from astropy import units as u
from astropy.table import Table
from astropy import coordinates as coords
from astropy.coordinates import SkyCoord
def load_phot(use_NUV=False, verbose=True):
""" Load the WISE and GALEX photometry
Uses MIS data where applicable
Parameters
----------
use_NUV: bool, optional
Returns
-------
z1_galex: Table
GALEX photometry
z1_wise: Table
WISE-matched photometry
"""
# WISE and GALEX AIS
if use_NUV:
galex_wise_fil = resource_filename('uvqs','/data/photom/GALEX_NODUP_NUV_WISE_2015apr06.fits')
else:
galex_wise_fil = resource_filename('uvqs','/data/photom/GALEX_NODUP_WISE_2014apr16.fits')
z1_galex = Table.read(galex_wise_fil)
z1_wise = Table.read(galex_wise_fil, exten=2)
# Update for GALEX MIS photometry (might need to get NUV MIS)
galex_MIS = resource_filename('uvqs','/data/photom/GALEX_MIS_xavier_2014apr18.fit.gz')
mis = Table.read(galex_MIS)
nmis = len(mis)
z1_rad = SkyCoord(ra=z1_galex['RA']*u.degree, dec=z1_galex['DEC']*u.degree)
mis_rad = SkyCoord(ra=mis['ra']*u.degree, dec=mis['dec']*u.degree)
idx, d2d, d3d = coords.match_coordinates_sky(z1_rad, mis_rad, nthneighbor=1)
mt = d2d.to('arcsec').value < 5.
z1_galex[mt]['NUV'] = mis[idx[mt]]['nuv']
z1_galex[mt]['FUV'] = mis[idx[mt]]['fuv']
if verbose:
print('Updated {:d} sources with MIS'.format(len(mt)))
# Return
return z1_galex, z1_wise
|
import numpy as np
from enum import Enum
import math
import matplotlib.pyplot as plt
class KType(Enum):
PRISMATIC = 1
REVOLUTE = 2
class KinematicLinkage(object):
def __init__(self):
self.joints = []
self.transforms = []
self.operations = []
# Add a transform in the chain
def transform(self, name, ktype, j_min, j_max, alpha, a, d, theta):
current_joint = np.array([name, ktype, j_min, j_max, alpha, a, d, theta])
current_transform = np.array([self.transform_matrix(alpha, a, d, theta)])
if len(self.joints) == 0:
self.joints = current_joint
self.transforms = current_transform
self.operations = current_transform.copy()
else:
self.joints = np.vstack((self.joints, current_joint))
self.transforms = np.append(self.transforms, current_transform, axis=0)
self.operations = np.append(self.operations, [np.matmul(self.operations[-1], self.transforms[-1])], axis=0)
return self
# Edit d_i or theta_i on an existing transform
def edit(self, index, delta):
i = self.get_index_from_name(index)
# Check joint type and constraints
if self.joints[i,1] == KType.PRISMATIC:
self.joints[i,6] += delta
if self.joints[i,6] + delta <= self.joints[i,2]:
self.joints[i,6] = self.joints[i,2]
elif self.joints[i,6] + delta > self.joints[i,3]:
self.joints[i,6] = self.joints[i,3]
elif self.joints[i,1] == KType.REVOLUTE:
self.joints[i,7] += delta
# Do not limit full revolutions
if not (self.joints[i,2] == -180 and self.joints[i,3] == 180):
if self.joints[i,7] + delta <= self.joints[i,2]:
self.joints[i,7] = self.joints[i,2]
elif self.joints[i,7] + delta > self.joints[i,3]:
self.joints[i,7] = self.joints[i,3]
# Simplify theta
while self.joints[i,7] < -180:
self.joints[i,7] += 360
while self.joints[i,7] >= 180:
self.joints[i,7] -= 360
joint = self.joints[i]
self.transforms[i] = self.transform_matrix(joint[4], joint[5], joint[6], joint[7])
for j in range(i, len(self.joints)):
self.operations[j] = np.matmul(self.operations[j-1], self.transforms[j])
return self
# Position of end effector from operations matrix
def end_position(self):
e = self.operations[-1]
x = e[0,3]
y = e[1,3]
z = e[2,3]
# Convert to degrees and keep within [0, 359]
roll = (math.atan2(e[1,0], e[0,0]) * 180. / np.pi) % 360
pitch = (math.atan2(-e[2,0], math.sqrt(e[2,1]**2 + e[2,2]**2)) * 180. / np.pi) % 360
yaw = (math.atan2(e[2,1], e[2,2]) * 180 / np.pi) % 360
return np.round(np.array([x, y, z, roll, pitch, yaw]), decimals=5)
def jacobian(self, x='na', y='na', z='na', roll='na', pitch='na', yaw='na'):
exclusion = np.array([x, y, z, roll, pitch, yaw])
J = np.array([[0 for v in exclusion if not v == 'na']])
for i in range(1, len(self.joints)):
# Determine joint type
if self.joints[i,1] == KType.PRISMATIC:
delta = 0.1
elif self.joints[i,1] == KType.REVOLUTE:
delta = 1 # degrees
# Store original end effector position
orig_pos = np.array([v for k, v in enumerate(self.end_position()) if not exclusion[k] == 'na'])
# Add a small delta to variable for this joint
self.edit(i, delta)
# Calculate change in position
new_pos = np.array([v for k, v in enumerate(self.end_position()) if not exclusion[k] == 'na'])
# Append row to Jacobian
J = np.append(J, [np.divide(new_pos - orig_pos, delta)], axis=0)
# Revert change
self.edit(i, -delta)
np.delete(J, (0), axis=0)
return J.T
def set_effector_position(self, x='na', y='na', z='na', roll='na', pitch='na', yaw='na'):
exclusion = np.array([x, y, z, roll, pitch, yaw])
target = np.array([float(v) for v in exclusion if not v == 'na'])
pos = np.array([v for k, v in enumerate(self.end_position()) if not exclusion[k] == 'na'])
delta = target - pos
learning_rate = 0.1
path = np.array([pos])
while np.linalg.norm(delta) > 0.1:
J = self.jacobian(x, y, z, roll, pitch, yaw)
# Pseudo-inverse of J
J = np.linalg.pinv(J)
# Change in d and theta
change = learning_rate * np.matmul(J, delta)
# Update
for i in range(1, len(self.joints)):
self.edit(i, change[i])
pos = np.array([v for k, v in enumerate(self.end_position()) if not exclusion[k] == 'na'])
path = np.append(path, [pos], axis=0)
delta = target - pos
return path
def transform_matrix(self, alpha, a, d, theta):
alpha = alpha * np.pi / 180.
theta = theta * np.pi / 180.
return np.array([
[np.cos(theta), -np.sin(theta) , 0 , a ],
[np.sin(theta)*np.cos(alpha), np.cos(theta)*np.cos(alpha), -np.sin(alpha), -d*np.sin(alpha)],
[np.sin(theta)*np.sin(alpha), np.cos(theta)*np.sin(alpha), np.cos(alpha), d*np.cos(alpha)],
[0 , 0 , 0 , 1 ]])
def get_index_from_name(self, name):
if isinstance(name, str):
for ind, val in enumerate(self.joints):
if val == name:
return ind
# name is string but not found
return -1
# name is not a string, probably index
return name
def get_joints(self):
return self.joints
def get_transforms(self):
return np.round(self.transforms, decimals=3)
def get_operations(self):
return np.round(self.operations, decimals=3)
# Set up linkage
Linkage = KinematicLinkage()
Linkage.transform('base', KType.REVOLUTE, -180, 180, 0, 0, 0, 0)
Linkage.transform('height adjustment', KType.PRISMATIC, 7, 13, 0, 0, 10, 0)
Linkage.transform('main arm', KType.REVOLUTE, -180, 180, 0, 0, 0, 0)
Linkage.transform('secondary arm', KType.REVOLUTE, -90, 90, 0, 3, 1, -30)
Linkage.transform('reflector', KType.REVOLUTE, -180, 180, 90, 6, 0, 0)
Linkage.transform('end effector', KType.REVOLUTE, -180, 180, 0, 3, 0, 0)
# Swing secondary arm to front -- naive path
initial_pos = Linkage.end_position()
print("Initial position: ", initial_pos)
print("Initial operation space:\n ", Linkage.get_operations()[-1])
path = Linkage.set_effector_position(3, 9, 11)
final_pos = Linkage.end_position()
print("Final position: ", final_pos)
print("Final operation space:\n ", Linkage.get_operations()[-1])
# Plot path [x, y]
x_straight = np.linspace(path[0,0], path[-1,0], 10)
y_straight = np.linspace(path[0,1], path[-1,1], 10)
plt.plot(path[:,0], path[:,1])
plt.plot(x_straight, y_straight, linestyle='--', linewidth=1)
plt.plot()
plt.xlabel('x')
plt.ylabel('y', rotation=0)
plt.title('Movement Path')
plt.show() |
#
# This file is part of LUNA.
#
# Copyright (c) 2020 Great Scott Gadgets <info@greatscottgadgets.com>
#
# SPDX-License-Identifier: BSD-3-Clause
""" Generating and recognizing LFPS square wave patterns.
SerDes blocks differ in their out-of-band signaling capabilities. Some are capable of detecting
and generating LFPS signaling on their own; others only make it possible to access the high-speed
I/O buffers directly through fabric. This gateware can detect patterns that fit LFPS requriements
given only a bare input buffer, or vice versa.
"""
from math import ceil
from amaranth import *
from amaranth.lib.cdc import FFSynchronizer
__all__ = ['LFPSSquareWaveDetector', 'LFPSSquareWaveGenerator']
# From [USB3.2: Table 6-29]; the maximum and minimum
_LFPS_PERIOD_MIN = 20e-9 # seconds
_LFPS_PERIOD_MAX = 100e-9
class LFPSSquareWaveDetector(Elaboratable):
""" Detector that identifies LFPS square-wave patterns.
Operates in the ``pipe`` domain.
Attributes
----------
rx_gpio: Signal(), input
The current state of the Rx lines, as retrieved by our SerDes.
present: Signal(), output
High whenever we detect an LFPS toggling.
"""
def __init__(self, pipe_clock_frequency=250e6):
# Compute the minimum and maximum cycles we're allowed to see.
# Our multipliers allow for up to a 10% devication in duty cycle.
self._half_cycle_min = ceil(pipe_clock_frequency * (_LFPS_PERIOD_MIN / 2) * 0.8) - 1
self._half_cycle_max = ceil(pipe_clock_frequency * (_LFPS_PERIOD_MAX / 2) * 1.2) + 1
assert self._half_cycle_min >= 1
#
# I/O ports
#
self.rx_gpio = Signal() # i
self.present = Signal() # o
def elaborate(self, platform):
m = Module()
# Synchronize the GPIO to our clock domain.
rx_gpio = Signal()
m.submodules += FFSynchronizer(self.rx_gpio, rx_gpio, o_domain="pipe")
# Our mechanism is simple: we measure the length of any periods of consecutive highs and lows
# we see, and then check to see when they're both in acceptable ranges. Theoretically, we should
# also check the duty cycle, but as of now, that doesn't seem necessary. [USB3.2: Table 6-29]
# Keep track of the GPIO's value a cycle ago, so we can easily detect rising and falling edges.
last_gpio = Signal()
m.d.pipe += last_gpio.eq(rx_gpio)
# We'll allow each timer to go one cycle past our half-cycle-max, so it can saturate at an unacceptable
# level, and mark the ranges as invalid.
timer_max = self._half_cycle_max + 1
#
# Time-high detection.
#
# Keep track of our current/total time high.
current_time_high = Signal(range(0, timer_max + 1))
total_time_high = Signal.like(current_time_high)
# If our GPIO is high, count it.
with m.If(rx_gpio):
# Count only when we've reached a value lower than the timer's max,
# so we saturate once we're outside the acceptable range.
with m.If(current_time_high != timer_max):
m.d.pipe += current_time_high.eq(current_time_high + 1)
# If we've saturated our count, immediately set the total time
# to the saturation value. This prevents false detections after long
# strings of constant value.
with m.Else():
m.d.pipe += total_time_high.eq(timer_max)
# If we were still counting last cycle, we'll latch our observed time
# high before our timer gets cleared. This value represents our total
# time high, and thus the value we'll use for comparison.
with m.Elif(last_gpio):
m.d.pipe += [
total_time_high .eq(current_time_high),
current_time_high .eq(0)
]
#
# Time-low detection.
#
# Keep track of our current/total time low.
current_time_low = Signal(range(0, timer_max + 1))
total_time_low = Signal.like(current_time_low)
# If our GPIO is low, count it.
with m.If(~rx_gpio):
# Count only when we've reached a value lower than the timer's max,
# so we saturate once we're outside the acceptable range.
with m.If(current_time_low != timer_max):
m.d.pipe += current_time_low.eq(current_time_low + 1)
# If we've saturated our count, immediately set the total time
# to the saturation value. This prevents false detections after long
# strings of constant value.
with m.Else():
m.d.pipe += total_time_low.eq(timer_max)
# If we were still counting last cycle, we'll latch our observed time
# low before our timer gets cleared. This value represents our total
# time high, and thus the value we'll use for comparison.
with m.Elif(~last_gpio):
m.d.pipe += [
total_time_low .eq(current_time_low),
current_time_low .eq(0)
]
#
# Final detection.
#
# Whenever both our time high and time low are in range, we have a valid period.
time_high_valid = ((total_time_high >= self._half_cycle_min) & (total_time_high <= self._half_cycle_max))
time_low_valid = ((total_time_low >= self._half_cycle_min) & (total_time_low <= self._half_cycle_max))
m.d.comb += self.present.eq(time_high_valid & time_low_valid)
return m
class LFPSSquareWaveGenerator(Elaboratable):
"""Generator that outputs LFPS square-wave patterns.
"""
def __init__(self, lfps_frequency, pipe_clock_frequency):
# Compute the cycles in one half-period, and make sure the final period is within the spec.
self._half_cycle = ceil(pipe_clock_frequency / (2 * lfps_frequency))
assert _LFPS_PERIOD_MIN <= (2 * self._half_cycle) / pipe_clock_frequency <= _LFPS_PERIOD_MAX
#
# I/O ports
#
self.generate = Signal() # i
self.tx_gpio_en = Signal() # o
self.tx_gpio = Signal() # o
def elaborate(self, platform):
m = Module()
#
# LFPS square-wave generator.
#
period_timer = Signal(range(self._half_cycle))
square_wave = Signal()
m.d.pipe += period_timer.eq(period_timer + 1)
with m.If(period_timer + 1 == self._half_cycle):
m.d.pipe += period_timer.eq(0)
m.d.pipe += square_wave.eq(~square_wave)
with m.If(self.generate):
m.d.comb += [
self.tx_gpio_en.eq(1),
self.tx_gpio .eq(square_wave),
]
return m
|
import time, unittest, os, sys
from selenium import webdriver
from main.page.desktop_v3.login.pe_login import *
from main.page.desktop_v3.shop.pe_shop import *
from main.activity.desktop_v3.activity_inbox_message import *
from main.activity.desktop_v3.activity_login import *
from main.activity.desktop_v3.activity_send_message import *
from utils.function.setup import *
from utils.lib.user_data import *
class TestSendMessage(unittest.TestCase):
_site = "beta" #"http://new.st-steph.dvl/"
_domain_shop = user5['domain']
count, loop, cycle = 1, 4, 4
def setUp(self):
#self.driver = webdriver.Chrome("C:\driver\chromedriver\chromedriver.exe")
self.driver = tsetup('firefox')
self.login = loginActivity()
self.shop = ShopPage(self.driver)
self.message = sendMessageActivity(self.driver)
self.inbox = inboxMessageActivity()
self.sender = user7
self.receiver = user5
#def test_do_fav_shop(self):
def test_flow_send_message(self):
new_sent_msg_list=[]
print('==================================')
print('TEST : SEND MESSAGE VIA PRODUCT')
print('==================================')
print('!SENDER SIDE!')
self.login.do_login(self.driver, self.sender, self.sender['email'], self.sender['password'], self._site)
print('++CHECK INBOX SENT BEFORE SEND MESSAGE++')
old_sent_msg_list, total_old_msg_list = self.inbox.get_list_sent_message(self.driver, self._site)
print('')
print('++GO TO TARGET SHOP++')
self.shop.domain(self._site, self._domain_shop)
print('')
print('++SEND MESSAGE++')
subject, message_prev = self.message.send_message(self.driver, self.count)
#self.message.send_message(self.driver, self.count, self._domain_shop, self._site)
print('')
print('++CHECK INBOX SENT AFTER SEND MESSAGE++')
new_sent_msg_list, total_new_msg_list = self.inbox.get_list_sent_message(self.driver, self._site)
#check is message sent
stat_sent_msg, total_new_sent_msg, new_sent_msg = self.message.is_message_sent(self.driver, total_old_msg_list, total_new_msg_list, new_sent_msg_list, subject, message_prev)
print('status sent message : ' + str(stat_sent_msg))
print('Total New Sent Message : ' + str(total_new_sent_msg))
print(new_sent_msg)
self.driver.close()
time.sleep(2)
print('')
print('!RECEIVER SIDE!')
i = 0
while i < self.cycle:
print('')
print('Test reply no.' + str(i+1))
self.driver = tsetup('firefox')
#self.driver = webdriver.Chrome("C:\driver\chromedriver\chromedriver.exe")
self.login.do_login(self.driver, self.receiver, self.receiver['email'], self.receiver['password'], self._site)
self.inbox.is_message_received(self.driver, self._site, new_sent_msg)
#self.inbox.is_message_contains_blacklisted_links(self.driver, self._site, new_sent_msg, message_prev)
self.inbox.reply_message(self.driver, self._site, new_sent_msg)
self.sender, self.receiver = self.receiver, self.sender #swap sender and receiver
self.driver.close()
i+=1
self.driver = tsetup('firefox')
#self.driver = webdriver.Chrome("C:\driver\chromedriver\chromedriver.exe")
self.login.do_login(self.driver, self.receiver, self.receiver['email'], self.receiver['password'], self._site)
self.inbox.is_message_received(self.driver, self._site, new_sent_msg)
#self.inbox.is_message_contains_blacklisted_links(self.driver, self._site, new_sent_msg, message_prev)
self.inbox.reply_message(self.driver, self._site, new_sent_msg)
"""def test_case_loop_send_msg(self):
print("Test loop send message.")
self.login.do_login(self.driver, self.sender, self.sender['email'], self.sender['password'], self._site)
self.shop.domain(self._site, self._domain_shop)
self.message.loop_send_msg(self.message, self.loop)"""
def tearDown(self):
print("Testing akan selesai dalam beberapa saat..")
time.sleep(5)
self.driver.quit()
# main
if(__name__ == "__main__"):
unittest.main()
|
a = "Hello World"
print(a.replace("o", "J")) |
import os
import sys
import FileUtilities as fu
import functions_alt_count as AltCnt
### Tabulate pileup files (list and count all allternative alleles from pileup files)
## INPUT: chr${ichar}_q${MapQual}_d${depth}_mapped.pileup
## OUTPUT: chr${ichar}_q${MapQual}_d${depth}_mapped.pileup.alt_count
q_d_pileup=sys.argv[1]
AltCnt.get_count_alt_qpileup(pileup=q_d_pileup)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from head import *
from db_base import MssqlConnection
from db_env import *
class DbOperator(MssqlConnection):
def __init__(self, ):
MssqlConnection.__init__(self)
def get_latest_data(self, room_id):
"""
通过房间ID查询实时的数据
:param room_id: 传感器ID
:rtype: json格式化字典
"""
sql_str = "select top 1 instance_id, sense_time, room_id from tb_instance where room_id = %d order by instance_id desc " %(room_id)
self.connect()
result = self.queryAll(sql_str)
instance_id = result[0][0]
sense_time = result[0][1].strftime('%Y/%m/%d %H:%M:%S')
sql_str = '''select tb_data.sensor_id, data, sensor_type from tb_data left join tb_sensor
on tb_sensor.sensor_id = tb_data.sensor_id
where instance_id = %d''' %instance_id
result = self.queryAll(sql_str)
self.close()
json_inst = {'instance_id' : instance_id,
'sense_time' : sense_time,
'room_id' : room_id,
'sense_data' :{
'temperature' : [],
'humidity' : [],
'co2' : [],
'light' : [],
}
}
for one_row in result:
sensor_type = one_row[2]
sensor_id = one_row[0]
data = one_row[1]
json_inst['sense_data'][sensor_type].append({'id': sensor_id, 'data': data})
return json_inst
def get_room_info(self, room_id):
"""
通过Room ID获取房间信息
:param room_id: 房间号
:rtype: 待定
"""
plant_dict = {}
self.connect()
sql_str = u'''select top 1 tb_room.room_id, room_description, tb_plant.plant_id, plant_name, policy_id from
tb_policy_instance left join tb_plant
on tb_policy_instance.plant_id = tb_plant.plant_id, tb_room
where tb_policy_instance.policy_instance_id in (select distinct policy_instance_id from tb_absolute_time)
and tb_room.room_id = %d and state >= %d''' %(room_id, POLICY_RUNNING)
# 这里有一个问题，当用户向tb_policy_instance表中一次添加了多个（>=2）个同房间不同开始时间的policy_instance时，
# 理论上是可以的，但这时就会有上述的查询返回多组，其中只有一组是正在执行的，其他的均为当前执行周期结束后才执行的新的周期。
plant_room = self.queryAll(sql_str)
self.close()
try:
plant_dict['roomId'] = plant_room[0][0]
plant_dict['roomName'] = plant_room[0][1]
plant_dict['plantId'] = plant_room[0][2]
plant_dict['plantName'] = plant_room[0][3]
plant_dict['nowPolicy'] = plant_room[0][4]
except IndexError, e:
print 'get nothing in room_id: %d' %room_id
return plant_dict
def get_all_room(self):
"""
获取所有房间的最新基础信息
:rtype: 所有房间信息的队列
"""
sql_str = '''
select room_id from tb_room
'''
self.connect()
room_list = self.queryAll(sql_str)
self.close()
all_room_info = []
for i in room_list:
all_room_info.append(self.get_room_info(i[0]))
return all_room_info
def get_time_reange_data(self, room_id, start_time, end_time):
"""
获取指定房间的指定范围环境信息（采集值）
:param room_id: 房间号
:param start_time: 开始时间
:param end_time: 结束时间
:rtype: 指定时间段的数据队列
"""
sql_str = u'''
select tb_temp.sensor_id, tb_sensor.sensor_type, position, sense_time, data from
(select sensor_id, sense_time, data
from tb_data left join tb_instance on tb_instance.instance_id = tb_data.instance_id
where sense_time >= '%s' and sense_time < '%s' and room_id = %d) as tb_temp
left join tb_sensor on tb_temp.sensor_id = tb_sensor.sensor_id
order by sensor_id, sense_time
''' %(start_time, end_time, room_id)
self.connect()
data = self.queryAll(sql_str)
self.close()
temp = {}
temp['sensorId'] = data[0][0]
temp['sensorName'] = data[0][1]
temp['position'] = data[0][2]
data_list = []
print 'length = %d' %len(data)
for i in data:
data_list.append((i[3].strftime('%Y/%m/%d %H:%M:%S'), i[4]))
temp['values'] = tuple(data_list)
return temp
def certain_sensor_time_range_data(self, sensor_id, start_time, end_time):
"""
通过sensor_id查询一段时间的数据
:param sensor_id: 传感器ID
:param start_time: 起时间
:param end_time: 末时间
:rtype: json格式化字典
"""
sql_str = '''
select sense_time, position, sensor_type, data from
tb_data left join tb_instance on tb_data.instance_id = tb_instance.instance_id --as tb_temp
left join tb_sensor on tb_sensor.sensor_id = tb_data.sensor_id
where tb_data.sensor_id = %d and sense_time >= '%s' and sense_time <= '%s'
''' %(sensor_id, start_time, end_time)
self.connect()
result = self.queryAll(sql_str)
self.close()
json_inst = {
"sensorId": sensor_id,
"sensorType": "",
"position": "",
"values":[],
}
for one_row in result:
sense_time = one_row[0].strftime('%Y/%m/%d %H:%M:%S')
position = one_row[1]
sensor_type = one_row[2]
data = one_row[3]
json_inst['sensorType'] = sensor_type
json_inst['position'] = position
json_inst['values'].append((sense_time, data))
json_inst['values'] = tuple(json_inst['values'])
return json_inst
def update_room_name(self, room_id, room_description):
"""
修改房间名称
:param room_id: 房间号
:param room_description: 房间描述
:rtype: 修改结果，code: 0 成功， -1 失败
"""
sql_str = u'''
update tb_room
set room_description = '%s'
where room_id = %d
''' %(room_description, room_id)
self.connect()
self.executeDML(sql_str)
self.close()
result = {}
result['code'] = 0
result['definition'] = ''
return result
def update_plant_info(self, plant_id, plant_name):
"""
修改植物名称
:param plant_id: 植物编号
:param plant_name: 植物名
:rtype: 修改结果，code: 0 成功， -1 失败
"""
sql_str = u'''
update tb_plant
set plant_name = '%s'
where plant_id = %d
''' %(plant_name, plant_id)
self.connect()
self.executeDML(sql_str)
self.close()
self.load_table()
return {'code': 0, 'definition': ''}
def all_policy_info(self):
"""
获取养殖模式简要信息
:rtype: 所有养殖策略简要信息
"""
sql_str = u'''
select policy_id, description from tb_policy
'''
self.connect()
temp_list = self.queryAll(sql_str)
self.close()
policy_list = []
for i in temp_list:
policy_list.append({'policyId':i[0], 'description': i[1]})
return policy_list
def get_policy(self, policy_id):
"""
获取指定养殖模式的全部信息
:param policy_id: 策略号
:rtype: 指定养殖模式的详细信息,失败返回FAI
"""
sql_str = u'''
select description, interval_date, hours,
temperature_peak, temperature_valle, humidity_peak, humidity_valle,
co2_peak, co2_valle, reserved1_peak, reserved1_valle
from tb_rule left join tb_policy
on tb_rule.policy_id = tb_policy.policy_id
where tb_policy.policy_id = %d
''' %(policy_id)
self.connect()
temp_list = self.queryAll(sql_str)
self.close()
policy_info = {}
policy_info['policyId'] = policy_id
policy_info['policy'] = []
try:
policy_info['description'] = temp_list[0][0]
except IndexError, e:
policy_info['description'] = ''
return policy_info
for i in temp_list:
temp = {}
temp['date'] = i[1]
temp['hour'] = i[2]
temp['temperature'] = (i[3], i[4])
temp['humidity'] = (i[5], i[6])
temp['co2'] = (i[7], i[8])
temp['brightness'] = (i[9], i[10])
temp['light'] = ''
policy_info['policy'].append(temp)
return policy_info
def get_policy_instance_now(self, policy_id = None, room_id = None):
"""
获取中正在执行的实例
:param policy_id:
:param room_id:
:rtype: 指定养殖模式的详细信息,失败返回FAI
"""
if policy_id != None:
sql_str = u'''
select change_time,
temperature_peak, temperature_valle,
humidity_peak, humidity_valle,
co2_peak, co2_valle,
reserved1_peak, reserved1_valle,
light_color, policy_id, room_id
from vw_task
where vw_task.policy_id = %d
order by change_time
''' %(policy_id)
self.connect()
temp_list = self.queryAll(sql_str)
self.close()
the_end = {}
for i in temp_list:
policy_id = i[10]
room_id = i[11]
if the_end.has_key(room_id):
pass
else:
the_end[room_id] = {'roomId' : room_id,
'roomDesc' : self.room_id2desc[room_id],
'policy_id' : policy_id,
'now' : '',
'rules' : []
}
for i in temp_list:
temp = {}
temp['changeTime'] = i[0].strftime('%Y/%m/%d %H:%M:%S')
temp['temperature'] = (i[1], i[2])
temp['humidity'] = (i[3], i[4])
temp['co2'] = (i[5], i[6])
temp['brightness'] = (i[7], i[8])
temp['light'] = ''
room_id = i[11]
the_end[room_id]['rules'].append(temp)
if i[0] <= datetime.now():
the_end[room_id]['now'] = temp['changeTime']
end_list = []
for key in the_end.keys():
end_list.append(the_end[key])
return end_list
elif room_id != None:
sql_str = u'''
select change_time,
temperature_peak, temperature_valle,
humidity_peak, humidity_valle,
co2_peak, co2_valle,
reserved1_peak, reserved1_valle,
light_color, policy_id, room_id
from vw_task
where vw_task.room_id = %d
order by change_time
''' %(room_id)
self.connect()
temp_list = self.queryAll(sql_str)
self.close()
rule_list = []
current_instance = {'roomId' : room_id,
'roomDesc' : self.room_id2desc[room_id],
'now': '',
'rules': rule_list,
}
current_rule_time = ''
policy_id = -1
for i in temp_list:
temp = {}
temp['changeTime'] = i[0].strftime('%Y/%m/%d %H:%M:%S')
temp['temperature'] = (i[1], i[2])
temp['humidity'] = (i[3], i[4])
temp['co2'] = (i[5], i[6])
temp['brightness'] = (i[7], i[8])
temp['light'] = ''
policy_id = i[10]
rule_list.append(temp)
if i[0] <= datetime.now():
current_rule_time = temp['changeTime']
current_instance['policyId'] = policy_id
current_instance['now'] = current_rule_time
return [current_instance]
else:
return FAI
def get_policy_instance_plan_list(self, policy_id):
"""
获取计划中的实例
:param policy_id: 策略号
:rtype: 指定格式的数据
"""
instance_info = []
sql_str = ''' select policy_instance_id, room_id, start_time, plant_id from tb_policy_instance
where policy_id = %d and state = %d ''' %(policy_id, POLICY_NEW)
self.connect()
instance_list = self.queryAll(sql_str)
self.close()
for one_instance in instance_list:
temp_instance = {}
temp_instance['policyInstanceId'] = one_instance[0]
temp_instance['roomDesc'] = self.room_id2desc[one_instance[1]]
temp_instance['startAt'] = one_instance[2]
temp_instance['plantName'] = self.plant_id2name[one_instance[3]]
instance_info.append(temp_instance)
return instance_info
def get_policy_instance_done_list(self, policy_id):
"""
获取执行过的实例
:param policy_id: 策略号
:rtype: 指定格式的数据
"""
instance_info = []
sql_str = ''' select policy_instance_id, room_id, start_time, plant_id from tb_policy_instance
where policy_id = %d and state = %d ''' %(policy_id, POLICY_OLD)
self.connect()
instance_list = self.queryAll(sql_str)
self.close()
for one_instance in instance_list:
temp_instance = {}
temp_instance['policyInstanceId'] = one_instance[0]
temp_instance['roomDesc'] = self.room_id2desc[one_instance[1]]
temp_instance['startAt'] = one_instance[2]
temp_instance['plantName'] = self.plant_id2name[one_instance[3]]
instance_info.append(temp_instance)
return instance_info
def get_policy_2(self, policy_id):
"""
获取指定策略的部分信息
:param policy_id: 策略号
:rtype: 指定格式的策略信息,失败返回 FAI
"""
policy_info = self.get_policy(policy_id)
policy_info['rules'] = policy_info['policy']
policy_info.pop('policy')
policy_info['now'] = []
policy_info['old'] = []
policy_info['plan'] = []
self.connect()
try:
sql_str = " select policy_instance_id from tb_policy_instance where policy_id = %d and state = %d" %(policy_id, POLICY_RUNNING)
now_instance_list = self.queryAll(sql_str)
for one_instance in now_instance_list:
policy_info['now'].append(one_instance[0])
except IndexError:
pass
try:
sql_str = " select policy_instance_id from tb_policy_instance where policy_id = %d and state = %d " %(policy_id, POLICY_NEW)
plan_instance_id_list = self.queryAll(sql_str)
for instance in plan_instance_id_list:
policy_info['plan'].append(instance[0])
except IndexError:
pass
try:
sql_str = " select policy_instance_id from tb_policy_instance where policy_id = %d and state = %d " %(policy_id, POLICY_OLD)
old_instance_id_list= self.queryAll(sql_str)
for instance in old_instance_id_list:
policy_info['old'].append(instance[0])
return policy_info
except IndexError:
return FAI
def current_policy(self, room_id):
"""
获取正在执行的养殖策略
:param room_id: 房间号
:rtype: 指定房间的当前养殖模式的详细信息
"""
sql_str = u'''
select change_time,
temperature_peak, temperature_valle,
humidity_peak, humidity_valle,
co2_peak, co2_valle,
reserved1_peak, reserved1_valle, light_color,
tb_policy.policy_id, tb_policy.description, vw_task.policy_instance_id
from vw_task left join tb_policy_instance on vw_task.policy_instance_id = tb_policy_instance.policy_instance_id
left join tb_policy on tb_policy_instance.policy_id = tb_policy.policy_id
where vw_task.room_id = %d
''' %(room_id)
self.connect()
temp_list = self.queryAll(sql_str)
self.close()
rule_list = []
for i in temp_list:
temp = {}
temp['changeTime'] = i[0].strftime('%Y/%m/%d %H:%M:%S')
temp['temperature'] = (i[1], i[2])
temp['humidity'] = (i[3], i[4])
temp['co2'] = (i[5], i[6])
temp['brightness'] = (i[7], i[8])
temp['light'] = ''
rule_list.append(temp)
current_policy = {'pid': temp_list[0][10],
'description' : temp_list[0][11],
'rules': rule_list,
}
return current_policy
def new_policy(self, description, rules = ''):
"""
创建新策略
:param description: 策略描述，长度限制 <20字符
:rtype: 成功返回新建的策略号， 失败返回 -1
"""
if len(description) > 20:
log_msg = 'description is too long, please make sure the lenght less than 20'
print
return -1
sql_str = u"insert into tb_policy(description) values('%s')" %(description)
try:
self.connect()
self.executeDML(sql_str)
sql_str = "select top 1 policy_id from tb_policy where description = '%s' order by policy_id desc" %(description)
policy_id = self.queryAll(sql_str)[0][0]
self.close()
if len(rules) > 0:
self.create_rule(policy_id, rules)
return policy_id
except KeyboardInterrupt, e:
print e
return ERR
def new_policy_instance_2(self, policy_id, plant_name, room_desc, start_time):
"""
创建新的策略实例
:param policy_id: 策略号
:param plany_name: 名称
:param room_desc: 房间描述
:param start_time: 开始执行时间,格式要求： 2013-12-17 15:45:00 （格式受限于SQLServer）
:rtype: 成功返回新建的实例号，失败返回 -1， 异常返回 -2
"""
self.connect()
try:
plant_id = self.plant_name2id[plant_name]
except KeyError:
self.executeDML("insert into tb_plant(plant_name) values('%s')" %(plant_name))
self.load_table()
plant_id = self.plant_name2id[plant_name]
try:
room_id = self.room_desc2id[room_desc]
except KeyError:
return FAI
# self.executeDML("insert into tb_room(room_description) values('%s')" %(room_desc))
# self.load_table()
# room_id = self.room_desc2id[room_desc]
try:
sql_str = '''insert into tb_policy_instance(policy_id, plant_id, room_id, start_time, state)
values(%d, %d, %d, '%s', %d)''' %(policy_id, plant_id, room_id, start_time, POLICY_NEW)
self.executeDML(sql_str)
instance_id = self.queryAll('''select top 1 policy_instance_id from tb_policy_instance
where policy_id = %d order by policy_instance_id desc''' %(policy_id))[0][0]
self.close()
return instance_id
except Exception, e:
print 'in create_policy_instance: '
print e
return ERR
def update_policy_desc(self, policy_id, description):
"""
修改现存policy的名称
:param policy_id: 待修改的策略号
:param description: 策略描述
:rtype: 修改结果，code: 0 成功， -1 失败
"""
sql_str = '''update tb_policy
set description = '%s'
where policy_id = %d
''' %(description, policy_id)
self.connect()
self.executeDML(sql_str)
self.close()
return {'code': 0, 'definition': 'Successful'}
def update_policy(self, policy_id, rules):
"""
修改指定策略
:param policy_id: 策略号
:rules rules: 执行规则
:rtype: SUC / FAI / ERR
"""
sql_str = 'delete from tb_rule where policy_id = %d' %(policy_id)
self.connect()
self.executeDML(sql_str)
self.close()
if len(rules) > 0:
result = self.create_rule(policy_id, rules)
def update_policy_instance(self, policy_instance_id, room_desc, plant_name, start_time):
"""
更改策略实例信息
:param policy_instance_id: 实例号
:param room_desc: 房间描述
:param plant_name: 植物名称
:param start_time: 开始执行时间
:rtype: SUC 成功， FAI 失败， ERR 异常
"""
self.connect()
try:
plant_id = self.plant_name2id[plant_name]
room_id = self.room_desc2id[room_desc]
except KeyError:
print 'Some info provited not exist, please check it'
return FAI
sql_str = '''
update tb_policy_instance
set room_id = %d,
plant_id = %d,
start_time = '%s'
where policy_instance_id = %d
''' %(room_id, plant_id, start_time, policy_instance_id)
self.executeDML(sql_str)
self.close()
return SUC
def delete_policy(self, policy_id):
"""
删除指定policy
:param policy_id: 策略号
:rtype: 删除结果， code: 0 成功， -1 失败
"""
self.connect()
# self.executeDML(u'delete from tb_policy_instance where policy_id = %d' %(policy_id))
# self.executeDML(u'delete from tb_rule where policy_id = %d' %(policy_id))
self.executeDML(u'delete from tb_policy where policy_id = %d' %(policy_id))
self.close()
return {'code': 0, 'definition': 'Successful'}
def delete_policy_instance(self, policy_instance_id):
sql_str = 'delete from tb_policy_instance where policy_instance_id = %d' %(policy_instance_id)
self.connect()
self.executeDML(sql_str)
self.close()
return SUC
if __name__ == '__main__':
temp = DbOperator()
temp.test_connection()
# print temp.current_policy(3)
print temp.get_policy_2(142) #check
rules = [
{'co2': (12.0, 12.0),
'temperature': (12.0, 12.0),
'hour': 1,
'brightness': (12.0, 12.0),
'light': '',
'humidity': (12.0, 12.0),
'date': 0
},
{'co2': (12.0, 12.0),
'temperature': (12.0, 12.0),
'hour': 1,
'brightness': (12.0, 12.0),
'light': '',
'humidity': (12.0, 12.0),
'date': 0
},
{'co2': (12.0, 12.0),
'temperature': (12.0, 12.0),
'hour': 1,
'brightness': (12.0, 12.0),
'light': '',
'humidity': (12.0, 12.0),
'date': 0}
]
# temp.new_policy(u'新策略', rules) # check
# temp.update_policy(124, rules) # check
# temp.new_policy_instance_2(124, 'mongou', 'left_second', '2014-04-15 12:12:00.000') #check
# temp.update_policy_instance(106, 'left_first', 'xianggu', '2014-04-16 12:12:00.000') #check
# temp.delete_policy_instance(106) #check
# print temp.get_policy_instance_now(142, None) #check
# print temp.get_policy_instance_plan_list(142) # check
# print temp.get_policy_instance_done_list(53) # check
len(temp.get_time_reange_data(1,'2014-04-28 1:1:1', '2014-04-28 20:10:00'))
print 'search end'
[
{'roomDesc': u'left_second',
'now': '2014/04/22 15:12:00',
'roomId': 2,
'policy_id': 142,
'rules': [
{'changeTime': '2014/04/22 11:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 12:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 14:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 15:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 17:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 18:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 20:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 21:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 23:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)}
],
},
{
'roomDesc': u'one month',
'now': '2014/04/22 15:12:00',
'roomId': 3,
'policy_id': 142,
'rules': [
{'changeTime': '2014/04/22 11:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 12:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 14:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 15:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 17:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 18:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 20:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 21:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)},
{'changeTime': '2014/04/22 23:12:00', 'co2': (200.0, 100.0), 'temperature': (200.0, 100.0), 'brightness': (200.0, 100.0), 'light': '', 'humidity': (200.0, 100.0)}
],
}
]
|
from pickle import dumps
from typing import Tuple
import numpy as np
from stratego_env.game.stratego_procedural_impl import INT_DTYPE_NP, StateLayers, SP, \
_get_max_possible_actions_per_start_position, _create_initial_state, _get_action_size, \
_get_action_1d_index_from_positions, _get_action_positions_from_1d_index, _get_valid_moves_as_1d_mask, \
_get_state_from_player_perspective, _get_action_positions_from_player_perspective, \
_get_action_1d_index_from_player_perspective, _is_move_valid_by_position, _is_move_valid_by_1d_index, \
_get_game_ended, _get_game_result_is_invalid, _get_next_state, _get_fully_observable_observation, \
_get_partially_observable_observation, _get_fully_observable_observation_extended_channels, \
_get_partially_observable_observation_extended_channels, \
_get_dict_of_valid_moves_by_position, \
_get_action_spatial_index_from_positions, _get_action_positions_from_spatial_index, \
_get_valid_moves_as_spatial_mask, _get_action_1d_index_from_spatial_index, _get_action_spatial_index_from_1d_index, \
_get_spatial_action_size
class StrategoProceduralEnv(object):
"""StrategoProceduralEnv
Class that retains a minimal amount of information (rows, columns, action_size, etc.) to make
function calls simpler to call for a given configuration of the game.
"""
def __init__(self, rows: int, columns: int):
if rows < 3 or columns < 3:
raise ValueError("Both rows and columns have to be at least 3 (you passed rows: {} columns: {})."
.format(rows, columns))
self.rows = INT_DTYPE_NP(rows)
self.columns = INT_DTYPE_NP(columns)
self.action_size = _get_action_size(rows=self.rows, columns=self.columns)
self.spatial_action_size = _get_spatial_action_size(rows=self.rows, columns=self.columns)
self._mpapsp = _get_max_possible_actions_per_start_position(rows=self.rows, columns=self.columns)
def create_initial_state(self,
obstacle_map: np.ndarray,
player_1_initial_piece_map: np.ndarray,
player_2_initial_piece_map: np.ndarray,
max_turns: int):
correct_shape = (self.rows, self.columns)
if not np.array_equal(obstacle_map.shape, correct_shape):
raise ValueError("obstacle map needs to be of shape {}, was {}", correct_shape,
obstacle_map.shape)
if not np.array_equal(player_1_initial_piece_map.shape, correct_shape):
raise ValueError("player_1_initial_piece_map map needs to be of shape {}, was {}", correct_shape,
player_1_initial_piece_map.shape)
if not np.array_equal(player_2_initial_piece_map.shape, correct_shape):
raise ValueError("player_2_initial_piece_map map needs to be of shape {}, was {}", correct_shape,
player_2_initial_piece_map.shape)
return _create_initial_state(obstacle_map=obstacle_map,
player_1_initial_piece_map=player_1_initial_piece_map,
player_2_initial_piece_map=player_2_initial_piece_map,
max_turns=INT_DTYPE_NP(max_turns))
def get_action_1d_index_from_positions(self, start_r, start_c, end_r, end_c):
return _get_action_1d_index_from_positions(rows=self.rows, columns=self.columns,
start_r=INT_DTYPE_NP(start_r), start_c=INT_DTYPE_NP(start_c),
end_r=INT_DTYPE_NP(end_r), end_c=INT_DTYPE_NP(end_c),
max_possible_actions_per_start_position=self._mpapsp)
def get_action_positions_from_1d_index(self, action_index):
return _get_action_positions_from_1d_index(rows=self.rows, columns=self.columns,
action_index=INT_DTYPE_NP(action_index),
action_size=self.action_size,
max_possible_actions_per_start_position=self._mpapsp)
def get_valid_moves_as_1d_mask(self, state: np.ndarray, player, player_perspective=False):
if player_perspective and player == -1:
state = _get_state_from_player_perspective(state=state, player=player)
return _get_valid_moves_as_1d_mask(state=state, player=INT_DTYPE_NP(player), action_size=self.action_size,
max_possible_actions_per_start_position=self._mpapsp)
def get_dict_of_valid_moves_by_position(self, state: np.ndarray, player):
return _get_dict_of_valid_moves_by_position(state=state, player=player, rows=self.rows, columns=self.columns,
action_size=self.action_size,
max_possible_actions_per_start_position=self._mpapsp)
def is_move_valid_by_position(self, state: np.ndarray, player, start_r, start_c, end_r, end_c,
allow_piece_oscillation=False):
return _is_move_valid_by_position(state=state, player=INT_DTYPE_NP(player), start_r=INT_DTYPE_NP(start_r),
start_c=INT_DTYPE_NP(start_c), end_r=INT_DTYPE_NP(end_r),
end_c=INT_DTYPE_NP(end_c),
allow_piece_oscillation=allow_piece_oscillation)
def is_move_valid_by_1d_index(self, state: np.ndarray, player, action_index, allow_piece_oscillation=False):
return _is_move_valid_by_1d_index(state=state, player=INT_DTYPE_NP(player),
action_index=INT_DTYPE_NP(action_index),
action_size=self.action_size,
max_possible_actions_per_start_position=self._mpapsp,
allow_piece_oscillation=allow_piece_oscillation)
def get_state_from_player_perspective(self, state: np.ndarray, player):
return _get_state_from_player_perspective(state=np.asarray(state, dtype=INT_DTYPE_NP),
player=INT_DTYPE_NP(player))
def get_action_positions_from_player_perspective(self, player, start_r, start_c, end_r, end_c):
return _get_action_positions_from_player_perspective(player=player, start_r=start_r, start_c=start_c,
end_r=end_r, end_c=end_c, rows=self.rows,
columns=self.columns)
def get_action_1d_index_from_player_perspective(self, action_index, player):
return _get_action_1d_index_from_player_perspective(action_index=INT_DTYPE_NP(action_index),
player=INT_DTYPE_NP(player),
action_size=self.action_size, rows=self.rows,
columns=self.columns,
max_possible_actions_per_start_position=self._mpapsp)
def get_action_spatial_index_from_positions(self, start_r, start_c, end_r, end_c):
return _get_action_spatial_index_from_positions(
rows=self.rows, columns=self.columns,
start_r=INT_DTYPE_NP(start_r), start_c=INT_DTYPE_NP(start_c),
end_r=INT_DTYPE_NP(end_r), end_c=INT_DTYPE_NP(end_c))
def get_action_positions_from_spatial_index(self, spatial_index: np.ndarray):
return _get_action_positions_from_spatial_index(rows=self.rows, columns=self.columns,
spatial_index=spatial_index)
def get_valid_moves_as_spatial_mask(self, state, player):
return _get_valid_moves_as_spatial_mask(state=state, player=INT_DTYPE_NP(player))
def get_action_1d_index_from_spatial_index(self, spatial_index):
return _get_action_1d_index_from_spatial_index(rows=self.rows, columns=self.columns,
spatial_index=spatial_index,
max_possible_actions_per_start_position=self._mpapsp)
def get_action_spatial_index_from_1d_index(self, action_index):
return _get_action_spatial_index_from_1d_index(rows=self.rows, columns=self.columns,
action_index=INT_DTYPE_NP(action_index),
action_size=self.action_size,
max_possible_actions_per_start_position=self._mpapsp)
def get_game_ended(self, state: np.ndarray, player):
return _get_game_ended(state=state, player=INT_DTYPE_NP(player))
def get_game_result_is_invalid(self, state: np.ndarray):
return _get_game_result_is_invalid(state)
def get_next_state(self, state: np.ndarray, player, action_index, allow_piece_oscillation=False):
new_state = _get_next_state(state=state, player=INT_DTYPE_NP(player), action_index=INT_DTYPE_NP(action_index),
action_size=self.action_size, max_possible_actions_per_start_position=self._mpapsp,
allow_piece_oscillation=allow_piece_oscillation)
new_player = player * -1
return new_state, new_player
def get_fully_observable_observation(self, state: np.ndarray, player):
return _get_fully_observable_observation(state=state, player=INT_DTYPE_NP(player),
rows=self.rows, columns=self.columns)
def get_partially_observable_observation(self, state: np.ndarray, player):
return _get_partially_observable_observation(state=state, player=INT_DTYPE_NP(player),
rows=self.rows, columns=self.columns)
def get_fully_observable_observation_extended_channels(self, state: np.ndarray, player):
return _get_fully_observable_observation_extended_channels(state=state, player=INT_DTYPE_NP(player),
rows=self.rows, columns=self.columns)
def get_partially_observable_observation_extended_channels(self, state: np.ndarray, player):
return _get_partially_observable_observation_extended_channels(state=state, player=INT_DTYPE_NP(player),
rows=self.rows, columns=self.columns)
def get_serializable_string_for_fully_observable_state(self, state: np.ndarray):
return dumps(_get_fully_observable_observation(state=state, player=INT_DTYPE_NP(1), rows=self.rows,
columns=self.columns))
def get_serializable_string_for_partially_observable_state(self, state: np.ndarray):
return dumps(_get_partially_observable_observation(state=state, player=INT_DTYPE_NP(1), rows=self.rows,
columns=self.columns))
def print_board_to_console(self, state, partially_observable=False, hide_still_piece_markers=True):
p2_state_layer = StateLayers.PLAYER_2_PO_PIECES.value if partially_observable else StateLayers.PLAYER_2_PIECES.value
spaces_per_piece = 4
layers, rows, columns = state.shape
width = rows * 6 + 1
print(" COL", end="")
for column in range(columns - 1, -1, -1):
print(f" {str(column).rjust(2)} ", end="")
print("\n {}".format("-" * width))
for row in range(rows - 1, -1, -1):
print(f"Row {str(row).rjust(2)}", end=" ")
print("|", end="")
for column in range(columns - 1, -1, -1):
item = ""
if state[StateLayers.PLAYER_1_PIECES.value, row, column] != 0:
item = str(state[StateLayers.PLAYER_1_PIECES.value, row, column])
elif state[p2_state_layer, row, column] != 0:
item = str(-1 * state[p2_state_layer, row, column])
elif state[StateLayers.OBSTACLES.value, row, column] != 0:
item = "R"
if not hide_still_piece_markers:
if state[StateLayers.PLAYER_1_STILL_PIECES.value, row, column] == 1:
item += "a"
if state[StateLayers.PLAYER_2_STILL_PIECES.value, row, column] == 1:
item += "b"
print(str(item).rjust(spaces_per_piece), end=" |")
print("\n {}".format("-" * width))
#
# if __name__ == '__main__':
# state = create_initial_state_tiny_stratego()
# import sys
# np.set_printoptions(threshold=sys.maxsize)
#
# print(state)
#
# display_board(state)
#
# print("action size: ", _get_action_size(10, 10))
#
# valid_actions = _get_valid_moves_as_1d_mask(state, player=STATE_DATA_TYPE_NP(1))
# print(sum(_get_valid_moves_as_1d_mask(state, player=STATE_DATA_TYPE_NP(1))))
#
# action_index = _get_action_1d_index_from_positions(rows=10
# ,columns=10,
# start_r=1,
# start_c=2,
# end_r=1,
# end_c=3,
# max_possible_actions_per_start_position=_get_max_possible_actions_per_start_position(10,10))
#
# print(action_index)
#
# print(_get_action_positions_from_1d_index(10,10, action_index, _get_action_size(10, 10), _get_max_possible_actions_per_start_position(10,10)))
#
# print(_is_move_valid_by_1d_index(state, player=1, action_index=np.random.choice(list(range(len(valid_actions))),p=valid_actions/sum(valid_actions))))
#
# print(NUM_STATE_LAYERS)
#
# new_state = _get_next_state(state = state, player=1, action_index=np.random.choice(list(range(len(valid_actions))),p=valid_actions/sum(valid_actions)))
#
# display_board(state)
|
import numpy as np
import pandas as pd
from r.pca.prcomp import prcomp_r
from r.pca.rpca import rpca_r
### principal component analysis
# X : pd.DataFrame
# col : pd.Index
# num_components : int
# -> np.ndarray
def pca_components(X, col=None, num_components=None):
return prcomp_r(X.as_matrix(columns=col), num_components)[1]
# X : pd.DataFrame
# col : pd.Index
# num_components : int
# -> pd.DataFrame
def pca_reduce(X, col=None, num_components=None):
return pd.DataFrame(prcomp_r(X.as_matrix(columns=col), num_components)[0], index=X.index)
### robust principal component analysis
### see reference Candes09
# X : pd.DataFrame
# col : pd.Index
# -> pd.DataFrame
def rpca_low_rank(X, col=None):
return pd.DataFrame(rpca_r(X.as_matrix(columns=col))[0], index=X.index)
# X : pd.DataFrame
# col : pd.Index
# -> pd.DataFrame
def rpca_sparse(X, col=None):
return pd.DataFrame(rpca_r(X.as_matrix(columns=col))[1], index=X.index)
|
# Copyright 2020 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations
import configparser
from dataclasses import dataclass
from enum import Enum
from io import StringIO
from pathlib import PurePath
from typing import Any, MutableMapping, cast
import toml
from pants.backend.python.subsystems.python_tool_base import PythonToolBase
from pants.backend.python.target_types import ConsoleScript
from pants.backend.python.util_rules.pex import PexRequest, VenvPex, VenvPexProcess
from pants.backend.python.util_rules.python_sources import (
PythonSourceFiles,
PythonSourceFilesRequest,
)
from pants.core.goals.test import (
ConsoleCoverageReport,
CoverageData,
CoverageDataCollection,
CoverageReport,
CoverageReports,
FilesystemCoverageReport,
)
from pants.core.util_rules.config_files import ConfigFiles, ConfigFilesRequest
from pants.core.util_rules.distdir import DistDir
from pants.engine.addresses import Address
from pants.engine.fs import (
EMPTY_DIGEST,
AddPrefix,
CreateDigest,
Digest,
DigestContents,
FileContent,
MergeDigests,
PathGlobs,
Snapshot,
)
from pants.engine.process import FallibleProcessResult, ProcessExecutionFailure, ProcessResult
from pants.engine.rules import Get, MultiGet, collect_rules, rule
from pants.engine.target import TransitiveTargets, TransitiveTargetsRequest
from pants.engine.unions import UnionRule
from pants.option.global_options import KeepSandboxes
from pants.option.option_types import (
BoolOption,
EnumListOption,
FileOption,
FloatOption,
StrListOption,
StrOption,
)
from pants.source.source_root import AllSourceRoots
from pants.util.logging import LogLevel
from pants.util.strutil import softwrap
"""
An overview:
Step 1: Run each test with the appropriate `--cov` arguments.
In `python_test_runner.py`, we pass options so that the pytest-cov plugin runs and records which
lines were encountered in the test. For each test, it will save a `.coverage` file (SQLite DB
format).
Step 2: Merge the results with `coverage combine`.
We now have a bunch of individual `PytestCoverageData` values, each with their own `.coverage` file.
We run `coverage combine` to convert this into a single `.coverage` file.
Step 3: Generate the report with `coverage {html,xml,console}`.
All the files in the single merged `.coverage` file are still stripped, and we want to generate a
report with the source roots restored. Coverage requires that the files it's reporting on be present
when it generates the report, so we populate all the source files.
Step 4: `test.py` outputs the final report.
"""
class CoverageReportType(Enum):
CONSOLE = ("console", "report")
XML = ("xml", None)
HTML = ("html", None)
RAW = ("raw", None)
JSON = ("json", None)
LCOV = ("lcov", None)
_report_name: str
def __new__(cls, value: str, report_name: str | None = None) -> CoverageReportType:
member: CoverageReportType = object.__new__(cls)
member._value_ = value
member._report_name = report_name if report_name is not None else value
return member
@property
def report_name(self) -> str:
return self._report_name
@property
def value(self) -> str:
return cast(str, super().value)
class CoverageSubsystem(PythonToolBase):
options_scope = "coverage-py"
help = "Configuration for Python test coverage measurement."
default_main = ConsoleScript("coverage")
default_requirements = ["coverage[toml]>=6.5,<8"]
register_interpreter_constraints = True
default_lockfile_resource = ("pants.backend.python.subsystems", "coverage_py.lock")
filter = StrListOption(
help=softwrap(
"""
A list of Python modules or filesystem paths to use in the coverage report, e.g.
`['helloworld_test', 'helloworld/util/dirutil']`.
Both modules and directory paths are recursive: any submodules or child paths,
respectively, will be included.
If you leave this off, the coverage report will include every file
in the transitive closure of the address/file arguments; for example, `test ::`
will include every Python file in your project, whereas
`test project/app_test.py` will include `app_test.py` and any of its transitive
dependencies.
"""
),
)
report = EnumListOption(
default=[CoverageReportType.CONSOLE],
help="Which coverage report type(s) to emit.",
)
_output_dir = StrOption(
default=str(PurePath("{distdir}", "coverage", "python")),
advanced=True,
help="Path to write the Pytest Coverage report to. Must be relative to the build root.",
)
config = FileOption(
default=None,
advanced=True,
help=lambda cls: softwrap(
f"""
Path to an INI or TOML config file understood by coverage.py
(https://coverage.readthedocs.io/en/stable/config.html).
Setting this option will disable `[{cls.options_scope}].config_discovery`. Use
this option if the config is located in a non-standard location.
"""
),
)
config_discovery = BoolOption(
default=True,
advanced=True,
help=lambda cls: softwrap(
f"""
If true, Pants will include any relevant config files during runs
(`.coveragerc`, `setup.cfg`, `tox.ini`, and `pyproject.toml`).
Use `[{cls.options_scope}].config` instead if your config is in a
non-standard location.
"""
),
)
global_report = BoolOption(
default=False,
help=softwrap(
"""
If true, Pants will generate a global coverage report.
The global report will include all Python source files in the workspace and not just
those depended on by the tests that were run.
"""
),
)
fail_under = FloatOption(
default=None,
help=softwrap(
"""
Fail if the total combined coverage percentage for all tests is less than this
number.
Use this instead of setting `fail_under` in a coverage.py config file,
as the config will apply to each test separately, while you typically want this
to apply to the combined coverage for all tests run.
Note that you must generate at least one (non-raw) coverage report for this
check to trigger.
Note also that if you specify a non-integral value, you must
also set `[report] precision` properly in the coverage.py config file to make use
of the decimal places. See https://coverage.readthedocs.io/en/latest/config.html.
"""
),
)
def output_dir(self, distdir: DistDir) -> PurePath:
return PurePath(self._output_dir.format(distdir=distdir.relpath))
@property
def config_request(self) -> ConfigFilesRequest:
# Refer to https://coverage.readthedocs.io/en/stable/config.html.
return ConfigFilesRequest(
specified=self.config,
specified_option_name=f"[{self.options_scope}].config",
discovery=self.config_discovery,
check_existence=[".coveragerc"],
check_content={
"setup.cfg": b"[coverage:",
"tox.ini": b"[coverage:]",
"pyproject.toml": b"[tool.coverage",
},
)
@dataclass(frozen=True)
class PytestCoverageData(CoverageData):
addresses: tuple[Address, ...]
digest: Digest
class PytestCoverageDataCollection(CoverageDataCollection[PytestCoverageData]):
element_type = PytestCoverageData
@dataclass(frozen=True)
class CoverageConfig:
digest: Digest
path: str
class InvalidCoverageConfigError(Exception):
pass
def _parse_toml_config(fc: FileContent) -> MutableMapping[str, Any]:
try:
return toml.loads(fc.content.decode())
except toml.TomlDecodeError as exc:
raise InvalidCoverageConfigError(
softwrap(
f"""
Failed to parse the coverage.py config `{fc.path}` as TOML. Please either fix
the config or update `[coverage-py].config` and/or
`[coverage-py].config_discovery`.
Parse error: {repr(exc)}
"""
)
)
def _parse_ini_config(fc: FileContent) -> configparser.ConfigParser:
cp = configparser.ConfigParser()
try:
cp.read_string(fc.content.decode())
return cp
except configparser.Error as exc:
raise InvalidCoverageConfigError(
softwrap(
f"""
Failed to parse the coverage.py config `{fc.path}` as INI. Please either fix
the config or update `[coverage-py].config` and/or `[coverage-py].config_discovery`.
Parse error: {repr(exc)}
"""
)
)
def _update_config(fc: FileContent) -> FileContent:
if PurePath(fc.path).suffix == ".toml":
all_config = _parse_toml_config(fc)
tool = all_config.setdefault("tool", {})
coverage = tool.setdefault("coverage", {})
run = coverage.setdefault("run", {})
run["relative_files"] = True
if "pytest.pex/*" not in run.get("omit", []):
run["omit"] = [*run.get("omit", []), "pytest.pex/*"]
return FileContent(fc.path, toml.dumps(all_config).encode())
cp = _parse_ini_config(fc)
run_section = "coverage:run" if fc.path in ("tox.ini", "setup.cfg") else "run"
if not cp.has_section(run_section):
cp.add_section(run_section)
cp.set(run_section, "relative_files", "True")
omit_elements = cp[run_section].get("omit", "").split("\n") or ["\n"]
if "pytest.pex/*" not in omit_elements:
omit_elements.append("pytest.pex/*")
cp.set(run_section, "omit", "\n".join(omit_elements))
stream = StringIO()
cp.write(stream)
return FileContent(fc.path, stream.getvalue().encode())
def get_branch_value_from_config(fc: FileContent) -> bool:
# Note that coverage's default value for the branch setting is False, which we mirror here.
if PurePath(fc.path).suffix == ".toml":
all_config = _parse_toml_config(fc)
return bool(
all_config.get("tool", {}).get("coverage", {}).get("run", {}).get("branch", False)
)
cp = _parse_ini_config(fc)
run_section = "coverage:run" if fc.path in ("tox.ini", "setup.cfg") else "run"
if not cp.has_section(run_section):
return False
return cp.getboolean(run_section, "branch", fallback=False)
@rule
async def create_or_update_coverage_config(coverage: CoverageSubsystem) -> CoverageConfig:
config_files = await Get(ConfigFiles, ConfigFilesRequest, coverage.config_request)
if config_files.snapshot.files:
digest_contents = await Get(DigestContents, Digest, config_files.snapshot.digest)
file_content = _update_config(digest_contents[0])
else:
cp = configparser.ConfigParser()
cp.add_section("run")
cp.set("run", "relative_files", "True")
cp.set("run", "omit", "\npytest.pex/*")
stream = StringIO()
cp.write(stream)
# We know that .coveragerc doesn't exist, so it's fine to create one.
file_content = FileContent(".coveragerc", stream.getvalue().encode())
digest = await Get(Digest, CreateDigest([file_content]))
return CoverageConfig(digest, file_content.path)
@dataclass(frozen=True)
class CoverageSetup:
pex: VenvPex
@rule
async def setup_coverage(coverage: CoverageSubsystem) -> CoverageSetup:
pex = await Get(VenvPex, PexRequest, coverage.to_pex_request())
return CoverageSetup(pex)
@dataclass(frozen=True)
class MergedCoverageData:
coverage_data: Digest
addresses: tuple[Address, ...]
@rule(desc="Merge Pytest coverage data", level=LogLevel.DEBUG)
async def merge_coverage_data(
data_collection: PytestCoverageDataCollection,
coverage_setup: CoverageSetup,
coverage_config: CoverageConfig,
coverage: CoverageSubsystem,
source_roots: AllSourceRoots,
) -> MergedCoverageData:
if len(data_collection) == 1 and not coverage.global_report:
coverage_data = data_collection[0]
return MergedCoverageData(coverage_data.digest, coverage_data.addresses)
coverage_digest_gets = []
coverage_data_file_paths = []
addresses: list[Address] = []
for data in data_collection:
path_prefix = data.addresses[0].path_safe_spec
if len(data.addresses) > 1:
path_prefix = f"{path_prefix}+{len(data.addresses)-1}-others"
# We prefix each .coverage file with its corresponding address to avoid collisions.
coverage_digest_gets.append(Get(Digest, AddPrefix(data.digest, prefix=path_prefix)))
coverage_data_file_paths.append(f"{path_prefix}/.coverage")
addresses.extend(data.addresses)
if coverage.global_report:
# It's important to set the `branch` value in the empty base report to the value it will
# have when running on real inputs, so that the reports are of the same type, and can be
# merged successfully. Otherwise we may get "Can't combine arc data with line data" errors.
# See https://github.com/pantsbuild/pants/issues/14542 .
config_contents = await Get(DigestContents, Digest, coverage_config.digest)
branch = get_branch_value_from_config(config_contents[0]) if config_contents else False
global_coverage_base_dir = PurePath("__global_coverage__")
global_coverage_config_path = global_coverage_base_dir / "pyproject.toml"
global_coverage_config_content = toml.dumps(
{
"tool": {
"coverage": {
"run": {
"relative_files": True,
"source": [source_root.path for source_root in source_roots],
"branch": branch,
}
}
}
}
).encode()
no_op_exe_py_path = global_coverage_base_dir / "no-op-exe.py"
all_sources_digest, no_op_exe_py_digest, global_coverage_config_digest = await MultiGet(
Get(
Digest,
PathGlobs(globs=[f"{source_root.path}/**/*.py" for source_root in source_roots]),
),
Get(Digest, CreateDigest([FileContent(path=str(no_op_exe_py_path), content=b"")])),
Get(
Digest,
CreateDigest(
[
FileContent(
path=str(global_coverage_config_path),
content=global_coverage_config_content,
),
]
),
),
)
extra_sources_digest = await Get(
Digest, MergeDigests((all_sources_digest, no_op_exe_py_digest))
)
input_digest = await Get(
Digest, MergeDigests((extra_sources_digest, global_coverage_config_digest))
)
result = await Get(
ProcessResult,
VenvPexProcess(
coverage_setup.pex,
argv=("run", "--rcfile", str(global_coverage_config_path), str(no_op_exe_py_path)),
input_digest=input_digest,
output_files=(".coverage",),
description="Create base global Pytest coverage report.",
level=LogLevel.DEBUG,
),
)
coverage_digest_gets.append(
Get(
Digest, AddPrefix(digest=result.output_digest, prefix=str(global_coverage_base_dir))
)
)
coverage_data_file_paths.append(str(global_coverage_base_dir / ".coverage"))
else:
extra_sources_digest = EMPTY_DIGEST
input_digest = await Get(Digest, MergeDigests(await MultiGet(coverage_digest_gets)))
result = await Get(
ProcessResult,
VenvPexProcess(
coverage_setup.pex,
# We tell combine to keep the original input files, to aid debugging in the sandbox.
argv=("combine", "--keep", *sorted(coverage_data_file_paths)),
input_digest=input_digest,
output_files=(".coverage",),
description=f"Merge {len(coverage_data_file_paths)} Pytest coverage reports.",
level=LogLevel.DEBUG,
),
)
return MergedCoverageData(
await Get(Digest, MergeDigests((result.output_digest, extra_sources_digest))),
tuple(addresses),
)
@rule(desc="Generate Pytest coverage reports", level=LogLevel.DEBUG)
async def generate_coverage_reports(
merged_coverage_data: MergedCoverageData,
coverage_setup: CoverageSetup,
coverage_config: CoverageConfig,
coverage_subsystem: CoverageSubsystem,
keep_sandboxes: KeepSandboxes,
distdir: DistDir,
) -> CoverageReports:
"""Takes all Python test results and generates a single coverage report."""
transitive_targets = await Get(
TransitiveTargets, TransitiveTargetsRequest(merged_coverage_data.addresses)
)
sources = await Get(
PythonSourceFiles,
# Coverage sometimes includes non-Python files in its `.coverage` data. We need to
# ensure that they're present when generating the report. We include all the files included
# by `pytest_runner.py`.
PythonSourceFilesRequest(
transitive_targets.closure, include_files=True, include_resources=True
),
)
input_digest = await Get(
Digest,
MergeDigests(
(
merged_coverage_data.coverage_data,
coverage_config.digest,
sources.source_files.snapshot.digest,
)
),
)
pex_processes = []
report_types = []
result_snapshot = await Get(Snapshot, Digest, merged_coverage_data.coverage_data)
coverage_reports: list[CoverageReport] = []
output_dir: PurePath = coverage_subsystem.output_dir(distdir)
for report_type in coverage_subsystem.report:
if report_type == CoverageReportType.RAW:
coverage_reports.append(
FilesystemCoverageReport(
# We don't know yet if the coverage is sufficient, so we let some other report
# trigger the failure if necessary.
coverage_insufficient=False,
report_type=CoverageReportType.RAW.value,
result_snapshot=result_snapshot,
directory_to_materialize_to=output_dir,
report_file=output_dir / ".coverage",
)
)
continue
report_types.append(report_type)
output_file = (
f"coverage.{report_type.value}"
if report_type
in {CoverageReportType.XML, CoverageReportType.JSON, CoverageReportType.LCOV}
else None
)
args = [report_type.report_name, f"--rcfile={coverage_config.path}"]
if coverage_subsystem.fail_under is not None:
args.append(f"--fail-under={coverage_subsystem.fail_under}")
pex_processes.append(
VenvPexProcess(
coverage_setup.pex,
argv=tuple(args),
input_digest=input_digest,
output_directories=("htmlcov",) if report_type == CoverageReportType.HTML else None,
output_files=(output_file,) if output_file else None,
description=f"Generate Pytest {report_type.report_name} coverage report.",
level=LogLevel.DEBUG,
)
)
results = await MultiGet(
Get(FallibleProcessResult, VenvPexProcess, process) for process in pex_processes
)
for proc, res in zip(pex_processes, results):
if res.exit_code not in {0, 2}:
# coverage.py uses exit code 2 if --fail-under triggers, in which case the
# reports are still generated.
raise ProcessExecutionFailure(
res.exit_code,
res.stdout,
res.stderr,
proc.description,
keep_sandboxes=keep_sandboxes,
)
# In practice if one result triggers --fail-under, they all will, but no need to rely on that.
result_exit_codes = tuple(res.exit_code for res in results)
result_stdouts = tuple(res.stdout for res in results)
result_snapshots = await MultiGet(Get(Snapshot, Digest, res.output_digest) for res in results)
coverage_reports.extend(
_get_coverage_report(output_dir, report_type, exit_code != 0, stdout, snapshot)
for (report_type, exit_code, stdout, snapshot) in zip(
report_types, result_exit_codes, result_stdouts, result_snapshots
)
)
return CoverageReports(tuple(coverage_reports))
def _get_coverage_report(
output_dir: PurePath,
report_type: CoverageReportType,
coverage_insufficient: bool,
result_stdout: bytes,
result_snapshot: Snapshot,
) -> CoverageReport:
if report_type == CoverageReportType.CONSOLE:
return ConsoleCoverageReport(coverage_insufficient, result_stdout.decode())
try:
report_file = {
CoverageReportType.HTML: output_dir / "htmlcov" / "index.html",
CoverageReportType.XML: output_dir / "coverage.xml",
CoverageReportType.JSON: output_dir / "coverage.json",
CoverageReportType.LCOV: output_dir / "coverage.lcov",
}[report_type]
except KeyError:
raise ValueError(f"Invalid coverage report type: {report_type}") from None
return FilesystemCoverageReport(
coverage_insufficient=coverage_insufficient,
report_type=report_type.value,
result_snapshot=result_snapshot,
directory_to_materialize_to=output_dir,
report_file=report_file,
)
def rules():
return [
*collect_rules(),
UnionRule(CoverageDataCollection, PytestCoverageDataCollection),
]
|
from django.shortcuts import render,redirect
import math
from . import Imap_utility
import os
from . import Pickle_util
from . import indiutil
from django.contrib import messages
def other(request,foldername,page_num):
print('hey',page_num)
IMP = 'INBOX All Mail'
try:
pkl=Pickle_util.PickleData('userinfo.pkl')
d = pkl.depickle()
user=d['user']
pas=d['pas']
host=d['host']
client = Imap_utility.CustomMailBox(user,pas,host,folder=foldername)
fname=None
rename=None
cur= client.get_cur()
Info = client.get_info(cur)
F= client.get_folders()
cur = [cur,cur.split('/')[-1]]
Folders = []
if request.method=="GET":
fname = request.GET.get('folder-name')
rename = request.GET.get('new-name')
if fname:
stat = client.create_folder(fname)
if stat=='no':
messages.warning(request,f"specified folder {fname} already exists!")
else:
messages.success(request,f"{fname} has been created successfully!")
if rename:
ok=True
for f in F:
if rename == f['name'].split('/')[-1]:
ok=False
messages.warning(request,'Folder already exists!')
break
if ok:
cur = [rename,rename.split('/')[-1]]
client.rename_folder(rename)
messages.success(request,'updated successfully!')
if request.method=="POST":
delete = request.POST.get('delete')
print('delte to be fone',delete)
if cur[1] not in IMP:
client.delete_folder(cur[0])
messages.success(request,f'{cur[1]} has been deleted successfully!')
return redirect('pagenated',foldername='INBOX',page_num=1)
messages.warning(request,'You cannot delete this folder!')
except:
messages.info(request,'Please login!')
print('redirectiong to login')
return redirect('login')
for f in F:
if '\\Noselect' in f['flags']:
continue
if f['name']!=cur[0]:
Folders.append([f['name'],f['name'].split('/')[-1]])
now,last = client.getbypagenum(page_num,'')
context = {'msgs':now,'D':list(Info.items()),'last':last,'pn':page_num,'prev':max(page_num-1,1),'nxt':min(page_num+1,last),
'folders':Folders,'cur':cur,'type_name': 'Folder'}
return render(request,'MailBoX/dumb.html',context)
def loginview(request):
if request.method=='POST':
user = request.POST.get('email')
pas = request.POST.get('password')
host = request.POST.get('host')
if not (host):
host='imap.gmail.com'
mb = Imap_utility.CustomMailBox(user,pas,host)
if mb.authuser():
d = {'user':user,'pas':pas,'host':host}
pkl = Pickle_util.PickleData('userinfo.pkl')
pkl.dump_object(d)
messages.success(request,'HELLO User')
return redirect('pagenated',page_num=1,foldername='INBOX')
else:
messages.info(request,'please enter valid credentials!')
messages.warning(request,'Please make sure that you\'ve enabled imap')
return render(request,'MailBox/login.html')
def logoutview(request):
messages.info(request,'you\'ve been logged out!')
os.remove('userinfo.pkl')
return redirect('login')
def pageview(request,foldername,uid):
try:
pkl=Pickle_util.PickleData('userinfo.pkl')
d = pkl.depickle()
user=d['user']
pas=d['pas']
host=d['host']
client = Imap_utility.CustomMailBox(user,pas,host,folder=foldername)
Mailobj = next(client.getbyuid(uid))
cur= client.get_cur()
cur = [cur,cur.split('/')[-1]]
if request.method=="POST":
delete = request.POST.get('delete')
move = request.POST.get('fname')
cpfolder = request.POST.get('copyfname')
if delete:
client.delete_msg(Mailobj.uid)
messages.success(request,'Message has been deleted successfully!')
return redirect('pagenated',page_num=1,foldername=foldername)
if move:
client.move_msgto(move,Mailobj.uid)
messages.success(request,'1 message has been moved !')
return redirect('pagenated',page_num=1,foldername=foldername)
if cpfolder:
client.copy_msgto(cpfolder,Mailobj.uid)
messages.success(request,'1 message has been copied !')
return redirect('pagenated',page_num=1,foldername=foldername)
except:
messages.info(request,'Please login!')
return redirect('login')
statpath = os.path.join('MailBoX','static','MailBoX')
for f in os.listdir(statpath):
os.remove(os.path.join(statpath,f))
attach_names = []
for att in Mailobj.attachments:
with open(os.path.join(statpath,att.filename),'wb') as f:
attach_names.append(att.filename)
f.write(att.payload)
top,bottom,card = indiutil.get_patches(foldername,Mailobj.subject,Mailobj.html,attach_names,len(attach_names))
with open('MailBox/templates/MailBoX/pageview.html','wb') as f:
f.write(top)
f.write(card)
f.write(bottom)
F= client.get_folders()
Folders = []
for f in F:
if '\\Noselect' in f['flags']:
continue
if f['name']!=cur[0]:
Folders.append([f['name'],f['name'].split('/')[-1]])
context = {'D':Mailobj.from_values.items(),'type_name': 'Message','folders':Folders}
return render(request,'MailBox/pageview.html',context)
def subjectview(self,foldername,subject,page_num):
pass
|
#!/usr/bin/python3
## This is simple Python 3 application.
## It generates a random ascii string and inserts it into table in PostgreSQL DB.
# Import required modules.
# 'psycopg2' is used to mainain interaction with PostgreSQL DB.
import psycopg2
# 'time' is used to control execution flow.
import time
# 'random' and 'string' modules are used to generate random strings.
import random
import string
# Declare a function, that returns random string.
def rstring():
return ''.join(random.choices(string.ascii_letters + string.digits, k=16))
# Create 'cn' object - a connection to database.
cn = psycopg2.connect("dbname='sample_db' user='sample' host='postgres' port=5432 password='sample'")
# Create 'cr' object - cursor to interact with database.
cr = cn.cursor()
# Simple infinite loop, that inserts randomly generated string into database.
while True:
cr.execute(f"INSERT INTO t1(c) VALUES('{rstring()}')")
# Using 'time.sleep' method to pause for 1 second between queries.
time.sleep(1)
# Commit changes made to database after each insertion.
cn.commit()
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11.4 on 2017-11-20 22:49
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('eleicao', '0006_auto_20171120_1948'),
]
operations = [
migrations.AlterField(
model_name='eleitor',
name='cpf',
field=models.CharField(max_length=14),
),
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.