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(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"))
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, 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 __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 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')
"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
})
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 pubkeyO():
priv_key = PrivateKey.unhexlify(Oracle())
return priv_key.pub()
# -*- 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"
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
