def main():
server = ara.Web('192.168.43.33', 1234)
server.init()
thread = ara.Thread(target=server.start(read_f))
thread.start()
inter.interpreter()
def check(self):
if self.text == "out":
try:
interpreter.interpreter(
self.text.append(token.Result(token.TokenTypes.semi)))
return 0
except:
return 1
def deal(input): # if success, case == 1; if failed, case == 0
if interpreter.interpreter(input):
situation, detail = interpreter.interpreter(input)
else:
return
# Read dictionary files
dic = read_csv()
case = 0
if situation == 2: # create table
table_name = detail['table']
unique = [x for x in detail['unique']]
key = dict.keys(detail)
attr = [
x for x in key
if (x != 'unique' and x != 'table' and x != 'primary')
]
attr_type = {}
for attr_name in attr:
attr_type[attr_name] = detail[attr_name]
primary = detail['primary']
dic, case = create_table(dic, table_name, unique, attr, attr_type,
primary)
elif situation == 3: # create index
index_name = detail['index']
table_name = detail['table']
attr = detail['column']
dic, case = create_index(dic, index_name, table_name, attr)
elif situation == 5: # drop table
table_name = detail['table']
dic, case = drop_table(dic, table_name)
elif situation == 6: # drop index
index_name = detail['index']
dic, case = drop_index(dic, index_name)
elif situation == 7: # select
table_name = detail['table']
condition = detail['condition']
case = select(dic, table_name, condition)
elif situation == 8: # insert
table_name = detail['table']
line = detail['condition']
values = line.split(',')
case = insert(dic, table_name, values)
elif situation == 9: # delete
table_name = detail['table']
condition = detail['condition']
case = delete(dic, table_name, condition)
# Output dictionary file
write_csv(dic)
return case
def __init__(self, size):
print('Create Agent')
self.size = size
setpoint = 50
reward_type = 'classic'
action_type = "discrete"
self.agent = interpreter(setpoint, reward_type, action_type)
self.model = model()
self.observation = self.agent.step(2 * np.random.rand(3) - 1)
self.buffer_states = (self.observation)
# Buffer inizialisieren mit 30 states und random action
for buffer in range(3):
action = 2 * np.random.rand(3) - 1
self.observation = self.agent.step(action)
self.buffer_states = np.expand_dims(self.buffer_states,
self.observation,
axis=3)
#self.buffer_states = np.vstack([self.buffer_states, self.observation])
print(self.buffer_states)
#print(self.buffer_states[1,:])
self.state = np.array(self.buffer_states)
self.step()
def input_instruction(string):
situation, detail=interpreter.interpreter(string)
if situation == 12:
for i in detail:
print(i)
if i[0] == "q":
break
else:
input_instruction(i)
if situation == 0 or situation == 11:
return
elif catalog_manager.deal(string) == 0:
return
elif situation == 1 or situation == 2 or situation == 3:
return create(situation,detail)
elif situation == 4 or situation == 5 or situation == 6:
return drop(situation,detail)
elif situation == 7:
return select(detail)
elif situation == 8:
return insert(detail)
elif situation == 9:
return delete(detail)
# use database
elif situation == 10:
return
def lambda_handler(event, context):
if DORMANT:
return data
try:
params = event.get('queryStringParameters')
resource = event.get('path')
except:
params = event
resource = '/users'
if (resource == '/users'):
text = params.get("text")
msisdn = params.get("msisdn")
v_num = params.get("to")
# if null, request, return 200 OK and do nothing
if not text or text == 'None':
return data
sent = interpreter(text, msisdn, v_num)
data["body"] = json.dumps({"Status": "%s" % sent})
print(data)
return data
def testDriver_i():
for line in sys.stdin:
outPut = ''
if line == '\n':
print('The input line is empty, exit program')
sys.exit()
info, status = parser(scanner(line,'s'),'t')
if status == True:
info = interpreter(info)
outPut = "\n> " + line + str(info) + '\n'
sys.stdout.write(outPut)
def __init__(self):
self.logger = logging.getLogger(__name__)
logging.basicConfig()
self.val = 0
self.interpret = interpreter.interpreter(self.logger)
self.ev = evaluator.Evaluator()
self.start = datetime.now()
self.act = action()
self.clear = lambda: os.system('cls')
self.hands = []
self.folded = 0
self.won = 0
self.pl = 0
self.er = 0
self.startVal = 120
self.positioning = ['BTN', 'CO', 'HJ', 'UTH', 'BB', 'SB']
self.early_range = Range('ATs+, KTs+, 77+, QTs+, T9s, KJ+, ATs+')
self.mid_range = Range(
'55+, A6s+, K9s+, Q8s+, J8s+, 98s+, KT+, QT+, JT+')
self.late_range = Range(
'22+, A2s+, K2s+, Q8s+, J7s+, 98, 87, 76, 65, 54')
self.allin_range = Range('QQ+, AK+')
self.state = ["|", "", [], []]
self.prevstate = ["|", "", [], []]
self.position = None
self.winp = ""
self.losep = ""
self.tiep = ""
self.percent = ""
self.hnd = ""
self.notes = ""
self.pos = ""
self.board = []
self.handcards = []
os.system('SET OMP_THREAD_LIMIT=1')
self.output_loop()
self.run()
from interpreter import interpreter
# Main
with open('program.txt', 'r') as file:
# Read input program
program = list(map(int, file.readline().strip().split(",")))
# Reset the input program
program[1] = 12
program[2] = 2
# Interpreter
print(interpreter(program)[0])
# -*- coding: utf-8 -*-
import err
from interpreter import interpreter
print "#" * 32 + "\n#SAVAGE PROGRAMMING INTERPRETER#\n" + "#" * 32
print "Type \"run\" to run code in \"code\" file, or \"run file\" to run code from an alternate file."
while 1:
p = raw_input("> ")
if p.lower() == "run":
interpreter('code').run()
elif p.split(" ")[0] == "run":
interpreter(p.split[1]).run()
__author__ = 'Levon'
import interpreter
print(
"Enter your expressions to be calculated. Enter 'Exit' to exit the calculator."
)
expression = ""
tokenizer = interpreter.Tokenizer()
parser = interpreter.parseTree()
interpr = interpreter.interpreter()
while True:
expression = input('> ')
if expression != "Exit":
try:
result = interpr.evaluate(
parser.buildParseTree(tokenizer.tokenize(expression)))
print(result)
except Exception as e:
print(e)
else:
break
print("Thank you for using My calculator!")
def run_python_code():
script_text = request.form['script']
inter_preter = interpreter()
result = inter_preter.call_python(script_text)
return result
message_timestamp = form.getvalue('message-timestamp')
type = form.getvalue('type')
msisdn = str(msisdn)
msisdn = msisdn.translate(None, "'")
to = str(to)
to = to.translate(None, "'")
messageId = str(messageId)
messageId = messageId.translate(None, "'")
text = str(text)
text = text.translate(None, "'")
message_timestamp = str(message_timestamp)
message_timestamp = message_timestamp.translate(None, "'")
type = str(type)
type = type.translate(None, "'")
print "<html>"
print "<head>"
print "<title>Debugging</title>"
print "</head>"
print "<body>"
print "<h2>MSISDN: %s \nTo:%s \nmessageId: %s \nText: %s \nTimestamp: %s \nType %s</h2>" % (msisdn, to, messageId, text, message_timestamp, type)
print "</body>"
print "</html>"
# Build an object with all message details
content = {'msisdn': msisdn, 'recipient': to, 'id': messageId,
'message': text, 'timestamp': message_timestamp}
interpreter(content)
def __init__(self):
#interpreter = interpreter.interpreter()
self.boot_time = utime.time()
self.config_handler = config.local()
self.receiver_enabled, self.external_sensor_enabled, self.disable_status_led = self.config_handler.getSettings(
[
'receiver_enabled', 'external_sensor_enabled',
'disable_status_led'
])
if type(self.receiver_enabled) != bool:
self.receiver_enabled = False
if type(self.external_sensor_enabled) != bool:
self.external_sensor_enabled = False
if type(self.disable_status_led) != bool:
self.disable_status_led = False
# t_disable_local_config = self.config_handler.getSettings(['disable_local_config'])
# if type(t_disable_local_config) != bool:
# t_disable_local_config = False
# if t_disable_local_config:
# localserver.stop()
self.dht11_enabled, self.dht22_enabled = self.config_handler.getSettings(
['dht11_enabled', 'dht22_enabled'])
if type(self.dht11_enabled) != bool:
self.dht11_enabled = False
if type(self.dht22_enabled) != bool:
self.dht22_enabled = False
self.data_handler = interpreter.interpreter()
self.sensor = sht30.SHT30(scl_pin=SCL_PIN, sda_pin=SDA_PIN)
if self.receiver_enabled:
print('******Receiver enabled')
self.irrcv = irget.receiver(ADC_PIN)
self.helper = test_helper.helper(self.irrcv, self.data_handler)
else:
print('******Analog input enabled')
self.adc_input = ADC(Pin(ADC_PIN))
self.adc_input.atten(ADC.ATTN_11DB)
if self.external_sensor_enabled:
print('******External sensor enabled')
self.external_sensor = dht.DHT22(Pin(CURR_PIN))
else:
self.curr_input = ADC(Pin(CURR_PIN))
self.curr_input.atten(ADC.ATTN_11DB)
if self.dht11_enabled:
self.onboard_dht_sensor = dht.DHT11(Pin(DHT_PIN))
elif self.dht22_enabled:
self.onboard_dht_sensor = dht.DHT22(Pin(DHT_PIN))
self.led_blue = Pin(LED_BLUE, Pin.OUT)
self.led_red = Pin(LED_RED, Pin.OUT)
self.led_green = Pin(LED_GREEN, Pin.OUT)
self.led_red.on() #leds turn on with ground, so on() turn it off
self.led_green.on()
self.led_blue.on()
self.player = buzzer
self.player.play(2217, 100)
self.player.play(2489, 100)
self.player.play(2794, 200)
self.device_id = 'node-' + ubinascii.hexlify(
unique_id()).decode('utf-8')
self.irout = irsend.sender(38000, LED_IR)
self.temp_sensor_cal_prop = 1.0
self.temp_sensor_cal_offset = 0
self.hum_sensor_cal_prop = 1.0
self.hum_sensor_cal_offset = 0
try:
t_server, t_port, t_user, t_pass = self.config_handler.getSettings(
['mqtt_server', 'mqtt_port', 'mqtt_user', 'mqtt_pass'])
except:
t_server = None
t_port = None
t_user = None
t_pass = None
self.mqtt_client = mqtt_sub.handler(devicename=self.device_id,
server=t_server,
port=t_port,
username=t_user,
password=t_pass)
t_uplink_period, = self.config_handler.getSettings(['uplink_period'])
if t_uplink_period == None:
self.uplink_period = 300000
else:
self.uplink_period = (t_uplink_period if type(t_uplink_period)
== int else int(t_uplink_period))
self.curr_conversion, = self.config_handler.getSettings(
['current_conversion'])
if self.curr_conversion == None:
self.curr_conversion = 1.0
self.vol_conversion, = self.config_handler.getSettings(
['vol_conversion'])
if self.vol_conversion == None:
self.vol_conversion = 1.0
t_sensor_cal_tuple_temp, = self.config_handler.getSettings(
['sensor_calibration_temp'])
if type(t_sensor_cal_tuple_temp) == list:
self.temp_sensor_cal_prop = t_sensor_cal_tuple_temp[0]
self.temp_sensor_cal_offset = t_sensor_cal_tuple_temp[1]
t_sensor_cal_tuple_hum, = self.config_handler.getSettings(
['sensor_calibration_hum'])
if type(t_sensor_cal_tuple_hum) == list:
self.hum_sensor_cal_prop = t_sensor_cal_tuple_hum[0]
self.hum_sensor_cal_offset = t_sensor_cal_tuple_hum[1]
self.msg_to_publish = {}
self.player.play(2489, 200)
self.prev_millis = utime.ticks_ms()
from AST import AST
from interpreter import interpreter
from lxml import etree
def transfer(eroot):
root = AST(eroot.tag)
for echild in eroot.getchildren():
root.childrens.append(transfer(echild))
return root
if __name__ == '__main__':
ehtml = etree.parse('index1.html')
eroot = ehtml.getroot()
root = transfer(eroot)
s = interpreter(root)
print s
return(0)"""
inputlist = []
preservada = []
token = [0]
loaded = []
tokenstb = {}
error = None
hypocode = []
datapile = []
txt = open('test.txt', 'r')
brutecode = txt.read()
txt.close
val = 0
val = lexiconanal(brutecode)
if val==1:
val = syntaxanal()
if val==1:
val = interpreter(hypocode)
print ("EOF")
def commandline():
"""zhpy, the python language in chinese
Accept options:
-i --input:
speficy the input source
-o --output:
speficy the output source
-p --python:
compile to python and run
-c --cmp:
input raw zhpy source and run
-e --encoding:
specify the encoding
--info:
zhpy information
-v --verbose:
show zhpy progress in detail
--tw:
convert python to twpy
--cn:
convert python to cnpy
help:
get information:
zhpy --info
interpreter usage:
zhpy [--tw | --cn]
command usage:
zhpy [-i | -p] input [-o] [output] [-e] [encoding] [-v]
::
$ zhpy input.py (.twpy, .cnpy) [arguments]
$ zhpy -i input.py (.twpy, .cnpy)
$ zhpy -i input.py -o output.py (.twpy, .cnpy)
$ zhpy -p input.py
script usage:
zhpy [-c] source [-e] [encoding] [-v]
convertor usage:
zhpy [--tw | --cn] input.py [-v]
::
$ zhpy --tw input.py [-v]
$ zhpy --cn input.py [-v]
"""
argv = sys.argv[1:]
os.chdir(os.getcwd())
source = None
target = None
encoding = None
raw_source = None
verbose = False
python = False
tw = False
cn = False
# run as interpreter
if len(argv) == 0:
from interpreter import interpreter
interpreter()
sys.exit()
# run as script
# not accept any option
elif not argv[0].startswith('-'):
source = argv[0]
sys.argv = argv
# run as command
elif len(argv) == 1:
if argv[0] == '--info':
from info import info
info()
sys.exit()
elif argv[0] == '-h' or argv[0] == '--help':
print commandline.__doc__
sys.exit()
# run as native interpreter
elif argv[0] == '--tw':
from interpreter import interpreter
interpreter('tw')
sys.exit()
elif argv[0] == '--cn':
from interpreter import interpreter
interpreter('cn')
sys.exit()
else:
print commandline.__doc__
sys.exit()
# accept "-c -e -v"
elif len(argv) >= 2:
if argv[0] == '-c' or argv[0] == '--cmp':
raw_source = argv[1]
del (argv[:2])
if len(argv) >= 2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
# python to twpy
elif argv[0] == '--tw':
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .tw in filename
profix = os.path.splitext(filename)[-1]
if profix == '.tw':
filename = os.path.splitext(filename)[0]
del (argv[:2])
tw = True
target = "v_" + filename + ".twpy"
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
# python to cnpy
elif argv[0] == '--cn':
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .cn in filename
profix = os.path.splitext(filename)[-1]
if profix == '.cn':
filename = os.path.splitext(filename)[0]
del (argv[:2])
cn = True
target = "v_" + filename + ".cnpy"
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
# accept "-i -o -e -v" or "-p -e" or "-c -e -v"
elif argv[0] == '-i' or argv[0] == '--input':
source = argv[1]
del (argv[:2])
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
if len(argv) >= 2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
if len(argv) >= 2 and (argv[0] == '-o' or argv[0] == '--output'):
target = argv[1]
del (argv[:2])
if len(argv) >= 2 and (argv[0] == '-e'
or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-p' or argv[0] == '--python':
source = argv[1]
filename = os.path.splitext(source)[0]
del (argv[:2])
target = "n_" + filename + ".py"
python = True
print "compile to python and run: %s" % ("n_" + filename + ".py")
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
if len(argv) >= 2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if (len(argv) != 0) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
else:
print commandline.__doc__
sys.exit()
#convert
if raw_source:
if verbose:
print "run raw_source", raw_source
annotator()
if encoding:
result = convertor(raw_source, verbose, encoding)
else:
result = convertor(raw_source, verbose)
try_run(result)
sys.exit()
if encoding:
print "encoding", encoding
if source:
if verbose:
print "input", source
# convertor
if (tw or cn):
if verbose:
print "convert python code to",
try:
from pyzh import rev_annotator, python_convertor
test = file(source, "r").read()
if tw:
print "twpy"
rev_annotator('tw', verbose)
result = python_convertor(test, lang='tw')
if cn:
print "cnpy"
rev_annotator('cn', verbose)
result = python_convertor(test, lang='cn')
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
else:
try:
test = file(source, "r").read()
annotator()
if encoding:
result = convertor(test, verbose, encoding)
else:
result = convertor(test, verbose)
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
def test_single_num_creation_arg(self):
program = [5]
i = interpreter(program)
result = i.run()
self.assertEqual(5, result)
__author__ = 'Levon'
from interpreter import interpreter
from tokenizer import Tokenizer
from tree import parseTree
pT = parseTree()
tok = Tokenizer()
interp = interpreter()
Tree = pT.buildParseTree(tok.tokenize("1+2"))
assert (interp.evaluate(Tree) == 3)
Tree = pT.buildParseTree(tok.tokenize("(5+(2*3+2))-3*((5+6)/2-4)"))
assert (interp.evaluate(Tree) == 8.5)
Tree = pT.buildParseTree(tok.tokenize("x = 2"))
assert (interp.evaluate(Tree) == 2)
Tree = pT.buildParseTree(tok.tokenize("y = 4^3"))
assert (interp.evaluate(Tree) == 64)
Tree = pT.buildParseTree(tok.tokenize("y^x*2-3"))
assert (interp.evaluate(Tree) == 8189)
Tree = pT.buildParseTree(tok.tokenize("(x+(2*y+2))-y*((5+x)/2-4)"))
assert (interp.evaluate(Tree) == 164)
Tree = pT.buildParseTree(tok.tokenize("sin(10)"))
assert (interp.evaluate(Tree) == -0.5440211108893698)
Tree = pT.buildParseTree(tok.tokenize("2^(5+1)"))
assert (interp.evaluate(Tree) == 64)
Tree = pT.buildParseTree(tok.tokenize("(2+1)^(2+1)"))
assert (interp.evaluate(Tree) == 27)
def setUp(self):
self.interpreter = interpreter()
#!/usr/bin/env python3
import subprocess
import interpreter
if __name__ == '__main__':
exec(open("phase1.py").read())
subprocess.call(['./phase2.sh'])
interpreter.interpreter()
def commandline():
"""zhpy, the python language on chinese
Accept options:
input: speficy the input source
output: speficy the output source
python: compile to python and run
cmp: input raw zhpy source and run
encoding: specify the encoding
info: zhpy information
verbose: show zhpy progress in detail
# zhpy: compile python code to zhpy
help:
command usage: zhpy [-i|-p] input [-o] [output] [-e] [encoding] [-v]
script usage: zhpy [-c] source [-e] [encoding] [-v]
$ zhpy input.py (.twpy, .cnpy) [arguments]
$ zhpy -i input.py (.twpy, .cnpy)
$ zhpy -i input.py -o output.py (.twpy, .cnpy)
$ zhpy -p input.py
"""
argv = sys.argv[1:]
os.chdir(os.getcwd())
source = None
target = None
encoding = None
raw_source = None
verbose = False
python = False
# run as interpreter
if len(argv) == 0:
from interpreter import interpreter
interpreter()
sys.exit()
# run as script
# not accept any option
elif not argv[0].startswith('-'):
source = argv[0]
sys.argv = argv
# run as command
# accept "-i -o -e" or "-p -e" or "-c -e"
elif len(argv)==1:
if argv[0] == '--info':
from info import info
info()
sys.exit()
if argv[0] == '-h' or argv[0] == '--help':
print commandline.__doc__
sys.exit()
elif len(argv)>=2:
if argv[0] == '-c' or argv[0] == '--cmp':
raw_source = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if not len(argv) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-i' or argv[0] == '--input':
source = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-o' or argv[0] == '--output'):
target = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if not len(argv) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-p' or argv[0] == '--python':
source = argv[1]
filename = os.path.splitext(source)[0]
del(argv[:2])
target = "n_"+filename+".py"
python = True
print "compile to python and run: %s"%("n_"+filename+".py")
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if not len(argv) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
else:
print commandline.__doc__
sys.exit()
#convert
if raw_source:
if verbose:
print "run raw_source", raw_source
annotator()
if encoding:
result = convertor(raw_source, encoding)
else:
result = convertor(raw_source)
try_run(result)
sys.exit()
if encoding:
print "encoding", encoding
if source:
if verbose:
print "input", source
# convertor
test = file(source, "r").read()
annotator()
if encoding:
result = convertor(test, encoding)
else:
result = convertor(test)
if target:
if verbose:
print "output", target
file(target,"w").write(result)
if python:
try_run(result)
else:
try_run(result)
import time
# Added efficiency with print statements
while True:
command = input(">>> ")
try:
if command[:4] == "run ":
try:
command = open(f"{command[4:]}.qball").read()
except FileNotFoundError:
raise Exception("File not found to run")
if command == "debug":
interpreter.debug = True
else:
result = lexer.lexer(command).generate_tokens()
interpret = interpreter.interpreter(result)
interpret.interpret()
except Exception as e:
try:
print(f"\033[91mError at section {interpret.section}: {e}\033[00m",
flush=True)
except NameError:
print(f"\033[91mLexer error: {e}\033[00m", flush=True)
try:
command.close()
except AttributeError:
pass
except Exception as e:
print(e)
from Grammar_analysis import Analysis
from Rearend_analysis import rear_analysis
from interpreter import interpreter
if __name__ == "__main__":
originalCodePath = 'in.txt'
outputPath = 'out.txt'
PascalAnalysis = Analysis(originalCodePath, 'first.txt')
arg = PascalAnalysis.prog()
if arg['stop'] is not True:
f = open(outputPath, 'w')
for index, c in enumerate(arg["mcode"]):
f.write('%d : %s' % (index, c))
f.write('\n')
RearendAnalysis = rear_analysis(arg)
code = RearendAnalysis.analysis()
for index, c in enumerate(code):
f.write('%d : %s' % (index, c))
f.write('\n')
f.close()
inter = interpreter(code)
inter.forward()
else:
print('Have error, stop!')
to = to.translate(None, "'")
messageId = str(messageId)
messageId = messageId.translate(None, "'")
text = str(text)
text = text.translate(None, "'")
message_timestamp = str(message_timestamp)
message_timestamp = message_timestamp.translate(None, "'")
type = str(type)
type = type.translate(None, "'")
print "<html>"
print "<head>"
print "<title>Debugging</title>"
print "</head>"
print "<body>"
print "<h2>MSISDN: %s \nTo:%s \nmessageId: %s \nText: %s \nTimestamp: %s \nType %s</h2>" % (
msisdn, to, messageId, text, message_timestamp, type)
print "</body>"
print "</html>"
# Build an object with all message details
content = {
'msisdn': msisdn,
'recipient': to,
'id': messageId,
'message': text,
'timestamp': message_timestamp
}
interpreter(content)
__author__ = 'Roland'
from interpreter import interpreter
from tokenizer import Tokenizer
from tree import parseTree
pT = parseTree()
tok = Tokenizer()
interp = interpreter()
Tree = pT.buildParseTree(tok.tokenize("1+2"))
assert(interp.evaluate(Tree) == 3)
Tree = pT.buildParseTree(tok.tokenize("(5+(2*3+2))-3*((5+6)/2-4)"))
assert(interp.evaluate(Tree) == 8.5)
Tree = pT.buildParseTree(tok.tokenize("x = 2"))
assert(interp.evaluate(Tree) == 2)
Tree = pT.buildParseTree(tok.tokenize("y = 4^3"))
assert(interp.evaluate(Tree) == 64)
Tree = pT.buildParseTree(tok.tokenize("y^x*2-3"))
assert(interp.evaluate(Tree) == 8189)
Tree = pT.buildParseTree(tok.tokenize("(x+(2*y+2))-y*((5+x)/2-4)"))
assert(interp.evaluate(Tree) == 164)
Tree = pT.buildParseTree(tok.tokenize("sin(10)"))
assert(interp.evaluate(Tree) == -0.5440211108893698)
Tree = pT.buildParseTree(tok.tokenize("2^(5+1)"))
assert(interp.evaluate(Tree) == 64)
Tree = pT.buildParseTree(tok.tokenize("(2+1)^(2+1)"))
assert(interp.evaluate(Tree) == 27)
def run():
a = text.get(1.0, "end")
interpreter.interpreter(lexer.lexer(a).generate_tokens()).interpret()
def run_python_code():
script_text = request.form['script']
inter_preter = interpreter()
result = inter_preter.call_python(script_text)
return result
def commandline():
"""zhpy, the python language in chinese
Accept options:
-i --input:
speficy the input source
-o --output:
speficy the output source
-p --python:
compile to python and run
-c --cmp:
input raw zhpy source and run
-e --encoding:
specify the encoding
--info:
zhpy information
-v --verbose:
show zhpy progress in detail
--tw:
convert python to twpy
--cn:
convert python to cnpy
help:
get information:
zhpy --info
interpreter usage:
zhpy [--tw | --cn]
command usage:
zhpy [-i | -p] input [-o] [output] [-e] [encoding] [-v]
::
$ zhpy input.py (.twpy, .cnpy) [arguments]
$ zhpy -i input.py (.twpy, .cnpy)
$ zhpy -i input.py -o output.py (.twpy, .cnpy)
$ zhpy -p input.py
script usage:
zhpy [-c] source [-e] [encoding] [-v]
convertor usage:
zhpy [--tw | --cn] input.py [-v]
::
$ zhpy --tw input.py [-v]
$ zhpy --cn input.py [-v]
"""
argv = sys.argv[1:]
os.chdir(os.getcwd())
source = None
target = None
encoding = None
raw_source = None
verbose = False
python = False
tw = False
cn = False
# run as interpreter
if len(argv) == 0:
from interpreter import interpreter
interpreter()
sys.exit()
# run as script
# not accept any option
elif not argv[0].startswith('-'):
source = argv[0]
sys.argv = argv
# run as command
elif len(argv)==1:
if argv[0] == '--info':
from info import info
info()
sys.exit()
elif argv[0] == '-h' or argv[0] == '--help':
print commandline.__doc__
sys.exit()
# run as native interpreter
elif argv[0] == '--tw':
from interpreter import interpreter
interpreter('tw')
sys.exit()
elif argv[0] == '--cn':
from interpreter import interpreter
interpreter('cn')
sys.exit()
else:
print commandline.__doc__
sys.exit()
# accept "-c -e -v"
elif len(argv)>=2:
if argv[0] == '-c' or argv[0] == '--cmp':
raw_source = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
# python to twpy
elif argv[0] == '--tw':
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .tw in filename
profix = os.path.splitext(filename)[-1]
if profix =='.tw':
filename = os.path.splitext(filename)[0]
del(argv[:2])
tw = True
target = "v_"+filename+".twpy"
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
# python to cnpy
elif argv[0] == '--cn':
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .cn in filename
profix = os.path.splitext(filename)[-1]
if profix == '.cn':
filename = os.path.splitext(filename)[0]
del(argv[:2])
cn = True
target = "v_"+filename+".cnpy"
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
# accept "-i -o -e -v" or "-p -e" or "-c -e -v"
elif argv[0] == '-i' or argv[0] == '--input':
source = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-o' or argv[0] == '--output'):
target = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-p' or argv[0] == '--python':
source = argv[1]
filename = os.path.splitext(source)[0]
del(argv[:2])
target = "n_"+filename+".py"
python = True
print "compile to python and run: %s"%("n_"+filename+".py")
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
else:
print commandline.__doc__
sys.exit()
#convert
if raw_source:
if verbose:
print "run raw_source", raw_source
annotator()
if encoding:
result = convertor(raw_source, verbose, encoding)
else:
result = convertor(raw_source, verbose)
try_run(result)
sys.exit()
if encoding:
print "encoding", encoding
if source:
if verbose:
print "input", source
# convertor
if(tw or cn):
if verbose:
print "convert python code to",
try:
from pyzh import rev_annotator, python_convertor
test = file(source, "r").read()
if tw:
print "twpy"
rev_annotator('tw', verbose)
result = python_convertor(test, lang='tw')
if cn:
print "cnpy"
rev_annotator('cn', verbose)
result = python_convertor(test, lang='cn')
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
else:
try:
test = file(source, "r").read()
annotator()
if encoding:
result = convertor(test, verbose, encoding)
else:
result = convertor(test, verbose)
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
logging.info("INIT STACK")
new_stack = stack()
logging.info("INIT PARSER")
new_decoder = parser()
new_encoder = encoder()
if args.path:
logging.info("LOAD CODE")
clean_code = load_from_fime(args.path)
else:
logging.error("No Input Specification")
exit()
logging.info("INIT MEMORY")
new_mem = pointer(clean_code, mem_size)
new_interp = interpreter(new_decoder, new_stack, new_encoder, new_mem)
logging.info("START EXECUTION")
while True:
os.system("clear")
new_interp.evaluate()
print("_______________________________")
logging.info("STACK DUMP:")
logging.info(new_interp.stack_ref.items)
print("_______________________________")
logging.info("REGISTER:")
logging.info(new_interp.register)
print("_______________________________")
logging.info("MEMORY DUMP:")
logging.info(new_mem.memory_register)
def commandline():
"""zhpy, the python language on chinese
Accept options:
-i --input:
speficy the input source
-o --output:
speficy the output source
-p --python:
compile to python and run
-c --cmp:
input raw zhpy source and run
-e --encoding:
specify the encoding
--info:
zhpy information
-v --verbose:
show zhpy progress in detail
help:
get information:
::
$ zhpy --info
interpreter usage:
::
$ zhpy
$ zhpy --tw
$ zhpy --cn
command usage:
zhpy [-i|-p] input [-o] [output] [-e] [encoding] [-v]
::
$ zhpy input.py (.twpy, .cnpy) [arguments]
$ zhpy -i input.py (.twpy, .cnpy)
$ zhpy -i input.py -o output.py (.twpy, .cnpy)
$ zhpy -p input.py
script usage:
zhpy [-c] source [-e] [encoding] [-v]
"""
argv = sys.argv[1:]
os.chdir(os.getcwd())
source = None
target = None
encoding = None
raw_source = None
verbose = False
python = False
# run as interpreter
if len(argv) == 0:
from interpreter import interpreter
interpreter()
sys.exit()
# run as script
# not accept any option
elif not argv[0].startswith('-'):
source = argv[0]
sys.argv = argv
# run as command
elif len(argv) == 1:
if argv[0] == '--info':
from info import info
info()
sys.exit()
elif argv[0] == '-h' or argv[0] == '--help':
print commandline.__doc__
sys.exit()
# run as native interpreter
elif argv[0] == '--tw':
from interpreter import interpreter
interpreter('tw')
sys.exit()
elif argv[0] == '--cn':
from interpreter import interpreter
interpreter('cn')
sys.exit()
else:
print commandline.__doc__
sys.exit()
# accept "-c -e -v" or "-i -o -e -v" or "-p -e" or "-c -e -v"
elif len(argv) >= 2:
if argv[0] == '-c' or argv[0] == '--cmp':
raw_source = argv[1]
del (argv[:2])
if len(argv) >= 2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if not len(argv) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-i' or argv[0] == '--input':
source = argv[1]
del (argv[:2])
if len(argv) >= 2 and (argv[0] == '-o' or argv[0] == '--output'):
target = argv[1]
del (argv[:2])
if len(argv) >= 2 and (argv[0] == '-e'
or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if not len(argv) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-p' or argv[0] == '--python':
source = argv[1]
filename = os.path.splitext(source)[0]
del (argv[:2])
target = "n_" + filename + ".py"
python = True
print "compile to python and run: %s" % ("n_" + filename + ".py")
if len(argv) >= 2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del (argv[:2])
if not len(argv) and (argv[0] == '-v'
or argv[0] == '--verbose'):
verbose = True
else:
print commandline.__doc__
sys.exit()
#convert
if raw_source:
if verbose:
print "run raw_source", raw_source
annotator()
if encoding:
result = convertor(raw_source, encoding)
else:
result = convertor(raw_source)
try_run(result)
sys.exit()
if encoding:
print "encoding", encoding
if source:
if verbose:
print "input", source
# convertor
try:
test = file(source, "r").read()
annotator()
if encoding:
result = convertor(test, encoding)
else:
result = convertor(test)
except:
print "zhpy Exception: you may input unproper source"
sys.exit()
if target:
if verbose:
print "output", target
file(target, "w").write(result)
if python:
try_run(result)
else:
try_run(result)
from interpreter import interpreter
with open('program.txt', 'r') as file:
# Read input program
program = list(map(int, file.readline().strip().split(",")))
target = 19690720
for noon in range(0, 100):
for verb in range(0, 100):
program_tmp = program.copy()
program_tmp[1] = noon
program_tmp[2] = verb
if(interpreter(program_tmp)[0] == target):
print(100*noon + verb)
exit()
__author__ = 'Roland'
import interpreter
print("Enter your expressions to be calculated. Enter 'Exit' to exit the calculator.")
expression = ""
tokenizer = interpreter.Tokenizer()
parser= interpreter.parseTree()
interpr = interpreter.interpreter()
while True:
expression = input('> ')
if expression != "Exit":
try:
result = interpr.evaluate(parser.buildParseTree(tokenizer.tokenize(expression)))
print(result)
except Exception as e:
print(e)
else:
break
print("Thank you for using rolisz calculator!")
def commandline():
"""zhpy, the python language in chinese
Accept options:
-i --input:
speficy the input source
-o --output:
speficy the output source
-p --python:
compile to python and run
-c --cmp:
input raw zhpy source and run
-e --encoding:
specify the encoding
--info:
zhpy information
-v --verbose:
show zhpy progress in detail
-V --version
show zhpy version
--tw:
convert python to twpy
--cn:
convert python to cnpy
help:
get information:
zhpy --info
interpreter usage:
zhpy [--tw | --cn]
command usage:
zhpy [-i | -p] input [-o] [output] [-e] [encoding] [-v]
::
$ zhpy input.py (.twpy, .cnpy) [arguments]
$ zhpy -i input.py (.twpy, .cnpy)
$ zhpy -i input.py -o output.py (.twpy, .cnpy)
$ zhpy -p input.py
script usage:
zhpy [-c] source [-e] [encoding] [-v]
convertor usage:
zhpy [--tw | --cn] input.py [-v]
::
$ zhpy --tw input.py [-v]
$ zhpy --cn input.py [-v]
"""
argv = sys.argv[1:]
os.chdir(os.getcwd())
source = None
target = None
encoding = None
raw_source = None
verbose = False
python = False
tw = False
cn = False
NonEnglish = False
# run as interpreter
if len(argv) == 0:
from interpreter import interpreter
import import_hook
display = os.getenv("LANG")
if display == None:
interpreter()
elif "zh_TW" in display:
interpreter('tw')
elif "zh_CN" in display:
interpreter('cn')
else:
interpreter()
sys.exit()
# run as script
# not accept any option
elif not argv[0].startswith('-'):
source = argv[0]
sys.argv = argv
# run as command
elif len(argv)==1:
if argv[0] == '--info':
from info import info
info()
sys.exit()
if argv[0] == '-V' or argv[0] == '--version':
from release import version
print "zhpy %s on python %s"%(version, sys.version.split()[0])
sys.exit()
elif argv[0] == '-h' or argv[0] == '--help':
print commandline.__doc__
sys.exit()
# run as native interpreter
elif argv[0] == '--tw':
from interpreter import interpreter
import import_hook
interpreter('tw')
sys.exit()
elif argv[0] == '--cn':
from interpreter import interpreter
import import_hook
interpreter('cn')
sys.exit()
else:
print commandline.__doc__
sys.exit()
# accept "-c -e -v"
elif len(argv)>=2:
if argv[0] == '-c' or argv[0] == '--cmp':
raw_source = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or \
argv[0] == '--verbose'):
verbose = True
# python to twpy
elif argv[0] == '--tw':
from pyzh import zh_chr, rev_annotator
rev_annotator()
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .tw in filename
profix = os.path.splitext(filename)[-1]
if profix =='.tw':
filename = os.path.splitext(filename)[0]
del(argv[:2])
tw = True
target = "v_"+zh_chr(filename)+".twpy"
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
# python to cnpy
elif argv[0] == '--cn':
from pyzh import zh_chr, rev_annotator
rev_annotator()
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .cn in filename
profix = os.path.splitext(filename)[-1]
if profix == '.cn':
filename = os.path.splitext(filename)[0]
del(argv[:2])
cn = True
target = "v_"+zh_chr(filename)+".cnpy"
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
# accept "-i -o -e -v" or "-p -e" or "-c -e -v"
elif argv[0] == '-i' or argv[0] == '--input':
source = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or \
argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-o' or argv[0] == '--output'):
target = argv[1]
del(argv[:2])
if len(argv)>=2 and (argv[0] == '-e' or \
argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or \
argv[0] == '--verbose'):
verbose = True
elif argv[0] == '-p' or argv[0] == '--python':
source = argv[1]
filename = os.path.splitext(source)[0]
# remove extra .tw in filename
profix = os.path.splitext(filename)[-1]
if (profix =='.tw') or (profix =='.cn'):
filename = os.path.splitext(filename)[0]
del(argv[:2])
# chinese filename to uri filename
for i in filename:
if i not in \
list('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.'):
NonEnglish = True
print i, "file name is not in english"
break
if NonEnglish:
target = zh_ord(filename.decode('utf8'))+".py"
print "compile to python and run: %s"%(
zh_ord(filename.decode('utf8'))+".py")
else:
target = "n_"+filename+".py"
print "compile to python and run: %s"%("n_"+filename+".py")
python = True
if (len(argv)!=0) and (argv[0] == '-v' or argv[0] == '--verbose'):
verbose = True
if len(argv)>=2 and (argv[0] == '-e' or argv[0] == '--encoding'):
encoding = argv[1]
del(argv[:2])
if (len(argv)!=0) and (argv[0] == '-v' or \
argv[0] == '--verbose'):
verbose = True
else:
print commandline.__doc__
sys.exit()
#convert
if raw_source:
if verbose:
print "run raw_source", raw_source
#annotator()
if encoding:
result = convertor(raw_source, verbose, encoding)
else:
result = convertor(raw_source, verbose)
zh_exec(result)
import import_hook
sys.exit()
if encoding:
print "encoding", encoding
if source:
if verbose:
print "input", source
# convertor
if(tw or cn):
if verbose:
print "convert python code to",
try:
from pyzh import rev_annotator, python_convertor
test = file(source, "r").read()
if tw:
print "twpy"
rev_annotator('tw', verbose)
result = python_convertor(test, lang='tw')
if cn:
print "cnpy"
rev_annotator('cn', verbose)
result = python_convertor(test, lang='cn')
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
else:
try:
test = file(source, "r").read()
#annotator()
import import_hook
if encoding:
result = convertor(test, verbose, encoding)
else:
result = convertor(test, verbose)
except Exception, e:
print "zhpy Exception: you may input unproper source"
if verbose:
print e
sys.exit()
