def test_limpiar_mensaje_debe_eliminar_letras_iguales_consecutivas(self):
pObj = Processor()
responseTrue = pObj.limpiar_mensaje("holaaaaa")
responseFalse = pObj.limpiar_mensaje("holaaaaasss")
self.assertEqual("hola", responseTrue)
self.assertNotEqual("hola", responseFalse)
def system_init():
processor_temp = Processor()
resource_temp = Resource()
processor_temp.create_process('init', 0)
for x in processor_temp.get_running_list():
print(x + " ", end='')
return processor_temp, resource_temp
def process(transaction):
"""Dropbox entry point.
@param transaction, the transaction object
"""
# Get path to containing folder
# __file__ does not work (reliably) in Jython
dbPath = "../core-plugins/microscopy/2/dss/drop-boxes/MicroscopyDropbox"
# Path to the logs subfolder
logPath = os.path.join(dbPath, "logs")
# Make sure the logs subfolder exist
if not os.path.exists(logPath):
os.makedirs(logPath)
# Path for the log file
logFile = os.path.join(logPath, "log.txt")
# Set up logging
logging.basicConfig(filename=logFile, level=logging.DEBUG,
format='%(asctime)-15s %(levelname)s: %(message)s')
logger = logging.getLogger("Microscopy")
# Create a Processor
processor = Processor(transaction, logger)
# Run
processor.run()
def __init_models(self):
for file in os.listdir(self.models_folder):
if file.endswith(".json"):
processor = Processor(sliding_window_frame_size=20,
stddev_threshold=0.1,
risk_iterations=5,
minimum_training_size=900,
starting_eval_size=5,
save_trained_model=True,
save_path='./')
processor.load_processor(self.models_folder + '/' + file, [{
'Learner':
AutoEncoderNNWeakLearner(cols_shape=24),
'Extractor':
DataReaderExtractor(),
'Stream':
DataReaderStream(
data_folder='C:/Users/ofiri/Desktop/Tests/B/test'),
'Sanitizer':
None
}, {
'Learner':
AutoEncoderNNWeakLearner(cols_shape=6),
'Extractor':
DataReaderExtractor(),
'Stream':
DataReaderStream(
data_folder='C:/Users/ofiri/Desktop/Tests/A/test'),
'Sanitizer':
None
}])
self.processes.append(processor)
def main():
clientGenerator = Generator(UniformDistribution(8, 12))
firstQueue = []
secondQueue = []
operators = [
Operator(firstQueue, UniformDistribution(15, 25)),
Operator(firstQueue, UniformDistribution(30, 50)),
Operator(secondQueue, UniformDistribution(20, 60))
]
processors = [
Processor(firstQueue, UniformDistribution(15, 15)),
Processor(secondQueue, UniformDistribution(30, 30))
]
totalRequests = 3000
tStart = time()
res = modeling(clientGenerator, operators, processors, totalRequests)
print('time (secs)', time() - tStart)
for key in res.keys():
print(key, res[key])
print('lost', res['lost'] / totalRequests)
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
# img = cv2.imread('inputs/{}'.format(args['image']))
input_image_paths = []
folder_path = args['image']
if os.path.isdir(folder_path):
ls = os.listdir(folder_path)
for file_name in sorted(ls, key=lambda x: str(x.split('.jpg')[0])):
input_image_paths.append(os.path.join(folder_path, file_name))
for input_image_path in input_image_paths:
img = cv2.imread(input_image_path)
# inference
output = processor.detect(img)
# final results
boxes, confs, classes = processor.post_process(output, conf_thres=0.3, iou_thres=0.4, origin_w=img.shape[1], origin_h=img.shape[0])
visualizer.draw_results(img, boxes, confs, classes)
def main():
client_generator = Generator(EvenDistribution(8, 12))
first_queue = []
second_queue = []
operators = [
Operator(first_queue, EvenDistribution(15,
25)), # самый производительный
Operator(first_queue, EvenDistribution(30, 50)),
Operator(second_queue,
EvenDistribution(20, 60)) # наименее производительный
]
processors = [
Processor(first_queue, EvenDistribution(15, 15)), # ровно 15 минут
Processor(second_queue, EvenDistribution(30, 30)) # ровно 30 минут
]
total_requests = 300
t_start = time()
res = modeling(client_generator, operators, processors, total_requests)
print('time seconds', time() - t_start)
for key in res.keys():
print(key, res[key])
print('lost', res['lost'] / total_requests)
def produceCode(filename,out):
try:
processor=Processor(filename)
msg=processor.getCode(out)
return 0, msg
except SemanticException, se:
return 1, se.msg
def process(transaction):
"""Dropbox entry point.
@param transaction, the transaction object
"""
# Get path to containing folder
# __file__ does not work (reliably) in Jython
dbPath = "../core-plugins/microscopy/4/dss/drop-boxes/MicroscopyDropbox"
# Path to the logs subfolder
logPath = os.path.join(dbPath, "logs")
# Make sure the logs subfolder exist
if not os.path.exists(logPath):
os.makedirs(logPath)
# Path for the log file
logFile = os.path.join(logPath, "log.txt")
# Set up logging
logging.basicConfig(filename=logFile,
level=logging.DEBUG,
format='%(asctime)-15s %(levelname)s: %(message)s')
logger = logging.getLogger("Microscopy")
# Create a Processor
processor = Processor(transaction, logger)
# Run
processor.run()
def train():
repsCount.configure(state=DISABLED)
setButtsDisabled()
progTrainLabel["text"] = 'Filtrujem signál...'
trainProgress["value"] = 0
global pr,trainedData
trainLetter = []
trainWords = open(trainLetters).readlines()
#nacitanie trenovacich a cielovych znakov do pola
for i in range(len(trainWords)):
tmp = map(int, trainWords[i].rstrip().split(','))
trainLetter.append(tmp)
trainProgress["maximum"] = len(sum(trainLetter[:len(trainDataFiles)],[])) - 1
pr = Processor(trainDataFiles,chanNum)
# postupne spracuj trenovaciu cast datasetu
pr.trainClassifier(trainLetter,trainProgress,progTrainLabel,int(repsCount.get()))
progTrainLabel["text"] = 'Trénovanie dokončené.'
repsCount.configure(state=NORMAL)
setButtsNormal()
trainedData = 1
print "Training completed"
def __init__(self, main_cfg):
# self.ns_reader = NSDataReader()
self.ns_reader = NSDataReaderRandom()
self.is_online = main_cfg.is_online
self.cue = CueInterface(main_cfg)
# self.cue = VRInterface(main_cfg)
self.stim = Stimulator(main_cfg.stim_cfg)
self.save_data_path = main_cfg.subject.get_date_dir()
self.filename = 'online' if main_cfg.is_online else 'acquire'
self.stim_cfg = main_cfg.stim_cfg
self.stim.subscribe(BCIEvent.change_stim, self.cue.handle_stim)
self.stim.subscribe(BCIEvent.change_stim, main_cfg.exo.handle_stim)
self.cue.subscribe(BCIEvent.gaze_focus, self.stim.get_gaze)
self.cue.subscribe(BCIEvent.cue_disconnect, self.stim.stop_stim)
self.stim.subscribe(BCIEvent.save_data, self.save_data)
if self.is_online:
self.processor = Processor(main_cfg)
self.processor.subscribe(BCIEvent.readns_header,
self.ns_reader.get_head_settings)
self.processor.subscribe(BCIEvent.readns,
self.ns_reader.get_ns_signal)
self.stim.subscribe(BCIEvent.change_stim,
self.processor.handle_stim)
self.processor.subscribe(BCIEvent.online_progressbar,
self.cue.send_progress)
self.processor.subscribe(BCIEvent.online_ctrl,
self.cue.online_feedback)
self.processor.subscribe(BCIEvent.online_ctrl,
main_cfg.exo.online_feedback)
self.stim.subscribe(BCIEvent.save_data, self.processor.save_log)
def proc(self, config: dict, record_dir: str, danmu_path: str,
current_state, state_change_time) -> None:
p = Processor(config, record_dir, danmu_path)
p.run()
if config.get('spec', {}).get('uploader', {}).get('record', {}).get(
'upload_record', False) or config.get('spec', {}).get(
'uploader', {}).get('clips', {}).get(
'upload_clips', False):
current_state.value = int(utils.state.UPLOADING_TO_BILIBILI)
state_change_time.value = time.time()
try:
u = Uploader(p.outputs_dir, p.splits_dir, config)
d = u.upload(p.global_start)
except Exception as e:
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
if d is None:
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
else:
if not config.get('spec', {}).get('uploader', {}).get(
'record',
{}).get('keep_record_after_upload', True) and d.get(
"record",
None) is not None and not config.get('root', {}).get(
'uploader', {}).get('upload_by_edit', False):
rc = BiliVideoChecker(d['record']['bvid'], p.splits_dir,
config)
rc.start()
if not config.get('spec', {}).get('uploader', {}).get(
'clips',
{}).get('keep_clips_after_upload', True) and d.get(
"clips",
None) is not None and not config.get('root', {}).get(
'uploader', {}).get('upload_by_edit', False):
cc = BiliVideoChecker(d['clips']['bvid'], p.outputs_dir,
config)
cc.start()
if config.get('root', {}).get('enable_baiduyun', False) and config.get(
'spec', {}).get('backup', False):
current_state.value = int(utils.state.UPLOADING_TO_BAIDUYUN)
state_change_time.value = time.time()
try:
from bypy import ByPy
bp = ByPy()
bp.upload(p.merged_file_path)
except Exception as e:
logging.error('Error when uploading to Baiduyun:' + str(e) +
traceback.format_exc())
current_state.value = int(utils.state.ERROR)
state_change_time.value = time.time()
return
if current_state.value != int(utils.state.LIVE_STARTED):
current_state.value = int(utils.state.WAITING_FOR_LIVE_START)
state_change_time.value = time.time()
def get_processor(f):
processor = Processor(int(f.readline()))
while True:
line = f.readline().split()
if len(line) == 0:
break
processor.insert_processor_mode(*map(float, line))
return processor
def test_letras_repetidas_verifica_si_el_texto_tienen_letras_consecutivas_repetidas(
self, ):
pObj = Processor()
response1 = pObj.letras_consecutivas_repetidas("holaaaaa")
response2 = pObj.letras_consecutivas_repetidas("hola")
self.assertTrue(response1)
self.assertFalse(response2)
def test_generar_mensaje_corectamente(self, ):
P_Obj = Processor()
response = P_Obj.generar_mensaje([
"11 14 38",
"CeseAlFuego",
"CoranACubierto",
"XXcaaamakkCCessseAAllFueeegooDLLKmmNNN",
])
self.assertEqual("Si\nNo", response)
def __init__(self, samp_T_us, cpi_samps, savefile, emulate=False):
"""
PURPOSE: creates a new Speed_Gun
ARGS:
samp_T_us (float): sampling period in microseconds
cpi_samps (int): number of samples in one cpi
emulate (bool): if True loads pre-recorded data, if False runs for
real
savefile (str): the file to save to
RETURNS: new instance of a Speed_Gun
NOTES:
"""
#Save arguments
self.samp_T_us = samp_T_us
self.fs = 1e6 / samp_T_us
self.cpi_samps = cpi_samps
self.emulate = emulate
self.savefile = savefile
#Setup app
self.app = QtWidgets.QApplication(sys.argv)
self.main_win = QtWidgets.QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.main_win)
#Initialize UI values
self.init_ui_values()
#Connect buttons
self.ui.run_button.clicked.connect(self.run_button_clicked)
self.ui.stop_button.clicked.connect(self.stop_button_clicked)
self.ui.vel_radbutton.toggled.connect(self.rad_button_toggled)
self.ui.raw_sig_radbutton.toggled.connect(self.rad_button_toggled)
#Setup queues
self.record_q = queue.Queue()
self.res_q = queue.Queue()
self.save_q = queue.Queue()
#Setup other modules
#Setup recorder.replayer
if emulate:
self.recorder = Replayer("C:\\Users\\rga0230\\Documents\\School\\EE-137\\EE-137-Doppler-Radar\\data\\car.mat", [self.record_q, self.save_q], ts_us=samp_T_us, chunk_size=cpi_samps)
else:
self.recorder = Chunked_Arduino_ADC(samp_T_us, cpi_samps, [self.record_q, self.save_q])
#Setup processor
self.proc = Processor(samp_T_us, cpi_samps, self.record_q, self.res_q)
#Setup saver
self.saver = Chunk_Saver(savefile, samp_T_us, cpi_samps, self.save_q)
#Setup variables for our update thread
self.update_thread = threading.Thread(target = self.update_thread_run)
self.update_keep_going = threading.Event()
self.update_keep_going.set()
def __init__(self, numOfLayer):
self.num = numOfLayer
self.parent = []
self.children = []
self.handled = []
self.Indexer = Indexer()
self.Processor = Processor()
self.Porter = PorterStemmer()
self.db = []
link = "http://www.cse.ust.hk/"
self.parent.append(link)
def test_single_instr(self):
prog = "I ADDI R1 R1 8"
memory = Memory()
memory.loadProgramDebugFromText(prog)
processor = Processor(memory, 0)
disablePrint()
processor.start()
enablePrint()
cpi = processor.getCPI()
r1_content = processor.register_file[1]
self.assertEqual(cpi, 5)
self.assertEqual(r1_content, 8)
def test_single_instr (self):
prog = "I ADDI R1 R1 8"
memory = Memory ()
memory.loadProgramDebugFromText (prog)
processor = Processor (memory, 0)
disablePrint ()
processor.start ()
enablePrint ()
cpi = processor.getCPI ()
r1_content = processor.register_file [1]
self.assertEqual (cpi, 5)
self.assertEqual (r1_content, 8)
def __init__(self, input=None, output=None, modules=None):
pp = Processor()
map(str.lower, modules)
for name in modules:
if Modules.modules.has_key(name):
module = Modules.modules[name]()
pp.register(module)
pp.input(input)
pp.process()
pp.output(output)
def test_independant_instrs_dummy (self):
prog = """I ADDI R1 R1 1
R ADD R3 R3 R2
"""
memory = Memory ()
memory.loadProgramDebugFromText (prog)
processor = Processor (memory, 0)
disablePrint ()
processor.start ()
enablePrint ()
cpi = processor.getCPI ()
# CPI should be 3 as there is no stall
# For the second instruction.
self.assertEqual (cpi, 3)
def test_independant_instrs_dummy(self):
prog = """I ADDI R1 R1 1
R ADD R3 R3 R2
"""
memory = Memory()
memory.loadProgramDebugFromText(prog)
processor = Processor(memory, 0)
disablePrint()
processor.start()
enablePrint()
cpi = processor.getCPI()
# CPI should be 3 as there is no stall
# For the second instruction.
self.assertEqual(cpi, 3)
def process(transaction):
"""Dropbox entry point.
@param transaction, the transaction object
"""
#
# Run registration
#
prefix = "LSR_FORTESSA"
version = 2
logDir = "../core-plugins/flow/4/dss/drop-boxes/BDLSRFortessaDropbox/logs"
processor = Processor(transaction, prefix, version, logDir)
processor.run()
def process(transaction):
"""Dropbox entry point.
@param transaction, the transaction object
"""
#
# Run registration
#
prefix = "INFLUX"
version = 2
logDir = "../core-plugins/flow/3/dss/drop-boxes/BDInfluxDropbox/logs"
processor = Processor(transaction, prefix, version, logDir)
processor.run()
def process(transaction):
"""Dropbox entry point.
@param transaction, the transaction object
"""
#
# Run registration
#
prefix = "MOFLO_XDP"
version = 2
logDir = "../core-plugins/flow/4/dss/drop-boxes/BCMoFloXDPDropbox/logs"
processor = Processor(transaction, prefix, version, logDir)
processor.run()
def add_processor(self, id, output_dist):
"""
Método de clase
Se agrega un procesador con un identificador y distribución de salidad, señalada por parámetros
"""
processor = Processor(id, output_dist)
self._processors_list.append(processor)
def run_tests():
global test_result
TEST_ENV = {
'stopped': False,
'test': True,
'send': False,
}
TEST_ENV['sender'] = TestSender()
TEST_ENV['enumerator'] = Enumerator(TEST_ENV)
TEST_ENV['parser'] = Parser(TEST_ENV)
TEST_ENV['screener'] = Screener(TEST_ENV)
TEST_ENV['logger'] = open('/dev/null', 'w')
TEST_ENV['processor'] = processor = Processor(TEST_ENV)
num_failures = 0
for (rcpttos, expected) in tests:
test_result = {}
processor.process_message({
'peer': None,
'mailfrom': 'mailfrom',
'rcpttos': rcpttos,
'data': 'message',
})
print 'testing sending to', rcpttos, '...'
for key in expected:
assert key in test_result
if type(test_result[key]) == type([]):
assert set(test_result[key]) == set(expected[key])
else:
assert test_result[key] == expected[key]
for key in test_result:
assert key in expected
def train():
global pr
trainLetter = []
trainWords = open(trainLetters).readlines()
#nacitanie trenovacich a cielovych znakov do pola
for i in range(len(trainWords)):
tmp = map(int, trainWords[i].rstrip().split(','))
trainLetter.append(tmp)
pr = Processor(trainDataFiles,chanNum)
# postupne spracuj trenovaciu cast datasetu
pr.trainClassifier(trainLetter,repsCount)
trainedData = 1
print "Training completed"
def system_init():
processor_tmp = Processor()
resourcer_tmp = Resourcer()
#for x in processor_tmp.get_running_list():
# print(x + " ", end='')
return processor_tmp, resourcer_tmp
def __init__(self, input=None, output=None, modules=None): pp = Processor() map(str.lower, modules) for name in modules: if Modules.modules.has_key(name): module = Modules.modules[name]() pp.register(module) pp.input(input) pp.process() pp.output(output)
def main():
# parse arguments
args = cli()
# setup processor and visualizer
processor = Processor(model=args['model'])
visualizer = Visualizer()
# fetch input
print('image arg', args['image'])
img = cv2.imread('inputs/{}'.format(args['image']))
# inference
output = processor.detect(img)
img = cv2.resize(img, (640, 640))
# object visualization
object_grids = processor.extract_object_grids(output)
visualizer.draw_object_grid(img, object_grids, 0.1)
# class visualization
class_grids = processor.extract_class_grids(output)
visualizer.draw_class_grid(img, class_grids, 0.01)
# bounding box visualization
boxes = processor.extract_boxes(output)
visualizer.draw_boxes(img, boxes)
# final results
boxes, confs, classes = processor.post_process(output)
visualizer.draw_results(img, boxes, confs, classes)
def test_generar_mensaje_genera_un_exception_por_recibir_dos_mensajes_posibles(
self, ):
try:
PObj = Processor()
response = PObj.generar_mensaje([
"11 14 80",
"CeseAlFuego",
"CoranACubierto",
"XXcaaamakkCCessseAAllFueeegooCoranACuuubiiiertoooDLLKmmNNN",
])
except ValueError as e:
# print(e)
pass
else:
raise ValueError(
"==> test_generar_mensaje_genera_un_exception_por_recibir_dos_mensajes_posibles"
)
def test_validar_datos_instrucciones_genera_exception_cuando_en_linea_1_parametro_1_no_coincida_con_texto_linea_2(
self, ):
try:
PObj = Processor()
response = PObj.validar_datos([
"5 14 80",
"CeseAlFuego",
"CoranACubierto",
"XXcaaamakkCCessseAAllFueeegooCoranACuuubiiiertoooDLLKmmNNN",
])
except ValueError as e:
# print(e)
pass
else:
raise ValueError(
"==> test_validar_datos_instrucciones_genera_exception_cuando_en_linea_1_parametro_1_no_coincida_con_texto_linea_2"
)
def proc(config: dict, record_dir: str, danmu_path: str) -> None:
p = Processor(config, record_dir, danmu_path)
p.run()
u = Uploader(p.outputs_dir, p.splits_dir, config)
d = u.upload(p.global_start)
if not config['spec']['uploader']['record'][
'keep_record_after_upload'] and d.get("record", None) is not None:
rc = BiliVideoChecker(d['record']['bvid'], p.splits_dir, config)
rc_process = Process(target=rc.check)
rc_process.start()
if not config['spec']['uploader']['clips'][
'keep_clips_after_upload'] and d.get("clips", None) is not None:
cc = BiliVideoChecker(d['clips']['bvid'], p.outputs_dir, config)
cc_process = Process(target=cc.check)
cc_process.start()
if config['root']['enable_baiduyun'] and config['spec']['backup']:
from bypy import ByPy
bp = ByPy()
bp.upload(p.merged_file_path)
def subscribe(self):
self.stim.subscribe(BCIEvent.change_stim, self.interface.handle_stim)
# self.stim.subscribe(BCIEvent.change_stim, main_cfg.exo.handle_stim)
# self.interface.subscribe(BCIEvent.gaze_focus, self.stim.get_gaze)
self.stim.subscribe(BCIEvent.stim_stop, self.stop_and_save)
self.interface.subscribe(BCIEvent.MRsubmit, self.stim.MRsubmit)
self.interface.subscribe(BCIEvent.cue_disconnect, self.stim.stop_stim)
self.interface.subscribe(BCIEvent.cue_disconnect, self.stop)
if self.is_feedback:
self.processor = Processor(self.main_cfg)
self.processor.subscribe(BCIEvent.readns_header,
self.ns_reader.get_sample_rate)
self.processor.subscribe(BCIEvent.readns,
self.ns_reader.get_ns_signal)
self.stim.subscribe(BCIEvent.change_stim,
self.processor.handle_stim)
self.processor.subscribe(BCIEvent.online_bar,
self.interface.online_bar)
self.processor.subscribe(BCIEvent.online_face,
self.interface.online_face)
def main():
# 封装
input_path = './Resources/2018Q3.pdf'
agent = Processor()
analyse_result = agent.analyzer(input_path)
# title and paragraph
content_list = analyse_result.article_list_extract()
# functions
find_result = analyse_result.find_content([['c3'], ['c1'], ['p2']])
find_sentence_result = analyse_result.find_content([['c3'], ['c1'],
['p2s2']])
target_result_01 = analyse_result.next_paragraph(
step=1, paragraph=find_result[0][0])
target_result_02 = analyse_result.next_paragraph(step=1,
path=[['c3'], ['c1'],
['p2']])
structure_list = analyse_result.article_structure_extract()
return structure_list
def __init__(self, number, mainMemory, UIManager, connectionBus):
threading.Thread.__init__(self)
self.chip = number
self.mainMemory = mainMemory
self.procesors = []
self.UIManager = UIManager
for i in range(2):
self.procesors.append(Processor(i, self))
self.procesors[i].start()
self.L2 = L2(self)
self.connectionBus = connectionBus
# -*- coding: utf-8 -*-
# Ниже приведен пример использования класса Processor
from Processor import Processor
# Загрузка обучающей выборки
proc = Processor("data/Learning_sample.txt")
# Выполнение PCA
proc.perform_pca(n_components=4)
# Анализ PCA спектра
proc.plot_pca_spectrum()
# Сокращение размерности - переход в новое пространство признаков
proc.reduce_dimension()
# Кластеризация методом k-means
proc.fit_kmeans()
proc.show_labels()
# Построение проекции кластеров на плоскости
proc.plot_clusters()
# Вычисление расстояния между кластерами и внутрикластерного среднего
print("Рассояние между кластерами: %f" % proc.cluster_distance())
print("Внутрикластерное среднее: %f" % proc.intra_cluster_average())
# Прогноз по файлу Test_sample.txt
from numpy import loadtxt, savetxt, transpose
def main(inhost,inport, outport):
me = ProcessorWorker()
c = Processor()
c.run(inhost,inport,outport,me)
def __init__(self):
Processor.__init__(self)
import sys
from Processor import Processor
from PathWalker import PathWalker
arguments = sys.argv
processor = Processor()
pathWalker = PathWalker()
if arguments[0] == '--cluster':
dir = arguments[1]
clustersNum = arguments[2]
files = pathWalker.getFilesInPath(dir, '*.wav')
print processor.cluster(files, clustersNum)
elif arguments[0] == '--classify':
file = arguments[1]
print processor.classify(file)
else:
print 'Bad arguments'
import sys
from Processor import Processor
from FileIO import FileIO
if __name__ =='__main__':
inFileName = sys.argv[1]
outFileName = 'result_'+inFileName
if len(sys.argv)==3:
outFileName = sys.argv[2]
fileStream = FileIO(inFileName,outFileName)
processor= Processor()
DNA = fileStream.readFile(inFileName)
aminoSeq = processor.process(DNA)
fileStream.outFile(outFileName,aminoSeq)
def main(inhost,inport, outport, type):
me = ProcessorWorkerFilter(type)
c = Processor()
c.run(inhost,inport,outport,me)
def handleConnected(self, con): "Protocol.handleConnected" print "[Protocol.handleConnected]" i = 6 con.send(str(i)*i, i) def handleError(self, con, str): "Protocol.handleError" print "[Protocol.handleError]" , str def handleClose(self, con): "Protocol.close" pass processor = Processor(4) manager = ConnectionManager() host = "192.168.10.1" port = 8008 def testConnectSuccess(): print '=' * 60 print '-' * 20, 'testConnectSuccess', '-'* 20 protocol = Protocol() newSock = AsynClientSocket() connection = SocketConnection(newSock, protocol, processor) manager.addConnection(newSock.getFileNo(), connection) assert len(manager) == 1 connection.connect(host, port)
def __init__(self, debug=False):
Processor.__init__(self)
self.debug = debug
self.nc, self.kc = self.get_clients(debug=debug)
puzzleJson = json.load(data_file)
# send json into object
puzzle = PuzzleModel(puzzleJson['id'], puzzleJson['width'], puzzleJson['height'], puzzleJson['puzzle'])
# Demonstrate some of the returned values
print('You retrieved a puzzle with {0} width x {1} height and ID={2}'.format(
puzzle.width,
puzzle.height,
puzzle.id))
print('Generating solution')
# normal single permutation method, works ok.. cannot solve 4*4 with missing last square
# -------------------------
p = Processor()
squares = p.solve(puzzle)
squaresAdvanced = p.advancedSolve(puzzle)
#print('Number of squares normal method')
#print(len(squares))
#print('Squares normal method')
#print(squares)
#print('Number of squares advanced method')
#print(len(squaresAdvanced))
#print('Squares advanced method')
#print(squaresAdvanced)
