def main(argv):
(inputfile, outputfile, shapesCount, primitive, method, gif, seed) = parseArguments(argv)
# Load image
img = loadImage(inputfile)
if img is None:
print "Input file is not an image"
sys.exit(2)
# Process image
random.seed(seed)
[rendering, shapes] = method(shapesCount, primitive, maxSize=240, randomIterations=500).process(img)
# Export rendering
exportFilename = '{}_{}_{:1.0f}'.format(os.path.splitext(os.path.basename(inputfile))[0], shapesCount, Method.rmse(rendering, np.asarray(img, dtype=np.float32)))
if gif:
renderings = Method.renderIntermediates(shapes, Method.backgroundImage(img), gif)
basesha1 = '%032x' % random.getrandbits(128)
dirpath = tempfile.mkdtemp()
for (i,render) in enumerate(renderings):
cv2.imwrite('{}_{:03}.png'.format(dirpath+basesha1, i), render)
os.system('convert -delay 75 {}_*.png {}.gif'.format(dirpath+basesha1, exportFilename))
shutil.rmtree(dirpath)
if not outputfile:
outputfile = '{}.png'.format(exportFilename)
cv2.imwrite(outputfile, rendering)
# Show rendering
plt.axis('off')
plt.imshow(cv2.cvtColor(rendering, cv2.COLOR_BGR2RGB))
plt.show()
def test(self):
"""
Test the model loaded from model_file on data in data_file
model_file: pkl file to read from
data_file: pcap file to read from
verbosity: verbosity
"""
self.method = Method(api=self.api, send_fn=self.send_to_monitor)
self.method.load_model(self.model_file)
self.monitor = Monitor(log_level=self.verbosity,
send_fn=self.send_to_method,
attack_type=self.attack_type)
pkts = []
with open(self.data_file, 'rb') as f:
pkts = pickle.load(f)
self.monitor.create_test_data(pkts)
self.monitor.send()
start_time = time.time()
# time out after 10 seconds
while not self.monitor.completed():
sleep(.1)
self.monitor.show_results()
if self.out_file:
pickle.dump(self.monitor.test_data, open(self.out_file, 'wb'))
def train(self):
"""
Train the model on data in data_file and save to model_file
model_file: pkl file to write to
data_file: pcap file to read from
"""
self.method = Method(api=self.api, send_fn=self.send_to_monitor)
self.method.train_model(self.model_file, self.data_file,
self.featurizer)
def add_main(self): main_cls = self.main_cls if any(main_cls.mtd_by_name(u"main")): return params = [ (u"String[]", u"args") ] main = Method(clazz=main_cls, mods=C.PBST, name=u"main", params=params) def to_call(mtd): return mtd.name + "();" body = '\n'.join(map(to_call, self.harness())) main.body = st.to_statements(main, body) main_cls.mtds.append(main)
def add_main(self):
main_cls = self.main_cls
if any(main_cls.mtd_by_name(u"main")): return
params = [(u"String[]", u"args")]
main = Method(clazz=main_cls, mods=C.PBST, name=u"main", params=params)
def to_call(mtd):
return mtd.name + "();"
body = '\n'.join(map(to_call, self.harness()))
main.body = st.to_statements(main, body)
main_cls.mtds.append(main)
def render_GET(self, request):
ret = Method.render_GET(self, request)
if ret:
return ret
entry = self.player.get_playing_entry()
header = utils.entry_header()
header.append('time')
item = utils.render_entry(entry)
r, shuffle, repeat = self.player.get_playback_state()
if entry:
[r, t] = self.player.get_playing_time()
item.append(t)
r, volume = self.player.get_volume()
r, mute = self.player.get_mute()
ret = {
'header': header,
'current': item,
'repeat': repeat,
'shuffle': shuffle,
'playing': self.player.props.playing,
'volume': volume,
'mute': mute
}
return json.dumps(ret)
def render_GET(self, request):
ret = Method.render_GET(self, request)
if ret:
return ret
entry = self.player.get_playing_entry()
header = utils.entry_header()
header.append('time')
item = utils.render_entry(entry)
r, shuffle, repeat = self.player.get_playback_state()
if entry:
[r, t] = self.player.get_playing_time()
item.append(t)
r, volume = self.player.get_volume()
r, mute = self.player.get_mute()
ret = {'header': header, 'current': item, 'repeat': repeat, 'shuffle': shuffle, 'playing': self.player.props.playing, 'volume': volume, 'mute': mute};
return json.dumps(ret)
def calculate(self):
'''Функция заполнение таблицы '''
if __import__('re').findall('\d+? *?\+ *?\d+?',
self.objectiv_func_edit.text()):
pass
else:
print("[SECURITY] F**K YOU!")
return
self.result_table.setColumnCount(0)
self.result_table.setRowCount(0)
self.except_label.setText('')
self.x1min = float(self.x1_min_edit.text())
self.x1max = float(self.x1_max_edit.text())
self.x2min = float(self.x2_min_edit.text())
self.x2max = float(self.x2_max_edit.text())
self.step = float(self.step_combBox.currentText())
self.function = str(self.objectiv_func_edit.text())
if self.x1min >= self.x1max or self.x2min >= self.x2max:
self.except_label.setText(
'Минимальное значение больше максимального !')
else:
self.excpts = []
# достает существующие ограничения и вносит в список
for expt in range(0, self.exeption_table.rowCount()):
if self.exeption_table.item(expt, 0).text():
self.excpts.append(
self.exeption_table.item(expt, 0).text())
self.method = Method(self.x1min, self.x2min, self.x1max,
self.x2max, self.step, self.function,
self.excpts)
bool_matrix = self.method.boolean_matrix
spis = self.method.spis
self.result_table.setColumnCount(len(spis[0]))
self.result_table.setRowCount(len(spis))
for i in range(len(spis)):
for j in range(len(spis[i])):
self.min(i, j, spis, bool_matrix)
self.min_label.setText(str(self.method.min_needed()))
def method_perebor(self):
method = Method(self.x1min, self.x2min, self.x1max, self.x2max,
self.step, self.function, self.excpts)
bool_matrix = method.boolean_matrix
spis = method.spis
self.result_table.setColumnCount(len(spis[0]))
self.result_table.setRowCount(len(spis))
for i in range(len(spis)):
for j in range(len(spis[i])):
self.min(i, j, spis, bool_matrix)
min_value_of_fuction, x1, x2 = method.min_needed()
QtWidgets.QMessageBox.information(
self, "Результат",
"Минимум функции:\t{0}\n\tx1:\t{1}\n\tx2:\t{2}".format(
min_value_of_fuction, x1, x2))
def __init__(self, *args):
"""Args can either be a single arg Method, or method_class, method_id, *args
where *args are passed onto the correct Method constructor"""
if len(args) == 1 and isinstance(args[0], Method):
self.method, = args
method_class, method_id = self.method.method_class, self.method.method_id
else:
if len(args) < 2:
raise TypeError("If no Method given, method_class and method_id must be provided")
method_class, method_id = args[:2]
args = args[2:]
self.method = Method.from_id(method_class, method_id)(*args)
super(MethodPayload, self).__init__(method_class, method_id)
def makeMethods(analysis):
objs = []
numMethods = 0
posMethods = []
for j in range(
0, len(analysis)
): #start with something that starts w def, ends when run into other def
if "def" in analysis[j]:
numMethods = numMethods + 1
posMethods.append(j)
for i in range(0, numMethods):
innerMethod = [] #strings of things in method
tempName = ""
tempArgs = []
if (i == numMethods - 1):
end = len(analysis)
else:
end = posMethods[i + 1] - 1
for a in range(posMethods[i], end):
if a == posMethods[i]:
tempName = analysis[a][4]
tempArgs = findArgs(tempName)
else:
if ("def" not in analysis[a][4]):
innerMethod.append(analysis[a])
organizedInnerMethod = organizeInnerMethod(tempName, innerMethod)
appendMeMethod = Method(tempName, tempArgs, organizedInnerMethod)
appendMeMethod.setMethodsCalled(findMethods(organizedInnerMethod))
appendMeMethod.setBasicMethodsCalled(
findBasicMethods(organizedInnerMethod))
appendMeMethod.setDocs(
makeDocs(appendMeMethod, tempName, tempArgs, organizedInnerMethod))
objs.append(appendMeMethod)
return objs
def parse(db, raw_recipe):
"""parsing recipe download into recipe structure"""
(raw_name, raw_ingredients, raw_directions) = raw_recipe
tokenized_dirs = [ nltk.word_tokenize(d) for d in raw_directions]
tagged_directions = [
nltk.pos_tag(d) for d in tokenized_dirs
]
name = raw_name
ingredients = [Ingredient.parse(db, i) for i in raw_ingredients]
directions = [
Direction.parse(d, ingredients)
for d in tagged_directions
]
methods = Method.find_methods(directions)
tok_text = [
word
for d in tokenized_dirs
for word in d
]
tools = Tool.find_tools(tok_text)
return Recipe(name, ingredients, tools, methods, directions)
def process(self):
if self.projects is None:
self.projects = {}
for name, module in self.project_args:
with open(f'{name}.json', 'r') as f:
project: Project = jsonpickle.decode(f.read())
self.projects[project.name] = project
for name, project in self.projects.items():
test_files = TestIndex.iter_test_files(name)
test_methods: Dict[PyDrillerMethod, Set[CustomCommit]] = {}
for commit in project.commits:
for method in commit.modified_methods:
if method.filename in test_files:
if method in test_methods:
test_methods[method].add(commit)
else:
test_methods[method] = set()
for method, commits in test_methods.items():
contributors = {commit.author.email for commit in commits}
new_method = Method.from_pydriller_method(method.filename, method, len(commits), contributors, project)
project.methods.append(new_method)
def __init__(self, cursor, comment):
Method.__init__(self, cursor, comment)
def getChild(self, name, request):
if name == 'seek':
return Seek(self)
else:
return Method.getChild(self, name, request)
def __init__(self, shell, sources):
Method.__init__(self)
self.shell = shell
self.sources = sources
self.player = shell.get_player()
class Simulator():
def __init__(self,
model_file,
data_file,
out_file,
attack_type,
is_training,
verbosity,
featurizer=None):
"""
This class will eventually simulate real communication between
the api, method, and monitor. This behavior only makes sense for
when the system is "deployed" aka making requests in real time.
Currently, it serves to stitch together the method and monitor
(train/test and display) of static data.
"""
self.model_file = model_file
self.data_file = data_file
self.out_file = out_file
self.attack_type = attack_type
self.is_training = is_training
self.verbosity = verbosity
self.featurizer = featurizer
# requires sudo to send and receive real packets
self.api = api.API()
def train(self):
"""
Train the model on data in data_file and save to model_file
model_file: pkl file to write to
data_file: pcap file to read from
"""
self.method = Method(api=self.api, send_fn=self.send_to_monitor)
self.method.train_model(self.model_file, self.data_file,
self.featurizer)
def test(self):
"""
Test the model loaded from model_file on data in data_file
model_file: pkl file to read from
data_file: pcap file to read from
verbosity: verbosity
"""
self.method = Method(api=self.api, send_fn=self.send_to_monitor)
self.method.load_model(self.model_file)
self.monitor = Monitor(log_level=self.verbosity,
send_fn=self.send_to_method,
attack_type=self.attack_type)
pkts = []
with open(self.data_file, 'rb') as f:
pkts = pickle.load(f)
self.monitor.create_test_data(pkts)
self.monitor.send()
start_time = time.time()
# time out after 10 seconds
while not self.monitor.completed():
sleep(.1)
self.monitor.show_results()
if self.out_file:
pickle.dump(self.monitor.test_data, open(self.out_file, 'wb'))
def run(self):
"""
Run the simulation in train or test mode
"""
if self.is_training:
self.train()
else:
self.test()
def send_to_method(self, pkt):
self.method.handle_pkt(pkt)
def send_to_monitor(self, pkt):
self.monitor.handle_pkt(pkt)
"""
name = driver.find_element_by_class_name(api.nome).text
message_content = driver.find_elements_by_class_name(api.chatdados)[-1]
message = message_content.text.lower()
if len(message) > 0:
if (message == "/ping"):
api.sendResponse(response='PONG')
elif (message == "/img"):
api.sendMedia(file=os.path.dirname(os.path.realpath(__file__)) + '/img/Prev.png')
elif (message == "/doc"):
api.sendDocument(file=os.path.dirname(os.path.realpath(__file__)) + '/main.py')
except Exception as error:
traceback.print_exc()
pass
driver.find_element_by_xpath(f"//span[@title='{contactorgroupname}']").click()
api.waittemp(slp=1)
if __name__ == '__main__':
options = webdriver.ChromeOptions()
options.add_argument("user-data-dir={}".format(os.path.join(os.getcwd(), "profile", "wpp")))
driver = webdriver.Chrome(executable_path='chromedriver', options=options)
meth = Method(driver)
meth.waittemp(temp=1)
driver.get("https://web.whatsapp.com/")
try:
while True:
whatsapp(driver, meth)
except KeyboardInterrupt:
print("\nClosing bot ...")
def method_init(variables):
method = Method(variables, '', time(), scriptpath)
return method
fig.canvas.draw_idle()
if __name__ == '__main__':
fig, ax = plt.subplots()
fig.canvas.set_window_title('Лабораторная работа №5')
ax.set(xlim=(-0.1, 1.1),
ylim=(0, 0.3),
xticks=np.arange(0, 1.1, 0.1),
yticks=np.arange(0, 0.31, 0.025))
ax_solution, = ax.plot([], [],
label=SolutionCauchyProblem.name_tex_notation())
add_plot(SolutionCauchyProblem, ax_solution, 200)
plot_dict = dict(
zip(Method.get_name_methods(),
[None for _ in range(len(Method.get_name_methods()))]))
for plot in plot_dict:
plot_dict[plot], = ax.plot([], [], label=plot)
add_plots(Method, plot_dict)
ax.legend(loc='upper left')
fig.subplots_adjust(bottom=0.2)
box_axes = fig.add_axes([0.125, 0.05, 0.3, 0.075])
text_box = TextBox(box_axes, 'N', initial='5')
text_box.on_submit(submit)
visible_grid = True
ax.grid(linestyle='--', visible=visible_grid)
def get_all_methods(gifts, log): return [sub(gifts, log) for sub in Method.__subclasses__()]
def actions(self, state, player):
return list(set(Method(player, state[1], state[2], state[3], state[4])))
def getChild(self, name, request):
if name == 'seek':
return Seek(self)
else:
return Method.getChild(self, name, request)
class Main(Ui_Form):
def __init__(self):
app = QtWidgets.QApplication(sys.argv)
Form = QtWidgets.QWidget()
self.setupUi(Form)
'''Назначение кнопкам события'''
self.run_button.clicked.connect(self.calculate)
self.add_btn.clicked.connect(self.add_exception)
self.btn_graph.clicked.connect(self.show_graph)
self.btn_rand.clicked.connect(self.show_rand)
Form.show()
sys.exit(app.exec_())
def show_rand(self):
monteCarlo = MonteCarlo(self.x1min, self.x1max, self.x2min, self.x2max,
10, self.function, self.excpts)
for i in range(121):
x1, x2 = monteCarlo.rand()
monteCarlo.func(x1, x2)
min_list = monteCarlo.get_min()
self.min_label.setText(str(min_list[:3]))
self.label.setText(str(min_list[3]))
#print(monteCarlo.get_min())
def show_graph(self):
xx1 = numpy.arange(self.x1min, self.x1max + self.step, self.step)
xx2 = numpy.arange(self.x2min, self.x2max + self.step, self.step)
x1, x2 = numpy.meshgrid(xx1, xx2)
zgrid = eval(self.function)
cs = pylab.contour(x1, x2, zgrid)
#pylab.clabel(cs, colors="black", inline=False)
pylab.show()
def add_exception(self):
'''Добавление исключений в таблицу'''
self.except_label.setText('')
left_edit = self.exeption_left_edit.text()
right_edit = self.exeption_right_edit.text()
if not left_edit or not right_edit:
self.except_label.setText(
'Заполните все поля при добавлении исключений!')
else:
kol = self.exeption_table.rowCount()
self.exeption_table.setRowCount(kol + 1)
tableItem = QtWidgets.QTableWidgetItem("{0} {1} {2}".format(
left_edit, self.combBox.currentText(), right_edit))
self.exeption_table.setItem(0, kol, tableItem)
def calculate(self):
'''Функция заполнение таблицы '''
if __import__('re').findall('\d+? *?\+ *?\d+?',
self.objectiv_func_edit.text()):
pass
else:
print("[SECURITY] F**K YOU!")
return
self.result_table.setColumnCount(0)
self.result_table.setRowCount(0)
self.except_label.setText('')
self.x1min = float(self.x1_min_edit.text())
self.x1max = float(self.x1_max_edit.text())
self.x2min = float(self.x2_min_edit.text())
self.x2max = float(self.x2_max_edit.text())
self.step = float(self.step_combBox.currentText())
self.function = str(self.objectiv_func_edit.text())
if self.x1min >= self.x1max or self.x2min >= self.x2max:
self.except_label.setText(
'Минимальное значение больше максимального !')
else:
self.excpts = []
# достает существующие ограничения и вносит в список
for expt in range(0, self.exeption_table.rowCount()):
if self.exeption_table.item(expt, 0).text():
self.excpts.append(
self.exeption_table.item(expt, 0).text())
self.method = Method(self.x1min, self.x2min, self.x1max,
self.x2max, self.step, self.function,
self.excpts)
bool_matrix = self.method.boolean_matrix
spis = self.method.spis
self.result_table.setColumnCount(len(spis[0]))
self.result_table.setRowCount(len(spis))
for i in range(len(spis)):
for j in range(len(spis[i])):
self.min(i, j, spis, bool_matrix)
self.min_label.setText(str(self.method.min_needed()))
def min(self, i, j, spis, bool_matrix):
if i == len(spis) - 1 or j == 0:
tableItem = QtWidgets.QTableWidgetItem("{0}".format(spis[i][j]))
self.result_table.setItem(i, j, tableItem)
self.result_table.item(i, j).setForeground(
QtGui.QColor(140, 100, 150))
elif bool_matrix[i][j]:
tableItem = QtWidgets.QTableWidgetItem(str(spis[i][j]))
self.result_table.setItem(i, j, tableItem)
else:
tableItem = QtWidgets.QTableWidgetItem("{0}".format(spis[i][j]))
self.result_table.setItem(i, j, tableItem)
self.result_table.item(i, j).setBackground(
QtGui.QColor(140, 100, 150))
self.result_table.item(i, j).setForeground(
QtGui.QColor(255, 255, 255))
@function_timer
def t2wv(db) :
return dict((attrib["title"], model[jieba.cut(text)]) for text, attrib in db)
if __name__ == "__main__" :
db = Database("data/zhwiki-extracted/", conditions = [
Database.cond_length(50),
Database.cond_title(lambda t: not t.startswith("Wikipedia:")),
Database.cond_title(lambda t: not t.startswith("File:")),
Database.cond_title(lambda t: not t.startswith("Draft:"))
])
# 767125 loaded, 451657 filtered, 31997 fails
model = Method.load("dump/lda-model.dump")
title2topic = t2wv(db)
pickle.dump(title2topic, open("dump/title2topic.dump", "w"))
#title2wv = pickle.load(open("dump/title2wv.dump"))
vectors = []
id2title = {}
for i, (t, v) in enumerate(title2topic.items()) :
vectors.append(v)
id2title[i] = t
fin = codecs.open("样例数据.txt", "r", "utf-8")
lines = map(lambda l: l.strip(), fin.readlines())
fin.close()
queries = map(lambda l: l[:l.find(u"？")], lines)
import sys
def unpack(cls, data):
method_class, data = Short.unpack(data)
method_id, data = Short.unpack(data)
method_type = Method.from_id(method_class.value, method_id.value)
method, data = method_type.unpack(data)
return cls(method), data
def __init__(self, cursor, comment):
Method.__init__(self, cursor, comment)
def __init__(self, shell, sources):
Method.__init__(self)
self.shell = shell
self.sources = sources
self.player = shell.get_player()
