def testhaltsViaPeano():
# Since trueInPeano() is an oracle function that could never be
# implemented, there is nothing reasonable to assert in this
# test. We just run the code.
inString = 'asdf'
val = haltsViaPeano(inString)
utils.tprint(inString, ':', val)
def testTspDirK():
testvals = [
(';1', 'no'),
('a,a,3;1', 3),
('a,a,3 ; 1 ', 3),
('a,a,3;2', 'no'),
('a,b,4;1', 'no'),
('a,b,4;2', 'no'),
('a,b,4;3', 'no'),
('a,b,4 b,a,9;1', 13),
('a,b,4 b,a,9;2', 13),
('a,b,4 b,a,9;3', 'no'),
('a,b,4 b,a,9 b,c,6 c,a,10;2', 13),
('a,b,4 b,a,9 b,c,6 c,a,10;3', 20),
('a,b,4 b,a,9 b,c,6 c,a,1;2', 11),
('a,b,4 b,a,9 b,c,6 c,a,10;4', 'no'),
('a,b,4 b,a,9 b,c,6 c,a,10 a,c,2 c,b,3;3', 14),
('a,b,4 b,a,9 b,c,6 c,a,10 a,c,2 c,b,3;4', 'no'),
]
for (inString, solution) in testvals:
val = tspDirK(inString)
utils.tprint(inString.strip(), ':', val)
if solution == 'no':
assert val == solution
else:
(graphString, K) = inString.split(';')
graph = Graph(graphString, directed=True)
K = int(K)
cycle = Path.fromString(val)
dist = graph.cycleLength(cycle)
assert graph.isCycle(cycle)
assert len(cycle) >= K
assert dist == solution
def testprovableInPeano():
# isPeanoProof() works only for one particular string ('0=0') in our
# artificial, skeletal implementation for testing purposes. So we test only that string.
inString = '0=0'
val = provableInPeano(inString)
utils.tprint(inString, ':', val)
assert val == 'yes'
def train(self, max_iter: int = 200, tol: float = 1e-4, model_path: str = None) -> None:
loss = np.exp(50)
Ik = np.eye(self.k, dtype=np.float32)
if model_path is not None and os.path.isdir(model_path):
self.import_embeddings(model_path)
for it in range(max_iter):
t1 = time.time()
loss_old = loss
loss = 0
Vr = self.fie[np.array(self.i_rated), :]
XX = np.dot(Vr.T, Vr)*self.b + Ik*self.lu
for i in self.usm:
if len(self.usm[i]) > 0:
Vi = self.fie[np.array(self.usm[i]), :]
self.fue[i, :] = np.linalg.solve(np.dot(Vi.T, Vi)*(self.a-self.b)+XX, np.sum(Vi, axis=0)*self.a)
loss += 0.5 * self.lu * np.sum(self.fue[i,:]**2)
Ur = self.fue[np.array(self.u_rated), :]
XX = np.dot(Ur.T, Ur)*self.b
for j in self.ism:
if len(self.ism[j]) > 0:
Uj = self.fue[np.array(self.ism[j]), :]
B = np.dot(Uj.T, Uj)*(self.a-self.b) + XX
self.fie[j, :] = np.linalg.solve(B+Ik*self.lv, np.sum(Uj, axis = 0) * self.a)
loss += 0.5 * len(self.ism[j])*self.a
loss += 0.5 * np.linalg.multi_dot((self.fie[j, :], B, self.fie[j, :]))
loss -= np.sum(np.multiply(Uj, self.fie[j, :]))*self.a
loss += 0.5 * self.lv * np.sum(self.fie[j, :]**2)
cond = np.abs(loss_old - loss) / loss_old
tprint('Iter %3d, loss %.6f, converge %.6f, time %.2fs'%(it, loss, cond, time.time()-t1))
if cond < tol:
break
def testEmptyOnEmpty():
testvals = [('containsGAGA.py', 'no'), ('isEmpty.py', 'no'),
('onlyZs.py', 'yes')]
for (progName, solution) in testvals:
val = emptyOnEmpty(rf(progName))
utils.tprint(progName, ":", val)
assert val == solution
def testConvertSatTo3Sat():
s0 = '(x1 OR x2 OR NOT x3 OR NOT x4 OR x5) AND (NOT x1 OR NOT x2 OR x3 OR x4) AND (x4 OR NOT x5)'
s0soln = '(d1 OR d2 OR x1) AND (NOT d2 OR x2 OR NOT x3) AND (NOT d1 OR NOT x4 OR x5) AND (d3 OR NOT x1 OR NOT x2) AND (NOT d3 OR x3 OR x4) AND (x4 OR NOT x5)'
s1 = ''
s1soln = ''
s2 = 'x1'
s2soln = '(x1)'
s3 = 'x1 AND NOT x2'
s3soln = '(x1) AND (NOT x2)'
s4 = 'x1 OR NOT x2'
s4soln = '(x1 OR NOT x2)'
testvals = [
(s0, s0soln),
(s1, s1soln),
(s2, s2soln),
(s3, s3soln),
(s4, s4soln),
]
for (inString, soln) in testvals:
utils.tprint('**', inString, '**')
converted = convertSatTo3Sat(inString)
utils.tprint(converted, '\n\n')
assert converted == soln
def testThreshToOpt():
global FThresh
FThresh = minThresh
inStrings = [\
'13 18 16 35 23 19 42 73 4 13 8 22',\
'',\
'0',\
'0 1 2 3',\
'4',\
'4 4 4',\
'7 6 5 4',\
'4 5',\
'4 5 6',\
'5',\
'5 6',\
'5 6 7',\
'105 106 107',\
'100 105 106 107',\
]
upperBound = 100
for inString in inStrings:
val = threshToOpt(inString, upperBound)
utils.tprint('with upper bound', upperBound, ', min of', inString, ':', val)
nums = [int(x) for x in inString.split()]
if len(nums)==0 or min(nums) > upperBound:
solution = 'no'
else:
solution = str(min(nums))
assert val == solution
def testConvertDHCtoUHC():
from uhc import uhc
from dhc import dhc
from graph import Path
instances = [
'',
'a,a',
'a,b',
'a,b b,a',
'a,b b,c c,a',
'a,b b,c a,c',
'a,b b,c c,d',
'a,b b,c c,d d,a',
'a,b b,c c,d a,d',
'a,b b,c c,d a,d d,b c,a',
]
for instance in instances:
convertedInstance = convertDHCtoUHC(instance)
instanceSolution = dhc(instance)
convertedInstanceSolution = uhc(convertedInstance)
revertedSolution = revertSolution(convertedInstanceSolution)
utils.tprint(instance, 'maps to', convertedInstance,\
' solutions were: ', instanceSolution, ';', convertedInstanceSolution)
utils.tprint('revertedSolution', revertedSolution)
if revertedSolution == 'no':
assert instanceSolution == 'no'
else:
g = Graph(instance, weighted=False)
path = Path.fromString(revertedSolution)
# print('g', g, 'path', path)
assert g.isHamiltonCycle(path) or g.isHamiltonCycle(path.reverse())
def testMultiply():
testVals = [('4 5', 4 * 5), ('100 10000', 100 * 10000),
('1024 256', 1024 * 256)]
for (inString, solution) in testVals:
val = multiply(inString)
utils.tprint(inString, val)
assert int(val) == solution
def testHasSameTransitions():
s1 = '''
q0->q0:f;x,R
q0->q1:abc;x,R
q0->q1:d;x,S
q0->q1:e;y,R
'''
s2 = '''
q0->q0:!abcde;x,R
q0->q1:ab;x,R
q0->q1:c;x,R
q0->q1:d;x,S
q0->q1:e;y,R
q1->q2:~;R
'''
testVals = [
( rf('containsGAGA.tm'), rf('containsGAGA.tm'), True),
( rf('binaryIncrementer.tm'), rf('binaryIncrementer.tm'), True),
( s1, s2, True),
( s2, s1, False),
]
for (tm1str, tm2str, result) in testVals:
tm1 = TuringMachine(tm1str)
tm2 = TuringMachine(tm2str)
val = tm1.hasSameTransitions(tm2)
utils.tprint(val, result)
assert val == result
def testhaltsOnString():
for (progName, inString, solution) in [
('loopIfContainsGAGA.py', 'GAGAGAGAG', 'no'), \
('loopIfContainsGAGA.py', 'TTTTGGCCGGT', 'yes') ]:
val = haltsOnString(rf(progName), inString)
utils.tprint((progName, inString), ":", val)
assert val == solution
def testNdFindNANADivConq():
testVals = [
('1000Ts', 1000 * 'T', 'no'),
('1000Ts1GAGA', 1000 * 'T' + 'GAGA', 'yes'),
('1millionTs', 1000000 * 'T', 'no'),
('1millionTs1GAGA', 1000000 * 'T' + 'GAGA', 'yes'),
('10millionTs', 10000000 * 'T', 'no'),
('10millionTs1GAGA', 10000000 * 'T' + 'GAGA', 'yes'),
('10000CACAs10000TATAs', 10000 * 'CACA' + 10000 * 'TATA', 'yes'),
('10000CACAs10000TATAs', 10000 * 'CACA' + 10000 * 'TATA', 'yes'),
('10000CACAs10000TATAs', 10000 * 'CACA' + 10000 * 'TATA', 'yes'),
('10000CACAs10000TATAs', 10000 * 'CACA' + 10000 * 'TATA', 'yes'),
('10000CACAs10000TATAs', 10000 * 'CACA' + 10000 * 'TATA', 'yes'),
]
for (desc, inString, solution) in testVals:
val = ndFindNANADivConq(inString)
utils.tprint(desc, ':', val)
if val == 'no':
assert val == solution
else:
assert val in ['GAGA', 'CACA', 'AAAA', 'TATA']
assert val in inString
utils.NonDetSolution.printLock.acquire()
utils.tprint(desc, ':', val)
utils.NonDetSolution.printLock.release()
def export_model(self, model_path: str) -> None:
if os.path.exists(
model_path
) and self.__sess is not None and self.__saver is not None:
file_path = os.path.join(model_path, 'weights')
tprint('Saving tensorflow graph to path %s' % (file_path))
self.__saver.save(self.__sess, file_path)
def evaluate(self):
"""
+ example:
>> pipeline = Pipeline()
>> pipeline.prepare_data()
>> pipeline.build_network()
>> pipeline.evaluate()
"""
self.load_model()
self.network.eval()
error_count = 0
psnr_list = []
for step, (img, target, path) in enumerate(self.dataloader_inference):
if config.device == "cuda":
img, target = [item.cuda() for item in (img, target)]
new_img = self.network(img)
output_img = new_img.squeeze().permute(1, 2, 0).detach().cpu().numpy()
plt.imsave(os.path.join(self.config.DATA_ROOT_PATH, "inference_generated", path[0]), output_img)
if target.shape != new_img.shape:
error_count += 1
continue
psnr_list.append(get_batch_PSNR(target.float(), new_img.float()))
tprint("Processed %.2f%% samples...\r" % (step / self.dataloader_inference.__len__() * 100), end="")
print("error: %s" % error_count)
print("\n")
return np.mean(psnr_list)
def export_model(self, model_path: str) -> None:
if os.path.exists(model_path):
if hasattr(self, 'E'):
tprint('Saving content projection matrix to %s' %
os.path.join(model_path, 'final-E.dat'))
export_embed_to_file(os.path.join(model_path, 'final-E.dat'),
self.E)
def testConvertPartitionToPacking():
from packing import packing
from partition import partition
instances = [
'5',
'5 6',
'5 6 7',
'5 6 7 8',
'',
'5 7',
'6 6',
'6 6 7 7',
'10 20 30 40 11 21 31 41',
]
for instance in instances:
convertedInstance = convertPartitionToPacking(instance)
instanceSolution = partition(instance)
convertedInstanceSolution = packing(convertedInstance)
revertedSolution = convertedInstanceSolution
utils.tprint(instance, 'maps to', convertedInstance,\
' solutions were: ', instanceSolution, ';', convertedInstanceSolution)
if revertedSolution == 'no':
assert instanceSolution == 'no'
else:
total = sum([int(x) for x in instance.split()])
solutionTotal = sum([int(x) for x in revertedSolution.split()])
assert solutionTotal * 2 == total
def import_model(self, model_path: str) -> None:
file_path = os.path.join(model_path, 'weights')
if os.path.exists(
model_path
) and self.__sess is not None and self.__saver is not None:
tprint('Restoring tensorflow graph from path %s' % (file_path))
self.__saver.restore(self.__sess, file_path)
def get_example_keys(self):
tprint(
'Converting micrographs to tiles of %d pixels, particle diameter %d pixels ...'
% (cfg.PICK_WIN, cfg.PART_D_PIXELS))
micros = self.allmicros.keys()
# random.shuffle(micros)
# convert each micro into a set of tiles of cfg.PICK_WIN size
# the training will run on one tile per record
keys = []
for m in micros:
D = self.allmicros[m]['part_diameter']
sz, bn = calc_micro_pick_shape(m, D)
xs, ys = image.tile2D(sz, (cfg.PICK_WIN, ) * 2, 0.0)
# create keys using tile coordinates
for x in xs:
for y in ys:
tcoords = self.calc_tile_coords(m, x, y, bn)
# see how many particles of each class
lens = [len(tcoords[k]) for k in tcoords]
if np.sum(np.array(lens)) < 1:
# skip empty tile
continue
else:
keys.append('%s:%d,%d' % (m, x, y))
# shuffle all example records to sit randomly in shards
random.shuffle(keys)
return keys
def testTwoTDCM():
for (filename, inString, tapeSoln, outputSoln) in [
('containsGAGA.tm', 'CCCCCCCCCAAAAAA', 'no', ''),
('containsGAGA.tm', 'CCCGAGACCAAAAAA', 'yes', ''),
('loop.tm', 'x', TuringMachine.exceededMaxStepsMsg, ''),
('alternating01.tm', '', TuringMachine.exceededMaxStepsMsg,
'010101010101010101010101'),
('unarySequence.tm', '', TuringMachine.exceededMaxStepsMsg,
'0010110111011110111110111111011111110111111110'),
]:
tm = TwoTDCM(rf(filename), inString)
try:
tape = tm.run()
except utils.WcbcException as e:
if str(e).startswith(TuringMachine.exceededMaxStepsMsg):
tape = TuringMachine.exceededMaxStepsMsg
else:
raise
output = tm.getOutput()
utils.tprint('filename:', filename, 'inString:', inString, 'tape:',
tape, 'output:', output)
assert tape == tapeSoln
if outputSoln == '':
assert output == outputSoln
else:
assert output.startswith(outputSoln)
def testOnlyZs():
for (inString, solution) in [('', ''), ('aassdc', ''), ('ZZZ', 'ZZZ'),
('Z', 'Z'),
('ascZsfaasZZsacscaZZZ', 'ZZZZZZ')]:
val = onlyZs(inString)
utils.tprint(inString, ":", val)
assert val == solution
def testRecYesOnString():
for (progName, inString, solution) in [('containsGAGA.py', 'GAGAGAGAG', 'yes'), \
('containsGAGA.py', 'TTTTGGCCGGT', 'no') ]:
combinedString = utils.ESS(rf(progName), inString)
val = recYesOnString(combinedString)
utils.tprint( (progName, inString), ":", val )
assert val == solution
def fit(self, X, y):
y = y.flatten()
if len(y) != X.shape[0]:
raise ValueError('Data has {} samples and {} labels.'.format(
X.shape[0], len(y)))
if self.verbose_:
tprint('Fitting MLP ensemble with {} regressors'.format(
self.n_regressors_))
self._create_models(X, y)
if self.backend_ == 'sklearn':
[model.fit(X, y) for model in self.models_]
elif self.backend_ == 'keras':
[
model.fit(X,
y,
batch_size=self.batch_sizes_[model_idx],
epochs=self.max_iters_[model_idx],
verbose=self.verbose_)
for model_idx, model in enumerate(self.models_)
]
if self.verbose_:
tprint('Done fitting MLP ensemble.')
return self
def testPathContains():
p1 = Path([])
p2 = Path(['a'])
p4 = Path(['a', 'b'])
p6 = Path(['a', 'b', 'c'])
e5 = Edge(['a123', 'b123'])
testvals = [
(p1, 'a', False),
(p2, 'a', True),
(p4, 'a', True),
(p4, 'b', True),
(p4, 'c', False),
(e5, 'a123', True),
(e5, 'b123', True),
(e5, 'c123', False),
(p6, 'a', True),
(p6, 'b', True),
(p6, 'c', True),
(p6, 'd', False),
]
for (path, node, solution) in testvals:
val = (node in path)
utils.tprint(path, node, ':', val)
assert val == solution
def testGraphCycleLength():
graphStr = 'a,b,1 b,c,2 c,d,3 d,e,4 e,a,5 c,c,6 z'
g1 = Graph(graphStr)
g2 = Graph(graphStr, directed=False)
testvals = [
( (Graph(''), ''), 0),
( (Graph('a'), ''), 0),
( (Graph('a'), 'a'), 'exception'),
( (Graph('a,a,1'), 'a'), 1),
( (Graph('a,a,1'), 'a,a'), 'exception'),
( (g1, 'a,d'), 'exception'),
( (g1, 'a,b'), 'exception'),
( (g1, 'c'), 6),
( (g1, 'a,b,c,d,e'), 15),
( (g2, 'a,b,c,d,e'), 15),
]
for ( args, solution) in testvals:
g, pathStr = args
path = Path.fromString(pathStr)
try:
val = g.cycleLength(path)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
val = 'exception'
utils.tprint(args, ':', val)
assert val == solution
def testGraphIsHamiltonCycle():
graphStr = 'a,b,1 b,c,2 c,d,3 d,e,4 c,c,6'
g1 = Graph(graphStr)
g2 = Graph(graphStr, directed=False)
g3 = g1.clone(); g3.addEdge(Edge(['e','a']))
g3b = g1.clone(); g3b.addEdge(Edge(['a','e']))
g4 = g2.clone(); g4.addEdge(Edge(['a','e']))
testvals = [
( (Graph(''), ''), True),
( (Graph('a'), ''), False),
( (Graph('a'), 'a'), False),
( (Graph('a,a', weighted=False), 'a'), True),
( (Graph('a,a,1'), 'a'), True),
( (Graph('a,a,1'), 'a,a'), False),
( (g1, 'a,b'), False),
( (g1, 'a,b,c'), False),
( (g2, 'a,b,c'), False),
( (g1, 'a,b,c,d,e'), False),
( (g2, 'a,b,c,d,e'), False),
( (g3, 'a,b,c,d,e'), True),
( (g3b, 'a,b,c,d,e'), False),
( (g4, 'a,b,c,d,e'), True),
( (g3, 'a,b,c,c,d,e'), False),
( (g4, 'a,b,c,c,d,e'), False),
]
for ( args, solution) in testvals:
g, pathStr = args
path = Path.fromString(pathStr)
val = g.isHamiltonCycle(path)
utils.tprint(args, ':', val)
assert val == solution
def testPathStr():
testvals = [
([], ''),
([''], 'exception'),
('', 'exception'),
('asdf', 'exception'),
([1,2,3,4], 'exception'),
(['a1'], 'a1'),
(['ab1'], 'ab1'),
(['ab1', 'zxy'], 'ab1,zxy'),
('a,b,c'.split(','), 'a,b,c'),
('a,b,,c'.split(','), 'exception'),
('a1,b1,c1'.split(','), 'a1,b1,c1'),
]
for (nodes, solution) in testvals:
try:
p = Path(nodes)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
val = 'exception, as expected'
utils.tprint(nodes,':',solution)
s = str(p)
if solution != 'exception':
assert s == solution
def testGraphRemoveEdge():
testvals = [
( ('',), Edge(['a','b']), 'exception'),
( ('a',), Edge(['a','a']), 'exception'),
( ('a,a b', False), Edge(['a','a']), 'a b'),
( ('a,a', False), Edge(['a','a']), 'a'),
( ('a,b', False), Edge(['a','b']), 'a b'),
( ('a,b', False), Edge(['b','a']), 'exception'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6',), Edge(['a','ccc']), 'ccc b,a,3 a,a,4 b,d,6'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6',), Edge(['ccc','a']), 'exception'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6', True, False), Edge(['d','b']), 'd b,a,3 a,a,4 a,ccc,5'),
]
for ( args, edge, solution) in testvals:
g = Graph(*args)
try:
g.removeEdge(edge)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
g = 'exception'
solnArgs = list(args)
solnArgs[0] = solution
if solution != 'exception':
solution = Graph(*solnArgs)
utils.tprint(args, edge, ':', g)
assert g == solution
def testGraphAddEdge():
testvals = [
( ('',), Edge(['a','b']), 'exception'),
( ('a',), Edge(['a','a']), 'a,a,1'),
( ('a,a b', False), Edge(['b','a']), 'a,a b,a'),
( ('a,a', False), Edge(['a','a']), 'exception'),
( ('a,b', False), Edge(['a','b']), 'exception'),
( ('a,b', False), Edge(['b','a']), 'a,b b,a'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6',), (Edge(['a','ccc']),9), 'exception'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6',), (Edge(['ccc','a']),9), 'ccc,a,9 b,a,3 a,a,4 a,ccc,5 b,d,6'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6', True, False), (Edge(['b','ccc']),9), 'b,ccc,9 b,a,3 a,a,4 a,ccc,5 b,d,6'),
( ('b,a,3 a,a,4 z a,ccc,5 b,d,6',), Edge(['z','z']), 'b,a,3 a,a,4 z,z,1 a,ccc,5 b,d,6'),
]
for ( args, edgeArgs, solution) in testvals:
g = Graph(*args)
if isinstance(edgeArgs, Edge):
edgeArgs = tuple(edgeArgs,)
try:
g.addEdge(*edgeArgs)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
g = 'exception'
solnArgs = list(args)
solnArgs[0] = solution
if solution != 'exception':
solution = Graph(*solnArgs)
utils.tprint(args, edgeArgs, ':', g)
assert g == solution
def testNeighbors():
testvals = [
( ('',), 'a', 'exception'),
( ('a',),'a', []),
( ('', False), 'a', 'exception'),
( ('', False, False), 'a', 'exception'),
( ('a,a', False), 'a', ['a']),
( ('a,b', False), 'a', ['b']),
( ('a,b', False), 'b', []),
( ('b,a,3 a,a,4', True, False), 'a', ['a', 'b']),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6 e',), 'e', []),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6 e a,d,3',), 'a', ['a', 'ccc', 'd']),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6 e a,d,3',), 'b', ['a', 'd']),
]
for ( args, node, solution) in testvals:
g = Graph(*args)
try:
val = g.neighbors(node)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
val = 'exception'
utils.tprint(args, node, ':', val)
if solution != 'exception':
solution = set(solution)
val = set(val)
assert val == solution
def testGraphAddNode():
testvals = [
( ('',), 'a', 'a'),
( ('a',), 'a', 'exception'),
( ('', False), 'a', 'a'),
( ('', False, False), 'a', 'a'),
( ('a,a', False), 'b', 'a,a b'),
( ('a,a', False), 'a', 'exception'),
( ('a,b', False), 'a', 'exception'),
( ('b,a,3 a,a,4', True, False), 'c', 'a,a,4 b,a,3 c'),
( ('b,a,3 a,a,4 a,ccc,5 b,d,6',), 'aaa', 'aaa a,a,4 a,ccc,5 b,a,3 b,d,6'),
( ('b,a,3 a,a,4', True, False), 'c', 'a,a,4 a,b,3 c'),
]
for ( args, node, solution) in testvals:
graphString = args[0]
try:
g = Graph(*args)
g.addNode(node)
except utils.WcbcException as e:
if solution != 'exception':
raise e
else:
g = 'exception'
utils.tprint(args, node, ':', g)
if solution != 'exception':
solution = Graph(solution, *args[1:])
assert g == solution
def __init__(self):
tprint("HomeState")
tprint("== Pizaid ==")
tprint(time.strftime("%H:%M:%S"))
tprint("\033[3A")
send_clr()
send_str(" == Pizaid ==")
send_newline()
send_str(time.strftime("%H:%M:%S") + " 30% AC")
def updateDisplay(self):
tprint("HomeState: update ")
tprint(time.strftime("%H:%M:%S"))
tprint("\033[3A")
send_newline()
send_str(time.strftime("%H:%M:%S"))
return self
def updateDisplay(self):
tprint("NetworkState: update ")
tprint(self.network.get_ipv4() + " ")
tprint("\033[3A")
send_newline()
send_str(self.network.get_ipv4() + " ")
return self
def __init__(self):
tprint("Battery State ")
tprint(" "*30)
tprint("\033[3A")
send_clr()
send_str("Battery State")
send_newline()
send_str("100% Ganbaru ZOI")
def __init__(self):
tprint("Storage State ")
tprint(" "*30)
tprint("\033[3A")
send_clr()
send_str("Storage State")
send_newline()
send_str("XXX GB / YYY GB")
def __init__(self):
tprint("Storage Detail ")
tprint(" "*30)
tprint("\033[3A")
send_clr()
send_str("Storage Detail")
send_newline()
send_str("1:TOSHIBA,Main")
def run(self):
tprint("start ioserver")
self.timer.start()
lcd = self.lcd
while True:
c = getch()
if (c == 'w'):
lcd.up()
elif (c == 'a'):
lcd.left()
elif (c == 's'):
lcd.down()
elif (c == 'd'):
lcd.right()
elif (c == ' '):
lcd.center()
elif (c == 'u'):
lcd.updateDisplay()
elif (c == 'q'):
self.quit = True
break
else:
tprint("Unknown Command")
def __init__(self):
tprint("NetworkState ")
self.network = get_controllercomm().network()
tprint(self.network.get_ipv4() + " ")
tprint("\033[3A")
send_clr()
send_str("Network")
send_newline()
send_str(self.network.get_ipv4() + " ")
def run(self):
self.ioserver = IOServer()
self.ioserver.start()
tprint("Run io and dbus server")
tprint("Wait to stop ioserver")
self.ioserver.join()
def up(self):
tprint("NetworkState: up ")
tprint("\033[2A")
return HomeState()
def down(self):
tprint("NetworkState: down ")
tprint("\033[2A")
return StorageState()
def up(self):
tprint("HomeState: up ")
tprint(time.strftime("%d/%m/%Y %H:%M:%S"))
tprint("\033[3A")
return BatteryState()
def down(self):
tprint("HomeState: down ")
tprint(time.strftime("%d/%m/%Y %H:%M:%S"))
tprint("\033[3A")
return NetworkState()
def start():
tprint("Hello Pizaid!")
tprint("This program is a server to display the status of RaspberryPi.")
server = create_lcdserver()
server.run()
