index
int64 | repo_name
string | branch_name
string | path
string | content
string | import_graph
string |
|---|---|---|---|---|---|
15,440
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/gui/baseEntry.py
|
from tkinter import *
import PyPennet.utility.util as my_util
import PyPennet.utility.constants as const
class BaseEntry(Entry):
def __init__(self, w, parent=None):
Entry.__init__(self, parent)
self.menu = None
self.initUI(w)
def initUI(self, w):
# Расчитываем размер символов полей ввода
fsize = 22 - w
if fsize < 10:
fsize = 10
strFont = 'Helvetica {} bold'.format(str(fsize))
# Определяем ширину поля ввода, фонт и положение текста в нем
self.config(width=w + 2, font=strFont, justify=CENTER, bd=5, relief=RIDGE)
# Привязываем процедуру сортировки строки к событию ввода символов в поле ввода
# Если мы введем аА, то получим Аа
self.bind('<KeyRelease>', self.sortStr)
# Создаем всплывающее меню
self.menu = Menu(self, tearoff=0)
self.menu.add_command(label='Цвет фона', command=lambda: self.setBackGround(None))
self.menu.add_command(label='Цвет текста', command=lambda: self.setForeGround(None))
self.bind('<Button-3>', self.showMenu)
def showMenu(self, event):
self.menu.post(event.x_root, event.y_root)
def getText(self): # Получаем строку из поля ввода
return self.get()
def setText(self, string): # Заносим строку в поле ввода
# Так как поля ввода для резултата имеют статус только для чтения, то их надо венуть в нормальное
# состояние,записать текст, а затем опять вернуть в предыдущее состояние
state = self['state'] # Определяем статус поля ввода
if state == DISABLED:
self['state'] = NORMAL
if len(self.get()) > 0: # Усли в поле ввода есть текст - удаляем его
self.delete(0, END)
if len(string) > 0:
self.insert(0, string) # Записываем текст в поле ввода
if state == DISABLED: # Устанавливаем статус в предыдущее состояние
self['state'] = DISABLED
def setBackGround(self,color): # Устанавливаем цвет фона поля ввода
if color is None:
color = my_util.selectColor()
state = self['state']
if state == DISABLED:
self['state'] = NORMAL
self.config(bg=color)
self['state'] = state
def setForeGround(self, color): # Устанавливаем цвет текста поля ввода
if color is None:
color = my_util.selectColor()
state = self['state']
if state == DISABLED:
self['state'] = NORMAL
self.config(fg=color)
self['state'] = state
def sortStr(self, event): # Прцедура сортировки текста в поле ввода
s = self.get()
if len(s) > 0:
if const.orig_char in s: # Так как символ $ используется в подпрограмме сортировки, то запретим его ввод
i = s.index('$')
self.setText(s[:i])
else:
ss = my_util.sortStr(s)
self.setText(ss)
def setReadOnly(self): # Установка поля ввода в состояние ТОЛЬКО ДЛЯ ЧТЕНИЯ
state = self['state']
if state == NORMAL:
self['state'] = DISABLED
if __name__ == '__main__':
root = Tk()
frame = Frame(root)
frame.pack(side=TOP)
be = BaseEntry(8, frame)
be.setText('Test')
be.setBackGround('blue')
be.setForeGround('yellow')
be.pack()
print(be.getText())
root.mainloop()
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,441
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/gui/showresult.py
|
from tkinter import Frame, Label, Text, Scrollbar, Entry, Button
from tkinter import END, TOP, WORD, RIDGE, BOTH, RIGHT, LEFT, X, Y, SUNKEN, RAISED
from PyPennet.utility import util as my_util, constants as const
# Здесь будем отображать результат подсчета генотипов и фенотипа
class ShowResult(Frame):
def __init__(self, parent = None):
Frame.__init__(self, parent)
self.parent = parent
self.text_width = 65
self.initUI()
def initUI(self):
frameSource = Frame(self, bd = 5, relief = SUNKEN)
frameSource.pack(side = TOP, expand = True, fill = BOTH)
lblSource = Label(frameSource, text = 'Исходные данные', font = 'Courier 10 bold')
lblSource.pack(side = TOP)
self.source = Text(frameSource, height = 4, width = self.text_width, bd = 5, relief = RIDGE, font = 'Courier 10 bold', wrap = WORD)
scrlSource = Scrollbar(frameSource, relief = SUNKEN)
scrlSource['command'] = self.source.yview
self.source['yscrollcommand'] = scrlSource.set
scrlSource.pack(side = RIGHT, expand = True, fill = Y)
self.source.pack(side=TOP, expand=True, fill = X)
frameGenotype = Frame(self, bd = 5, relief = SUNKEN)
frameGenotype.pack(side = TOP, expand = True, fill = BOTH)
# Создаем метку заголовка текстового поля результата вычисления генотипов
lblGenotype = Label(frameGenotype, text = 'Результат вычисления генотипов', font = 'Courier 10 bold')
lblGenotype.pack(side = TOP)
# Сщздаем текстовое поле для представления результат вычисления генотипов
self.genotype = Text(frameGenotype, height = 4, width = self.text_width, bd = 5, relief = RIDGE, font = 'Courier 10 bold', wrap = WORD)
# Создаем скролбар для скроллинга текста по горизонтали
scrolbar = Scrollbar(frameGenotype, relief = SUNKEN)
scrolbar['command'] = self.genotype.yview
self.genotype['yscrollcommand'] = scrolbar.set
scrolbar.pack(side = RIGHT, expand = True, fill = Y)
self.genotype.pack(side=TOP, padx=5, pady=5, expand=True, fill = X)
# Создаем контейнер для элементов вычисления фенотипа
frame = Frame(self, bd = 5, relief = SUNKEN)
frame.pack(side = TOP, padx = 5, pady = 5, expand = True, fill = BOTH)
# Создаем метку заголовка раздела вычисления фенотипа
lblPhenotype = Label(frame, font = 'Courier 10 bold', text = 'Вычисление фенотипов')
lblPhenotype.pack(side = TOP)
lblData = Label(frame, font = 'Courier 10 bold', text = 'Искомый фенотип')
lblData.pack(side = LEFT, padx = 5, pady = 5)
self.entrData = Entry(frame, bd = 5, relief = RIDGE, width = 10, font = 'Courier 10 bold')
self.entrData.pack(side = LEFT, padx = 5, pady = 5)
lblResult = Label(frame, text = 'Результат:', font = 'Courier 10 bold')
lblResult.pack(side = LEFT, padx = 5, pady = 5)
self.entrResult = Entry(frame, bd = 5, relief = RIDGE, width = 10, font = 'Courier 10 bold')
self.entrResult.pack(side = LEFT, padx = 5, pady = 5)
self.entrData.bind('<KeyPress>', self.clearResult)
btnExec = Button(frame, text = 'Вычислить', bd = 5, relief = RAISED, command = self.execPhenotype)
btnExec.pack(side = RIGHT, padx = 5, pady = 5)
def clearResult(self, event):
self.entrResult.delete('0', END)
def execPhenotype(self):
string = self.source.get('3.0', END).rstrip('\n')
ss = string.split(':')
data = ss[1].strip()
phenotype = self.entrData.get()
result = my_util.calcPhenotype(data,phenotype)
self.entrResult.insert(0, result)
def clearData(self):
self.source.delete('1.0', END)
self.genotype.delete('1.0', END)
self.entrData.delete('0', END)
self.entrResult.delete('0', END)
def insertData(self, my_grid):
temp = 'Заголовки колонок: ' + my_grid[const.pos_columns] + '\n'
self.source.insert('1.0', temp)
temp = 'Загловки строк: ' + my_grid[const.pos_rows] + '\n'
self.source.insert('2.0', temp)
temp = 'Данные решетки: ' + my_grid[const.pos_data] + '\n'
self.source.insert('3.0', temp)
if len(my_grid[const.pos_data]) > 1: #
temp = my_util.calcGenotype(my_grid[const.pos_data])
self.genotype.insert('1.0', temp)
if __name__ == '__main__':
from tkinter import Tk
root = Tk()
#root.geometry('600x400')
showResult = ShowResult(root)
showResult.pack()
root.mainloop()
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,442
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/gui/about_dlg.py
|
from tkinter import Toplevel, Button, Label
from PIL import Image, ImageTk
class AboutDlg():
def __init__(self, parent=None):
self.dlg = Toplevel(parent)
self.dlg.pack_slaves()
self.dlg.geometry('610x375')
self.dlg.title = 'О Программе'
self.dlg.resizable(False,False)
self.initUI()
def initUI(self):
try:
im = Image.open("about.jpg")
except FileNotFoundError:
lbl = Label(self.dlg, text='Генетический калькулятор', font=("Arial", 24, "bold"))
lbl.place(x=80, y=20)
lbl_name = Label(self.dlg, text='Автор: Никита Загородников', font=("Arial", 18, "bold"))
lbl_name.place(x=120, y=100)
lbl_mail = Label(self.dlg, text='e-mail: nikitazggor01@gmail.com', font=("Arial", 18, "bold"))
lbl_mail.place(x=100, y=130)
else:
photo = ImageTk.PhotoImage(im)
lbl = Label(self.dlg, image=photo)
lbl.place(x=0, y=0, relheight=1, relwidth=1)
lbl.image = photo
finally:
btn = Button(self.dlg, text='Закрыть', command=self.dlg.destroy)
btn.place(x=280, y=330)
if __name__ == '__main__':
from tkinter import Tk
root = Tk()
dlg = AboutDlg(root)
root.mainloop()
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,443
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/gui/gridparams.py
|
from tkinter import Toplevel, Frame, Button, Label, Entry, Menu, StringVar
from tkinter import END, LEFT, RIGHT, RAISED, RIDGE, TOP, BOTH, X
import PyPennet.utility.util as my_util
import PyPennet.gui.prev_perult as prev
# Вспомогательный класс контейнер для элементов основоного окна диалога
class FrameRow(Frame):
def __init__(self, title, t_size, e_size, parent=None):
Frame.__init__(self, parent)
self.parent = parent
self.cur_font = 'Courier 10 bold'
self.enter = None
self.initUI(title, t_size, e_size)
def initUI(self, title, t_size, e_size):
frame = Frame(self.parent)
frame.pack(side=TOP, expand=True, fill=X)
sf = '{: <' + str(t_size) + '}' # Шаблон для выравнивания метки контейнера к одному размеру
s_title = sf.format(title)
lbl = Label(frame, text=s_title, font=self.cur_font)
lbl.pack(side=LEFT, padx=5, pady=5)
self.enter = Entry(frame, width=e_size, bd=5, relief=RIDGE, font=self.cur_font)
self.enter.pack(side=LEFT, padx=5, pady=5)
def get_entry(self):
return self.enter
# Класс диалога для определения параметов создаваемой решетки
# В качестве параметров получает: Пустой список для заполнения параметрами и ссылку на владельца окна
class GridParams(Toplevel):
def __init__(self, lst_params, grids, parent=None):
Toplevel.__init__(self, parent)
self.resizable(False,False)
self.parent = parent
self.title('Параметры новой решетки')
self.lst_params = lst_params
self.grids = grids
self.initUI()
def initUI(self):
grid_menubar = Menu(self, tearoff=0)
self.config(menu=grid_menubar)
file_menu = Menu(grid_menubar, tearoff=0)
file_menu.add_command(label='Очистить заголовоки колонок', command=self.clearColumns)
file_menu.add_command(label='Очистить заголовки строк', command=self.clearRows)
file_menu.add_separator()
file_menu.add_command(label='Заполнить колоноки из файла', command=self.fillColumns)
file_menu.add_command(label='Заполнить заголовки из файла', command=self.fillRows)
file_menu.add_separator()
file_menu.add_command(label='Колонки из предыдущего результата', command=self.column_prev)
file_menu.add_command(label='Строки из предыдущего результата', command=self.row_prev)
file_menu.add_separator()
file_menu.add_command(label='Закрыть', command=self.onCancel)
grid_menubar.add_cascade(label='Файл', menu=file_menu)
frame_params = Frame(self, bd=5, relief=RIDGE)
frame_params.pack(side=TOP, expand=True, fill=BOTH)
t_size = 18 # Длина всех меток
# Контьейнер для ввода размера решетки
frm_size = FrameRow('Размер решетки', t_size, 4, frame_params)
self.entr_size = frm_size.get_entry()
# Контейнер для ввода заголовка окна
frm_title = FrameRow('Заголовок окна', t_size, 50, frame_params)
self.entr_name = frm_title.get_entry()
# Контейнер для ввода заголовок колонок
frm_column_title = FrameRow('Заголовки колонок', t_size, 50, frame_params)
self.entr_title_column = frm_column_title.get_entry()
# Контейнер для ввода заголовок строк
frm_row_title = FrameRow('Заголовки строк', t_size, 50, frame_params)
self.entr_title_row = frm_row_title = frm_row_title.get_entry()
frame_buttons = Frame(self, bd=5, relief=RIDGE)
frame_buttons.pack(side=TOP, expand=True, fill=X)
btnOk = Button(frame_buttons, text='Создать ', bd=5, relief=RAISED, command=self.onOk)
btnOk.pack(side=LEFT, padx=5, pady=5)
btnCancel = Button(frame_buttons, text='Отменить', bd=5, relief=RAISED, command=self.onCancel)
btnCancel.pack(side=RIGHT, padx=5, pady=5)
def clearColumns(self):
self.entr_title_column.delete('0', END)
def clearRows(self):
self.entr_title_row.delete('0', END)
def fillColumns(self):
string = my_util.getFromFile()
if string is not None:
self.entr_title_column.insert(END, string)
def fillRows(self):
string = my_util.getFromFile()
if string is not None:
self.entr_title_row.insert(END, string)
def getEntryTitleColumns(self):
return self.entr_title_column
def getEntryTitleRows(self):
return self.entr_title_row
def column_prev(self):
name = StringVar()
prev_grid = prev.PrevResult(self.grids, name, self.parent)
prev_grid.focus_set()
prev_grid.grab_set()
prev_grid.wait_window()
if name is not None:
lst = self.grids[name.get()]
self.entr_title_column.insert(END, lst[4])
def row_prev(self):
name = StringVar()
prev_grid = prev.PrevResult(self.grids, name, self.parent)
prev_grid.focus_set()
prev_grid.grab_set()
prev_grid.wait_window()
if name is not None:
lst = self.grids[name.get()]
self.entr_title_row.insert(END, lst[4])
# Процедура считывания введенных параметров
def onOk(self):
# Должен быть введен либо размер решетки, либо заголовки колонок (и) или загололвки строк
grid_size = self.entr_size.get().strip()
lst_column = [s.strip() for s in self.entr_title_column.get().split(',')]
len_column = len(lst_column)
lst_row = [s.strip() for s in self.entr_title_row.get().split(',')]
len_row = len(lst_row)
if not grid_size.isdigit():
if len_column > 1:
grid_size = str(len_column)
elif len_row > 1:
grid_size = str(len_row)
else:
self.destroy()
self.lst_params = []
return
self.lst_params.append(grid_size)
title = self.entr_name.get().strip()
if len(title) == 0:
title = 'Решетка Пенета {} на {}'.format(grid_size, grid_size) # Иначе устанавливаем стандартный заголовок
self.lst_params.append(title)
self.lst_params.append(self.entr_title_column.get().strip())
self.lst_params.append(self.entr_title_row.get().strip())
self.destroy()
def onCancel(self):
self.destroy()
if __name__ == '__main__':
from tkinter import Tk
def showDialog(lst):
if len(lst) > 0:
lst.clear()
gridParams = GridParams(lst, root)
gridParams.focus_set()
gridParams.grab_set()
gridParams.wait_window()
print(lst)
lst_params = []
root = Tk()
btn = Button(root, text='Show Dlg', command=lambda: showDialog(lst_params)).pack()
root.mainloop()
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,444
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/gui/listwindow.py
|
from tkinter import Frame, Listbox, Label, Scrollbar
from tkinter import RIGHT, RIDGE, SUNKEN, TOP, BOTH, X, Y, SINGLE, END
from tkinter import messagebox
class ListWindow(Frame):
def __init__(self, showSelected, parent=None):
Frame.__init__(self, parent)
self.parent = parent
self.showSelected = showSelected
self.listBox = None
self.initUI()
def initUI(self):
frame_lbl = Frame(self.parent, bd=5, relief=RIDGE)
frame_lbl.pack(side=TOP, expand=True, fill=X)
lbl_name = Label(frame_lbl, text='Созданные решетки')
lbl_name.pack()
frame_listbox = Frame(self.parent)
frame_listbox.pack(side=TOP, expand=True, fill=BOTH)
self.listBox = Listbox(frame_listbox, width=65, height=4, selectmode=SINGLE, bd=5, relief=RIDGE)
self.listBox.bind('<<ListboxSelect>>', self.showSelect)
scrbary = Scrollbar(frame_listbox, orient='vertical')
scrbarx = Scrollbar(frame_listbox, orient='horizontal')
scrbary.config(command=self.listBox.yview, relief=SUNKEN)
scrbarx.config(command=self.listBox.xview, relief=SUNKEN)
self.listBox.config(yscrollcommand=scrbary.set, xscrollcommand=scrbarx.set)
scrbary.pack(side=RIGHT, fill=Y)
scrbarx.pack(side='bottom', fill=X)
self.listBox.pack(side=TOP, expand=True, fill=BOTH)
def showSelect(self, event):
item = self.getSelectedItem()
self.showSelected(item)
def getSelectedItem(self):
items = self.listBox.curselection()
item = self.listBox.get(items[0])
return item
def insertData(self, item):
count = self.listBox.size()
for i in range(count):
s = self.listBox.get(i)
if s == item:
messagebox.showerror('Ошибка', 'Окно с таким заголовком уже есть в списке')
return False
self.listBox.insert(END, item)
return True
def removeData(self, title):
count = self.listBox.size()
for i in range(count):
string = self.listBox.get(i)
if string == title:
self.listBox.delete(i)
break
def clear(self):
count = self.listBox.size()
self.listBox.delete(0, count - 1)
if __name__ == '__main__':
from tkinter import Tk
def showSelected(selected):
print(selected)
root = Tk()
root.title('Тест Listbox')
frame = Frame(root)
frame.pack(expand = True, fill = BOTH)
listWindow = ListWindow(showSelected, frame)
for i in range(20):
string = 'Это окно №{:0>10}'.format(i)
listWindow.insertData(string)
string = 'Это окно №{:0>10}'.format(10)
listWindow.removeData(string)
root.mainloop()
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,445
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/utility/constants.py
|
# Позиции параметров в списке параметров решетки
pos_size = 0
pos_name = 1
pos_columns = 2
pos_rows = 3
pos_data = 4
# Служебный символ для нестандартной сортировки строк
orig_char = '$'
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,446
|
NikitaZagor/PyPennet
|
refs/heads/master
|
/PyPennet/utility/util.py
|
from tkinter.colorchooser import askcolor
from tkinter.filedialog import *
from PyPennet.utility import constants as const
# Сортирует строку символов в алфавитном порядке независимо от регистра
def sortStr(string):
source = list(string)
source.sort()
if source[0].islower():
return ''.join(source)
else:
result = []
length = len(source)
for i in range(length):
char = ''
if source[i] != const.orig_char:
result.append(source[i])
char = source[i].upper()
else:
continue
for j in range(i + 1, length):
if source[j] != const.orig_char:
temp = source[j].upper()
if temp == char:
result.append(source[j])
source[j] = const.orig_char
return ''.join(result)
# Выбор цвета из стандартного диалога
def selectColor():
color = askcolor()
return color[1]
# Подсчитываем генотипы. Так как один генотип может несколько раз повторятся в данном наборе,
# то количество и процентное содержание данного генотипа мы сохраняем в словаре
# где ключом будет данный генотип, а данные - кортежиз количества и процентного содержания
def calcGenotype(string):
ss = string.split(',') # Разбиваем строку на элементы
num = len(ss) # Общее количество элементов
dict_count = {} # Словарь для генотипов
for elm in ss:
count = ss.count(elm) # Количество данного генотипа
proc = (count/num) * 100 # Процентное содержание данного геноттиипа
dict_count[elm] = (count, proc) # Заносим эти данные в словарь
result = ''
for key in dict_count.keys():
count, proc = dict_count[key]
temp = '{} {} {:.2f}%, '.format(key, count, proc)
result += temp
result = result.rstrip(' ')
result = result.rstrip(',')
return result
def newList(source, data):
result = []
for item in source:
if data in item:
result.append(item)
return result
def calcPhenResult(num_base, num_find):
proc = (num_find/num_base) * 100
result = '{} {:.2f}%'.format(num_find, proc) # Формируем строку результата
return result
# Вычисляем данные по конкретному фенотипу
# Используем то свойство нашей сортировки строк, что символы идут в алфавитном порядке независимо от регистра
# В стандартоной сортировке сначала идут символы верхнего регистра, затем символы нижнего регистра
# Например стандартная: ACacgg, наша сортировка: AaCcgg
def calcPhenotype(string, phenotype):
main_lst = string.split(',') # Разбиваем входную строку данных на элементы
num = len(main_lst) # Общее количество элементов
simbols = list(phenotype) # Преобразуем входную строку наименования фенотипа в список символов
set_one = set() # Здесь будет символы, которые встречаются в фенотипе только один раз
dic_more = {} # Здесь будут символы входящие в имя феноипа более одного раза
for ch in simbols: # Заполняем множество и словарь
number = simbols.count(ch)
if number == 1:
set_one.add(ch)
else:
dic_more[ch] = number
notfind = False
for ch in set_one:
main_lst = newList(main_lst, ch)
if len(main_lst) == 0:
notfind = True
break
if notfind:
return '0 0%'
lst_keys = dic_more.keys() # Получаем список двойных символов
if len(lst_keys) == 0: # Это значит двойных и более символов нет
length = len(main_lst)
result = calcPhenResult(num, length)
return result
notfind = False
for key in lst_keys:
number = dic_more[key]
s = key * number # Формируем строку из данного количества символов
main_lst = newList(main_lst, s)
if len(main_lst) == 0:
notfind = True
break
if notfind:
return '0 0%'
else:
length = len(main_lst)
result = calcPhenResult(num, length)
return result
# Здесь мы должны расчитать и сформировать результат
# Получаем список из трех строк: заглавной строки, заглавной колонки и строки данных матрицы
def calcResult(lst_string):
genotype = calcGenotype(lst_string[2])
result = 'Row:{}\nColumn:{}\nData:{}\nGenotype:{}\n'.format(lst_string[0], lst_string[1], lst_string[2],genotype)
return result
# Сохранение результата в файле
def saveToFile(lst_string):
result = calcResult(lst_string)
save = asksaveasfilename()
file = open(save, 'w')
file.write(result)
file.close()
# Получение предыдущего результата из файла
def getFromFile():
op = askopenfilename()
file = open(op, 'r')
for line in file:
if line.startswith('Data:'):
s = line.split(':')
return s[1].rstrip('\n')
return None
# Формируем строку из списка Entries
def getStrFromEntries(entries):
result =''
for entr in entries:
result += entr.get()
result += ','
result = result.rstrip(',')
return result
|
{"/PyPennet/gui/baseFrame.py": ["/PyPennet/gui/baseEntry.py", "/PyPennet/utility/util.py"], "/PyPennet/mainWindow.py": ["/PyPennet/gui/listwindow.py", "/PyPennet/gui/gridparams.py", "/PyPennet/gui/baseFrame.py", "/PyPennet/gui/showresult.py", "/PyPennet/gui/about_dlg.py"], "/PyPennet/gui/baseEntry.py": ["/PyPennet/utility/util.py", "/PyPennet/utility/constants.py"], "/PyPennet/gui/gridparams.py": ["/PyPennet/utility/util.py", "/PyPennet/gui/prev_perult.py"]}
|
15,447
|
mouryabs/Coherence-Resolution-Resolver
|
refs/heads/master
|
/main.py
|
from flask import Flask,request,jsonify
import coref
app = Flask(__name__)
"""
expected input:
{
"text" : "text that you need to send"
}
expected ouput:
{
"text" : "output text"
}
"""
@app.route('/getCoreRef', methods=['GET', 'POST'])
def perform_coreref():
my_json = request.json
text = my_json['text']
text = coref.coref(text)
my_dict = dict()
my_dict['text'] = text
return jsonify(my_dict)
app.run()
|
{"/main.py": ["/coref.py"]}
|
15,448
|
mouryabs/Coherence-Resolution-Resolver
|
refs/heads/master
|
/coref.py
|
import spacy
import neuralcoref
## Input: text - string of the text
## Output: modified text
def coref(text):
nlp = spacy.load("en_core_web_md")
neuralcoref.add_to_pipe(nlp)
doc = nlp(text)
return doc._.coref_resolved
if __name__ == "__main__":
text = "Barack Obama is the first president of US. He is from Hawaii and his wife is Michelle"
print(coref(text))
print(coref("Mourya is good. He is awesome"))
|
{"/main.py": ["/coref.py"]}
|
15,450
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/management/commands/parce_cian.py
|
from django.core.management.base import BaseCommand
from adverts.parcer import CianParcer
class Command(BaseCommand):
def handle(self, adv_type='suburban', cian_id=2386544, *args, **options):
print(adv_type)
print(cian_id)
p = CianParcer()
if adv_type == 'flat':
p.parce_rent_flat(cian_id=cian_id)
elif adv_type == 'suburban':
p.parce_rent_suburban(cian_id=cian_id)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,451
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/models.py
|
from django.db import models
from django.forms import model_to_dict
from .amodels import AbstractAdvert
from core.amodels import TimeStampModel
class Advert(AbstractAdvert, TimeStampModel):
cian_id = models.BigIntegerField('id на cian.ru ', unique=True, db_index=True)
description = models.TextField('Описание')
price = models.PositiveIntegerField('Цена', default=0)
PERIOD_DAY = 1
PERIOD_MONTH = 30
PERIOD_CHOICES = (
(PERIOD_DAY, 'в день'),
(PERIOD_MONTH, 'в месяц'),
)
price_period = models.PositiveSmallIntegerField('Период оплаты', choices=PERIOD_CHOICES, null=True, blank=True)
storey = models.SmallIntegerField('Этаж', null=True, blank=True)
number_of_storeys = models.SmallIntegerField('Этажность', null=True, blank=True)
area_all = models.PositiveIntegerField('Общая площадь', null=True, blank=True)
area_kitchen = models.PositiveIntegerField('Площадь кухни', null=True, blank=True)
area_living = models.PositiveIntegerField('Жилая площадь', null=True, blank=True)
area_rooms = models.PositiveIntegerField('Площадь комнат', null=True, blank=True)
class Meta:
verbose_name = 'Объяление'
verbose_name_plural = 'Объявления'
ordering = ('-id',)
def __str__(self):
return str(self.id)
def serialize_to_dict(self):
base_fields = ['id', 'is_rent', 'price_min', 'price_max']
if self.section == self.SECTION_HOUSE:
house_fields = ['furniture', 'tv', 'balcony', 'kitchen_furniture', 'fridge', 'animals',
'phone', 'washing_machine', 'children']
base_fields += house_fields
fields_dict = model_to_dict(self, fields=base_fields)
fields_dict['section'] = self.get_section_display()
return fields_dict
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,452
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/nedviga_backend/urls.py
|
# coding: utf-8
from django.conf.urls import patterns, include, url
from django.contrib import admin
from core.views import BaseHTMLPage, RawHTMLPage
admin.autodiscover()
urlpatterns = patterns(
'',
url(
r'^templates/(?P<template_path>[\w\-\.\/]+)',
RawHTMLPage.as_view(),
name='raw_html'
),
url(r'^admin/', include(admin.site.urls)),
url(r'^frontend_docs/', include('core.urls', namespace='frontend_docs')),
url(r'^api/adverts/', include('adverts.urls', namespace='adverts')),
url(r'^api/filters/', include('filters.urls', namespace='filters')),
url(r'^api/authentication/', include('authentication.urls', namespace='authentication')),
)
urlpatterns += patterns(
'',
url(r'', BaseHTMLPage.as_view(), name='base_page'),
)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,453
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/core/models.py
|
from django.db import models
from core.amodels import TimeStampModel
class Settings(TimeStampModel):
"""
Настройки
"""
key = models.CharField(verbose_name='Ключ', max_length=255, unique=True)
value = models.CharField(verbose_name='Значение', max_length=500)
class Meta:
verbose_name = 'Настройка'
verbose_name_plural = 'Настройки'
ordering = ('key',)
def __str__(self):
return '{0}. {1} - {2}'.format(self.pk, self.key, self.value)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,454
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/authentication/views.py
|
# coding: utf-8
from django.contrib.auth import login, authenticate
from django.contrib.sessions.models import Session
from django.http import HttpResponse
from authentication.models import User, DEFAULT_PASSWORD
from authentication.utils import send_sms, re_phone
from core.views import BaseView
from redis_connector import redis
class SessionidView(BaseView):
""""
View для тестирования авторизации через sessionid в url
"""
def is_authenticated(self, request):
if request.user.is_authenticated():
print('авторизирован id={}'.format(request.user.id))
else:
print('не авторизирован')
def get(self, request):
self.is_authenticated(request)
return HttpResponse()
def post(self, request):
self.is_authenticated(request)
return HttpResponse()
def put(self, request):
self.is_authenticated(request)
return HttpResponse()
def delete(self, request):
self.is_authenticated(request)
return HttpResponse()
class PhoneMixin(object):
def get_phone(self, request):
phone = request.POST.get('phone')
if not phone:
return self.render_internal_error('Empty phone')
if not re_phone.match(phone):
return self.render_internal_error('Invalid phone')
self.phone = phone
def get_user(self, phone, resend):
if resend:
self.sms_code = User().generate_sms_code()
try:
user = User.objects.get(phone=phone)
self.user = user
if not user.is_active:
return self.render_internal_error('User is blocked')
except User.DoesNotExist:
pass
if resend:
redis.setex('nedviga_user_sms_{}'.format(phone), self.sms_code, 300)
class PreLogin(BaseView, PhoneMixin):
def post(self, request):
"""
:param request:
:return:
По номеру телефона зарегистрированного пользователя отсылает sms с кодом авторизации на этот номер
Варианты ошибок:
'Empty phone' - пустой телефон
'Invalid phone' - неверный формат номера
'User not registered' - пользователь с таким телефоном не зарегистрирован
'User is blocked' - пользователь заблокирован
"""
# TODO - сделать защиту от частой отправки смс
# TODO - сделать на фронте возможность повторной отправки смс
result = self.get_phone(request)
if result:
return result
result = self.get_user(self.phone, True)
if result:
return result
send_sms(self.phone, self.sms_code)
return self.render_empty_success()
class Login(BaseView, PhoneMixin):
def get_sms_code(self, request):
sms_code = request.POST.get('key')
user_sms_code = redis.get('nedviga_user_sms_{}'.format(self.phone))
if user_sms_code:
if int(user_sms_code) == int(sms_code):
if not User.objects.filter(phone=self.phone):
self.user = User()
self.user.phone = self.phone
self.user.set_password(DEFAULT_PASSWORD)
self.user.save()
else:
return self.render_internal_error('Invalid sms-code')
else:
return self.render_internal_error('Sms-code expired')
def post(self, request):
"""
:param request:
:param phone: номер телефона
:param sms_code: sms код проверки
:return:
Авторизует пользователя по номеру телефона и sms-коду
Варианты ошибок:
'User not registered' - пользователь с таким телефоном не зарегистрирован
'User is blocked' - пользователь заблокирован
'Invalid sms-code' - неверный sms-код авторизации
"""
result = self.get_phone(request)
if result:
return result
result = self.get_user(self.phone, False)
if result:
return result
result = self.get_sms_code(request)
if result:
return result
# еще раз вытаскиваем юзера, чтобы django его авторизировала, просто User передать нельзя
self.user = authenticate(phone=self.phone, password=DEFAULT_PASSWORD)
# удаляем все другие сессии этого пользователя, чтобы был залогинен всегда с одного устройства
my_old_sessions = Session.objects.all()
for row in my_old_sessions:
if row.get_decoded().get("_auth_user_id") == self.user.id:
row.delete()
# теперь спокойно логиним
login(request, self.user)
return self.render_json_response(data={'sessionid': request.session.session_key})
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,455
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/authentication/urls.py
|
# coding: utf-8
from django.conf.urls import patterns, url
from .views import PreLogin, Login, SessionidView
urlpatterns = patterns(
'authentication.views',
url(r'^sessionid/?$', SessionidView.as_view(), name='sessionid'),
url(r'^prelogin/?$', PreLogin.as_view(), name='prelogin'),
url(r'^login/?$', Login.as_view(), name='login'),
)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,456
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/views.py
|
# coding: utf-8
import random
from core.views import BaseView
class ListAdverts(BaseView):
def get(self, request):
results = []
count = 0
for x in range(10):
count += 1
result = {
"count": count,
"type": "Жилой гараж",
"address": "Каштаянца 15, кв. 80",
"cost": "{0} сутки".format(random.randint(500, 15000)),
"description": "ОТ СОБСТВЕННИКА.Звонить можно круглосуточно.Сдается комната посуточно в квартире , со всеми удобствами, с евроремонтом и новой мебелью. Для вашего комфортного проживания ЖК телевизор, спутниковое ТВ. Все входит в стоимость проживания Заселение круглосуточно.Без комиссий, предоплат и залога.",
"images": ['http://lorempixel.com/512/512/' for x in range(random.randint(2, 6))],
"numbers": ['8 (900) 000 00 00' for x in range(random.randint(0, 4))],
}
results.append(result)
return self.render_json_response(results)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,457
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/core/views.py
|
# coding: utf-8
import json
import os
from django.http import HttpResponse
from django.shortcuts import render
from django.views.generic import View
class BaseView(View):
content_type = 'application/json'
# def dispatch(self, request, *args, **kwargs):
# if request.user.is_authenticated():
# return super(BaseView, self).dispatch(request, *args, **kwargs)
# else:
# return self.render_json_response(success=False, errors={'internal_error': 'auth_required'}, status=401)
def render_json_response(self, data=None, errors=None, success=None, status=200):
"""
Стандартная view для проекта
"""
#если success не заполенен, то заполняем автоматически
if not success:
if data:
success = True
if errors:
success = False
if data and errors:
raise Exception('Manually specify "success" arg, because both "error" and "data" are not empty')
ctx = {
'success': success,
'errors': errors,
'data': data,
}
json_context = json.dumps(ctx).encode('utf-8')
response = HttpResponse(json_context, self.content_type, status=status)
response['Access-Control-Allow-Origin'] = '*'
response['Access-Control-Allow-Credentials'] = 'True'
return response
def render_internal_error(self, text):
return self.render_json_response(errors={'internal_error': text})
def render_empty_success(self):
return self.render_json_response(success=True)
class BaseHTMLPage(View):
@staticmethod
def get(request):
return render(request, 'base_page.html')
class RawHTMLPage(View):
def get(self, request, template_path):
base_dir = os.path.dirname(os.path.dirname(__file__))
te = os.path.join(base_dir, '../_public/www/templates/%s' % template_path)
data = open(te, mode="r", encoding='utf-8', closefd=True).read().encode('utf-8')
return HttpResponse(data)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,458
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/core/amodels.py
|
from django.db import models
class TimeStampModel(models.Model):
"""
Время создания и удаления
"""
when_created = models.DateTimeField(verbose_name='Когда создана', auto_now_add=True)
when_modified = models.DateTimeField(verbose_name='Когда отредактирована', auto_now=True)
class Meta:
abstract = True
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,459
|
l-liava-l/real_estate
|
refs/heads/master
|
/parse.py
|
# coding: utf-8
def parse():
g = Grab()
try:
g.go('http://www.cian.ru/cat.php?deal_type=1&obl_id=1&city[0]=1&totime=300', log_file='./log')
except (GrabNetworkError, GrabTimeoutError, GrabConnectionError, GrabAuthError) as details:
print(details)
return False
reals = dict()
for tr in g.doc.select('//*[@id="tbody"]//fieldset//table[@class="cat"]/tr'):
cian_id = tr.node.get('id')
real = dict()
if cian_id:
real['cian_id'] = cian_id
for td in tr.select('//td'):
td_id = td.node.get('id')
if td_id:
if 'metro' in td_id:
real['city'] = td.node.findall('a')[0].text
print(td.node.findall('a')[len(td.node.findall('a'))-1].text)
if cian_id not in reals:
reals[cian_id] = real
if __name__ == '__main__':
p = CianParcer()
p.parce_adv(adv_id=11359831)
# parse()
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,460
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/filters/admin.py
|
#coding: utf-8
from django.contrib import admin
from bitfield import BitField
from bitfield.forms import BitFieldCheckboxSelectMultiple
from .models import Filter, UserAdvert
class AdminFilter(admin.ModelAdmin):
formfield_overrides = {
BitField: {'widget': BitFieldCheckboxSelectMultiple},
}
list_display = ('id', 'user', 'is_rent', 'price_min', 'price_max', 'section',)
list_filter = ('is_rent', 'section',)
class AdminUserAdvert(admin.ModelAdmin):
list_display = ('id', 'filter', 'advert', 'is_read',)
list_filter = ('is_read',)
admin.site.register(Filter, AdminFilter)
admin.site.register(UserAdvert, AdminUserAdvert)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,461
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/urls.py
|
# coding: utf-8
from django.conf.urls import patterns, url
from .views import ListAdverts
urlpatterns = patterns(
'adverts.views',
url(r'random/?$', ListAdverts.as_view(), name='list_random_adverts'),
)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,462
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/filters/urls.py
|
# coding: utf-8
from django.conf.urls import patterns, url
from .views import FilterView
urlpatterns = patterns(
'filters.views',
url(r'^get_list/?$', FilterView.as_view(), name='filter'),
url(r'^save/?$', FilterView.as_view(), name='save_filter'),
)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,463
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/authentication/utils.py
|
# coding: utf-8
import re
re_phone = re.compile("^[0-9]+$")
from urllib.request import urlopen
def send_sms(phone, message):
url = 'https://smsimple.ru/http_send.php?user=yorcc-lark&pass=aLt4U5C6&or_id=59989&phone={0}&message={1}'.\
format(phone, message)
urlopen(url)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,464
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/redis_connector.py
|
# -*- coding: utf-8 -*-
from redis import Redis
print('111')
redis = Redis()
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,465
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/authentication/models.py
|
#coding: utf-8
import pdb
import random
import string
from django.core.validators import RegexValidator
from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.utils import timezone
from authentication.utils import re_phone
DEFAULT_PASSWORD = 'yorcc-lab'
class UserManager(BaseUserManager):
def _create_user(self, phone, password, is_staff, is_superuser, **extra_fields):
"""
Creates and saves a User with the given username and password.
"""
now = timezone.now()
if not phone:
raise ValueError('The given username must be set')
user = self.model(phone=phone,
is_staff=is_staff, is_active=True,
is_superuser=is_superuser, last_login=now,
date_joined=now, **extra_fields)
user.set_password(DEFAULT_PASSWORD)
user.save(using=self._db)
return user
def create_user(self, phone, password=None, **extra_fields):
return self._create_user(phone, DEFAULT_PASSWORD, False, False, **extra_fields)
def create_superuser(self, phone, password, **extra_fields):
return self._create_user(phone, DEFAULT_PASSWORD, True, True, **extra_fields)
class User(AbstractBaseUser, PermissionsMixin):
phone = models.CharField('Номер телефона', unique=True, max_length=15, validators=[RegexValidator(re_phone)])
is_staff = models.BooleanField('staff status', default=False)
is_active = models.BooleanField('active', default=True)
date_joined = models.DateTimeField('Когда зарегистрировался?', auto_now_add=True)
objects = UserManager()
USERNAME_FIELD = 'phone'
REQUIRED_FIELDS = []
class Meta:
verbose_name = 'Пользователь'
verbose_name_plural = 'Пользователи'
ordering = ('id',)
def get_full_name(self):
"""
Returns the first_name plus the last_name, with a space in between.
"""
return self.phone
def get_short_name(self):
"""
Returns the short name for the user.
"""
return self.phone
def generate_sms_code(self):
return ''.join([random.choice(string.digits) for i in range(4)])
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,466
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/admin.py
|
from django.contrib import admin
from bitfield import BitField
from bitfield.forms import BitFieldCheckboxSelectMultiple
from .models import Advert
class AdminAdvert(admin.ModelAdmin):
formfield_overrides = {
BitField: {'widget': BitFieldCheckboxSelectMultiple},
}
list_display = ('id', 'is_rent', 'price', 'section', 'cian_id',)
list_filter = ('is_rent', 'section',)
admin.site.register(Advert, AdminAdvert)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,467
|
l-liava-l/real_estate
|
refs/heads/master
|
/fabfile.py
|
from fabric.api import run, settings, local, prompt
from fabric.context_managers import lcd
def commit():
"""
Commit change
"""
local('git status')
prompt('Press <Enter> to continue or <Ctrl+C> to cancel.')
local('git add .')
local('git commit')
def ch(branch):
"""
Move your branch to current HEAD and checkout
"""
local('git branch -f %s' % branch)
local('git checkout %s' % branch)
def rebase(brunch='master'):
"""
Rebase current branch on other brunch
"""
current_branch = local('git rev-parse --abbrev-ref HEAD', capture=True)
local('git checkout %s' % brunch)
local('git pull origin %s' % brunch)
def merge(brunch='master', push=True, with_commit=True):
""" Merge with master
"""
current_branch = local('git rev-parse --abbrev-ref HEAD', capture=True)
try:
if with_commit:
commit()
rebase(brunch)
local('git checkout %s' % brunch)
local('git merge --no-ff %s' % current_branch)
if push:
local('git push origin %s' % brunch)
finally:
local('git checkout %s' % current_branch)
local('git rebase master')
def pull():
current_branch = local('git rev-parse --abbrev-ref HEAD', capture=True)
rebase()
local('git checkout %s' % current_branch)
local('git rebase master')
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,468
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/nedviga_backend/settings_prod.py
|
from nedviga_backend.settings_base import *
DEBUG = True
TEMPLATE_DEBUG = DEBUG
APPEND_SLASH = True
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'nedviga',
'HOST': '192.168.10.1',
'PORT': '5432',
'USER': 'postgres',
'PASSWORD': 'raw_type_999',
}
}
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,469
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/management/commands/get_parce_list.py
|
from django.core.management.base import BaseCommand
from adverts.parcer import ParseSearchList, CianParcer
class Command(BaseCommand):
def handle(self, *args, **options):
p = ParseSearchList()
ids = p.get_flat_rent_list()
pp = CianParcer()
for x in ids:
print(x)
pp.parce_rent_flat(x)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,470
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/amodels.py
|
from django.db import models
from bitfield import BitField
from djorm_pgarray.fields import IntegerArrayField
class AbstractAdvert(models.Model):
is_rent = models.BooleanField('True = аренда, False = продажа', default=True)
SECTION_APARTMENT = 1
SECTION_HOUSE = 2
SECTION_NOT_LIVE = 3
SECTION_CHOICES = (
(SECTION_APARTMENT, 'Квартира'),
(SECTION_HOUSE, 'Дом, коттедж'),
(SECTION_NOT_LIVE, 'Нежилое помещение'),
)
section = models.PositiveSmallIntegerField('Тип помещения', choices=SECTION_CHOICES)
section_additional = BitField(flags=range(1, 60))
additional_requirements = BitField(flags=range(1, 60))
metro = IntegerArrayField()
class Meta:
abstract = True
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,471
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/filters/models.py
|
from django.db import models
from adverts.amodels import AbstractAdvert
from core.amodels import TimeStampModel
class Filter(AbstractAdvert, TimeStampModel):
user = models.ForeignKey('authentication.User', verbose_name='Пользователь')
name = models.CharField('Название', null=False, blank=False, max_length=50)
price_min = models.PositiveIntegerField('Нижняя граница цены', blank=True, null=True)
price_max = models.PositiveIntegerField('Верхняя граница цены', blank=True, null=True)
class Meta:
verbose_name = 'Пользовательский фильтр'
verbose_name_plural = 'Пользовательские фильтры'
ordering = ('-id',)
def __str__(self):
return str(self.id)
class UserAdvert(TimeStampModel):
filter = models.ForeignKey('Filter', verbose_name='Фильтр')
advert = models.ForeignKey('adverts.Advert', verbose_name='Объявление')
is_read = models.BooleanField('Прочитано?', default=False)
class Meta:
verbose_name = 'Объявление, подходящее под фильтр'
verbose_name_plural = 'Объявления, подходящие под фильтр'
ordering = ('-id',)
unique_together = ('filter', 'advert')
def __str__(self):
return '{} фильтр {} объявление {}'.format(self.id, self.filter_id, self.advert_id)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,472
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/adverts/parcer.py
|
import string
from grab import Grab
from grab.error import GrabNetworkError, GrabTimeoutError, GrabConnectionError, GrabAuthError
from .models import Advert
class CianParcer(object):
def check_extra_options(self, class_name):
el = self.g.doc.select('//*[@class="{}"]'.format(class_name))
if len(el) > 0:
return Advert.EXTRA_YES
else:
return Advert.EXTRA_NO
def normalize_integer(self, x):
if not isinstance(x, int):
return x
if x > 2147483647:
return 2147483647
else:
return x
def extract_digits(self, str):
return ''.join([x for x in str if x in string.digits])
def parce_rent_suburban(self, cian_id, is_rent=True, section=Advert.SECTION_HOUSE):
self.g = Grab()
try:
url = 'http://www.cian.ru/rent/suburban/{}/'.format(cian_id)
print(url)
self.g.go(url)
except (GrabNetworkError, GrabTimeoutError, GrabConnectionError, GrabAuthError) as details:
print(details)
return False
raw_advert = {}
#дом, часть дома, таунхауз, участок
el = self.g.doc.select('//*[@class="object_descr_title"]')[0]
raw_text = el.node.text.strip()
if 'дом' in raw_text:
set_room = 'Дом'
elif 'часть' in raw_text:
set_room = 'Часть дома'
elif 'таунхаус' in raw_text:
set_room = 'Таунхаус'
elif 'участок' in raw_text:
set_room = 'Участок'
else:
set_room = False
el = self.g.doc.select('//*[@class="object_descr_addr"]')[0]
raw_advert['street'] = el.node.text.strip()
el = self.g.doc.select('//*[@class="object_descr_price"]')[0]
raw_price = el.node.text.strip()
price = [x for x in raw_price if x in string.digits]
raw_advert['price'] = int(''.join(price))
if 'в сутки' in raw_price:
raw_advert['price_period'] = Advert.PERIOD_DAY
elif 'в месяц' in raw_price:
raw_advert['price_period'] = Advert.PERIOD_MONTH
else:
print('Не смог вычислить период оплаты')
el = self.g.doc.select('//*[@class="object_descr_text"]')[0]
description = el.node.text.strip()
if not description:
#если так не нашли описания - поищем в потомках
cc = el.node.iterchildren()
description = ''
for c in cc:
raw_text = c.text or ' '
raw_tail = c.tail or ' '
if 'Телефоны' in raw_text:
continue
description += raw_text.strip()
description += raw_tail.strip()
raw_advert['description'] = description
try:
advert = Advert.objects.get(cian_id=cian_id)
for key, value in raw_advert.items():
setattr(advert, key, value)
except Advert.DoesNotExist:
advert = Advert(**raw_advert)
advert.is_rent = is_rent
advert.section = section
advert.cian_id = cian_id
advert.rooms_count = 0
advert.house_type = 0
if set_room:
setattr(advert.house_type, set_room, set_room)
advert.save()
def parce_rent_flat(self, cian_id, is_rent=True, section=Advert.SECTION_APARTMENT):
self.g = Grab()
try:
url = 'http://www.cian.ru/rent/flat/{}/'.format(cian_id)
# url = 'http://www.cian.ru/rent/suburban/{}/'.format(cian_id)
print(url)
self.g.go(url)
except (GrabNetworkError, GrabTimeoutError, GrabConnectionError, GrabAuthError) as details:
print(details)
return False
raw_advert = {}
#комната или количество комнат
el = self.g.doc.select('//*[@class="object_descr_title"]')[0]
raw_text = el.node.text.strip()
if 'комната' in raw_text:
set_room = 'room'
elif 'комн.' in raw_text:
for x in range(1, 7):
print(x)
if str(x) in raw_text:
set_room = str(x)
else:
set_room = False
el = self.g.doc.select('//*[@class="object_descr_addr"]')[0]
raw_advert['street'] = el.node.text.strip()
el = self.g.doc.select('//*[@class="object_descr_props"]')[0]
for tr in el.node.findall('tr'):
th = tr.findall('th')
td = tr.findall('td')
th_text = th[0].text
try:
td_text = td[0].text
except IndexError:
td_text = ''
if th_text == 'Этаж:':
raw_storey, raw_number_of_storeys = td_text.split('/')
raw_advert['storey'] = int(raw_storey.strip())
raw_advert['number_of_storeys'] = int(raw_number_of_storeys.strip())
elif th_text == 'Общая площадь:':
raw_area_all = td[0].findall('i')[0].tail.strip()
raw_area_all_clean = self.extract_digits(raw_area_all)
if not raw_area_all_clean:
raw_advert['area_all'] = None
else:
raw_advert['area_all'] = int(raw_area_all_clean)
elif th_text == 'Площадь комнат:':
raw_area = td[0].findall('i')[0].tail.strip()
raw_area = raw_area.split('-')[-1]
raw_area_clean = self.extract_digits(raw_area)
if not raw_area_clean:
raw_advert['area_rooms'] = None
else:
raw_advert['area_rooms'] = int(raw_area_clean)
elif th_text == 'Жилая площадь:':
raw_area_living = td[0].findall('i')[0].tail.strip()
raw_area_living_clean = self.extract_digits(raw_area_living)
if not raw_area_living_clean:
raw_advert['area_living'] = None
else:
raw_advert['area_living'] = int(raw_area_living_clean)
elif th_text == 'Площадь кухни:':
raw_area = td[0].findall('i')[0].tail.strip()
raw_area_clean = self.extract_digits(raw_area)
if not raw_area_clean:
raw_advert['area_kitchen'] = None
else:
raw_advert['area_kitchen'] = int(raw_area_clean)
raw_advert['area_all'] = self.normalize_integer(raw_advert.get('area_all', 0))
raw_advert['area_rooms'] = self.normalize_integer(raw_advert.get('area_rooms', 0))
raw_advert['area_living'] = self.normalize_integer(raw_advert.get('area_living', 0))
raw_advert['area_kitchen'] = self.normalize_integer(raw_advert.get('area_kitchen', 0))
el = self.g.doc.select('//*[@class="metro_icon"]')[0]
raw_metro = el.node.tail.strip()
raw_advert['metro'] = ''.join(x for x in raw_metro if x not in string.punctuation)
el = self.g.doc.select('//*[@class="object_descr_price"]')[0]
raw_price = el.node.text.strip()
price = [x for x in raw_price if x in string.digits]
raw_advert['price'] = int(''.join(price))
if 'в сутки' in raw_price:
raw_advert['price_period'] = Advert.PERIOD_DAY
elif 'в месяц' in raw_price:
raw_advert['price_period'] = Advert.PERIOD_MONTH
else:
print('Не смог вычислить период оплаты')
el = self.g.doc.select('//*[@class="object_descr_text"]')[0]
raw_advert['description'] = el.node.text.strip()
raw_advert['furniture'] = self.check_extra_options('objects_item_details_i_living_furnished')
raw_advert['tv'] = self.check_extra_options('objects_item_details_i_tv')
raw_advert['balcony'] = self.check_extra_options('objects_item_details_i_balcony')
raw_advert['kitchen_furniture'] = self.check_extra_options('objects_item_details_i_kitchen_furnished')
raw_advert['fridge'] = self.check_extra_options('objects_item_details_i_fridge')
raw_advert['animals'] = self.check_extra_options('objects_item_details_i_animals')
raw_advert['phone'] = self.check_extra_options('objects_item_details_i_phone')
raw_advert['washing_machine'] = self.check_extra_options('objects_item_details_i_washing_machine')
raw_advert['children'] = self.check_extra_options('objects_item_details_i_children')
try:
advert = Advert.objects.get(cian_id=cian_id)
for key, value in raw_advert.items():
setattr(advert, key, value)
except Advert.DoesNotExist:
advert = Advert(**raw_advert)
advert.is_rent = is_rent
advert.section = section
advert.cian_id = cian_id
advert.rooms_count = 0
if set_room:
setattr(advert.rooms_count, set_room, set_room)
advert.save()
class ParseSearchList(object):
totime = 300
def __init__(self, totime=totime):
self.totime = totime
def get_flat_rent_list(self):
url = 'http://www.cian.ru/cat.php?deal_type=1&obl_id=1&city[0]=1'
self.g = Grab()
try:
print(url)
self.g.go(url)
except (GrabNetworkError, GrabTimeoutError, GrabConnectionError, GrabAuthError) as details:
print(details)
return False
a_tag_list = self.g.doc.select('//a[@target="_blank"]')
count = 0
ids = []
for a_tag in a_tag_list:
#нужны не все ссылки, а только те, в которых есть 1 тег font
font_tag_list = a_tag.node.findall('font')
if len(font_tag_list) == 1:
count += 1
href = a_tag.node.attrib.get('href')
ids.append(int(href.split('/')[-1]))
print(count)
print(ids)
return ids
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,473
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/authentication/middleware.py
|
# coding: utf-8
from django.conf import settings
class SessionUrlHackMiddleware(object):
def process_request(self, request):
raw_session_key = request.GET.get(settings.SESSION_COOKIE_NAME)
if raw_session_key:
request.COOKIES[settings.SESSION_COOKIE_NAME] = raw_session_key
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,474
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/filters/views.py
|
# coding: utf-8
from core.views import BaseView
from adverts.models import Advert
class FilterView(BaseView):
def get(self, request):
filter_id = int(request.GET.get('filter_id'))
user = request.user
adverts = Advert.objects.filter(useradvert__filter__id=filter_id, useradvert__filter__user__id=user.id)
adverts_list = []
for advert in adverts:
adverts_list.append(advert.serialize_to_dict())
return self.render_json_response(data=adverts_list)
def post(self, request):
print(request)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,475
|
l-liava-l/real_estate
|
refs/heads/master
|
/nedviga_backend/core/urls.py
|
# coding: utf-8
from django.conf.urls import patterns, url
from django.views.generic import TemplateView
urlpatterns = patterns(
'core.views',
url(r'^$', TemplateView.as_view(template_name='frontend_docs/base.html'), name='base'),
url(r'^authentication/?$', TemplateView.as_view(template_name='frontend_docs/auth.html'), name='auth'),
url(r'^adverts/?$', TemplateView.as_view(template_name='frontend_docs/adverts.html'), name='adverts'),
)
|
{"/nedviga_backend/adverts/models.py": ["/nedviga_backend/adverts/amodels.py"], "/nedviga_backend/authentication/urls.py": ["/nedviga_backend/authentication/views.py"], "/nedviga_backend/filters/admin.py": ["/nedviga_backend/filters/models.py"], "/nedviga_backend/adverts/urls.py": ["/nedviga_backend/adverts/views.py"], "/nedviga_backend/filters/urls.py": ["/nedviga_backend/filters/views.py"], "/nedviga_backend/adverts/admin.py": ["/nedviga_backend/adverts/models.py"], "/nedviga_backend/adverts/parcer.py": ["/nedviga_backend/adverts/models.py"]}
|
15,482
|
j-luis996/crud_python-dic
|
refs/heads/main
|
/crud.py
|
from ej import search_client
import const
class crud:
def __get_client_field(self, field_name, message = "What's the client {}? "):
field = None
while not field:
field = input(message.format(field_name))
return field
def __get_client_from_user(self):
client = {
'name': self.__get_client_field(field_name = 'name'),
'company': self.__get_client_field(field_name = 'company'),
'email': self.__get_client_field(field_name = 'email'),
'position': self.__get_client_field(field_name = 'position'),
}
return client
def __add_client(self, client):
if client in const.clients:
print("Client alredy in client's list")
else:
const.clients.append(client)
def create_client(self):
client = self.__get_client_from_user()
self.__add_client(client)
print('Added client successful')
def read_clients(self):
print('uid | name | company | email | position')
print('*' * 50)
for idx, client in enumerate(const.clients):
print(f'{idx} | {client["name"]} | {client["company"]} | {client["email"]} | {client["position"]}')
def update_client(self):
id_client = int(self.__get_client_field(field_name="id"))
if id_client < len(const.clients):
client_update = self.__get_client_from_user()
const.clients[id_client] = client_update
print("Client updated in client's list")
else:
print('id invalid')
def delete_client(self):
id_client = int(self.__get_client_field(field_name="id"))
if id_client < len(const.clients):
for idx, client in enumerate(const.clients):
if idx == id_client:
del const.clients[idx]
break
print("Client deleted in client's list")
else:
print('id invalid')
def search_client(self, data, key = "name"):
client_exist = False
for client in const.clients:
if client[key] ==data:
client_exist = True
break
else:
continue
return client_exist
|
{"/crud.py": ["/const.py"], "/main.py": ["/const.py", "/crud.py"]}
|
15,483
|
j-luis996/crud_python-dic
|
refs/heads/main
|
/const.py
|
menu = """
Welcome to my fist CRUD in python
please choose any option
[C] create
[R] read
[U] update
[D] delete
[S] search for name
[E] exit
"""
clients = [
{
'name': 'jorge',
'company': 'Upiita',
'email': 'algo@algo.com',
'position': "student"
},
{
'name': 'carlos',
'company': 'Upiita',
'email': 'prof@prof.com',
'position': "teacher"
},
]
|
{"/crud.py": ["/const.py"], "/main.py": ["/const.py", "/crud.py"]}
|
15,484
|
j-luis996/crud_python-dic
|
refs/heads/main
|
/main.py
|
import os
import const
import crud
crud = crud.crud()
def main():
command = None
while command != 'E':
os.system('clear')
print(const.menu)
command = input()
command = command.upper()
if command == 'C':
crud.create_client()
elif command == 'R':
crud.read_clients()
elif command == 'U':
crud.update_client()
elif command == 'D':
crud.delete_client()
elif command == 'S':
name = input('What is the client name? ')
if crud.search_client(name):
print("The client is in the client's list")
else:
print(f"The client: {name} is not in our client's list")
else:
if command != 'E':
print('command invalid')
if command != 'E':
input('press any key for continue')
if __name__ == "__main__":
main()
|
{"/crud.py": ["/const.py"], "/main.py": ["/const.py", "/crud.py"]}
|
15,494
|
twinstae/joyuris-classifier
|
refs/heads/main
|
/model.py
|
import os
from keras.models import load_model
import numpy as np
checkpoint_dir = os.getcwd()+"/model/"
model = load_model(checkpoint_dir+"weight_1.hdf5")
target_x = 224
target_y = 224
CATEGORIES = ["최예나", "조유리", "김채원"]
def predict(img):
img = img.convert("RGB")
img = img.resize((target_x, target_y))
data = np.asarray(img)
raw_x = np.array(data)
float_x = raw_x.astype("float") / 256
x = float_x.reshape(-1, target_x, target_y, 3)
pred = model.predict(x)[0]
result = CATEGORIES[int(np.argmax(pred))] # 예측 값중 가장 높은 클래스 반환
return result, {
"최예나": int(100 * pred[0]),
"조유리": int(100 * pred[1]),
"김채원": int(100 * pred[2])
}
|
{"/main.py": ["/model.py"], "/streamlit_app.py": ["/model.py"]}
|
15,495
|
twinstae/joyuris-classifier
|
refs/heads/main
|
/main.py
|
from fastapi import FastAPI, UploadFile, File
from starlette.responses import HTMLResponse
from model import predict
import os
app = FastAPI()
@app.get("/")
def main():
content = """
<body>
<form action="/upload" enctype="multipart/form-data" method="post">
<input name="image" type="file">
<input type="submit">
</form>
</body>
"""
return HTMLResponse(content=content)
@app.post("/upload")
def upload_file(image: UploadFile = File(...)):
file_name = os.getcwd() + "/img/test/" + image.filename.replace(" ", "-")
with open(file_name, 'wb+') as f:
f.write(image.file.read())
f.close()
return predict(file_name)
|
{"/main.py": ["/model.py"], "/streamlit_app.py": ["/model.py"]}
|
15,496
|
twinstae/joyuris-classifier
|
refs/heads/main
|
/streamlit_app.py
|
import streamlit as st
import pandas as pd
from math import pi
from PIL import Image
from bokeh.plotting import figure
from bokeh.transform import cumsum
from model import predict
def create_pie_chart(probability_dict):
data = pd.Series(probability_dict).reset_index(name='value').rename(columns={'index': 'candidate'})
data['angle'] = data['value'] / data['value'].sum() * 2 * pi
data['color'] = ['#ccebc5', '#fed9a6', '#ffffcc']
print(data)
p = figure(plot_height=350, title="신경망이 예측한 확률 비율", toolbar_location=None,
tools="hover", tooltips="@candidate: @value", x_range=(-0.5, 1.0))
p.wedge(x=0, y=1, radius=0.4,
start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
line_color="white", fill_color='color', legend_field='candidate', source=data)
p.axis.axis_label = None
p.axis.visible = False
p.grid.grid_line_color = None
st.bokeh_chart(p, use_container_width=False)
st.title("조유리즈 판별기")
uploaded_file = st.file_uploader("얼굴만 자른 사진을 올려주세요...", type="jpg")
if uploaded_file is not None:
img = Image.open(uploaded_file)
prediction, probability = predict(img)
st.image(
img,
width=256,
caption=f"이 사람은... {prediction}!",
)
create_pie_chart(probability)
|
{"/main.py": ["/model.py"], "/streamlit_app.py": ["/model.py"]}
|
15,508
|
yuvan03/sequence-processors
|
refs/heads/master
|
/file_parser.py
|
import sys
import os
class FileParser():
def __init__(self, filelocation):
self.filelocation = filelocation
input_data = self.read_file()
print("File contents: {}".format(input_data))
def read_file(self):
file_contents = ""
with open(self.filelocation, "r") as f:
file_contents="".join(each_line.rstrip() for each_line in f)
return file_contents
if __name__ == '__main__':
current_location = os.getcwd()
print ("Current working dir : %s" % current_location)
file_location = current_location+'/phrases.txt'
FileParser(file_location)
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,509
|
yuvan03/sequence-processors
|
refs/heads/master
|
/assign_grades.py
|
import os
class AssignGrades():
""" User is given a grade and test report for items correct and incorrect."""
def __init__(self, file_location, subject):
self.file_location = file_location
if subject == 'chem':
self.chem_assign_grades()
def get_names(self):
e_temp = []
print("Please enter 5 elements from the first 20 in the periodic table")
while len(e_temp) < 5:
elem = (input("Please enter element: ")).lower()
if elem in e_temp:
print ("Duplicate entered")
elif len(elem) == 0:
print("No value entered")
else:
e_temp.append(elem)
return e_temp
def compute_grades(self, element_file):
tmp_element_list = []
element_list = element_file.readline()
while element_list:
tmp_element_list.append(element_list.strip().lower())
element_list = element_file.readline()
e_list = self.get_names()
correct_list = []
mistake_list = []
for temp in range(5):
if e_list[temp] in tmp_element_list:
correct_list.append(e_list[temp])
else:
mistake_list.append(e_list[temp])
correctpercent = (int(len(correct_list)))*20
print ("Score: ", correctpercent, "%")
print ("Found: ",correct_list)
print("Not Found:", mistake_list)
def chem_assign_grades(self):
element_file = open(self.file_location,'r')
self.compute_grades(element_file)
if __name__ == '__main__':
current_location = os.getcwd()
print ("Current working dir : %s" % current_location)
AssignGrades(current_location+'/elements1_20.txt', 'chem')
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,510
|
yuvan03/sequence-processors
|
refs/heads/master
|
/filter_sequence.py
|
from file_parser import FileParser
import os
class FilterSequence():
def __init__(self, filelocation, filter_letter):
self.filelocation = filelocation
file_contents = FileParser(filelocation).read_file()
print("File contents: {}".format(file_contents))
filtered = self.first_letter_filter(filter_letter, file_contents)
print(filtered)
def first_letter_filter(self, letter, phrase):
"""Returns the words in [phrase] with starting letter after [letter]"""
result, word = "", ""
for letter in phrase:
if letter.isalpha():
word += letter
elif word.lower() > "h":
result += word.upper() + " "
word = ""
else:
word = ""
if word.lower() > "h":
result += word.upper()
return result
if __name__ == '__main__':
current_location = os.getcwd()
print ("Current working dir : %s" % current_location)
filelocation = current_location+'/phrases.txt'
filter_letter = 'G'
FilterSequence(filelocation, filter_letter)
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,511
|
yuvan03/sequence-processors
|
refs/heads/master
|
/compute_weather.py
|
import os
class ComputeWeather():
def __init__(self, file_location):
self.file_location = file_location
self.get_avg_temp()
def get_avg_temp(self):
avg_temps = open(self.file_location,'a+')
avg_temps.write("Rio de Janeiro, Brazil, 30.0,18.0\n")
avg_temps.seek(0)
heading = avg_temps.readline()
headings = heading.split(',')
city_temp = avg_temps.readline()
city_list = city_temp.split(',')
while city_temp:
print(headings[0].capitalize(), 'of', city_list[0], headings[2], 'is', city_list[2], 'Celsius')
city_temp = avg_temps.readline()
city_list = city_temp.split(',')
avg_temps.close()
if __name__ == '__main__':
current_location = os.getcwd()
print ("Current working dir : %s" % current_location)
ComputeWeather(current_location+'/avg_temp.txt')
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,512
|
yuvan03/sequence-processors
|
refs/heads/master
|
/string_mixer.py
|
class StringMixer():
""" Takes string input and then prints out a mixed order version of the string"""
def __init__(self, word_list):
self.word_list = word_list
self.mix_sentence()
def mix_word(self, word_list):
word_list.sort()
new_words = []
while len(word_list) > 5:
new_words.append(word_list[-5])
word_list.pop(-5)
new_words.append(word_list[0])
word_list.pop(0)
new_words.append(word_list[-1])
word_list.pop(-1)
return new_words
def mix_sentence(self):
word_list = self.word_list
word_length = len(word_list)
for index in range(word_length):
if len(word_list[index]) <= 3:
word_list[index] = word_list[index].lower()
elif len(word_list[index]) >=7:
word_list[index] = word_list[index].upper()
mixed = self.mix_word(word_list)
for each_word in mixed:
print(each_word, end=" ")
print()
if __name__ == '__main__':
word = input ("Please enter poem/saying: ")
word_list = word.split()
StringMixer(word_list)
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,513
|
yuvan03/sequence-processors
|
refs/heads/master
|
/check_string_list.py
|
class CheckStringList():
"""
Takes string input and checks if that string is in a list of strings
if string is in the list it removes the first instance from list
if string is not in the list the input gets appended to the list
if the string is empty then the last item is popped from the list
if the list becomes empty the program ends
if the user enters "quit" then the program ends
"""
def __init__(self, entity_list):
self.entity_list = entity_list
self.get_user_choice()
def construct_entity_list(self, new_entity):
if new_entity == "":
entity = entity_list.pop()
print(new_entity + " has been popped from list")
elif new_entity.lower() in entity_list:
print(new_entity + " has been removed from list")
return entity_list.remove(new_entity)
else:
print ("1 instance of " + new_entity + " has been appended to the list")
return entity_list.append(new_entity)
def get_user_choice(self):
while self.entity_list:
new_entity = input("Please enter any entity name to add to list or press 'q' to quit program: ")
if new_entity.lower() == "q":
print("Quitting program now")
break
else:
print("List of entitys: " + str(entity_list))
self.construct_entity_list(new_entity)
print (entity_list)
print ("Goodbye!")
if __name__ == '__main__':
entity_list = ["rabbit", "lion", "dog"]
CheckStringList(entity_list)
|
{"/filter_sequence.py": ["/file_parser.py"]}
|
15,587
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/generic/models.py
|
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
from django.db import models
from positions.fields import PositionField
class GenericThing(models.Model):
name = models.CharField(max_length=80)
object_id = models.PositiveIntegerField()
content_type = models.ForeignKey(ContentType)
content_object = generic.GenericForeignKey()
position = PositionField(collection=('object_id', 'content_type'))
def __unicode__(self):
return self.name
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,588
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/ci_settings_sqlite.py
|
from .settings_sqlite import *
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,589
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/ci_settings_postgres.py
|
from .settings_postgres import *
DATABASES['default'].update({'USER': 'postgres', 'PASSWORD': ''})
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,590
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/generic/tests.py
|
import doctest
import unittest
from django.contrib.contenttypes.models import ContentType
from positions.examples.lists.models import List
from positions.examples.generic.models import GenericThing
from django.test import TestCase
class GenericTestCase(TestCase):
def setUp(self):
pass
def tearDown(self):
GenericThing.objects.all().delete()
ContentType.objects.all().delete()
List.objects.all().delete()
# @unittest.skip("Some reason. If you are reading this in a test run someone did not fill this in.")
def test_doctests_standin(self):
# This code just contains the old doctests for this module. They should be most likely split out into their own
# tests at some point.
self.l = List.objects.create(name='To Do')
self.ct = ContentType.objects.get_for_model(self.l)
self.t1 = GenericThing.objects.create(name="First Generic Thing", object_id=self.l.pk, content_type=self.ct)
self.t2 = GenericThing.objects.create(name="Second Generic Thing", object_id=self.l.pk, content_type=self.ct)
self.assertEquals(self.t1.position, 0)
self.assertEquals(self.t2.position, 1)
self.t1.position = 1
self.t1.save()
self.assertEquals(self.t1.position, 1)
self.t2 = GenericThing.objects.get(pk=2)
self.assertEquals(self.t2.position, 0)
self.t1.delete()
actual_order = list(GenericThing.objects.filter(object_id=self.l.pk, content_type=self.ct).values_list('name', 'position').order_by('position'))
expected_order = [(u'Second Generic Thing', 0)]
self.assertEqual(actual_order, expected_order)
self.t3 = GenericThing.objects.create(object_id=self.l.pk, content_type=self.ct, name='Mr. None')
self.t3.save()
self.assertEquals(self.t3.position, 1)
self.t4 = GenericThing.objects.create(object_id=self.l.pk, content_type=self.ct, name='Mrs. None')
self.assertEquals(self.t4.position, 2)
self.t4.position = -2
self.t4.save()
self.assertEquals(self.t4.position, 1)
actual_order = list(GenericThing.objects.order_by('position').values_list('name', flat=True))
expected_order = [u'Second Generic Thing', u'Mrs. None', u'Mr. None']
self.assertEqual(actual_order, expected_order)
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,591
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/todo/models.py
|
from django.db import models
import positions
class Item(models.Model):
description = models.CharField(max_length=50)
# I'm calling the PositionField "index" to make sure any internal code that
# relies on a PositionField being called "position" will break.
# https://github.com/jpwatts/django-positions/pull/12
index = positions.PositionField()
objects = positions.PositionManager('index')
def __unicode__(self):
return self.description
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,592
|
elec/django-positions
|
refs/heads/master
|
/positions/__init__.py
|
from positions.fields import PositionField
from positions.managers import PositionManager
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,593
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/migration/migrations/0003_migrationtest_position.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import positions.fields
class Migration(migrations.Migration):
dependencies = [
('migration', '0002_insert_test_data'),
]
operations = [
migrations.AddField(
model_name='migrationtest',
name='position',
field=positions.fields.PositionField(default=-1),
preserve_default=True,
),
]
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,594
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/settings_mysql.py
|
from .settings import *
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'django_positions',
'USER': 'django_positions',
'PASSWORD': 'django_positions',
}
}
LOGGING['handlers']['debug_log_file']['formatter'] = 'simple'
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,595
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/migration/models.py
|
from django.db import models
# Create your models here.
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
from django.db import models
from positions.fields import PositionField
class MigrationTest(models.Model):
name = models.CharField(max_length=80)
age = models.IntegerField(null=True, blank=True)
favorite_color = models.CharField(max_length=255, null=True, blank=True)
position = PositionField(collection=('name', 'age'))
def __unicode__(self):
return self.name
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,596
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/migration/migrations/0002_insert_test_data.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import positions.fields
def add_test_data(apps, schema_editor):
# We can't import the Person model directly as it may be a newer
# version than this migration expects. We use the historical version.
MigrationTest = apps.get_model("migration", "MigrationTest")
test_record = MigrationTest.objects.create(name='Test Name', age=99, favorite_color='Red')
class Migration(migrations.Migration):
dependencies = [
('migration', '0001_initial'),
]
operations = [
migrations.RunPython(add_test_data),
]
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,597
|
elec/django-positions
|
refs/heads/master
|
/positions/examples/ci_settings_mysql.py
|
from .settings_mysql import *
DATABASES['default'].update({'USER': 'root', 'PASSWORD': ''})
|
{"/positions/examples/generic/tests.py": ["/positions/examples/generic/models.py"], "/positions/examples/todo/models.py": ["/positions/__init__.py"], "/positions/examples/ci_settings_mysql.py": ["/positions/examples/settings_mysql.py"]}
|
15,598
|
acoastalfog/covid-county-plotter
|
refs/heads/master
|
/county_plotter.py
|
#!/usr/bin/env/python
import os
import sys
import numpy as np
import pandas as pd
import matplotlib
import datetime as dt
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from mpl_toolkits.axes_grid.inset_locator import (inset_axes, InsetPosition, mark_inset)
class countyDataPlotter:
def __init__ (self, county, state, dataType, insertType = None):
# County, state, and data type are static per instantiation
self.county = county
self.state = state
self.dataType = dataType
self.insertType = insertType
# Data type readers just grab lists of dates, cases, and deaths. Preprocessing in __init__
if self.dataType == "NYT":
readFunction = self.readNYTData
elif self.dataType == "JHU":
readFunction = self.readJHUData
else:
print ("Unknown data type, options are 'NYT' or 'JHU'.")
sys.exit ()
# Should assert
if self.insertType:
if self.insertType == "right" or self.insertType == "left":
pass
else:
print ("Unknown insert type, options are 'right' or 'left'.")
sys.exit ()
# Read data
self.dates, self.cumulativeCases, self.cumulativeDeaths = readFunction ()
# Compute date limits (future: adjustable)
self.dateLims = [self.dates[0], self.dates[-1]]
# Compute daily cases from cumulatives
self.dailyCases = [self.cumulativeCases[0]]
self.dailyDeaths = [self.cumulativeDeaths[0]]
for i in range(1, len(self.cumulativeCases)):
self.dailyCases.append(self.cumulativeCases[i] - self.cumulativeCases[i - 1])
self.dailyDeaths.append(self.cumulativeDeaths[i] - self.cumulativeDeaths[i - 1])
def readNYTData (self):
usCounties = pd.read_csv("https://github.com/nytimes/covid-19-data/raw/master/us-counties.csv")
countyData = usCounties[(usCounties.state == self.state) & \
(usCounties.county == self.county)].reset_index()
dates = countyData['date'].tolist()
dates = [dt.datetime.strptime(date, '%Y-%m-%d').date() for date in dates]
cumulativeCases = countyData['cases'].tolist()
cumulativeDeaths = countyData['deaths'].tolist()
return dates, cumulativeCases, cumulativeDeaths
def readJHUData (self):
usCases = pd.read_csv("https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_US.csv")
usDeaths = pd.read_csv("https://github.com/CSSEGISandData/COVID-19/raw/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_US.csv")
countyCases = usCases[(usCases.Province_State == self.state) & \
(usCases.Admin2 == self.county)].reset_index()
countyDeaths = usDeaths[(usDeaths.Province_State == self.state) & \
(usDeaths.Admin2 == self.county)].reset_index()
# Return cumulative case list, find first non-zero index
# Deaths from JHU have one extra field, so offset the cumulative data in place
nonZeroIndex = np.nonzero(countyCases.values.tolist()[0][12:])[0][0] + 12
cumulativeCases = countyCases.values.tolist()[0][nonZeroIndex:]
cumulativeDeaths = countyDeaths.values.tolist()[0][nonZeroIndex + 1:]
dates = list(countyCases)[nonZeroIndex:]
dates = [dt.datetime.strptime(date, '%m/%d/%y').date() for date in dates]
return dates, cumulativeCases, cumulativeDeaths
def convolutionMovingAverage (self, data, window):
weights = np.repeat(1.0, window) / window
dataExtension = np.hstack([[0] * (window - 1), data])
# This is a bit of a hack. Just screw around with the convolution window to fit depending on the window size.
dataMovingAverage = \
np.convolve(dataExtension, weights)[window + (window - 8): -(window - (window - 6))]
return dataMovingAverage
def setTwoPaneFormatPerPane (self, ax, axDaily):
# Will use these to smooth out the x data for any called county
locator = mdates.AutoDateLocator(maxticks = 10)
formatter = mdates.ConciseDateFormatter(locator)
# Ensure cumulative curve sits on top of secondary cutve
ax.set_zorder(10)
ax.patch.set_visible(False)
ax.set_ylim(bottom=0)
ax.tick_params(labelsize=8)
# Apply formatting after second axis
axDaily.xaxis.set_major_locator(locator)
axDaily.xaxis.set_major_formatter(formatter)
# Only need to set the xlim on the second axis
axDaily.set_xlim(self.dateLims)
# NYTimes data is sometimes a little ridiculous
axDaily.set_ylim(bottom=0)
axDaily.tick_params(labelsize=8)
def plotCasesAndDeathsTwoPanes (self, window):
# Compute the moving average but just don't just truncate
dailyCasesMovingAverage = self.convolutionMovingAverage(self.dailyCases, window)
dailyDeathsMovingAverage = self.convolutionMovingAverage(self.dailyDeaths, window)
# Start figure
fig, ax = plt.subplots(2, 1, constrained_layout = True, figsize = (5, 6), dpi=300)
ax[0].plot(self.dates, self.cumulativeCases, '-', c='blue', lw=1.5)
ax[0].plot(self.dates, self.cumulativeCases, '.', c='blue', lw=1.5)
ax[0].set_title(self.county + ", " + self.state + " Cumulative Cases and Cases/Day", fontsize = 8)
ax[0].set_ylabel("Cumulative Cases", fontsize = 8)
axDaily0 = ax[0].twinx()
axDaily0.bar(self.dates, self.dailyCases, color='orange', align='edge')
axDaily0.plot(self.dates, dailyCasesMovingAverage, c='grey')
axDaily0.set_ylabel("Daily Cases", fontsize=8)
# Custom legend
convolutionLabel = str(window) + " Day Convolution"
legendElements = [matplotlib.lines.Line2D([0], [0], color='b', marker='.', lw=1.5, label='Cumulative Cases'), \
matplotlib.lines.Line2D([0], [0], color='grey', lw=1.5, label=convolutionLabel)]
ax[0].legend(handles=legendElements, loc=2, fontsize=8)
# Common pane format options
self.setTwoPaneFormatPerPane(ax[0], axDaily0)
if self.insertType:
# Optional inset with log daily data
axInset = plt.axes([0, 0, 1, 1])
if self.insertType == 'right':
ip = InsetPosition(ax[0], [0.40, 0.25, 0.4, 0.4])
elif self.insertType == 'left':
print ("'left' is not actually supported")
sys.exit()
axInset.set_axes_locator(ip)
axInset.bar(self.dates[-30:], self.dailyCases[-30:], color='orange', align='edge')
axInset.plot(self.dates[-30:], dailyCasesMovingAverage[-30:], c='grey')
# Will use these to smooth out the x data for any called county
locator = mdates.AutoDateLocator(maxticks = 6)
formatter = mdates.ConciseDateFormatter(locator)
# Apply formatting after second axis
axInset.xaxis.set_major_locator(locator)
axInset.xaxis.set_major_formatter(formatter)
# Only need to set the xlim on the second axis
newDateLims = [self.dates[-30], self.dates[-1]]
axInset.set_xlim(newDateLims)
# NYTimes data is sometimes a little ridiculous
axInset.set_ylim(bottom=0)
axInset.tick_params(labelsize=8)
# Ax[1] is deaths
ax[1].plot(self.dates, self.cumulativeDeaths, '-', c='blue', lw=1.5)
ax[1].plot(self.dates, self.cumulativeDeaths, '.', c='blue', lw=1.5)
ax[1].set_title(self.county + ", " + self.state + " Cumulative Deaths and Deaths/Day", fontsize=8)
ax[1].set_ylabel("Cumulative Deaths", fontsize=8)
axDaily1 = ax[1].twinx()
axDaily1.bar(self.dates, self.dailyDeaths, color='orange', align='edge')
axDaily1.plot(self.dates, dailyDeathsMovingAverage, c='grey')
axDaily1.set_ylabel("Daily Deaths", fontsize=8)
# Custom legend
convolutionLabel = str(window) + " Day Convolution"
legendElements = [matplotlib.lines.Line2D([0], [0], color='b', marker='.', lw=1.5, label='Cumulative Deaths'), matplotlib.lines.Line2D([0], [0], color='grey', lw=1.5, label=convolutionLabel)]
ax[1].legend(handles=legendElements, fontsize=8)
# Common pane format options
self.setTwoPaneFormatPerPane(ax[1], axDaily1)
# Save a figure
if not os.path.exists('images'):
os.makedirs('images')
nameOfFigure = 'images/' + self.county + "-" + self.state + "-" + self.dataType + ".png"
plt.savefig(nameOfFigure)
|
{"/county_caller.py": ["/county_plotter.py"]}
|
15,599
|
acoastalfog/covid-county-plotter
|
refs/heads/master
|
/county_caller.py
|
#!/usr/bin/env
import county_plotter as cp
rocklandJHU = cp.countyDataPlotter ("Rockland", "New York", "JHU")
rocklandJHU.plotCasesAndDeathsTwoPanes (7)
henricoJHU = cp.countyDataPlotter ("Henrico", "Virginia", "JHU")
henricoJHU.plotCasesAndDeathsTwoPanes (7)
knoxJHU = cp.countyDataPlotter ("Knox", "Tennessee", "JHU")
knoxJHU.plotCasesAndDeathsTwoPanes (7)
#washingtonJHU = cp.countyDataPlotter ("Washington", "Oregon", "JHU")
#washingtonJHU.plotCasesAndDeathsTwoPanes (7)
#
#lickingJHU = cp.countyDataPlotter ("Licking", "Ohio", "JHU")
#lickingJHU.plotCasesAndDeathsTwoPanes (7)
#
#dupageJHU = cp.countyDataPlotter ("DuPage", "Illinois", "JHU")
#dupageJHU.plotCasesAndDeathsTwoPanes (7)
#
#cookJHU = cp.countyDataPlotter ("Cook", "Illinois", "JHU")
#cookJHU.plotCasesAndDeathsTwoPanes (7)
#
#deschutesJHU = cp.countyDataPlotter ("Deschutes", "Oregon", "JHU")
#deschutesJHU.plotCasesAndDeathsTwoPanes (7)
#
#delawareJHU = cp.countyDataPlotter ("Delaware", "New York", "JHU")
#delawareJHU.plotCasesAndDeathsTwoPanes (7)
#
#otsegoJHU = cp.countyDataPlotter ("Otsego", "New York", "JHU")
#otsegoJHU.plotCasesAndDeathsTwoPanes (7)
|
{"/county_caller.py": ["/county_plotter.py"]}
|
15,609
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Backend/backend.py
|
from Backend.CellArray import CellArray
from Backend.rule import Rule
from Backend.rulesCollection import RulesCollection
class Backend:
def __init__(self, rules, cell_tabs):
self.__cell_tabs = None
self.rules = None
try:
self.__cell_tabs = cell_tabs
self.__rules = rules
except Exception as e:
raise e
def getCellArray(self):
return self.__cell_tabs
def getRules(self):
return self.__rules
def setRules(self, rules_dict):
if not isinstance(rules_dict, RulesCollection):
raise TypeError('Expeting a RuleCollection')
self.__rules = rules_dict
def setCellArray(self, cell_array):
if not isinstance(cell_array, CellArray):
raise TypeError('Expeting a CellArray')
self.__cell_tabs = cell_array
def __generateLineFromRules(self, lastLine):
newLine =[]
for i in range(0, len(lastLine)):
if i != 0:
a = lastLine[i-1]
else:
a = True
b = lastLine[i]
if i != (len(lastLine)-1):
c = lastLine[i+1]
else:
c = True
try:
rule = Rule(False,int(a),int(b),int(c))
except Exception as e:
raise e
return
newLine.append(self.__rules.getRulesDictionnary()[rule])
for i in range(0, len(newLine)):
self.__cell_tabs.SetCell(self.__cell_tabs.GetCurrentIterID(), i, newLine[i])
def tick(self):
lastline = []
for item in self.__cell_tabs:
lastline.append(item)
self.__cell_tabs.StartNextIteration()
try:
self.__generateLineFromRules(lastline)
except Exception as e:
raise e
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,610
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Backend/rule.py
|
import hashlib
import binascii
class Rule:
# -1 unknown 0 black 1 white
def __init__(self, rule_type, b1, b2, b3):
self.__rule = [False, -1, -1, -1]
try:
self.SetRuleType(rule_type)
self.__SetB1(b1)
self.__SetB2(b2)
self.__SetB3(b3)
except Exception as e:
raise e
def SetRuleType(self, inputType):
if type(inputType) is not bool:
raise TypeError('Only Boolean is allowed')
else:
self.__rule[0] = type
def GetRuleType(self):
return self.__rule[0]
def __SetColor(self, color, pos):
if not isinstance(color, int):
raise TypeError('Only Int is allowed')
elif color not in [0, 1, -1]:
raise ValueError('Only 0, 1 or -1 is allowed')
else:
self.__rule[pos] = color
def __SetB1(self, color):
try:
self.__SetColor(color, 1)
except Exception as e:
raise e
def __SetB2(self, color):
try:
self.__SetColor(color, 2)
except Exception as e:
raise e
def __SetB3(self, color):
try:
self.__SetColor(color, 3)
except Exception as e:
raise e
def GetB1(self):
return self.__rule[1]
def GetB2(self):
return self.__rule[2]
def GetB3(self):
return self.__rule[3]
def __eq__(self, other):
return (self.GetB1() == other.GetB1()) and (self.GetB2() == other.GetB2()) and (self.GetB3() == other.GetB3())
def __hash__(self):
s = str(int(self.GetB1()))+str(int(self.GetB2()))+str(int(self.GetB3()))
return int(s, 2)
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,611
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Backend/rulesCollection.py
|
from Backend.rule import Rule
class RulesCollection:
def __init__(self, rulesDictionnaryInput):
self.__rulesDictionnary = None
try:
self.setRulesDictionnary(rulesDictionnaryInput)
except Exception as e:
raise e
def setRulesDictionnary(self, rulesDictionnaryInput):
if type(rulesDictionnaryInput) is not dict:
raise TypeError('Only Dictionnary is allowed')
for key in rulesDictionnaryInput:
if type(key) is not Rule:
raise TypeError('Only Rule object is allowed as key')
if type(rulesDictionnaryInput[key]) is not bool:
raise TypeError('Only bool is allowed as value')
self.__rulesDictionnary = rulesDictionnaryInput
def getRulesDictionnary(self):
return self.__rulesDictionnary
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,612
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Backend/CellArray.py
|
from random import randint
class CellArray:
def __init__(self, row_size):
# Main array of cell, true = white, false=black
self.__cell_array = []
self.__row_size = row_size
self._cursor = 0
try:
self.__InitArray(row_size)
except Exception as v:
raise v
# Fill line with True and add it to main array
def StartNextIteration(self):
self.__cell_array.append(self.__InitLine())
# Get size of line
def GetRowSize(self):
return self.__row_size
# Return the ID of current iteration
def GetCurrentIterID(self):
return len(self.__cell_array)-1
# Fill a line with True and return it
def __InitLine(self):
y_array = []
for x in range(0, self.GetRowSize()):
y_array.append(True)
return y_array
# Check if input is good and init the first line with a black pixel
def __InitArray(self, row_size):
if type(row_size) is not int:
raise TypeError(str(row_size) + 'is not a integer')
# Init whole tab to white
y_array = self.__InitLine()
self.__cell_array.append(y_array)
self.__cell_array[0][randint(0, row_size - 1)] = False
# Return the boolean for the iterd_id at the postion y
def GetCell(self, iterd_id, y):
try:
current_cell = self.__cell_array[iterd_id][y]
except Exception as e:
raise e
return current_cell
# Get the position of the cursor
def GetCursor(self):
if self.iterate:
return self.__x
else:
raise Exception("not currently iterate")
# Set the boolean for the iterd_id at the postion y
def SetCell(self, x, y, state):
if type(state) != bool:
raise TypeError('Je veux un boolean putain !')
try:
self.__cell_array[x][y] = state
except Exception as e:
raise e
# Iterate over the line of the current iteration
def __iter__(self):
self.__x = self.GetCurrentIterID()
self.__y = 0
self.iterate = True
return self
def next(self):
return self.__next__()
def __next__(self):
row_size = self.GetRowSize() - 1
cell = self.GetCell(self.__x, self.__y)
if self.__y == row_size:
raise StopIteration
self.iterate = False
return cell
else:
self.__y += 1
return cell
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,613
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Backend/main.py
|
from Backend.backend import Backend
from Backend.CellArray import CellArray
from Backend.rule import Rule
from Backend.rulesCollection import RulesCollection
cells = CellArray(50)
rule1 = Rule(False, 0, 0, 0)
rule2 = Rule(False, 0, 0, 1)
rule3 = Rule(False, 0, 1, 0)
rule4 = Rule(False, 0, 1, 1)
rule5 = Rule(False, 1, 0, 0)
rule6 = Rule(False, 1, 0, 1)
rule7 = Rule(False, 1, 1, 0)
rule8 = Rule(False, 1, 1, 1)
rules = {rule1: True, rule2: False, rule3: True, rule4: False, rule5: False, rule6: True, rule7: False, rule8: True}
rules = RulesCollection(rules)
engine = Backend(rules, cells)
for i in range(0, 100):
line = []
cells = engine.getCellArray()
for e in cells:
if e:
line.append(' ')
else:
line.append(chr(219))
print(line)
engine.tick()
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,614
|
McKay1717/Jeux-de-la-vie
|
refs/heads/master
|
/Front/__init__.py
|
import time
from PyQt5 import uic, QtWidgets, QtCore, Qt
import sys
from PyQt5.QtGui import QPixmap, QImage, QBrush
from PyQt5.QtWidgets import QFileDialog
from Backend.CellArray import CellArray
from Backend.backend import Backend
from Backend.rule import Rule
from Backend.rulesCollection import RulesCollection
Row = 0
line = 0
column = 2
current_exec = -1
tStart = 0
isExec = False
isTime = False
class Ui(QtWidgets.QMainWindow):
def __init__(self):
super(Ui, self).__init__()
uic.loadUi('../Interface/lp74.ui', self)
self.show()
btn_pause = self.findChild(QtWidgets.QPushButton, "btn_pause")
btn_screen = self.findChild(QtWidgets.QPushButton, "btn_screen")
graphic = self.findChild(QtWidgets.QGraphicsView, "graphic")
btn_screen.setEnabled(False)
btn_pause.setEnabled(False)
scene = QtWidgets.QGraphicsScene()
img = QImage(10, 10, QImage.Format_Mono)
for i in range(img.height()):
for j in range(img.height()):
img.setPixel(i, j, 1)
pixmap = QPixmap(img)
pixmap_scaled = pixmap.scaled(graphic.width() - 5, graphic.height() - 5, QtCore.Qt.IgnoreAspectRatio)
cont = QtWidgets.QLabel()
cont.setScaledContents(1)
cont.setPixmap(pixmap_scaled)
scene.addWidget(cont)
graphic.setScene(scene)
rules = self.findChild(QtWidgets.QGraphicsView, "regle")
img_rules = QPixmap("../Interface/regle254_600.png")
img_scaled = img_rules.scaled(rules.width() - 3, rules.height() - 3, QtCore.Qt.IgnoreAspectRatio)
container = QtWidgets.QLabel()
container.setScaledContents(1)
container.setPixmap(img_scaled)
rule_scene = QtWidgets.QGraphicsScene()
rule_scene.addWidget(container)
rules.setScene(rule_scene)
check1 = self.findChild(QtWidgets.QCheckBox, "check1")
check2 = self.findChild(QtWidgets.QCheckBox, "check2")
check3 = self.findChild(QtWidgets.QCheckBox, "check3")
check4 = self.findChild(QtWidgets.QCheckBox, "check4")
check5 = self.findChild(QtWidgets.QCheckBox, "check5")
check6 = self.findChild(QtWidgets.QCheckBox, "check6")
check7 = self.findChild(QtWidgets.QCheckBox, "check7")
check8 = self.findChild(QtWidgets.QCheckBox, "check8")
check1.stateChanged.connect(lambda: state(1, self))
check2.stateChanged.connect(lambda: state(2, self))
check3.stateChanged.connect(lambda: state(3, self))
check4.stateChanged.connect(lambda: state(4, self))
check5.stateChanged.connect(lambda: state(5, self))
check6.stateChanged.connect(lambda: state(6, self))
check7.stateChanged.connect(lambda: state(7, self))
check8.stateChanged.connect(lambda: state(8, self))
cbb_regle = self.findChild(QtWidgets.QComboBox, "cbb_regle")
f = open("../Interface/regles.txt", "r")
for x in f.readlines():
splited = x.split(";")
cbb_regle.addItem(splited[0], splited[1])
dic = eval(cbb_regle.currentData())
if dic['111'] == 1:
check1.setStyleSheet("QCheckBox::indicator {background-color: black}")
check1.setCheckState(2)
if dic['110'] == 1:
check2.setStyleSheet("QCheckBox::indicator {background-color: black}")
check2.setCheckState(2)
if dic['101'] == 1:
check3.setStyleSheet("QCheckBox::indicator {background-color: black}")
check3.setCheckState(2)
if dic['100'] == 1:
check4.setStyleSheet("QCheckBox::indicator {background-color: black}")
check4.setCheckState(2)
if dic['011'] == 1:
check5.setStyleSheet("QCheckBox::indicator {background-color: black}")
check5.setCheckState(2)
if dic['010'] == 1:
check6.setStyleSheet("QCheckBox::indicator {background-color: black}")
check6.setCheckState(2)
if dic['001'] == 1:
check7.setStyleSheet("QCheckBox::indicator {background-color: black}")
check7.setCheckState(2)
if dic['000'] == 1:
check8.setStyleSheet("QCheckBox::indicator {background-color: black}")
check8.setCheckState(2)
cbb_regle.currentIndexChanged.connect(lambda: regles(self))
f.close()
def regles(self):
check1 = self.findChild(QtWidgets.QCheckBox, "check1")
check2 = self.findChild(QtWidgets.QCheckBox, "check2")
check3 = self.findChild(QtWidgets.QCheckBox, "check3")
check4 = self.findChild(QtWidgets.QCheckBox, "check4")
check5 = self.findChild(QtWidgets.QCheckBox, "check5")
check6 = self.findChild(QtWidgets.QCheckBox, "check6")
check7 = self.findChild(QtWidgets.QCheckBox, "check7")
check8 = self.findChild(QtWidgets.QCheckBox, "check8")
cbb_regle = self.findChild(QtWidgets.QComboBox, "cbb_regle")
if cbb_regle.currentData():
dic = eval(cbb_regle.currentData())
if dic['111'] == 1:
check1.setStyleSheet("QCheckBox::indicator {background-color: black}")
check1.setCheckState(2)
else:
check1.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check1.setCheckState(0)
if dic['110'] == 1:
check2.setStyleSheet("QCheckBox::indicator {background-color: black}")
check2.setCheckState(2)
else:
check2.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check2.setCheckState(0)
if dic['101'] == 1:
check3.setStyleSheet("QCheckBox::indicator {background-color: black}")
check3.setCheckState(2)
else:
check3.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check3.setCheckState(0)
if dic['100'] == 1:
check4.setStyleSheet("QCheckBox::indicator {background-color: black}")
check4.setCheckState(2)
else:
check4.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check4.setCheckState(0)
if dic['011'] == 1:
check5.setStyleSheet("QCheckBox::indicator {background-color: black}")
check5.setCheckState(2)
else:
check5.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check5.setCheckState(0)
if dic['010'] == 1:
check6.setStyleSheet("QCheckBox::indicator {background-color: black}")
check6.setCheckState(2)
else:
check6.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check6.setCheckState(0)
if dic['001'] == 1:
check7.setStyleSheet("QCheckBox::indicator {background-color: black}")
check7.setCheckState(2)
else:
check7.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check7.setCheckState(0)
if dic['000'] == 1:
check8.setStyleSheet("QCheckBox::indicator {background-color: black}")
check8.setCheckState(2)
else:
check8.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
check8.setCheckState(0)
def state(i, self):
check = self.findChild(QtWidgets.QCheckBox, "check" + str(i))
if check.isChecked():
check.setStyleSheet("QCheckBox::indicator {background-color: black}")
else:
check.setStyleSheet("QCheckBox::indicator {background-color: white; border: 1px solid}")
def resizeMatrice():
global line, matrix
for i in range(line - 1):
matrix[i].append(0)
matrix[i].insert(0, 0)
return matrix
def matrice(engine, nb_exec, code, matrix):
if code == 0:
Line = []
matrix = []
cells = engine.getCellArray()
for i in range(nb_exec):
for e in cells:
if e:
Line.append(1)
else:
Line.append(0)
matrix.append(Line)
Line = []
engine.tick()
return matrix
else:
Line = []
cells = engine.getCellArray()
for e in cells:
if e:
Line.append(1)
else:
Line.append(0)
matrix.append(Line)
Line = []
engine.tick()
return matrix
def etape(self, timer, engine, matrix):
global Row, line, column, current_exec, tStart
form = self.findChild(QtWidgets.QFrame, "form")
sp_exec = self.findChild(QtWidgets.QSpinBox, "sp_nbexec")
sp_temps = self.findChild(QtWidgets.QSpinBox, "sp_temps")
nb_exec = sp_exec.value()
nb_temps = sp_temps.value()
total_exec = nb_exec
current_exec += 1
if isTime:
matrix = matrice(engine, 0, 1, matrix)
print('Exec total = ' + str(total_exec) + ' | current = ' + str(current_exec) + ' | time = ' + str(
time.time() - tStart))
lcd = self.findChild(QtWidgets.QLCDNumber,"lcdNumber")
lcd.display(time.time() - tStart)
if isExec and current_exec >= total_exec:
timer.stop()
timer.disconnect()
del timer
del matrix
form.setEnabled(True)
popup = QtWidgets.QMessageBox().information(self, "Fin de l'éxécution",
str(current_exec) + " itérations effectuées. Simulation terminée.",
QtWidgets.QMessageBox.Ok)
btn_start.setEnabled(True)
btn_screen.setEnabled(True)
return
if isTime and (time.time() - tStart) > nb_temps:
timer.stop()
timer.disconnect()
del timer
del matrix
form.setEnabled(True)
popup = QtWidgets.QMessageBox().information(self, "Fin de l'éxécution",
str(nb_temps) + " secondes écoulées. Simulation terminée.",
QtWidgets.QMessageBox.Ok)
btn_start.setEnabled(True)
btn_screen.setEnabled(True)
return
graphic = self.findChild(QtWidgets.QGraphicsView, "graphic")
scene = QtWidgets.QGraphicsScene()
img = QImage(len(matrix[0]), line - 1, QImage.Format_Mono)
if isExec:
for i in range(line):
for j in range(len(matrix[i])):
if matrix[i][j] == 1:
img.setPixel(j, i, 0)
else:
img.setPixel(j, i, 1)
if isTime:
for i in range(line):
for j in range(len(matrix[i])):
if matrix[i][j] == 1:
img.setPixel(j, i, 0)
else:
img.setPixel(j, i, 1)
pixmap = QPixmap(img)
pixmap_scaled = pixmap.scaled(graphic.width() - 5, graphic.height() - 5, QtCore.Qt.IgnoreAspectRatio)
gr = QtWidgets.QGraphicsPixmapItem()
gr.setPixmap(pixmap_scaled)
scene.addItem(gr)
graphic.setScene(scene)
line = line + 1
def resetvar():
global tStart, current_exec, Row, line, column
column = 2
line = 1
Row = 0
current_exec = -1
matrix = []
tStart = time.time()
def start(self):
form = self.findChild(QtWidgets.QFrame, "form")
sp_taille = self.findChild(QtWidgets.QSpinBox, "sp_taille")
if (isTime == False and isExec == False) or sp_taille.value() == 0:
popup = QtWidgets.QMessageBox().information(self, "Pas de paramètres",
" Vous devez choisir un nombre d'éxécution ou une durée ainsi qu'une taille de ligne",
QtWidgets.QMessageBox.Ok)
return
resetvar()
btn_start.setEnabled(False)
btn_pause.setEnabled(True)
btn_screen.setEnabled(False)
form.setEnabled(False)
check2 = self.findChild(QtWidgets.QCheckBox, "check2")
check3 = self.findChild(QtWidgets.QCheckBox, "check3")
check4 = self.findChild(QtWidgets.QCheckBox, "check4")
check5 = self.findChild(QtWidgets.QCheckBox, "check5")
check6 = self.findChild(QtWidgets.QCheckBox, "check6")
check7 = self.findChild(QtWidgets.QCheckBox, "check7")
check8 = self.findChild(QtWidgets.QCheckBox, "check8")
rule1 = Rule(False, 0, 0, 0)
rule2 = Rule(False, 0, 0, 1)
rule3 = Rule(False, 0, 1, 0)
rule4 = Rule(False, 0, 1, 1)
rule5 = Rule(False, 1, 0, 0)
rule6 = Rule(False, 1, 0, 1)
rule7 = Rule(False, 1, 1, 0)
rule8 = Rule(False, 1, 1, 1)
rules = {rule1: not check1.isChecked(), rule2: not check2.isChecked(), rule3: not check3.isChecked(),
rule4: not check4.isChecked(), rule5: not check5.isChecked(), rule6: not check6.isChecked(),
rule7: not check7.isChecked(), rule8: not check8.isChecked()}
cells = CellArray(sp_taille.value())
rules = RulesCollection(rules)
engine = Backend(rules, cells)
sp_exec = self.findChild(QtWidgets.QSpinBox, "sp_nbexec")
sp_temps = self.findChild(QtWidgets.QSpinBox, "sp_temps")
nb_exec = sp_exec.value()
nb_temps = sp_temps.value()
total_exec = nb_exec
matrix = []
if isExec:
matrix = matrice(engine, total_exec, 0, matrix)
timer = QtCore.QTimer()
timer.timeout.connect(lambda: etape(self, timer, engine, matrix))
timer.setInterval(100)
timer.start()
btn_pause.pressed.connect(lambda: pause(timer, window))
def StateSpinExec(self):
global isExec
radioButtonExec = self.findChild(QtWidgets.QRadioButton, "rb_is_exec")
sp_exec = self.findChild(QtWidgets.QSpinBox, "sp_nbexec")
if radioButtonExec.isChecked():
sp_exec.setEnabled(True)
isExec = True
else:
sp_exec.setEnabled(False)
isExec = False
def StateSpinTemps(self):
global isTime
radioButtonTemps = self.findChild(QtWidgets.QRadioButton, "rb_is_time")
sp_temps = self.findChild(QtWidgets.QSpinBox, "sp_temps")
if radioButtonTemps.isChecked():
sp_temps.setEnabled(True)
isTime = True
else:
sp_temps.setEnabled(False)
isTime = False
def save(self):
check1 = self.findChild(QtWidgets.QCheckBox, "check1")
check2 = self.findChild(QtWidgets.QCheckBox, "check2")
check3 = self.findChild(QtWidgets.QCheckBox, "check3")
check4 = self.findChild(QtWidgets.QCheckBox, "check4")
check5 = self.findChild(QtWidgets.QCheckBox, "check5")
check6 = self.findChild(QtWidgets.QCheckBox, "check6")
check7 = self.findChild(QtWidgets.QCheckBox, "check7")
check8 = self.findChild(QtWidgets.QCheckBox, "check8")
regle = {"111": int(check1.isChecked()), "110": int(check2.isChecked()), "101": int(check3.isChecked()),
"100": int(check4.isChecked()), "011": int(check5.isChecked()), "010": int(check6.isChecked()),
"001": int(check7.isChecked()), "000": int(check8.isChecked())}
text, popup = QtWidgets.QInputDialog.getText(self, 'Nom de la règle', 'Entrez le nom de la règle:')
if popup:
f = open("../Interface/regles.txt", "a")
string = text + ";" + str(regle) + "\n"
f.write(string)
f.close()
cbb_regle = self.findChild(QtWidgets.QComboBox, "cbb_regle")
cbb_regle.clear()
f = open("../Interface/regles.txt", "r")
for x in f.readlines():
splited = x.split(";")
cbb_regle.addItem(splited[0], splited[1])
popup = QtWidgets.QMessageBox().information(self, "Sauvegarde effectuée",
"La règle a été sauvegardée avec succés", QtWidgets.QMessageBox.Ok)
def pause(timer, self):
btn_screen = self.findChild(QtWidgets.QPushButton, "btn_screen")
if timer.isActive():
btn_pause.setText("Play")
timer.stop()
btn_screen.setEnabled(True)
else:
btn_pause.setText("Pause")
timer.start()
btn_screen.setEnabled(False)
def screen(self):
graphic = self.findChild(QtWidgets.QGraphicsView, "graphic")
scene = graphic.scene()
pixmap = graphic.grab(scene.sceneRect().toRect())
dlg = QFileDialog()
dlg.setAcceptMode(QFileDialog.AcceptSave)
dlg.setNameFilters(["Images (*.png *.jpg)"])
dlg.selectNameFilter("Images (*.png *.jpg)")
if dlg.exec_():
pixmap.save(dlg.selectedFiles()[0])
popup = QtWidgets.QMessageBox().information(self, "Fichier sauvegardé",
"L'image a été sauvegardé : " + dlg.selectedFiles()[0],
QtWidgets.QMessageBox.Ok)
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
window = Ui()
btn_start = window.findChild(QtWidgets.QPushButton, "btn_start")
btn_pause = window.findChild(QtWidgets.QPushButton, "btn_pause")
btn_exit = window.findChild(QtWidgets.QPushButton, "btn_exit")
btn_save = window.findChild(QtWidgets.QPushButton, "btn_save")
btn_screen = window.findChild(QtWidgets.QPushButton, "btn_screen")
check1 = window.findChild(QtWidgets.QCheckBox, "check1")
radioButtonExec = window.findChild(QtWidgets.QRadioButton, "rb_is_exec")
radioButtonExec.toggled.connect(lambda: StateSpinExec(window))
radioButtonTemps = window.findChild(QtWidgets.QRadioButton, "rb_is_time")
radioButtonTemps.toggled.connect(lambda: StateSpinTemps(window))
btn_start.pressed.connect(lambda: start(window))
btn_save.pressed.connect(lambda: save(window))
btn_exit.pressed.connect(app.quit)
btn_screen.pressed.connect(lambda: screen(window))
sys.exit(app.exec_())
|
{"/Backend/backend.py": ["/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Backend/rulesCollection.py": ["/Backend/rule.py"], "/Backend/main.py": ["/Backend/backend.py", "/Backend/CellArray.py", "/Backend/rule.py", "/Backend/rulesCollection.py"], "/Front/__init__.py": ["/Backend/CellArray.py", "/Backend/backend.py", "/Backend/rule.py", "/Backend/rulesCollection.py"]}
|
15,615
|
liupeng110/HuaShell
|
refs/heads/master
|
/HuaShell.py
|
from py_ssh.ssh_py import ssh2,download,upload
import datetime
import os
import threading
opera= input('''
* 首先请确保已经在 ./params文件夹中 填好了必要参数
================================================
================================================
1.批量输入命令
2.批量上传文件
3.批量下载文件
$你要执行什么操作（输入序号）:''')
if opera == '1':
#cmd
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取命令
cmds_f=open(".\\params\\cmds.txt")
cmds=cmds_f.readlines()
cmds_f.close()
#读取服务器列表
hosts_f=open(".\\params\\ip_list.txt")
hosts=hosts_f.readlines()
hosts_f.close()
for host_ip in hosts:
host_ip = host_ip.strip()
a=threading.Thread(target=ssh2,args=(host_ip,username,password,cmds))
a.start()
elif opera == '2':
#upload
dst_dir_path = input('请输入上传目的目录路径（直接回车默认上传至/tmp/）：')
if dst_dir_path == '':
dst_dir_path = '/tmp/'
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取上传文件所在文件夹路径
upload_dir = '.\\upload_dir'
#读取服务器列表
hosts_f=open(".\\params\\ip_list.txt")
hosts=hosts_f.readlines()
hosts_f.close()
for host_ip in hosts:
host_ip = host_ip.strip()
a=threading.Thread(target=upload,args=(host_ip,username,password,upload_dir,dst_dir_path))
a.start()
elif opera =='3':
#download
print('友情提示：确保下载源的文件夹无嵌套文件夹，下载目的文件夹是空文件夹')
print('-------------------------------------------------------------')
src_dir_path = input('请输入下载源的路径文件夹（直接回车默认上传至/tmp/）：')
if src_dir_path == '':
src_dir_path = '/tmp/'
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取下载文件目的文件夹路径
download_dir = '.\\download_dir'
#读取服务器列表
hosts_f=open(".\\params\\ip_list.txt")
hosts=hosts_f.readlines()
hosts_f.close()
for host_ip in hosts:
host_ip = host_ip.strip()
a=threading.Thread(target=download,args=(host_ip,username,password,download_dir,src_dir_path))
a.start()
else:
print('请输入序号！')
input('')
|
{"/HuaShell.py": ["/py_ssh/ssh_py.py"], "/HuaShell_pithy.py": ["/py_ssh/ssh_py.py", "/py_ssh/ip_range.py"]}
|
15,616
|
liupeng110/HuaShell
|
refs/heads/master
|
/py_ssh/ip_range.py
|
def isIP(str1):
tag = True
str1 = str1.strip()
section_num = len(str1.split('.')) # section_num == 4
if section_num != 4 :
tag = False
return tag
try:
for i in range(0,4):
if int(str1.split('.')[i]) < 0 :
tag = False
break
elif int(str1.split('.')[i]) > 255 :
tag = False
break
except :
tag = False
finally:
return tag
def isIPrange(str1):
str1 = str1.strip()
if isIP(str1.split(',')[0].split('-')[0]) :
return True
else:
return False
def iprange_to_list(ip_range):
ip_list = []
ip_range = ip_range.strip()
comma_section_num = len(ip_range.split(','))
comma_section = ip_range.split(',')
for i in range(0,comma_section_num):
cur_comma_section = comma_section[i].strip()
if len(cur_comma_section.split('-')) == 2:
#有范围，eg: 192.168.1.1-100
start_ip = cur_comma_section.split('-')[0]
start_ip_d = int(start_ip.split('.')[3])
end_ip_d = int(cur_comma_section.split('-')[1])
ip_abc = start_ip.split('.')[0]+'.'+start_ip.split('.')[1]+'.'+start_ip.split('.')[2]
for d in range(start_ip_d,end_ip_d+1):
cur_ip = ip_abc+'.'+str(d)
ip_list.append(cur_ip)
elif len(cur_comma_section.split('-')) == 1:
#单个IP
ip_list.append(cur_comma_section)
else:
print('Error:IP_range输入格式不合规')
return -1
return ip_list
def ip_parse(str1):
#输入的如果是IP range,则返回ip_list
#输入的如果是文件，则返回文件中的ip_list
ip_list = []
str1 = str1.strip()
if isIPrange(str1) :
#输入的是ip range
ip_list = iprange_to_list(str1)
for host in ip_list:
if not isIP(host):
print('Error:IP_range输入格式不合规')
return -1
else :
#输入的是文件路径
with open(str1,'r') as f:
hosts = f.readlines()
for host in hosts:
if isIP(host):
host = host.strip('\n')
ip_list.append(host)
else:
print('Error:'+str1+'文件中存在不合规ip')
return -1
return ip_list
if __name__=='__main__':
'''
ip = input('请输入测试IP：')
print(isIP(ip))
ip_r = input('请输入测试IP_range：')
print(isIPrange(ip_r))
ip_r = input('请输入测试IP_range：')
print(iprange_to_list(ip_r))
'''
str1 = input('请输入测试IP_range或文件路径:')
print(ip_parse(str1))
|
{"/HuaShell.py": ["/py_ssh/ssh_py.py"], "/HuaShell_pithy.py": ["/py_ssh/ssh_py.py", "/py_ssh/ip_range.py"]}
|
15,617
|
liupeng110/HuaShell
|
refs/heads/master
|
/HuaShell_pithy.py
|
from py_ssh.ssh_py import ssh2_pithy,download,upload
import datetime
import os
import threading
from py_ssh.ip_range import ip_parse
opera= input('''
* 命令手工输入，ip手工指定
================================================
================================================
1.批量输入命令
2.批量上传文件
3.批量下载文件
$你要执行什么操作（输入序号）:''')
if opera == '1':
#cmd
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取服务器列表
str_ip = input('请输入IP_range或ip_list文件路径:')
hosts = ip_parse(str_ip)
#输入命令
while True:
cmd = input('请输入命令#')
if cmd == 'quit' :
break
elif cmd == 'show help':
print(''' show help help file
quit quit Huashell''')
else:
for host_ip in hosts:
a=threading.Thread(target=ssh2_pithy,args=(host_ip,username,password,cmd))
a.start()
a.join()
elif opera == '2':
#upload
dst_dir_path = input('请输入上传目的目录路径（直接回车默认上传至/tmp/）：')
if dst_dir_path == '':
dst_dir_path = '/tmp/'
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取上传文件所在文件夹路径
upload_dir = '.\\upload_dir'
#读取服务器列表
str_ip = input('请输入IP_range或ip_list文件路径:')
hosts = ip_parse(str_ip)
for host_ip in hosts:
a=threading.Thread(target=upload,args=(host_ip,username,password,upload_dir,dst_dir_path))
a.start()
elif opera =='3':
#download
print('友情提示：确保下载源的文件夹无嵌套文件夹，下载目的文件夹是空文件夹')
print('-------------------------------------------------------------')
src_dir_path = input('请输入下载源的路径文件夹（直接回车默认上传至/tmp/）：')
if src_dir_path == '':
src_dir_path = '/tmp/'
#读取账号、密码
username = 'root'
password = 'Passwd@root&2018'
#读取下载文件目的文件夹路径
download_dir = '.\\download_dir'
#读取服务器列表
str_ip = input('请输入IP_range或ip_list文件路径:')
hosts = ip_parse(str_ip)
for host_ip in hosts:
a=threading.Thread(target=download,args=(host_ip,username,password,download_dir,src_dir_path))
a.start()
else:
print('请输入序号！')
|
{"/HuaShell.py": ["/py_ssh/ssh_py.py"], "/HuaShell_pithy.py": ["/py_ssh/ssh_py.py", "/py_ssh/ip_range.py"]}
|
15,618
|
liupeng110/HuaShell
|
refs/heads/master
|
/py_ssh/ssh_py.py
|
#-*- coding: utf-8 -*-
#!/usr/bin/python
import paramiko
import datetime
import os
import threading
def ssh2(ip,username,passwd,cmd):
try:
paramiko.util.log_to_file('paramiko________.log')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,username,passwd,timeout=5)
for m in cmd:
stdin,stdout,stderr = ssh.exec_command(m)
#stdin.write("Y") #简单交互，输入 ‘Y’
out = stdout.readlines()
# outerr = stderr.readlines()
#屏幕输出
for o in out:
print (o)
print ('%s %s\tOK\n'%(ip,m))
ssh.close()
except :
print ('%s\tError\n'%(ip))
def ssh2_pithy(ip,username,passwd,cmd):
try:
paramiko.util.log_to_file('paramiko________.log')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip,22,username,passwd,timeout=5)
stdin,stdout,stderr = ssh.exec_command(cmd)
out = stdout.readlines()
#屏幕输出
print ('[%s@%s]#%s\n'%(username,ip,cmd))
for o in out:
print (o)
ssh.close()
except :
print ('%s\tError\n'%(ip))
finally:
return 1
def download(ip, username, passwd, local_dir, remote_dir):
try:
paramiko.util.log_to_file('paramiko_download.log')
t = paramiko.Transport((ip,22))
t.connect(username=username,password=passwd)
sftp = paramiko.SFTPClient.from_transport(t)
files = sftp.listdir(remote_dir)
for f in files:
print ('')
print ('############################')
print ('Beginning to download file from %s %s ' % (ip, datetime.datetime.now()))
print ('Downloading file:', os.path.join(remote_dir, f))
sftp.get(os.path.join(remote_dir, f), os.path.join(local_dir, f))#下载
print ('Download file success %s ' % datetime.datetime.now())
print ('')
print ('############################')
t.close()
except:
print ("connect error!")
def upload(ip, username, passwd, local_dir, remote_dir):
try:
paramiko.util.log_to_file('paramiko_upload.log')
t = paramiko.Transport((ip, 22))
t.connect(username=username, password=passwd)
sftp = paramiko.SFTPClient.from_transport(t)
#files = sftp.listdir(remote_dir)
files = os.listdir(local_dir)
for f in files:
print ('')
print ('############################')
print ('Beginning to upload file to %s %s ' % (ip, datetime.datetime.now()))
print ('Uploading file:', os.path.join(local_dir, f))
sftp.put(os.path.join(local_dir, f), os.path.join(remote_dir, f))#上传
print ('Upload file success %s ' % datetime.datetime.now())
print ('')
print ('############################')
t.close()
except:
print ("connect error!")
print (ip, "fail!")
if __name__=='__main__':
a=threading.Thread(target=ssh2,args=('10.0.0.88','root','123456',['mkdir /root/look_at_this/','ls']))
a.start()
a=threading.Thread(target=upload,args=('10.0.0.88','root','123456','D:\\python-learn\\test_upload','/tmp/upload/'))
a.start()
a=threading.Thread(target=download,args=('10.0.0.88','root','123456','D:\\python-learn\\test_upload','/root/look_at_this/'))
a.start()
|
{"/HuaShell.py": ["/py_ssh/ssh_py.py"], "/HuaShell_pithy.py": ["/py_ssh/ssh_py.py", "/py_ssh/ip_range.py"]}
|
15,631
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/preferences.py
|
import numpy as np
import pandas as pd
# Define Saaty's 1-9 Scale for AHP Preference
def matrix_intervalos(A):
max_A = np.max(A, axis=0)
min_A = np.min(A, axis=0)
I = np.zeros(shape=(9, len(max_A)))
for i, (menor, maior) in enumerate(zip(min_A, max_A)):
intervalos = np.linspace(menor, maior, 9)
I[:, i] = intervalos.ravel()
return I
# Calculate the differences among the nominal values of the objectives
def my_cdist(df_obj):
n_row = df_obj.shape[0]
m1 = np.tile(df_obj, (n_row, 1))
m2 = np.tile(df_obj.reshape(-1, 1), (1, n_row))
return m2 - m1
# Calculate the preferences
def preferencia(df_dif, interval):
df_pref = np.ones(shape = df_dif.shape)
it = np.nditer(df_dif, flags=['multi_index'])
for x in it:
for j, _ in enumerate(interval):
if j == len(interval):
df_pref[it.multi_index] = 9 if x < 0 else 1.0 / 9.0
# df_pref[it.multi_index] = 1.0 / 9.0 if x > 0 else 9
break
if interval[j] <= np.abs(x) <= interval[j + 1]:
df_pref[it.multi_index] = 1.0 / (j + 1) if x < 0 else j + 1
# df_pref[it.multi_index] = j+1 if x > 0 else 1.0 / (j + 1)
break
return df_pref.round(3)
def notas_pref(A):
df_pref = pd.DataFrame()
I = matrix_intervalos(A)
# For each objective
for i, sol in enumerate(A.T):
# Calculate the difference among the values
df_dif = my_cdist(sol)
# Get the intervals
interval = I[:, i]
# Generate the PC matrices
pp = pd.DataFrame(preferencia(df_dif, interval), index=None)
df_pref = pd.concat([df_pref, pp], axis=1)
return df_pref
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,632
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/main.py
|
import pandas as pd
import random
import pickle
from tqdm import tqdm
import seaborn as sns
from sklearn.metrics import *
from matplotlib import pyplot as plt
from preferences import notas_pref
from ahp import ahp
from data_preparation import create_subsample
from fine_tunning import fine_tunning
from data_preparation import merge_matrices
from tau_distance import normalised_kendall_tau_distance
len_Q = 5 # n_samples to be evaluated
CV = 5 # number of cross-validation
test_size = 0.2 # 80% train and 20% test
accepted_error = .05 # max tau distance accepted between current ranking and the predicted one
df_var = pd.read_csv("dec_5obj_p2.csv", header=None) # decision variables
# df_var = df_var.iloc[0:55, :].round(5)
df_obj = pd.read_csv('obj_5obj_p2.csv', header=None) # values in Pareto front
# df_obj = df_obj.iloc[0:55, :].round(5)
npop, nvar = df_var.shape
nobj = df_obj.shape[1]
# Generate the preferences
df_obj = df_obj.to_numpy()
df_pref = notas_pref(df_obj)
# AHP from the original alternatives
rank_ahp = ahp(df_pref).index
# Generate the index to be evaluated
index = list(df_var.index)
# Aleatory ranking
aleatory = index.copy()
random.shuffle(aleatory)
# Start an aleatory ranking
rank_aleatory = aleatory.copy()
# Distances
current_previous = []
current_ahp = []
# Metrics
mse = []
rmse = []
r2 = []
mape = []
# Iterations
iteration = []
cont = 0
temp = 1
for aux in tqdm(range(len_Q, npop, len_Q)):
cont += 1
# Define Q and N-Q indexes
Q_index = aleatory[0:aux]
N_Q_index = [x for x in index if x not in Q_index]
# Train
df_Q = create_subsample(df_var=df_var, df_pref=df_pref, nobj=nobj, index=Q_index)
X_train = df_Q.iloc[:, :-nobj] # to predict
y_train = df_Q.iloc[:, -nobj:] # real targets
# Test
df_N_Q = create_subsample(df_var=df_var, df_pref=df_pref, nobj=nobj, index=N_Q_index)
X_test = df_N_Q.iloc[:, :-nobj] # to predict
y_test = df_N_Q.iloc[:, -nobj:] # real targets
# Model training
if temp > accepted_error:
tuned_model = fine_tunning(CV, X_train, y_train)
with open("tuned_model_cbic_5obj.pkl", 'wb') as arq: # Save best model
pickle.dump(tuned_model, arq)
tuned_model.fit(X_train, y_train)
else:
with open("tuned_model_cbic_5obj.pkl", "rb") as fp: # Load trained model
tuned_model = pickle.load(fp)
# Model evaluation
y_pred = tuned_model.predict(X_test)
y_pred = pd.DataFrame(y_pred)
# Metrics
mse.append(mean_squared_error(pd.DataFrame(y_test.values), pd.DataFrame(y_pred.values), squared=True))
rmse.append(mean_squared_error(pd.DataFrame(y_test.values), pd.DataFrame(y_pred.values), squared=False))
r2.append(r2_score(pd.DataFrame(y_test.values), pd.DataFrame(y_pred.values)))
mape.append(mean_absolute_percentage_error(pd.DataFrame(y_test.values), pd.DataFrame(y_pred.values)))
# Merge the predictions of the df train and df test
df_merged = merge_matrices(N_Q_index, df_pref, y_pred)
# Employ AHP in the predicted (mixed with preferences) dataset
rank_predicted = ahp(df_merged).index
# Calculate distances
temp = normalised_kendall_tau_distance(r1=rank_aleatory, r2=rank_predicted)
current_previous.append(temp)
current_ahp.append(normalised_kendall_tau_distance(r1=rank_ahp, r2=rank_predicted))
# df_obj = pd.DataFrame(df_obj)
# plt.scatter(df_obj.loc[:, 0], df_obj.loc[:, 1], color='b') # available
# plt.scatter(df_obj.loc[rank_predicted[0:aux], 0], df_obj.loc[rank_predicted[0:aux], 1], color='r',
# marker='^') # top ranked
# plt.scatter(df_obj.loc[rank_ahp[0:aux], 0], df_obj.loc[rank_ahp[0:aux], 1], color='g', marker='*') # ahp
# plt.legend(["Available", "Top ranked", 'AHP'])
# plt.show()
# Update the ranking
rank_aleatory = rank_predicted
# Storage the iterations
iteration.append(cont)
# if cont == 10:
# break
# Merge the results
results = pd.DataFrame({'Iteration': iteration,
'MSE': mse,
'RMSE': rmse,
'R2': r2,
'MAPE': mape,
'Current_Previous': current_previous,
'Current_AHP': current_ahp})
results_metrics = results[['Iteration', 'MSE', 'RMSE', 'R2', 'MAPE']]
results_tau = results[['Iteration', 'Current_Previous', 'Current_AHP']]
fig, ax = plt.subplots()
sns.lineplot(x='Iteration',
y='value',
hue='variable',
data=pd.melt(results_metrics, "Iteration"))
ax.legend(["MSE", "RMSE", 'R2', 'MAPE'])
plt.ylabel("Error metric")
# plt.show()
plt.savefig('error_metric_cbic_5obj__.png')
plt.close(fig) # close the figure window
fig, ax = plt.subplots()
sns.lineplot(x='Iteration',
y='value',
hue='variable',
data=pd.melt(results_tau, "Iteration"))
ax.legend(["Current vs Previous", 'Current vs AHP'])
ax.set_ylim(0, 1)
plt.ylabel("Tau similarity")
plt.axhline(y=.05, ls=':', color='red', marker='*')
# plt.show()
plt.savefig('similarity_cbic_5obj__.png')
plt.close(fig) # close the figure window
# Select top10 to plot
top10_pred = rank_predicted[0:10]
select_top10 = pd.DataFrame(df_obj)
select_top10 = select_top10.iloc[top10_pred, :]
select_top10.round(4)
select_top10.to_csv("selected_top10_cbic_5obj_.csv")
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,633
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/ahp.py
|
import pandas as pd
def ahp(df):
"""
Define the AHP method
:param df: preference matrix
:return: ranking
"""
return ((df / df.apply('sum', axis = 0)).apply("sum", axis = 1)).sort_values(ascending=False)
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,634
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/data_preparation.py
|
import pandas as pd
import numpy as np
def create_subsample(df_var, df_pref, nobj, index):
"""
Create sub-dataframes with the features (alternatives) and target (value in the objective space).
:param df_var:
:param df_pref:
:param nobj:
:param index:
:return:
"""
# Create a df_aux that receive the features concatenated (objectives) and targets (preference)
sub_df = pd.DataFrame(np.zeros((len(index), df_var.shape[1]*2 + nobj)))
cont = 0
for i in index:
for j in index:
# Concatenate the two rows - i.e. values of the objectives
# and the preference between the two objectives
sub_df.loc[cont] = pd.concat([df_var.loc[i], df_var.loc[j], df_pref.loc[i, j]], axis = 0, ignore_index = True)
cont += 1
return sub_df
def merge_matrices(idx_N_Q, preference_matrix, ml_predicted):
"""
Replace the predicted values in the preference matrix to calculate
if the rankings (predicted vs preference) are equal or not.
:param idx_N_Q: N-Q index
:param preference_matrix: preference matrix
:param ml_predicted: ranking obtained with the ML method
:return: dataframe merged with the real values and the predicted values
"""
df_merged = preference_matrix.copy()
nobj = ml_predicted.shape[1]
# Gera todas as combinações do N-Q
comb_idx = []
for i in idx_N_Q:
for k in idx_N_Q:
comb_idx.append(tuple([i, k]))
results = pd.DataFrame()
x = 0
for _ in range(0, df_merged.shape[1], df_merged.shape[0]):
m = df_merged.iloc[:, nobj:nobj+df_merged.shape[0]].to_numpy()
for i, idx in enumerate(comb_idx):
m[idx] = ml_predicted.values[i, x]
x += 1
m = pd.DataFrame(m)
results = pd.concat([results, m], ignore_index=False, axis=1)
return results
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,635
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/fine_tunning.py
|
from sklearn.multioutput import MultiOutputRegressor
from sklearn.model_selection import RandomizedSearchCV
from sklearn.ensemble import GradientBoostingRegressor
def fine_tunning(CV, X, y):
"""
Search the best parameters for the Gradient Boosting Regressor model.
"""
model = MultiOutputRegressor(GradientBoostingRegressor(loss='ls',
learning_rate=0.001,
n_estimators=500,
subsample=1.0,
criterion='friedman_mse',
min_samples_split=10,
min_samples_leaf=1,
min_weight_fraction_leaf=0.0,
max_depth=30,
min_impurity_decrease=0.0,
min_impurity_split=None,
init=None,
random_state= 42,
max_features=None,
alpha=0.9,
verbose=0,
max_leaf_nodes=None,
warm_start=False,
validation_fraction=0.1,
n_iter_no_change=None,
tol=0.0001,
ccp_alpha=0.0))
hyperparameters = dict(estimator__learning_rate=[0.05],
estimator__loss=['ls'],
estimator__n_estimators=[500, 1000],
estimator__criterion=['friedman_mse'],
estimator__min_samples_split=[7, 10],
estimator__max_depth=[15, 30],
estimator__min_samples_leaf=[1, 2],
estimator__min_impurity_decrease=[0],
estimator__max_leaf_nodes=[5, 30])
randomized_search = RandomizedSearchCV(model,
hyperparameters,
random_state=42,
n_iter=5,
scoring=None,
n_jobs=-1,
refit=True,
cv=CV,
verbose=True,
pre_dispatch='2*n_jobs',
error_score='raise',
return_train_score=True)
hyperparameters_tuning = randomized_search.fit(X, y)
tuned_model = hyperparameters_tuning.best_estimator_
return tuned_model
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,636
|
mvoicer/cbic-2021-learning-preferences
|
refs/heads/main
|
/tau_distance.py
|
import scipy.stats as stats
import numpy as np
def tau_distance(r1, r2):
"""
Tau distance
Values close to 1 indicate strong agreement,
and values close to -1 indicate strong disagreement.
:param r1: list1
:param r2: list2
:return: tau distance between two lists
"""
tau, p_value = stats.kendalltau(r1, r2)
return tau
def normalised_kendall_tau_distance(r1, r2):
"""
Compute the normalized Kendall tau distance.
:param r1: list1
:param r2: list2
:return: normalized tau distance between two lists
"""
n = len(r1)
assert len(r2) == n, "Both lists have to be of equal length"
i, j = np.meshgrid(np.arange(n), np.arange(n))
a = np.argsort(r1)
b = np.argsort(r2)
ndisordered = np.logical_or(np.logical_and(a[i] < a[j], b[i] > b[j]), np.logical_and(a[i] > a[j], b[i] < b[j])).sum()
return ndisordered / (n * (n - 1))
|
{"/main.py": ["/preferences.py", "/ahp.py", "/data_preparation.py", "/fine_tunning.py", "/tau_distance.py"]}
|
15,637
|
rg3915/banco_de_dados
|
refs/heads/master
|
/pedido/pedido_project/pedido/models.py
|
# encoding: utf-8
from django.db import models
from datetime import date
class Cliente(models.Model):
nome = models.CharField('Nome', max_length=50)
class Meta:
verbose_name=u'cliente'
verbose_name_plural=u'clientes'
def __unicode__(self):
return self.nome
class Categoria(models.Model):
categoria = models.CharField('Categoria', max_length=50)
class Meta:
verbose_name=u'categoria'
verbose_name_plural=u'categorias'
def __unicode__(self):
return self.categoria
class Produto(models.Model):
categoria = models.ForeignKey(Categoria)
produto = models.CharField('Produto', max_length=50)
preco = models.DecimalField('Preço', max_digits=8, decimal_places=2)
class Meta:
verbose_name=u'produto'
verbose_name_plural=u'produtos'
def __unicode__(self):
return self.produto
class Pedido(models.Model):
data_pedido = models.DateField('Data do pedido')
cliente = models.ForeignKey(Cliente)
def __unicode__(self):
return unicode(self.data_pedido)
class DetPedido(models.Model):
pedido = models.ForeignKey(Pedido)
produto = models.ForeignKey(Produto)
quantidade = models.IntegerField()
def __unicode__(self):
return unicode(self.pedido)
|
{"/agenda/admin.py": ["/agenda/models.py"]}
|
15,638
|
rg3915/banco_de_dados
|
refs/heads/master
|
/agenda/admin.py
|
# -*- coding: utf-8 -*-
from django.contrib import admin
from agenda.models import *
class RelacionamentoInline(admin.StackedInline):
model = Relacionamento
fk_name = 'contato'
class FoneInline(admin.TabularInline):
model = Fone
class EnderecoInline(admin.TabularInline):
model = Endereco
class ContatoTagInline(admin.TabularInline):
model = ContatoTag
fk_name = 'contato'
class ContatoAdmin(admin.ModelAdmin):
inlines = [RelacionamentoInline, FoneInline,
EnderecoInline, ContatoTagInline]
admin.site.register(Contato, ContatoAdmin)
admin.site.register(Endereco)
admin.site.register(Relacionamento)
admin.site.register(Tag)
|
{"/agenda/admin.py": ["/agenda/models.py"]}
|
15,639
|
rg3915/banco_de_dados
|
refs/heads/master
|
/agenda/models.py
|
# -*- coding: utf-8 -*-
from django.db import models
CONTATO_TRATAMENTO = (
('a', 'Arq.'),
('aa', 'Arqa.'),
('d', 'Dona'),
('dr', 'Dr.'),
('dra', 'Dra.'),
('e', 'Eng.'),
('p', 'Prof.'),
('pa', 'Profa.'),
('sr', 'Sr.'),
('sra', 'Sra.'),
('srta', 'Srta.'),
)
TIPO_CONTATO = (
('e', 'empresa'),
('p', 'pessoa'),
('c', 'colaborador'),
('f', u'funcionário'),
)
class Contato(models.Model):
confidencial = models.BooleanField(default=True)
tratamento = models.CharField(
max_length=4, choices=CONTATO_TRATAMENTO, blank=True)
nome = models.CharField(max_length=50)
sobrenome = models.CharField(max_length=50, blank=True)
nome_fantasia = models.CharField(max_length=50, blank=True)
razao_social = models.CharField(max_length=50, blank=True)
tipo_contato = models.CharField(max_length=1, choices=TIPO_CONTATO)
cargo = models.CharField(max_length=50, blank=True)
email = models.EmailField()
cnpj = models.CharField(max_length=13, blank=True)
ie = models.CharField(max_length=15, blank=True)
cpf = models.CharField(max_length=11, blank=True)
rg = models.CharField(max_length=10, blank=True)
criado_em = models.DateTimeField(auto_now_add=True, auto_now=False)
modificado_em = models.DateTimeField(auto_now_add=False, auto_now=True)
relationships = models.ManyToManyField(
'self', through='Relacionamento', symmetrical=False, related_name='related_to+')
class Meta:
ordering = ['criado_em']
verbose_name = (u'Contato')
verbose_name_plural = (u'Contatos')
def __unicode__(self):
return self.nome + " " + self.sobrenome
class Relacionamento(models.Model):
contato = models.ForeignKey('Contato', related_name='contato_de')
relaciona_com = models.ForeignKey('Contato', related_name='relaciona_com')
class Meta:
verbose_name = (u'Relacionamento')
verbose_name_plural = (u'Relacionamentos')
def __unicode__(self):
return u'%s -> %s' % (self.contato.nome, self.relaciona_com.nome)
def add_relationship(self, person, status, symm=True):
relationship, created = Relacionamento.objects.get_or_create(
contato=self,
relaciona_com=person,
status=status)
if symm:
person.add_relationship(self, status, False)
return relationship
def remove_relationship(self, person, status, symm=True):
Relacionamento.objects.filter(
contato=self,
relaciona_com=person,
status=status).delete()
if symm:
person.remove_relationship(self, status, False)
def get_relationship(self, status):
return self.relationships.filter(
to_people__contato=self)
class ContatoTag(models.Model):
contato = models.ForeignKey('Contato')
tag = models.ForeignKey('Tag')
class Tag(models.Model):
tag = models.CharField(max_length=100)
class Meta:
verbose_name = (u'tag')
verbose_name_plural = (u'tags')
def __unicode__(self):
return self.tag
TIPO_ENDERECO = (
('i', 'indefinido'),
('c', 'comercial'),
('r', 'residencial'),
('o', 'outros'),
)
class Endereco(models.Model):
contato = models.ForeignKey('Contato')
tipo_endereco = models.CharField(max_length=1, choices=TIPO_ENDERECO)
logradouro = models.CharField(max_length=200)
complemento = models.CharField(max_length=100, blank=True)
bairro = models.CharField(max_length=100, blank=True)
cidade = models.CharField(max_length=100, blank=True)
uf = models.CharField(max_length=100, blank=True)
pais = models.CharField(max_length=100, blank=True)
cep = models.CharField(max_length=50, blank=True)
class Meta:
verbose_name = (u'endereço')
verbose_name_plural = (u'endereços')
def __unicode__(self):
return self.logradouro
TIPO_FONE = (
('pri', 'principal'),
('com', 'comercial'),
('res', 'residencial'),
('cel', 'celular'),
('cl', 'Claro'),
('oi', 'Oi'),
('t', 'Tim'),
('v', 'Vivo'),
('n', 'Nextel'),
('fax', 'fax'),
('o', 'outros'),
)
class Fone(models.Model):
contato = models.ForeignKey('Contato')
fone = models.CharField(max_length=50)
tipo_fone = models.CharField(max_length=3, choices=TIPO_FONE)
|
{"/agenda/admin.py": ["/agenda/models.py"]}
|
15,640
|
rg3915/banco_de_dados
|
refs/heads/master
|
/pedido/pedido_project/pedido/admin.py
|
# encoding: utf-8
from pedido.models import *
from django.contrib import admin
admin.site.register((Cliente, Produto, Categoria, Pedido, DetPedido))
|
{"/agenda/admin.py": ["/agenda/models.py"]}
|
15,654
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/shop/urls.py
|
from django.urls import path
from . import views
urlpatterns = [
path("", views.index, name="ShopHome"),
path("about/", views.about, name="AboutUs"),
path("contact/", views.contact, name="ContactUs"),
path("tracker/", views.tracker, name="TrackingStatus"),
path("search/", views.search, name="Search"),
path("products/<int:myid>", views.productView, name="ProductView"),
path("checkout/", views.checkout, name="Checkout"),
path('logout/',views.user_logout,name='user_logout'),
path('login/',views.user_login,name='user_login'),
path('register/',views.user_register,name='user_register'),
path('profile/',views.user_profile,name='user_profile'),
path('user_update/',views.user_update,name='user_update'),
path('user_password/',views.user_password,name='user_password'),
path("handlerequest/", views.handlerequest, name="HandleRequest"),
path("paytm/", views.paytm, name="HandleRequest"),
]
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,655
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/blog/migrations/0003_auto_20201216_1204.py
|
# Generated by Django 3.1.4 on 2020-12-16 06:04
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('blog', '0002_auto_20200707_2226'),
]
operations = [
migrations.RenameField(
model_name='blogpost',
old_name='head0',
new_name='author',
),
migrations.RemoveField(
model_name='blogpost',
name='chead0',
),
migrations.RemoveField(
model_name='blogpost',
name='chead1',
),
migrations.RemoveField(
model_name='blogpost',
name='chead2',
),
migrations.RemoveField(
model_name='blogpost',
name='head1',
),
migrations.RemoveField(
model_name='blogpost',
name='head2',
),
migrations.AddField(
model_name='blogpost',
name='blog',
field=models.CharField(default='', max_length=9000),
),
migrations.AlterField(
model_name='blogpost',
name='title',
field=models.CharField(max_length=200),
),
]
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,656
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/shop/migrations/0010_auto_20201215_1247.py
|
# Generated by Django 3.1.4 on 2020-12-15 06:47
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('shop', '0009_projectsetting_title_icon'),
]
operations = [
migrations.AddField(
model_name='projectsetting',
name='team1',
field=models.ImageField(blank=True, null=True, upload_to='icon/'),
),
migrations.AddField(
model_name='projectsetting',
name='team2',
field=models.ImageField(blank=True, null=True, upload_to='icon/'),
),
migrations.AddField(
model_name='projectsetting',
name='team3',
field=models.ImageField(blank=True, null=True, upload_to='icon/'),
),
migrations.AddField(
model_name='projectsetting',
name='team4',
field=models.ImageField(blank=True, null=True, upload_to='icon/'),
),
migrations.AddField(
model_name='projectsetting',
name='team5',
field=models.ImageField(blank=True, null=True, upload_to='icon/'),
),
]
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,657
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/blog/models.py
|
from django.db import models
# Create your models here.
class Blogpost(models.Model):
post_id=models.AutoField(primary_key=True)
title=models.CharField(max_length=200)
author=models.CharField(max_length=500,default="")
blog=models.CharField(max_length=9000,default="")
pub_date=models.DateField()
thumbnail = models.ImageField(upload_to='shop/images', default="")
def __str__(self):
return self.title
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,658
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/blog/views.py
|
from django.shortcuts import render
from .models import Blogpost
from shop.models import ProjectSetting
# Create your views here.
from django.http import HttpResponse
def index(request):
myposts = Blogpost.objects.all()
setting = ProjectSetting.objects.get(id=1)
params={
'myposts':myposts,
'setting':setting,
}
return render(request, 'blog/index.html',params)
def blogpost(request, id):
post = Blogpost.objects.filter(post_id = id)[0]
setting = ProjectSetting.objects.get(id=1)
params={
'post':post,
'setting':setting,
}
return render(request, 'blog/blogpost.html',params)
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,659
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/shop/forms.py
|
from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm,UserChangeForm
from django.forms import ModelForm, TextInput, NumberInput, EmailInput, PasswordInput, Select, FileInput
from .models import UserProfile
from django.forms import ModelForm
class SignupForm(UserCreationForm):
username=forms.CharField(max_length=50, label="username",widget=forms.TextInput(
attrs={'placeholder':"Write your username",}
))
email=forms.EmailField(max_length=200, label="email",widget=forms.EmailInput(
attrs={'placeholder':"Write your email",}
))
first_name=forms.CharField(max_length=30, label="first name",widget=forms.TextInput(
attrs={'placeholder':"Write your first name",}
))
last_name=forms.CharField(max_length=30, label="last name",widget=forms.TextInput(
attrs={'placeholder':"Write your last name",}
))
class Meta:
model=User
fields=['username','email','first_name','last_name','password1','password2',]
widgets={
'password1':forms.PasswordInput(attrs={'class':'form-control','placeholder':'Enter a new Password'}),
'password2':forms.PasswordInput(attrs={'class':'form-control','placeholder':'Confirm your Password'}),
}
class UserUpdateForm(UserChangeForm):
class Meta:
model=User
fields=('username','email','first_name','last_name')
widgets={
'username':TextInput(attrs={'class':'input','placeholder':'username'}),
'email':EmailInput(attrs={'class':'input','placeholder':'email'}),
'first_name':TextInput(attrs={'class':'input','placeholder':'first_name'}),
'last_name':TextInput(attrs={'class':'input','placeholder':'last_name'}),
}
CITY = [
('Dhaka', 'Dhaka'),
('Mymensign', 'Mymensign'),
('Rajshahi', 'Rajshahi'),
('Rangpur', 'Rangpur'),
('Barisal', 'Barisal'),
('Chottogram', 'Chottogram'),
('Khulna', 'Khulna'),
]
class ProfileUpdateForm(forms.ModelForm):
class Meta:
model = UserProfile
fields = ('phone', 'address', 'city', 'country', 'image')
widgets = {
'phone': TextInput(attrs={'class': 'input', 'placeholder': 'phone'}),
'address': TextInput(attrs={'class': 'input', 'placeholder': 'address'}),
'city': Select(attrs={'class': 'input', 'placeholder': 'city'}, choices=CITY),
'country': TextInput(attrs={'class': 'input', 'placeholder': 'country'}),
'image': FileInput(attrs={'class': 'input', 'placeholder': 'image', }),
}
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,660
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/shop/admin.py
|
from django.contrib import admin
# Register your models here.
from .models import Product, Contact, Order, OrderUpdate,ProjectSetting,UserProfile
admin.site.register(Product)
admin.site.register(Contact)
admin.site.register(Order)
admin.site.register(OrderUpdate)
admin.site.register(ProjectSetting)
class UserProfileAdmin(admin.ModelAdmin):
list_display=['user','country','image_tag']
list_filter=['user',]
admin.site.register(UserProfile,UserProfileAdmin)
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,661
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/shop/models.py
|
from django.db import models
from django.contrib.auth.models import User
from django.utils.safestring import mark_safe
# Create your models here.
class ProjectSetting(models.Model):
STATUS = (
('True', 'True'),
('False', 'False'),)
title =models.CharField(max_length=200)
keyword=models.CharField(max_length=200)
description=models.TextField()
address=models.CharField(max_length=200)
phone=models.CharField(max_length=18)
fax=models.CharField(blank=True,max_length=50)
email=models.EmailField(blank=True,null=True,max_length=100)
smptserver=models.CharField(max_length=100)
smptemail=models.EmailField(blank=True,null=True,max_length=100)
smptpassword=models.CharField(blank=True,max_length=50)
smptport=models.CharField(blank=True,max_length=150)
icon=models.ImageField(blank=True,null=True,upload_to='icon/')
about_icon=models.ImageField(blank=True,null=True,upload_to='icon/')
title_icon=models.ImageField(blank=True,null=True,upload_to='icon/')
facebook=models.CharField(blank=True,max_length=100)
instagram=models.CharField(blank=True,max_length=100)
address=models.TextField()
contact=models.TextField()
reference=models.TextField()
status=models.CharField(max_length=50,choices=STATUS)
created_at=models.DateTimeField(auto_now_add=True)
updated_at=models.DateTimeField(auto_now_add=True)
team1=models.ImageField(blank=True,null=True,upload_to='icon/')
team2=models.ImageField(blank=True,null=True,upload_to='icon/')
team3=models.ImageField(blank=True,null=True,upload_to='icon/')
team4=models.ImageField(blank=True,null=True,upload_to='icon/')
team5=models.ImageField(blank=True,null=True,upload_to='icon/')
user=models.ImageField(blank=True,null=True,upload_to='icon/')
def __str__(self):
return self.title
class Product(models.Model):
product_id = models.AutoField
product_name = models.CharField(max_length=50)
category = models.CharField(max_length=50, default="")
subcategory = models.CharField(max_length=50, default="")
price = models.IntegerField(default=0)
desc = models.CharField(max_length=300)
pub_date = models.DateField()
image = models.ImageField(upload_to='shop/images', default="")
def __str__(self):
return self.product_name
class Contact(models.Model):
msg_id = models.AutoField(primary_key=True)
name = models.CharField(max_length=50)
email = models.CharField(max_length=70, default="")
phone = models.CharField(max_length=70, default="")
desc = models.CharField(max_length=500, default="")
def __str__(self):
return self.name
class Order(models.Model):
order_id = models.AutoField(primary_key=True)
items_json = models.CharField(max_length=5000)
amount = models.IntegerField(default=0)
name = models.CharField(max_length=90)
email = models.CharField(max_length=111)
address = models.CharField(max_length=111)
city = models.CharField(max_length=111)
state = models.CharField(max_length=111)
zip_code = models.CharField(max_length=111)
phone = models.CharField(max_length=111, default="")
def __str__(self):
return self.name+"\'s Product"
class OrderUpdate(models.Model):
update_id=models.AutoField(primary_key=True)
order_id=models.IntegerField(default="")
update_desc=models.CharField(max_length=5000)
timesetup=models.DateField(auto_now_add=True)
def __str__(self):
return self.update_desc[0:7] + "..."
class UserProfile(models.Model):
user=models.OneToOneField(User,on_delete=models.CASCADE)
phone=models.CharField(blank=True,max_length=20)
address=models.CharField(blank=True,max_length=250)
city=models.CharField(blank=True,max_length=25)
country=models.CharField(blank=True,max_length=30)
image=models.ImageField(blank=True,upload_to='user_img')
def __str__(self):
return self.user.username
def user_name(self):
return self.user.first_name+' '+ self.user.last_name+'['+self.user.username+']'
def image_tag(self):
return mark_safe('<img src="{}" heights="50" width="50" />'.format(self.image.url))
image_tag.short_description='Image'
def imageUrl(self):
if self.image:
return self.image.url
else:
return ""
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,662
|
Mahedihasan8855/E-com-using-Python-Django-
|
refs/heads/master
|
/mahedi/blog/migrations/0004_blogpost_types.py
|
# Generated by Django 3.1.4 on 2020-12-16 06:19
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('blog', '0003_auto_20201216_1204'),
]
operations = [
migrations.AddField(
model_name='blogpost',
name='types',
field=models.CharField(default='', editable=False, max_length=200),
),
]
|
{"/mahedi/blog/views.py": ["/mahedi/blog/models.py"], "/mahedi/shop/forms.py": ["/mahedi/shop/models.py"], "/mahedi/shop/admin.py": ["/mahedi/shop/models.py"]}
|
15,663
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/api/models.py
|
from django.db import models
RATE_CHOICES=(
('5','5 Stars'),
('4','4 Stars'),
('3','3 Stars'),
('2','2 Stars'),
('1','1 Stars'),
('N/A','N/A'),
)
TYPE=(
('movie','movie'),
('series','series'),
('episode','episode'),
)
class Movie(models.Model):
title=models.CharField(max_length=255)
description=models.TextField()
created=models.DateField()
rated=models.CharField(choices=RATE_CHOICES,max_length=4)
duration=models.CharField(max_length=10)
genre=models.ForeignKey('Genre',on_delete=models.SET_NULL,null=True,blank=True)
actors=models.TextField()
country=models.CharField(max_length=200)
type=models.CharField(choices=TYPE,max_length=10)
poster=models.ImageField()
director=models.CharField(max_length=250)
language=models.CharField(max_length=250)
def __str__(self) -> str:
return self.title
class Genre(models.Model):
name=models.CharField(max_length=300)
def __str__(self) -> str:
return self.name
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,664
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/api/serializers.py
|
from rest_framework.serializers import ModelSerializer
from .models import Genre, Movie
class GenreSerializer(ModelSerializer):
class Meta:
model=Genre
fields=['name']
class MovieSerializer(ModelSerializer):
genre=GenreSerializer()
class Meta:
model=Movie
fields=['title',
'description',
'created',
'rated',
'duration',
'genre',
'actors',
'country',
'type',
'poster',
'director',
'language',]
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,665
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/api/views.py
|
from django.db.models import query
from django.shortcuts import render
from rest_framework.generics import CreateAPIView, ListAPIView, ListCreateAPIView, RetrieveAPIView
from django_filters.rest_framework import DjangoFilterBackend
from .models import Genre, Movie
from .serializers import MovieSerializer,GenreSerializer
class MovieListView(ListAPIView):
queryset=Movie.objects.all()
serializer_class=MovieSerializer
filter_backends=[DjangoFilterBackend]
filterset_fields = ['title','genre__name','language','type']
class MovieCreateView(CreateAPIView):
serializer_class=MovieSerializer
queryset=Movie.objects.all()
class MovieDetailView(RetrieveAPIView):
lookup_field='title'
queryset=Movie.objects.all()
serializer_class=MovieSerializer
class GenreListCreateView(ListCreateAPIView):
queryset=Genre.objects.all()
serializer_class=GenreSerializer
filter_backends=[DjangoFilterBackend]
filterset_fields = ['name',]
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,666
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/api/migrations/0001_initial.py
|
# Generated by Django 3.1.7 on 2021-03-05 11:52
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Genre',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=300)),
],
),
migrations.CreateModel(
name='Movie',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(max_length=255)),
('description', models.TextField()),
('created', models.DateTimeField()),
('rated', models.CharField(choices=[('5', '5 Stars'), ('4', '4 Stars'), ('3', '3 Stars'), ('2', '2 Stars'), ('1', '1 Stars'), ('N/A', 'N/A')], max_length=4)),
('duration', models.TimeField()),
('actors', models.TextField()),
('country', models.CharField(max_length=200)),
('type', models.CharField(choices=[('movie', 'movie'), ('series', 'series'), ('episode', 'episode')], max_length=10)),
('poster', models.ImageField(upload_to='')),
('director', models.CharField(max_length=250)),
('language', models.CharField(max_length=250)),
('genre', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='api.genre')),
],
),
]
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,667
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/api/urls.py
|
from django.urls.conf import path
from .views import GenreListCreateView, MovieCreateView, MovieDetailView, MovieListView
from rest_framework import permissions
from drf_yasg.views import get_schema_view
from drf_yasg import openapi
schema_view = get_schema_view(
openapi.Info(
title="Omdbapi API Clone",
default_version='v1',
description="Test description",
terms_of_service="https://www.test@services.com/",
contact=openapi.Contact(email="contact@movies.local"),
license=openapi.License(name="BSD License"),
),
public=True,
permission_classes=(permissions.AllowAny,),
)
app_name='own_api'
urlpatterns = [
path('all_movies/',MovieListView.as_view()),
path('add_movie/',MovieCreateView.as_view()),
path('movie/<str:title>/',MovieDetailView.as_view()),
path('genre/',GenreListCreateView.as_view()),
path('swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
path('redoc/', schema_view.with_ui('redoc', cache_timeout=0), name='schema-redoc'),
]
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,668
|
OtchereDev/Omdbapi-Clone
|
refs/heads/main
|
/config/api_router.py
|
from django.conf import settings
from django.urls.conf import include, path
from rest_framework.routers import DefaultRouter, SimpleRouter
from drf_movies.users.api.views import UserViewSet
if settings.DEBUG:
router = DefaultRouter()
else:
router = SimpleRouter()
router.register("users", UserViewSet)
app_name = "api"
urlpatterns = [path('',include('api.urls')),]
urlpatterns+=router.urls
|
{"/api/serializers.py": ["/api/models.py"], "/api/views.py": ["/api/models.py", "/api/serializers.py"], "/api/urls.py": ["/api/views.py"]}
|
15,669
|
ohwani/molla
|
refs/heads/main
|
/accounts/models.py
|
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.utils.translation import ugettext_lazy as _
from .managers import CustomUserManager
class User(AbstractUser):
username = None
last_name = None
first_name = None
email = models.EmailField(unique=True)
password = models.CharField(max_length=128)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []
objects = CustomUserManager()
name = models.CharField(blank=True, max_length=100)
address = models.CharField(blank=True, max_length=200)
phone = models.CharField(blank=True, max_length=100)
date_of_birth = models.DateField(blank=True, null=True)
profile_image = models.ImageField(blank=True, null= True)
def __str__(self):
return self.email
|
{"/accounts/views.py": ["/accounts/serializers.py", "/accounts/models.py"], "/accounts/serializers.py": ["/accounts/models.py"], "/accounts/models.py": ["/accounts/regex.py"]}
|
15,670
|
ohwani/molla
|
refs/heads/main
|
/post/views.py
|
from django.shortcuts import render
# Create your views here.
# from rest_framework.gnerics import ListAPIview, RetrieveAPIView
|
{"/accounts/views.py": ["/accounts/serializers.py", "/accounts/models.py"], "/accounts/serializers.py": ["/accounts/models.py"], "/accounts/models.py": ["/accounts/regex.py"]}
|
15,671
|
ohwani/molla
|
refs/heads/main
|
/accounts/regex.py
|
EMAIL_RegEx = r'/^[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*.[a-zA-Z]{2,3}$/i'
Message = {
'email': 'INVALID EMAIL FORMAT'
}
|
{"/accounts/views.py": ["/accounts/serializers.py", "/accounts/models.py"], "/accounts/serializers.py": ["/accounts/models.py"], "/accounts/models.py": ["/accounts/regex.py"]}
|
15,672
|
ohwani/molla
|
refs/heads/main
|
/accounts/urls.py
|
from django.urls import path, include
# from rest_framework_simplejwt import views as jwt_views
from . import views
# from files.api.views import ProfileList
from rest_framework.routers import DefaultRouter
# from rest_framework_simplejwt.views import (
# TokenObtainPairView,
# TokenRefreshView,
# TokenVerifyView
# )
router = DefaultRouter()
router.register('', views.UserViewSet)
# router.register('login', views.)
urlpatterns = [
path('', include(router.urls)),
# path('gettoken/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
# path('refreshtoken/', TokenRefreshView.as_view(), name='token_refresh'),
# path('verifytoken/', TokenVerifyView.as_view(), name='token_verify'),
# path('user/', views.UserViewSet.as_view(), name='signup'),
# path('', views.accountsOverview, name="account-overview"),
# path('user-list/', views.userList, name="user-list"),
# path('user-list/<int:pk>/', views.userDetail, name="user-detail"),
# path('user-create/', views.userCreate, name="user-create"),
# path('user-update/<int:pk>/', views.userUpdate, name="user-update"),
# path('user-delete/<int:pk>/', views.userDelete, name="user-delete"),
# path('userdetail/<int:pk>/', views.userDetail, name="user-Detail"),
# path('userlist/', views.userDetail, name="user-Detail"),
# path('user/', views.UserListMixins.as_view()),
# path('userdetail/<int:pk>/', views.UserDetailMixins.as_view()),
]
# from django.urls import path, include
# from . import views
# urlpatterns = [
# # FBV
# path('user/', views.UserListAPIView.as_view()),
# path('user/<int:pk>/',views.UserDetailAPIView.as_view()),
# ]
|
{"/accounts/views.py": ["/accounts/serializers.py", "/accounts/models.py"], "/accounts/serializers.py": ["/accounts/models.py"], "/accounts/models.py": ["/accounts/regex.py"]}
|
15,673
|
ohwani/molla
|
refs/heads/main
|
/accounts/views.py
|
# from rest_framework import status
# from rest_framework.views import APIView
# from rest_framework.response import Response
from rest_framework import viewsets
from rest_framework.permissions import AllowAny
from rest_framework import viewsets, permissions, authentication
# from rest_framework.permissions import AllowAny, IsAuthenticated
from .serializers import (
UserSerializer,
)
from .models import User
# class UserRegisterationView(APIView):
# serializer_class = UserRegisterSerializer
# # permission_classes = (AllowAny)
# def post(self, request):
# serializer = self.serializer_class(data=request.data)
# vaild = serializer.is_valid(rasie_exception=True)
# if valid:
# serializer.save()
# status_code = status.HTTP_201_CREATED
# response = {
# 'success': True,
# 'statusCode': status_code,
# 'message': 'User successfully registered!',
# 'user': serializer.data
# }
# return Response(response, status=status_code)
class UserViewSet(viewsets.ModelViewSet):
queryset = User.objects.all()
serializer_class = UserSerializer
permissions_classes = [AllowAny]
# @action(detail=False)
# def create(self, request, *args, **kwargs):
# '''
# 사용자 등록
# '''
# data = request.data
|
{"/accounts/views.py": ["/accounts/serializers.py", "/accounts/models.py"], "/accounts/serializers.py": ["/accounts/models.py"], "/accounts/models.py": ["/accounts/regex.py"]}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.