def train(filename):
oracle = Oracle(filename)
print('oracle transitions parsing...')
oracle.search_transitions()
x = np.array(oracle.features)
y = np.array(oracle.transitions)
y = np.array([k['transition'] for k in y])
#shift:0, right:1, left:2
new_y = []
for i in range(len(y)):
if y[i] == 'shift':
new_y.append([1, 0, 0])
elif y[i] == 'right':
new_y.append([0, 1, 0])
elif y[i] == 'left':
new_y.append([0, 0, 1])
y = np.array(new_y)
print('sparse encoding of features...')
vocs, inverses = zip(*(np.unique(feature, return_inverse=True)
for feature in x.T))
x_new = np.vstack(inverses).T
x_new = np.squeeze(x_new)
clf = DecisionTreeClassifier(random_state=0)
clf.fit(x_new, y)
pickle.dump(vocs, open("vocs.p", "wb"))
pickle.dump(clf, open("model.p", "wb"))
class testOracle(unittest.TestCase):
def setUp(self):
self.Oc = Oracle(databaseName =":memory:",fr = 2009, to = 2012, calcFrom = 2009, calcTo=2012,calc=False)
@unittest.skipIf(options.fast,"skipping for fast testing")
def test_predict(self):
self.Oc.train()
pr = self.Oc.predict("Los Angeles Lakers","Boston Celtics",2012,"2012-02-03")
self.assertIn(pr,["Los Angeles Lakers", "Boston Celtics"])
@unittest.skipIf(options.fast,"skipping for fast testing")
def test_train(self):
self.Oc.train()
pr = self.Oc.predict("Los Angeles Lakers","Boston Celtics",2012,"2012-02-03")
self.assertIn(pr,["Los Angeles Lakers", "Boston Celtics"])
@unittest.skipIf(options.fast,"skipping for fast testing")
def test_evaluate(self):
for model in self.Oc.models:
self.Oc.switchModel(model)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
ev = self.Oc.evaluate()
self.assertLessEqual(ev,1)
self.assertGreaterEqual(ev,0)
def train(self, trainingSet, model):
corpus = Parser.load_corpus(trainingSet)
oracle = Oracle()
for sentence in corpus:
self.initialize(sentence)
while len(self.buff) > 0 or len(self.stack) > 1:
transition = oracle.getTransition(self.stack, self.buff, \
self.leftmostChildren, self.rightmostChildren, \
self.arcs, self.labeled)
#model.learn(transition, self.stack, self.buff, \
# self.labels, self.transitions, self.arcs, sentence)
model.compile_svm_feats(transition, self.stack, self.buff, \
self.labels, self.transitions, self.arcs, sentence)
self.execute_transition(transition)
model.train_svm()
def train(self, trainingSet, model):
corpus = Parser.load_corpus(trainingSet)
oracle = Oracle()
for sentence in corpus:
self.initialize(sentence)
while len(self.buff) > 0 or len(self.stack) > 1:
transition = oracle.getTransition(self.stack, self.buff, \
self.leftmostChildren, self.rightmostChildren, \
self.arcs, self.labeled)
#model.learn(transition, self.stack, self.buff, \
# self.labels, self.transitions, self.arcs, sentence)
model.compile_svm_feats(transition, self.stack, self.buff, \
self.labels, self.transitions, self.arcs, sentence)
self.execute_transition(transition)
model.train_svm()
def train(self, trainingSet):
for i in range(self.numIterations):
corpus = Parser.load_corpus(trainingSet)
oracle = Oracle()
for sentence in corpus:
self.initialize(sentence)
self.trackTypes(sentence)
while len(self.buff) > 0 or len(self.stack) > 1:
transition = oracle.getTransition(self.stack, self.buff,
self.dependentIDs,
self.arcs, self.labeled)
self.model.learn(transition, self.stack, self.buff,
self.labels, self.transitions, self.arcs,
self.wordsThatHaveHeads)
self.execute_transition(transition)
def transformDesignByJinja(designXmlPath, transformPath, outputFile,
additionalParam):
""" additionalParam - a dictionary that will be passed to the transform """
outputDirectory = os.path.dirname(outputFile)
if not os.path.isdir(outputDirectory):
os.makedirs(outputDirectory)
designInspector = DesignInspector(designXmlPath)
transformDir = os.path.dirname(transformPath)
commonTemplatesLoader = jinja2.FileSystemLoader(
os.path.join(transformDir, '..', '..', 'Common', 'templates'))
moduleTemplatesLoader = jinja2.FileSystemLoader(transformDir)
env = jinja2.Environment(loader=jinja2.ChoiceLoader(
[commonTemplatesLoader, moduleTemplatesLoader]))
transform_filters.setup_all_filters(env)
env.trim_blocks = True
fout = open(outputFile, 'wb')
render_args = {'designInspector': designInspector, 'oracle': Oracle()}
if not isinstance(additionalParam, dict):
render_args.update({'additionalParam': additionalParam})
else:
render_args.update(additionalParam)
fout.write(
env.get_template(os.path.basename(transformPath)).render(
render_args).encode('utf-8'))
print(Fore.BLUE +
'quasar Jinja2 generator: Generated {0}, wrote {1} bytes'.format(
outputFile, fout.tell()) + Style.RESET_ALL)
def train(self, trainingSet, model): corpus = Parser.load_corpus(trainingSet) oracle = Oracle() i = 0 for sentence in corpus: if i % 25 == 0: print >>sys.stderr, "%d/1921" % i i += 1 self.initialize(sentence) while len(self.buff) > 0 or len(self.stack) > 1: transition = oracle.getTransition(self.stack, self.buff, \ self.leftmostChildren, self.rightmostChildren, \ self.arcs, self.labeled) model.learn(transition, self.stack, self.buff, \ self.arcs, self.labels, self.transitions) self.execute_transition(transition) model.build_model()
def __init__(self, conllu_sentence, id_sentence, sentence):
self.iteration = 0
self.input_buffer = list()
for t in conllu_sentence:
# t is an ordered dictionnary [("id", <val>), ("form", <val>), ("lemma", <val>), ("upostag", <val>)]
self.input_buffer.append(ConLLUToken(t["id"], t["form"], t["lemma"], t["upostag"]))
self.original_conllu_sentence = list(self.input_buffer)
self.sentence = sentence
self.stack = list()
self.dependency_relations = {}
self.token_id = 0
self.oracle = Oracle()
self.oracle.set_reference_set("feattemp.txt")
self.parse_trace = '<sentence file="input.txt" id="' + str(id_sentence) + ' text="' + sentence + '">\n'
self.parse_trace += "Step\tStack\tWord List\tAction\tRelationAdded\n"
self.id_sentence = id_sentence
def init(game):
global PHandle
global POracle
PHandle = PirateHandler(game)
POracle = Oracle(game)
# Test code
#game.debug(PHandle.groups)
PHandle.groups[0].regroup(Location(0, 0))
PHandle.groups[0].regroup(Location(440, 4400))
'''PHandle.set_pirate_role(0, "camper").set_camp(game.get_enemy_mothership().get_location())
PHandle.set_pirate_role(1, "camper").set_camp(game.get_enemy_mothership().get_location())
PHandle.set_pirate_role(2, "camper").set_camp(game.get_enemy_mothership().get_location())
PHandle.set_pirate_role(3, "carrier")
#PHandle.set_camp(Location(300,300))'''
PHandle.debug(game)
roles = POracle.assign_roles(PHandle)
game.debug([i.name for i in roles])
def __init__(self, member_id, activity_year_month, game_id):
logging.basicConfig(filename="Player.log", filemode='a', format="%(asctime)s - %(message)s"
, datefmt="%d-%b-%y %H:%M:%S")
self.member_id = member_id
self.activity_year_month = activity_year_month
self.game_id = game_id
self.sql_string_condition = ''
if not self.activity_year_month == 'All':
self.sql_string_condition = ' and activity_year_month = {activity_year_month}'
if not self.game_id == 'All':
self.sql_string_condition = self.sql_string_condition + ' and game_id = {game_id}'
self.sql_string_condition = self.sql_string_condition + ' group by member_id'
try:
self.dbquery = Oracle()
self.dbquery.connect_2_db('SCHEMA', 'PW', 'DB')
except Exception:
logging.warning(f"Failed to query the total win amount for member {self.member_id}")
def __init__(self, filename):
self.word_list = []
self.pile = []
self.buffer = WordBuffer(self.mcd)
self.buffer.readFromConlluFile(filename)
self.oracle = Oracle(filename)
self.transitions = []
self.next_sentence()
self.sentence = []
def train(self, trainingSet):
for i in range(self.numIterations):
corpus = Parser.load_corpus(trainingSet)
oracle = Oracle()
for sentence in corpus:
self.initialize(sentence)
self.trackTypes(sentence)
while len(self.buff) > 0 or len(self.stack) > 1:
transition = oracle.getTransition(self.stack, self.buff, self.dependentIDs, self.arcs, self.labeled)
self.model.learn(
transition,
self.stack,
self.buff,
self.labels,
self.transitions,
self.arcs,
self.wordsThatHaveHeads,
)
self.execute_transition(transition)
def get_next_action_supervised_t(self, state_t, state_s, q, nu):
# rand_val = np.random.rand()
# if rand_val < 0.8:
if state_s.selected_index is None:
return Action.PICK, random.randint(0, state_s.block_count - 1)
else:
best_action, self.order = Oracle.get_oracle_best_action(
state=state_s,
block_idx=state_s.selected_index,
order=self.order)
print("Oracle action: %s" % best_action)
return best_action, state_s.selected_index
def get_state_as_state(self):
block_dict = self.block_dict
state = State(block_positions=[(block_dict[block_id].rect.centerx,
block_dict[block_id].rect.centery)
for block_id in block_dict],
goal_positions=None,
selected_index=None)
goal_conf = self.goal_config[0].copy()
goal_conf.reverse()
goal_positions = Oracle.get_goal_position(curr_state=state,
goal_config=goal_conf,
step_size=self.block_size)
return State(block_positions=state.block_positions,
goal_positions=goal_positions,
selected_index=self.selected_block_id)
def generate():
oracle = Oracle()
for initializer in Initializers:
for asWrite in AddressSpaceWrites:
for scalarArray in ['scalar', 'array']:
for nullPolicy in NullPolicy:
if initializer == 'valueAndStatus' and scalarArray == 'array':
continue # this is not supported
dataTypes = get_allowed_datatypes(initializer)
for dataType in dataTypes:
scenario_name = create_scenario_name(
dataType, scalarArray, initializer, asWrite,
nullPolicy)
print(scenario_name)
if initializer == 'valueAndStatus' and dataType == 'UaVariant' and nullPolicy == 'nullForbidden':
continue # this setting is clearly invalid!
generateDeviceLogicCase(dataType, scalarArray,
initializer, asWrite,
nullPolicy)
if initializer == 'valueAndStatus':
if dataType != 'UaVariant':
initialValue = SampleInitialValue[dataType]
extra = 'initialStatus="OpcUa_Good" initialValue="{0}"'.format(
initialValue)
else:
extra = 'initialStatus="OpcUa_Good" ' # no initial value!
else:
extra = ''
if scalarArray == 'scalar':
output(
'<d:cachevariable name="{0}" addressSpaceWrite="{1}" initializeWith="{2}" nullPolicy="{5}" dataType="{3}" {4} />\n'
.format(scenario_name, asWrite, initializer,
dataType, extra, nullPolicy))
else:
output(
'<d:cachevariable name="{0}" addressSpaceWrite="{1}" initializeWith="{2}" nullPolicy="{5}" dataType="{3}" {4} >\n'
.format(scenario_name, asWrite, initializer,
dataType, extra, nullPolicy))
output('<d:array/>\n')
output('</d:cachevariable>\n')
def slow_message_processing(bot, askers_table, registrators_table, messages_queue):
# probably not good idea
LANGUAGES = frozenset(['English', 'Russian'])
THEMES = frozenset(['Physics', 'IT'])
user_data_base = UserDataBase()
one_to_one = One_to_one()
oracle = Oracle(bot, user_data_base, one_to_one)
conversations = dict()
def _form_registration_data_message(user_id_):
answer = "Your registration data is:\n"
answer += "`Name: " + user_data_base.get_user(user_id_)['Name'] + "`\n"
answer += "`Languages: "
for language in user_data_base.get_user(user_id_)['Languages']:
answer += language + ", "
answer = answer[:-2] + "`\n"
answer += "`Themes: "
for theme in user_data_base.get_user(user_id_)['Themes']:
answer += theme + ", "
answer = answer[:-2] + "`"
return answer
def _process_conversation(message_chat_id_, message, new_conversation):
if new_conversation:
logger.info("Conversation with question '%s' started by chat_id: '%d'", message, message_chat_id_)
conversation = Conversation(Question(message_chat_id, message), oracle)
conversations[message_chat_id] = conversation
conversation.main()
else:
logger.info("Old conversation is processed with answer '%s'", message)
def _process_registration(message_chat_id_, message_text_):
if message_text_ in LANGUAGES:
reply_keyboard = [THEMES]
user_data_base.write_user_data(message_chat_id_, 'Languages', message_text_)
bot.send_message(chat_id = message_chat_id_,
text = 'Which topics do you know?',
reply_markup = ReplyKeyboardMarkup(
reply_keyboard,
one_time_keyboard = True,
resize_keyboard = True))
elif message_text_ in THEMES:
reply_keyboard = [['/ask', '/help', '/edit_profile']]
user_data_base.write_user_data(message_chat_id_, 'Themes', message_text_)
bot.send_message(chat_id = message_chat_id_,
text = _form_registration_data_message(message_chat_id_),
parse_mode = 'Markdown',
reply_markup = ReplyKeyboardMarkup(
reply_keyboard,
one_time_keyboard = True,
resize_keyboard = True))
logger.info("User %d removed from registrators_table", message_chat_id_)
registrators_table.remove_user(message_chat_id_)
else:
reply_keyboard = [LANGUAGES]
user_data_base.add_user(message_chat_id_, message_text_)
bot.send_message(chat_id = message_chat_id_,
text = 'Which languages do you know?',
reply_markup = ReplyKeyboardMarkup(
reply_keyboard,
one_time_keyboard = True,
resize_keyboard = True))
while True:
message_chat_id, message_text = messages_queue.get()
if one_to_one.search_and_pop(message_chat_id):
_process_conversation(message_chat_id, message_text, new_conversation = False)
elif askers_table.user_in_table(message_chat_id):
_process_conversation(message_chat_id, message_text, new_conversation = True)
elif registrators_table.user_in_table(message_chat_id):
_process_registration(message_chat_id, message_text)
value_num = Settings.get_value("value_num")
if Settings.has_value("pickup_delay"):
PICKUP_DELAY = Settings.get_value("pickup_delay")
TRAINING_DAYS: List[int] = list(range(3, 3 + training_days))
TEST_DAYS: List[int] = list(range(11, 11 + testing_days))
# Initialising components
# TODO: Save start hour not start epoch
envt = NYEnvironment(num_agents,
START_EPOCH=START_HOUR * 3600,
STOP_EPOCH=END_HOUR * 3600,
MAX_CAPACITY=CAPACITY,
EPOCH_LENGTH=DECISION_INTERVAL)
oracle = Oracle(envt)
central_agent = CentralAgent(envt)
central_agent.mode = "train"
value_function = ValueFunction.num_to_value_function(envt, value_num)
print("Input settings {}".format(Settings.settings_list))
max_test_score = 0
for epoch_id in range(NUM_EPOCHS):
for day in TRAINING_DAYS:
epoch_data = run_epoch(envt,
oracle,
central_agent,
value_function,
day,
is_training=True)
def setUp(self):
self.Oc = Oracle(databaseName =":memory:",fr = 2009, to = 2012, calcFrom = 2009, calcTo=2012,calc=False)
import numpy as np
import time
from multiprocessing import Pool
from Configuration import Configuration
from Oracle import Oracle
#from Model import TBP_AS_model
filename = "../UD_French-GSD/UD_French-GSD/fr_gsd-ud-train.conllu"
#filename = "../UD_French-GSD/UD_French-GSD/test.conllu"
oracle = Oracle(filename)
oracle.search_transitions()
x = np.array(oracle.features)
y = np.array(oracle.transitions)
y = np.array([k['transition'] for k in y])
#shift:0, right:1, left:2
new_y = []
for i in range(len(y)):
if y[i] == 'shift':
new_y.append([1, 0, 0])
elif y[i] == 'right':
new_y.append([0, 1, 0])
elif y[i] == 'left':
new_y.append([0, 0, 1])
y = np.array(new_y)
x.shape, y.shape
def pubkeyO():
priv_key = PrivateKey.unhexlify(Oracle())
return priv_key.pub()
if __name__ == '__main__':
# Point your browser to http://localhost:8080/
parser = OptionParser()
parser.add_option("-f",action="store_true",dest="fast", default = False)
(options,args) = parser.parse_args()
PORT_NAME = 'localhost'
PORT_NUMBER = 8080
user = ""
UserDatabase = sql.connect('OracleUsers.db',detect_types=sql.PARSE_DECLTYPES)
logging.basicConfig(filename='oracleserver.log',level=logging.DEBUG)
tableExists = lambda tableName,database: False if len(list(database.execute("select name from sqlite_master where type='table' and name = '%s'" % tableName))) < 1 else True #Checks whether the table exists.
if not tableExists('Users',UserDatabase):
UserDatabase.execute("CREATE TABLE Users (id INTEGER PRIMARY KEY AUTOINCREMENT , user varchar(255), pass varchar(255),loggedin boolean default false, credits int default 10)")
print "Starting Oracle and Fetching Schedule..."
Or=Oracle()
HomeGuesser = Oracle()
print "Starting Oracle and Fetching Schedule... Done"
HomeGuesser.switchModel("always_home")
if not options.fast:
Or.switchModel('randomForest', randomForestEstimators = 100, numberOfLastGames = 3)
print "Training model..."
Or.train()
print "Training model... Done"
teamNames=list(str(name[0]) for name in list(Or.Odb.dbConn.execute("select distinct realname from teamNames")))
class myHandler(BaseHTTPRequestHandler):
#This class handles incoming requests from the browser
def do_GET(self):
# Handler for the GET requests
logging.debug("<request>: %s" %(self.path))
"name": "success",
"type": "bool"
}
],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
}
]
''')
if __name__ == '__main__':
info('Enon oracle :: v0.1')
exchange_address = environ['ARG0']
oracle_address = environ['ARG1']
oracle = Oracle(exchange_address, oracle_address)
web3 = Web3(WebsocketProvider(WEB3_PROVIDER))
private_key = codecs.decode(environ['ARG2'], 'hex')
account_address = keys.PrivateKey(
private_key).public_key.to_checksum_address()
info('Use account: {}'.format(account_address))
def send_tx(tx_gen):
nonce = web3.eth.getTransactionCount(account_address)
unsigned = tx_gen.buildTransaction({
'chainId': 42,
'gas': 300000,
'gasPrice': web3.toWei(1, 'gwei'),
'nonce': nonce
})
# -*- coding: utf-8 -*-
##
# Oraclize oracle main
##
from os import environ
from Oracle import Oracle
if __name__ == '__main__':
Oracle(environ['ARG0'], environ['ARG1']).main()
'FHHHF',
'FHHHF',
'GFFFG'
]
lake = gym.make("FrozenLake-v0", desc=cstm_map, is_slippery=False)
"""
state_size = lake.observation_space.n
action_size = lake.action_space.n
qtable = Qtable.Qtable(state_size, action_size, True) # Initialize q-table
# Initialize oracle
oracle_qtable_initial = pickle.load(open('q_table_episode_4x4Oracle.pkl',
'rb')).qtable
oracle = Oracle(oracle_qtable_initial)
print(oracle.qtable)
episodes = 100
max_moves = 30 # Max moves per episode
# q-learning parameters
learning = .8
discount = .99
exploration_rate = .001
min_exploration = .01
exploration_decay = .001
# policy shaping parameters:
confidence = .9 # confidence that feedback is optimal
likelihood = .9 # likelihood feedback is provided
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. @contact: [email protected] ''' import sys from Oracle import Oracle from transform_filters import cap_first Pythia = Oracle() class Delphi(): def readPronouncementToType(self, dataType): """ Helper for read pronouncement based on the datatype """ if dataType == 'UaString': return "out = UaVariant(dataValues[0].Value).toString();" else: return '''\ UaStatus conversionStatus = (UaVariant(dataValues[0].Value)).{toType} (out); if (! conversionStatus.isGood()) {{ throw std::runtime_error(std::string(\"OPC-UA read: read succeeded but conversion to native type failed (was it NULL value?): \") + UaStatus(dataValues[0].StatusCode).toString().toUtf8() ); }}\ '''.format(
def communicate(self):
self.pre_key_generation()
while True:
rList, wList, error_sockets = select.select([self.socket, sys.stdin], [], [])
for sock in rList:
if sock == self.socket:
data = sock.recv(1024)
if self.secret_chat == 1 and data[:4] != b"SEEN" and data[:15] != b"STARTSECCHATREQ":
msg_key = data[:16]
d_msg = self.o.decrypt(data, msg_key, self.org)
sock.send(b"SEEN")
return d_msg
if data[:15] == b"STARTSECCHATREQ" and self.secret_chat == 0:
answer = input("New secret chat request. Do you want to accept? (Y/n): ")
if answer.lower() == "y" or answer.lower() == '':
self.org = "op"
self.socket.send(b"STARTSECCHATACK")
else:
self.socket.send(b"STARTSECCHATNACK")
sys.stdout.write("Peer refused secret chat connection!\n")
self.display()
elif data[:16] == b"STARTSECCHATNACK":
sys.stdout.write("Peer refused secret chat connection!\n")
self.display()
elif data[:15] == b"STARTSECCHATACK":
self.org = "org"
self.dh.gen_private()
self.socket.send(b"DHPARAMS" + self.dh.dh_parameters)
elif data[:8] == b"DHPARAMS":
self.dh.dh_parameters = data[8:]
self.dh.gen_private()
self.dh.gen_public()
self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
elif data[:10] == b"PPUBLICKEY":
peer_pub_key = data[10:]
self.shared_secret = self.dh.gen_shared_key(peer_pub_key)
self.o = Oracle(self.shared_secret)
self.secret_chat = 1
sys.stdout.write("Secret shared key generated\n")
self.display()
sys.stdout.write("~~~ [+] Secret chat started [+] ~~~\n")
self.display()
if self.dh.public_key is None:
self.dh.gen_public()
self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
elif data[:4] == b"SEEN":
sys.stdout.write("[*] Seen\n")
self.display()
else:
sock.send(b"SEEN")
return data
else:
msg = sys.stdin.readline()
if msg.strip() == "/help":
sys.stdout.write("/help : Help /secret : Starting secret chat\n")
self.display()
elif msg.strip() == "/secret":
if self.secret_chat == 0:
self.socket.send(b"STARTSECCHATREQ")
return "SENT"
else:
return b"Secret chat already established."
elif self.secret_chat == 1 and self.shared_secret is not None:
e_msg = self.o.encrypt(msg.encode(), self.org)
if self.socket.send(e_msg):
return "SENT"
elif self.socket.send(msg.encode()) and msg != '':
return "SENT"
class TransitionBasedDependencyParser:
def __init__(self, conllu_sentence, id_sentence, sentence):
self.iteration = 0
self.input_buffer = list()
for t in conllu_sentence:
# t is an ordered dictionnary [("id", <val>), ("form", <val>), ("lemma", <val>), ("upostag", <val>)]
self.input_buffer.append(ConLLUToken(t["id"], t["form"], t["lemma"], t["upostag"]))
self.original_conllu_sentence = list(self.input_buffer)
self.sentence = sentence
self.stack = list()
self.dependency_relations = {}
self.token_id = 0
self.oracle = Oracle()
self.oracle.set_reference_set("feattemp.txt")
self.parse_trace = '<sentence file="input.txt" id="' + str(id_sentence) + ' text="' + sentence + '">\n'
self.parse_trace += "Step\tStack\tWord List\tAction\tRelationAdded\n"
self.id_sentence = id_sentence
def parse(self):
# Initial state
# input buffer already set in the constructor
self.stack.append(ConLLUToken.create_root_token())
while not self.is_done():
transition_operator = self.oracle.consult(self.stack, self.input_buffer)
self.apply(transition_operator)
self.export_trace()
self.export_conllu()
def is_done(self):
assert len(self.stack) > 0
return len(self.input_buffer) == 0 and self.stack[-1].is_root()
def shift(self):
# self.add_to_trace(Action.SHIFT.name)
assert len(self.input_buffer) > 0
self.update_trace("shift", None, None)
element = self.input_buffer.pop(0)
self.stack.append(element)
def left_arc(self):
assert len(self.stack) > 1 and not self.stack[-2].is_root()
self.update_trace("leftarc", self.stack[-1], self.stack[-2])
head = self.stack[-1]
dependent = self.stack.pop(-2)
self.dependency_relations[dependent.id] = head.id
def right_arc(self):
assert len(self.stack) > 1
self.update_trace("rightarc", self.stack[-1], self.stack[-2])
if self.stack[-2].is_root():
self.dependency_relations[self.stack[-1].id] = 0
else:
self.dependency_relations[self.stack[-1].id] = self.stack[-2].id
self.stack.pop()
def update_trace(self, action, head, dependent):
self.iteration += 1
if action == "leftarc":
self.parse_trace += str(self.iteration) + "\t[" + ",".join(str(x) for x in self.stack) + "]\t[" + ",".join(str(x) for x in self.input_buffer)
self.parse_trace += "]\tLEFTARC\t(" + str(head) + "<-" + str(dependent) + ")\n"
elif action == "rightarc":
self.parse_trace += str(self.iteration) + "\t[" + ",".join(str(x) for x in self.stack) + "]\t[" + ",".join(str(x) for x in self.input_buffer)
self.parse_trace += "]\tRIGHTARC\t(" + str(head) + "->" + str(dependent) + ")\n"
elif action == "shift":
self.parse_trace += str(self.iteration) + "\t[" + ",".join(str(x) for x in self.stack) + "]\t[" + ",".join(str(x) for x in self.input_buffer)
self.parse_trace += "]\tSHIFT\n"
def apply(self, transition_operator):
assert transition_operator in ["shift", "leftarc", "rightarc", "done"]
if transition_operator == "shift":
self.shift()
elif transition_operator == "leftarc":
self.left_arc()
else:
self.right_arc()
def export_trace(self):
self.parse_trace += str(self.iteration) + "\t[root]\t[]\tDone\n</sentence>\n\n"
file = open("trace_sentences.txt", "a")
file.write(self.parse_trace)
file.close()
def export_conllu(self):
file = open("conllu_sentences.txt", "a")
file.write("# sent_id = " + str(self.id_sentence) + "\n# text = " + self.sentence + "\n")
file.write("#1.ID\t2.FORM\t3.LEMMA\t4.UPOSTAG\t5.XPOSTAG\t6.FEATS\t7.HEAD\t8.DEPREL\n")
for token in self.original_conllu_sentence:
file.write(str(token.id) + "\t" + token.form + "\t" + token.lemma + "\t" + token.upostag
+ "\t_\t_\t" + str(self.dependency_relations[token.id]) + "\tDEP\n")
file.write("\n\n")
file.close()
class Transport:
def __init__(self):
self.uri = None
self.socket = None
self.shared_secret = None
self.pre_dh_state = 0
self.dh = None
self.secret_chat = 0
self.o = None
self.org = None
def connect(self, ip, port):
self.uri = (ip, port)
csocket = socket(AF_INET, SOCK_STREAM)
try:
csocket.connect(self.uri)
self.socket = csocket
return True
except:
return False
def isseen(self):
state = self.socket.recv(4).decode()
if state == "SEEN":
return True
def start_secret_chat(self):
self.socket.send(b"STARTSECCHAT")
data = self.socket.recv(15).decode()
if data == "STARTSECCHATACK":
return True
exit("Peer refused chat or timeout reached!")
def send(self, message):
self.socket.send(message)
if self.isseen():
return True
return True
def pre_key_generation(self):
if self.pre_dh_state == 0:
sys.stdout.write("Pre Key Generation Started. Please Wait...\n")
self.dh = DH()
self.pre_dh_state = 1
sys.stdout.write("Pre Key Generation Completed.\n")
self.display()
def communicate(self):
self.pre_key_generation()
while True:
rList, wList, error_sockets = select.select([self.socket, sys.stdin], [], [])
for sock in rList:
if sock == self.socket:
data = sock.recv(1024)
if self.secret_chat == 1 and data[:4] != b"SEEN" and data[:15] != b"STARTSECCHATREQ":
msg_key = data[:16]
d_msg = self.o.decrypt(data, msg_key, self.org)
sock.send(b"SEEN")
return d_msg
if data[:15] == b"STARTSECCHATREQ" and self.secret_chat == 0:
answer = input("New secret chat request. Do you want to accept? (Y/n): ")
if answer.lower() == "y" or answer.lower() == '':
self.org = "op"
self.socket.send(b"STARTSECCHATACK")
else:
self.socket.send(b"STARTSECCHATNACK")
sys.stdout.write("Peer refused secret chat connection!\n")
self.display()
elif data[:16] == b"STARTSECCHATNACK":
sys.stdout.write("Peer refused secret chat connection!\n")
self.display()
elif data[:15] == b"STARTSECCHATACK":
self.org = "org"
self.dh.gen_private()
self.socket.send(b"DHPARAMS" + self.dh.dh_parameters)
elif data[:8] == b"DHPARAMS":
self.dh.dh_parameters = data[8:]
self.dh.gen_private()
self.dh.gen_public()
self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
elif data[:10] == b"PPUBLICKEY":
peer_pub_key = data[10:]
self.shared_secret = self.dh.gen_shared_key(peer_pub_key)
self.o = Oracle(self.shared_secret)
self.secret_chat = 1
sys.stdout.write("Secret shared key generated\n")
self.display()
sys.stdout.write("~~~ [+] Secret chat started [+] ~~~\n")
self.display()
if self.dh.public_key is None:
self.dh.gen_public()
self.socket.send(b"PPUBLICKEY" + self.dh.public_key)
elif data[:4] == b"SEEN":
sys.stdout.write("[*] Seen\n")
self.display()
else:
sock.send(b"SEEN")
return data
else:
msg = sys.stdin.readline()
if msg.strip() == "/help":
sys.stdout.write("/help : Help /secret : Starting secret chat\n")
self.display()
elif msg.strip() == "/secret":
if self.secret_chat == 0:
self.socket.send(b"STARTSECCHATREQ")
return "SENT"
else:
return b"Secret chat already established."
elif self.secret_chat == 1 and self.shared_secret is not None:
e_msg = self.o.encrypt(msg.encode(), self.org)
if self.socket.send(e_msg):
return "SENT"
elif self.socket.send(msg.encode()) and msg != '':
return "SENT"
def display(self):
you = "\33[33m\33[1m> \33[0m"
sys.stdout.write(you)
sys.stdout.flush()
def __init__(self):
Oracle.__init__(self)
names = self._names()
self.tableAlias = {'thisTable': '{schema}.{table}'.format(**names)}
self.tableAlias.update(self._tableAlias())
self.sqlPatterns = self._sqlPatterns()
class Player:
def __init__(self, member_id, activity_year_month, game_id):
logging.basicConfig(filename="Player.log", filemode='a', format="%(asctime)s - %(message)s"
, datefmt="%d-%b-%y %H:%M:%S")
self.member_id = member_id
self.activity_year_month = activity_year_month
self.game_id = game_id
self.sql_string_condition = ''
if not self.activity_year_month == 'All':
self.sql_string_condition = ' and activity_year_month = {activity_year_month}'
if not self.game_id == 'All':
self.sql_string_condition = self.sql_string_condition + ' and game_id = {game_id}'
self.sql_string_condition = self.sql_string_condition + ' group by member_id'
try:
self.dbquery = Oracle()
self.dbquery.connect_2_db('SCHEMA', 'PW', 'DB')
except Exception:
logging.warning(f"Failed to query the total win amount for member {self.member_id}")
def tot_win_amount(self):
sql_string = """
select sum(win_amount)
from revenue_analysis
where member_id = {member_id}
"""
sql_string = sql_string + self.sql_string_condition
sql_string.format(member_id=self.member_id,
activity_year_month=self.activity_year_month,
game_id=self.game_id)
try:
win_amount = self.dbquery.run_query(sql_string)
except Exception:
logging.warning(f"Failed to query the total win amount for member {self.member_id}")
return win_amount
def tot_wager_amount(self):
sql_string = """
select sum(wager_amount)
from revenue_analysis
where member_id = {member_id}
"""
sql_string = sql_string + self.sql_string_condition
sql_string.format(member_id=self.member_id,
activity_year_month=self.activity_year_month,
game_id=self.game_id)
try:
wager_amount = self.dbquery.run_query(sql_string)
except Exception:
logging.warning("Failed to query the total wager amount for"
"member {member_id}".format(member_id=self.member_id))
return wager_amount
def num_of_wagers(self):
sql_string = """
select count(wager_amount)
from revenue_analysis
where member_id = {member_id}
"""
sql_string = sql_string + self.sql_string_condition
sql_string.format(member_id=self.member_id,
activity_year_month=self.activity_year_month,
game_id=self.game_id)
try:
tot_num_of_wagers = self.dbquery.run_query(sql_string)
except Exception:
logging.warning(f"Failed to query the total win amount for member {self.member_id}")
return tot_num_of_wagers
def __init__(self):
Oracle.__init__(self)
names = self._names()
self.tableAlias = {'thisTable': '{schema}.{table}'.format(**names)}
self.tableAlias.update(self._tableAlias())
self.sqlPatterns = self._sqlPatterns()
