code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import tkinter as tk
from tkinter import filedialog
from urllib.request import urlopen
from pathlib import Path
from tkinter import ttk
import numpy as np
import base64
import io
import re
from src.theme import theme
from src.algorithm import blosum
from src.utils import RichText
def qopen(path:str):
'''Opens and returns file content'''
with open(path, 'r') as fh:
content = fh.read()
return content
class Pysum(tk.Frame):
def __init__(self, title):
self.root = tk.Tk()
self.root.title(title)
self.root.configure(background='#ecffde')
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(1, weight=1)
self.style = ttk.Style()
self.style.theme_create('bio', settings=theme())
self.style.theme_use('bio')
self.font_1 = ('Helvetica', 10, 'bold')
self.font_2 = ('Helvetica', 10)
self.main_text = qopen('src/main_texts.txt').split('\n\n')
self.tabs = ttk.Notebook(self.root, padding=10)
self.result_frame = None
self.matrix_labels = None
self.matrix_result = None
self.add_tabs()
self.add_content_tool()
self.add_content_result()
self.add_content_about()
self.root.mainloop()
def add_tabs(self):
self.tool = ttk.Frame(self.tabs)
self.tabs.add(self.tool, text=' Tool ')
self.results = ttk.Frame(self.tabs)
self.tabs.add(self.results, text=' Results ')
self.about = ttk.Frame(self.tabs)
self.tabs.add(self.about, text=' About ')
self.tabs.grid(row=0, column=0)
def add_content_tool(self):
'''Adds all content to the tool tab'''
tool_frame = ttk.LabelFrame(self.tool, text="File Structure", padding=50, relief=tk.RIDGE)
tool_frame.grid(row=0, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
tf_l1 = ttk.Label(tool_frame, text=self.main_text[0], font=self.font_1)
tf_l1.grid(row=0, column=0, pady=3, columnspan=3, sticky="w")
tf_l2 = ttk.Label(tool_frame, text=self.main_text[1], font=self.font_2)
tf_l2.grid(row=1, column=0, pady=3, columnspan=3, sticky="w")
tf_l3 = ttk.Label(tool_frame, text=self.main_text[2], font=self.font_1)
tf_l3.grid(row=2, column=0, pady=3, columnspan=3, sticky="w")
tf_l3 = ttk.Label(tool_frame, text=self.main_text[3], font=self.font_2)
tf_l3.grid(row=3, column=0, pady=3, columnspan=3, sticky="w")
# ---
in_frame = ttk.LabelFrame(self.tool, text="Input", padding=20, relief=tk.RIDGE)
in_frame.grid(row=1, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
self.tf_textin = tk.Text(in_frame, height=6, width=50)
self.tf_textin.grid(row=1, column=0, columnspan=1, sticky="w")
self.tf_textin.insert(tk.END, self.main_text[4])
tf_open_text = ttk.Button(in_frame, text="Open File", command=self.tf_open_file)
tf_open_text.grid(row=1, column=1, sticky="news")
tf_clear_text = ttk.Button(in_frame, text="Clear Input", command=lambda: self.tf_textin.delete(1.0, tk.END))
tf_clear_text.grid(row=1, column=2, sticky="news")
tf_l4 = ttk.Label(in_frame, text=self.main_text[5], font=self.font_1)
tf_l4.grid(row=2, column=0, pady=5, columnspan=1, sticky="w")
self.xx_textin = tk.Text(in_frame, height=1, width=9)
self.xx_textin.grid(row=2, column=1, columnspan=1, sticky="w")
self.xx_textin.insert(tk.END, '')
tf_start_calc = ttk.Button(in_frame, text="CALCULATE!", command=self.check_input_and_pass)
tf_start_calc.grid(row=2, column=2, sticky="news")
def add_content_result(self):
'''Adds all content to the result tab, when calculate is called'''
if self.result_frame is not None:
# dynamicly resize window
self.result_frame.destroy()
self.result_frame = ttk.LabelFrame(self.results, text="Matrix Representation", padding=50, relief=tk.RIDGE)
self.result_frame.grid(row=0, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
if self.matrix_result is None:
ttk.Label(self.result_frame, text="No result available.", font=self.font_2).grid(row=0, column=0, sticky="w")
return
for (row, col), value in np.ndenumerate(self.matrix_result):
if row == 0:
ttk.Label(self.result_frame, text=str(self.matrix_labels[col]), font=self.font_1).grid(row=row, column=col+1)
if col == 0:
ttk.Label(self.result_frame, width=2, text=str(self.matrix_labels[row]), font=self.font_1).grid(row=row+1, column=col)
_ = ttk.Entry(self.result_frame, width=8, font=self.font_2, justify='center')
_.insert(tk.END, str(value))
_.grid(row=row+1, column=col+1)
_.configure(state="readonly")
# ---
degree_frame = ttk.LabelFrame(self.results, text="BLOSUM Degree", padding=50, relief=tk.RIDGE)
degree_frame.grid(row=0, column=1, sticky=tk.E + tk.W + tk.N + tk.S)
ttk.Label(degree_frame, text=str(self.xx_textin.get("1.0", "end-1c").rstrip()), font=('consolas', 30, 'bold')).grid(row=0, column=0, sticky="news")
# ---
out_res_frame = ttk.LabelFrame(self.results, text="Output Settings", padding=50, relief=tk.RIDGE)
out_res_frame.grid(row=1, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
out_res_printtoconsole = ttk.Button(out_res_frame, text="Print to console", command=self.print_res_console_save)
out_res_printtoconsole.grid(row=0, column=0, sticky="w")
out_res_printtoconsole = ttk.Button(out_res_frame, text="Save to file", command=lambda: self.print_res_console_save(save_file=True))
out_res_printtoconsole.grid(row=0, column=2, sticky="w")
def add_content_about(self, renderimg=False):
if renderimg and self.ab_frame is not None:
self.ab_frame.destroy()
self.render_about.destroy()
if not renderimg:
self.render_about = ttk.Button(self.about, text="RENDER IMAGES", command=lambda: self.add_content_about(True))
self.render_about.grid(row=0, column=0, sticky="e")
# This functions as README.md parser in combination witch the class RichText
self.ab_frame = ttk.LabelFrame(self.about, text='About this program', relief=tk.RIDGE)
self.ab_frame.grid(row=(0 if renderimg else 1), column=0, sticky=tk.E + tk.W + tk.N + tk.S)
self.images = [] # need to store reference because of tkinter
with open('README.md', 'r') as fh:
about = fh.readlines()
ab_text = RichText(self.ab_frame, width=73, wrap=tk.WORD)
ab_text.grid(row=0, column=0)
for line in about:
line = line.replace('\\', '')
line = line.replace('**', '')
line = line.replace('```', '')
# title of the readme
if line.startswith('##'):
ab_text.insert("end", line[3:], "h1")
elif line.startswith('#'):
ab_text.insert("end", 'PYSUM\n', "h1")
#extract the url in parentheis and insert image
elif line.startswith('!'):
if renderimg:
image_url = line.split('(')[1].split(')')[0]
image_url = image_url.replace('svg', 'gif').replace('dpi%7B300', 'dpi%7B200')
try:
image_byt = urlopen(image_url).read()
image_b64 = base64.encodestring(image_byt)
photo = tk.PhotoImage(data=image_b64)
ab_text.image_create(tk.END, image = photo)
ab_text.insert('end', '\n')
self.images.append(photo)
except:
self.warn(mode='badinternet', label_loc=self.about, row=2, col=0)
else:
ab_text.insert('end', '\n[NOT RENDERED YET, click on above button!]\n\n')
# draw bulletpoints
elif re.match(r'^[1-9]',line) or line.startswith('*'):
ab_text.insert_bullet('end', line.split(' ', 1)[1])
else:
ab_text.insert("end", line)
ab_text.configure(state='disabled')
return True
def print_res_console_save(self, save_file=False):
label_matrix = self.matrix_result.astype('str')
label2 = self.matrix_labels
label2 = np.asarray(['-'] + label2).reshape((len(label2)+1, 1))
label_matrix = np.vstack((self.matrix_labels, label_matrix))
label_matrix = np.hstack((label2, label_matrix))
header_str = f'BLOSUM{self.xx_textin.get("1.0", "end-1c").rstrip()} Matrix:'
result_str = '\n'.join([''.join(['{:8}'.format(item) for item in row]) for row in label_matrix])
if save_file:
file = filedialog.asksaveasfile(initialdir=str(Path.home()), mode='w', defaultextension=".txt")
if file is None:
return False
file.write(header_str + "\n" + result_str)
file.close()
else:
print(header_str + "\n" + result_str)
def tf_open_file(self):
tf_filename = filedialog.askopenfilename(initialdir=str(Path.home()), title="Select Text File", filetypes=
(("txt files", "*.txt"), ("all files", "*.*")))
if len(tf_filename) == 0:
return False
with open(tf_filename, 'r') as fh:
tf_text = fh.read()
self.tf_textin.delete("1.0", tk.END)
#self.tf_textin.insert(tk.END, tf_text)
self.tf_textin.insert(tk.END, f'--File sucessfully loaded: {len(tf_text.splitlines())} sequences found.--\n'+tf_text.replace(' ', ''))
def check_input_and_pass(self):
dna_sequences = []
initial_len = None
xx_number = self.xx_textin.get("1.0", "end-1c").rstrip().replace(' ', '')
# first check xx_blosum value
try:
xx_number = int(xx_number)
if not xx_number in range(1, 101):
self.warn(mode='xnumrange', label_loc=self.tool)
return False
except:
self.warn(mode='xnuminvalid', label_loc=self.tool)
return False
seq_string = self.tf_textin.get("1.0", tk.END).rstrip().replace(' ', '')
if len(seq_string.splitlines()) < 2:
self.warn(mode='empty', label_loc=self.tool)
return False
for i, line in enumerate(seq_string.upper().splitlines()):
if line.startswith('-'):
continue
if initial_len is None:
initial_len = len(line)
if initial_len != len(line):
self.warn(mode='len', line=i, label_loc=self.tool)
return False
else:
dna_sequences.append(line)
try:
matrix, lables = blosum(dna_sequences, xx_number)
if (matrix is None) and (labels is None):
return self.warn(mode='elimination', label_loc=self.tool)
else:
self.matrix_result, self.matrix_labels = matrix, lables
except:
self.warn(mode='something', line=i, label_loc=self.tool)
return False
self.add_content_result()
self.tabs.select([1])
def warn(self, mode:str, line:int=0, label_loc=None, row=2, col=0):
warn_msg = tk.StringVar()
if mode == 'len':
warn_msg.set(f'[WARNING] Sequence nr.{line+1} differs in lenght!')
elif mode == 'empty':
warn_msg.set(f'[WARNING] At least 2 Sequences must be given!')
elif mode == 'xnumrange':
warn_msg.set(f'[WARNING] BLOSUM Degree must be between 1-100!')
elif mode == 'xnuminvalid':
warn_msg.set(f'[WARNING] BLOSUM Degree must be a number!')
elif mode== 'elimination':
warn_msg.set(f'[WARNING] Only one Sequnce left after elimination!')
elif mode == 'something':
warn_msg.set(f'[WARNING] BLOSUM cant be computed with that sequences!')
elif mode== 'badinternet':
warn_msg.set(f'[WARNING] Internet connection is reqired!')
else:
warn_msg.set(f'[WARNING] This will never happen.')
warning_label = tk.Label(label_loc, textvariable=warn_msg, font=self.font_1, fg="red", bg='#ecffde')
warning_label.grid(row=row, column=col, pady=5, sticky="w")
self.root.after(4000, lambda: warn_msg.set(""))
| [
"tkinter.ttk.Button",
"src.theme.theme",
"numpy.hstack",
"pathlib.Path.home",
"src.algorithm.blosum",
"tkinter.ttk.LabelFrame",
"base64.encodestring",
"src.utils.RichText",
"tkinter.Label",
"tkinter.ttk.Entry",
"tkinter.ttk.Frame",
"tkinter.ttk.Label",
"numpy.asarray",
"numpy.ndenumerate",... | [((500, 507), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (505, 507), True, 'import tkinter as tk\n'), ((702, 713), 'tkinter.ttk.Style', 'ttk.Style', ([], {}), '()\n', (711, 713), False, 'from tkinter import ttk\n'), ((984, 1019), 'tkinter.ttk.Notebook', 'ttk.Notebook', (['self.root'], {'padding': '(10)'}), '(self.root, padding=10)\n', (996, 1019), False, 'from tkinter import ttk\n'), ((1322, 1342), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1331, 1342), False, 'from tkinter import ttk\n'), ((1415, 1435), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1424, 1435), False, 'from tkinter import ttk\n'), ((1512, 1532), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1521, 1532), False, 'from tkinter import ttk\n'), ((1726, 1803), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.tool'], {'text': '"""File Structure"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.tool, text='File Structure', padding=50, relief=tk.RIDGE)\n", (1740, 1803), False, 'from tkinter import ttk\n'), ((1897, 1960), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[0]', 'font': 'self.font_1'}), '(tool_frame, text=self.main_text[0], font=self.font_1)\n', (1906, 1960), False, 'from tkinter import ttk\n'), ((2048, 2111), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[1]', 'font': 'self.font_2'}), '(tool_frame, text=self.main_text[1], font=self.font_2)\n', (2057, 2111), False, 'from tkinter import ttk\n'), ((2199, 2262), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[2]', 'font': 'self.font_1'}), '(tool_frame, text=self.main_text[2], font=self.font_1)\n', (2208, 2262), False, 'from tkinter import ttk\n'), ((2350, 2413), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[3]', 'font': 'self.font_2'}), '(tool_frame, text=self.main_text[3], font=self.font_2)\n', (2359, 2413), False, 'from tkinter import ttk\n'), ((2518, 2586), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.tool'], {'text': '"""Input"""', 'padding': '(20)', 'relief': 'tk.RIDGE'}), "(self.tool, text='Input', padding=20, relief=tk.RIDGE)\n", (2532, 2586), False, 'from tkinter import ttk\n'), ((2686, 2723), 'tkinter.Text', 'tk.Text', (['in_frame'], {'height': '(6)', 'width': '(50)'}), '(in_frame, height=6, width=50)\n', (2693, 2723), True, 'import tkinter as tk\n'), ((2876, 2941), 'tkinter.ttk.Button', 'ttk.Button', (['in_frame'], {'text': '"""Open File"""', 'command': 'self.tf_open_file'}), "(in_frame, text='Open File', command=self.tf_open_file)\n", (2886, 2941), False, 'from tkinter import ttk\n'), ((3194, 3255), 'tkinter.ttk.Label', 'ttk.Label', (['in_frame'], {'text': 'self.main_text[5]', 'font': 'self.font_1'}), '(in_frame, text=self.main_text[5], font=self.font_1)\n', (3203, 3255), False, 'from tkinter import ttk\n'), ((3352, 3388), 'tkinter.Text', 'tk.Text', (['in_frame'], {'height': '(1)', 'width': '(9)'}), '(in_frame, height=1, width=9)\n', (3359, 3388), True, 'import tkinter as tk\n'), ((3527, 3601), 'tkinter.ttk.Button', 'ttk.Button', (['in_frame'], {'text': '"""CALCULATE!"""', 'command': 'self.check_input_and_pass'}), "(in_frame, text='CALCULATE!', command=self.check_input_and_pass)\n", (3537, 3601), False, 'from tkinter import ttk\n'), ((3921, 4012), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""Matrix Representation"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='Matrix Representation', padding=50,\n relief=tk.RIDGE)\n", (3935, 4012), False, 'from tkinter import ttk\n'), ((4306, 4340), 'numpy.ndenumerate', 'np.ndenumerate', (['self.matrix_result'], {}), '(self.matrix_result)\n', (4320, 4340), True, 'import numpy as np\n'), ((4910, 4989), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""BLOSUM Degree"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='BLOSUM Degree', padding=50, relief=tk.RIDGE)\n", (4924, 4989), False, 'from tkinter import ttk\n'), ((5264, 5350), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""Output Settings"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='Output Settings', padding=50, relief=tk.\n RIDGE)\n", (5278, 5350), False, 'from tkinter import ttk\n'), ((5458, 5550), 'tkinter.ttk.Button', 'ttk.Button', (['out_res_frame'], {'text': '"""Print to console"""', 'command': 'self.print_res_console_save'}), "(out_res_frame, text='Print to console', command=self.\n print_res_console_save)\n", (5468, 5550), False, 'from tkinter import ttk\n'), ((6322, 6392), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.about'], {'text': '"""About this program"""', 'relief': 'tk.RIDGE'}), "(self.about, text='About this program', relief=tk.RIDGE)\n", (6336, 6392), False, 'from tkinter import ttk\n'), ((6661, 6708), 'src.utils.RichText', 'RichText', (['self.ab_frame'], {'width': '(73)', 'wrap': 'tk.WORD'}), '(self.ab_frame, width=73, wrap=tk.WORD)\n', (6669, 6708), False, 'from src.utils import RichText\n'), ((8577, 8622), 'numpy.vstack', 'np.vstack', (['(self.matrix_labels, label_matrix)'], {}), '((self.matrix_labels, label_matrix))\n', (8586, 8622), True, 'import numpy as np\n'), ((8646, 8679), 'numpy.hstack', 'np.hstack', (['(label2, label_matrix)'], {}), '((label2, label_matrix))\n', (8655, 8679), True, 'import numpy as np\n'), ((11467, 11481), 'tkinter.StringVar', 'tk.StringVar', ([], {}), '()\n', (11479, 11481), True, 'import tkinter as tk\n'), ((12350, 12439), 'tkinter.Label', 'tk.Label', (['label_loc'], {'textvariable': 'warn_msg', 'font': 'self.font_1', 'fg': '"""red"""', 'bg': '"""#ecffde"""'}), "(label_loc, textvariable=warn_msg, font=self.font_1, fg='red', bg=\n '#ecffde')\n", (12358, 12439), True, 'import tkinter as tk\n'), ((4671, 4744), 'tkinter.ttk.Entry', 'ttk.Entry', (['self.result_frame'], {'width': '(8)', 'font': 'self.font_2', 'justify': '"""center"""'}), "(self.result_frame, width=8, font=self.font_2, justify='center')\n", (4680, 4744), False, 'from tkinter import ttk\n'), ((10948, 10980), 'src.algorithm.blosum', 'blosum', (['dna_sequences', 'xx_number'], {}), '(dna_sequences, xx_number)\n', (10954, 10980), False, 'from src.algorithm import blosum\n'), ((762, 769), 'src.theme.theme', 'theme', ([], {}), '()\n', (767, 769), False, 'from src.theme import theme\n'), ((8498, 8524), 'numpy.asarray', 'np.asarray', (["(['-'] + label2)"], {}), "(['-'] + label2)\n", (8508, 8524), True, 'import numpy as np\n'), ((4143, 4218), 'tkinter.ttk.Label', 'ttk.Label', (['self.result_frame'], {'text': '"""No result available."""', 'font': 'self.font_2'}), "(self.result_frame, text='No result available.', font=self.font_2)\n", (4152, 4218), False, 'from tkinter import ttk\n'), ((9299, 9310), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (9308, 9310), False, 'from pathlib import Path\n'), ((8953, 8964), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (8962, 8964), False, 'from pathlib import Path\n'), ((8086, 8110), 're.match', 're.match', (['"""^[1-9]"""', 'line'], {}), "('^[1-9]', line)\n", (8094, 8110), False, 'import re\n'), ((7538, 7568), 'base64.encodestring', 'base64.encodestring', (['image_byt'], {}), '(image_byt)\n', (7557, 7568), False, 'import base64\n'), ((7601, 7630), 'tkinter.PhotoImage', 'tk.PhotoImage', ([], {'data': 'image_b64'}), '(data=image_b64)\n', (7614, 7630), True, 'import tkinter as tk\n'), ((7476, 7494), 'urllib.request.urlopen', 'urlopen', (['image_url'], {}), '(image_url)\n', (7483, 7494), False, 'from urllib.request import urlopen\n')] |
import numpy as np
import re
def apply_colormaps_based_on_mask(mask, data_for_inside_mask, data_for_outside_mask,
colormap_inside_mask, colormap_outside_mask):
"""
Returns the combination of applying two colormaps to two datasets on two mutually exclusive sets of pixels
as follows. Applies <colormap_inside_mask> to <data_for_inside_mask> for pixels where <thresh_mask> is True and applies
<colormap_outside_mask> to <data_for_outside_mask> for pixels where <thresh_mask> is False.
:param mask: boolean numpy.ndarray
:param data_for_inside_mask: float numpy.ndarray, having the same shape as thresh_mask
:param data_for_outside_mask: float numpy.ndarray, having the same shape as thresh_mask
:param colormap_inside_mask: matplotlib colormap
:param colormap_outside_mask: matplotlib colormap
:return: numpy.ndarray, having the same shape as thresh_mask
"""
assert data_for_inside_mask.shape == data_for_outside_mask.shape, f"data_within_mask and data_outside_mask " \
f"must have " \
f"the same shape. Given: {data_for_inside_mask.shape} " \
f"and {data_for_outside_mask.shape}"
assert mask.shape == data_for_inside_mask.shape, f"The shape of given thresh_mask ({mask.shape}) " \
f"does not match shape of data given " \
f"({data_for_inside_mask.shape})"
data_colorized = np.empty(list(data_for_inside_mask.shape) + [4])
data_colorized[mask, :] = colormap_inside_mask(data_for_inside_mask[mask])
data_colorized[~mask, :] = colormap_outside_mask(data_for_outside_mask[~mask])
return data_colorized
#
# data_masked_inside = np.ma.MaskedArray(data_for_outside_mask, mask, fill_value=0)
# data_masked_outside = np.ma.MaskedArray(data_for_inside_mask, ~mask, fill_value=0)
#
# data_colorized_outside = colormap_outside_mask(data_masked_inside)
# data_colorized_inside = colormap_inside_mask(data_masked_outside)
#
# return data_colorized_inside + data_colorized_outside
def stack_duplicate_frames(frame, depth):
"""
Retuns a numpy.ndarray formed by stacking <frame> along the third axis
:param frame: numpy.ndarray, of 2 dimensions
:param depth: int
:return: numpy.ndarray of shape (frame.shape[0], frame.shape[1], depth)
"""
return np.stack([frame] * depth, axis=2)
def resolve_thresholdOnValue(data, mv_thresholdOnValue):
"""
Interprets <mv_thresholdOnValue> in the context of <data>, calculates the threshold and returns it
:param data: numpy.ndarray
:param mv_thresholdOnValue: str
:return: float
"""
assert re.fullmatch(r"[ra][\-\.0-9]+", mv_thresholdOnValue) is not None, f"{mv_thresholdOnValue} is not a valid" \
f"threshold indicator. Valid formats are " \
f"'rxxx' for relative threshold and 'ayyy' " \
f" for absolute threshold where 'xxx' and" \
f"'yyy' represent numbers. " \
f"E.g.: a123.123, r0.4 and r-0.12533"
threshold_value = float(mv_thresholdOnValue[1:])
if mv_thresholdOnValue.startswith("r"):
thres_pc = np.clip(threshold_value, 0, 100)
data_min, data_max = data.min(), data.max()
threshold = data_min + 0.01 * thres_pc * (data_max - data_min)
elif mv_thresholdOnValue.startswith("a"):
threshold = threshold_value
else:
# Should not come here
raise ValueError()
return threshold
| [
"re.fullmatch",
"numpy.stack",
"numpy.clip"
] | [((2605, 2638), 'numpy.stack', 'np.stack', (['([frame] * depth)'], {'axis': '(2)'}), '([frame] * depth, axis=2)\n', (2613, 2638), True, 'import numpy as np\n'), ((2915, 2968), 're.fullmatch', 're.fullmatch', (['"""[ra][\\\\-\\\\.0-9]+"""', 'mv_thresholdOnValue'], {}), "('[ra][\\\\-\\\\.0-9]+', mv_thresholdOnValue)\n", (2927, 2968), False, 'import re\n'), ((3717, 3749), 'numpy.clip', 'np.clip', (['threshold_value', '(0)', '(100)'], {}), '(threshold_value, 0, 100)\n', (3724, 3749), True, 'import numpy as np\n')] |
import roslib;roslib.load_manifest('kobuki_dashboard')
import rospy
import diagnostic_msgs
from rqt_robot_dashboard.dashboard import Dashboard
from rqt_robot_dashboard.widgets import ConsoleDashWidget, MenuDashWidget, IconToolButton
from python_qt_binding.QtWidgets import QMessageBox, QAction
from python_qt_binding.QtCore import QSize,QTimer
from .battery_widget import BatteryWidget
from .led_widget import LedWidget
from .motor_widget import MotorWidget
from .monitor_dash_widget import MonitorDashWidget
class KobukiDashboard(Dashboard):
def setup(self, context):
self.message = None
self._dashboard_message = None
self._last_dashboard_message_time = 0.0
self._last_laptop_battery_update = 0.0
self._last_kobuki_battery_update = 0.0
self._stale_timer = QTimer()
self._stale_timer.timeout.connect(self.update_stale)
self._stale_timer.start(2500) # Set timeout for 2.5 seconds
self._motor_widget = MotorWidget('mobile_base/commands/motor_power')
self._laptop_bat = BatteryWidget("Laptop")
self._kobuki_bat = BatteryWidget("Kobuki")
self._dashboard_agg_sub = rospy.Subscriber('diagnostics_agg', diagnostic_msgs.msg.DiagnosticArray, self.dashboard_callback)
def get_widgets(self):
leds = [LedWidget('mobile_base/commands/led1'), LedWidget('mobile_base/commands/led2')]
return [[MonitorDashWidget(self.context), ConsoleDashWidget(self.context), self._motor_widget], leds, [self._laptop_bat, self._kobuki_bat]]
def update_stale(self):
current_time = rospy.get_time()
if ((current_time - self._last_kobuki_battery_update) > 15.0):
rospy.logwarn("Kobuki battery update is stale! last update=%f",self._last_dashboard_message_time);
self._kobuki_bat.set_stale()
self._last_kobuki_battery_update = self._last_dashboard_message_time # no need to keep calling
if ((current_time - self._last_laptop_battery_update) > 15.0):
rospy.logwarn("Laptop battery update is stale! last update=%f",self._last_dashboard_message_time);
self._laptop_bat.set_stale()
self._last_laptop_battery_update = self._last_dashboard_message_time # no need to keep calling
def dashboard_callback(self, msg):
self._dashboard_message = msg
self._last_dashboard_message_time = rospy.get_time()
laptop_battery_status = {}
for status in msg.status:
if status.name == "/Kobuki/Motor State":
motor_state = int(status.values[0].value)
self._motor_widget.update_state(motor_state)
elif status.name == "/Power System/Battery":
for value in status.values:
if value.key == 'Percent':
self._kobuki_bat.update_perc(float(value.value))
# This should be self._last_dashboard_message_time?
# Is it even used graphically by the widget
self._kobuki_bat.update_time(float(value.value))
self._kobuki_bat.unset_stale()
self._last_kobuki_battery_update = self._last_dashboard_message_time
elif value.key == "Charging State":
if value.value == "Trickle Charging" or value.value == "Full Charging":
self._kobuki_bat.set_charging(True)
else:
self._kobuki_bat.set_charging(False)
elif status.name == "/Power System/Laptop Battery":
for value in status.values:
laptop_battery_status[value.key]=value.value
if (laptop_battery_status):
percentage = float(laptop_battery_status['Charge (Ah)'])/float(laptop_battery_status['Capacity (Ah)'])
self._laptop_bat.update_perc(percentage*100)
self._laptop_bat.update_time(percentage*100)
charging_state = True if float(laptop_battery_status['Current (A)']) > 0.0 else False
self._laptop_bat.set_charging(charging_state)
self._laptop_bat.unset_stale()
self._last_laptop_battery_update = self._last_dashboard_message_time
def shutdown_dashboard(self):
self._dashboard_agg_sub.unregister()
self._stale_timer.stop()
del self._stale_timer
| [
"rqt_robot_dashboard.widgets.ConsoleDashWidget",
"rospy.logwarn",
"rospy.get_time",
"roslib.load_manifest",
"python_qt_binding.QtCore.QTimer",
"rospy.Subscriber"
] | [((14, 54), 'roslib.load_manifest', 'roslib.load_manifest', (['"""kobuki_dashboard"""'], {}), "('kobuki_dashboard')\n", (34, 54), False, 'import roslib\n'), ((818, 826), 'python_qt_binding.QtCore.QTimer', 'QTimer', ([], {}), '()\n', (824, 826), False, 'from python_qt_binding.QtCore import QSize, QTimer\n'), ((1171, 1272), 'rospy.Subscriber', 'rospy.Subscriber', (['"""diagnostics_agg"""', 'diagnostic_msgs.msg.DiagnosticArray', 'self.dashboard_callback'], {}), "('diagnostics_agg', diagnostic_msgs.msg.DiagnosticArray,\n self.dashboard_callback)\n", (1187, 1272), False, 'import rospy\n'), ((1593, 1609), 'rospy.get_time', 'rospy.get_time', ([], {}), '()\n', (1607, 1609), False, 'import rospy\n'), ((2393, 2409), 'rospy.get_time', 'rospy.get_time', ([], {}), '()\n', (2407, 2409), False, 'import rospy\n'), ((1693, 1796), 'rospy.logwarn', 'rospy.logwarn', (['"""Kobuki battery update is stale! last update=%f"""', 'self._last_dashboard_message_time'], {}), "('Kobuki battery update is stale! last update=%f', self.\n _last_dashboard_message_time)\n", (1706, 1796), False, 'import rospy\n'), ((2024, 2127), 'rospy.logwarn', 'rospy.logwarn', (['"""Laptop battery update is stale! last update=%f"""', 'self._last_dashboard_message_time'], {}), "('Laptop battery update is stale! last update=%f', self.\n _last_dashboard_message_time)\n", (2037, 2127), False, 'import rospy\n'), ((1443, 1474), 'rqt_robot_dashboard.widgets.ConsoleDashWidget', 'ConsoleDashWidget', (['self.context'], {}), '(self.context)\n', (1460, 1474), False, 'from rqt_robot_dashboard.widgets import ConsoleDashWidget, MenuDashWidget, IconToolButton\n')] |
from __future__ import absolute_import, division, print_function
import glob
# Format expected by setup.py and doc/source/conf.py: string of form "X.Y.Z"
_version_major = 0
_version_minor = 1
_version_micro = '' # use '' for first of series, number for 1 and above
_version_extra = 'dev'
# _version_extra = '' # Uncomment this for full releases
# Construct full version string from these.
_ver = [_version_major, _version_minor]
if _version_micro:
_ver.append(_version_micro)
if _version_extra:
_ver.append(_version_extra)
__version__ = '.'.join(map(str, _ver))
CLASSIFIERS = ["Development Status :: 3 - Alpha",
"Environment :: Console",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering"]
# Description should be a one-liner:
description = "Scilpy: diffusion MRI tools and utilities"
# Long description will go up on the pypi page
long_description = """
Scilpy
========
Scilpy is a small library mainly containing small tools and utilities
to quickly work with diffusion MRI. Most of the tools are based
on or wrapper of the Dipy_ library.
.. _Dipy: http://dipy.org
License
=======
``scilpy`` is licensed under the terms of the MIT license. See the file
"LICENSE" for information on the history of this software, terms & conditions
for usage, and a DISCLAIMER OF ALL WARRANTIES.
All trademarks referenced herein are property of their respective holders.
Copyright (c) 2012--, Sherbrooke Connectivity Imaging Lab [SCIL],
Université de Sherbrooke.
"""
NAME = "scilpy"
MAINTAINER = "<NAME>"
MAINTAINER_EMAIL = "<EMAIL>"
DESCRIPTION = description
LONG_DESCRIPTION = long_description
URL = "https://github.com/scilus/scilpy"
DOWNLOAD_URL = ""
LICENSE = "MIT"
AUTHOR = "The SCIL developers"
AUTHOR_EMAIL = ""
PLATFORMS = "OS Independent"
MAJOR = _version_major
MINOR = _version_minor
MICRO = _version_micro
VERSION = __version__
REQUIRES = ["numpy"]
SCRIPTS = glob.glob("scripts/*.py")
| [
"glob.glob"
] | [((2104, 2129), 'glob.glob', 'glob.glob', (['"""scripts/*.py"""'], {}), "('scripts/*.py')\n", (2113, 2129), False, 'import glob\n')] |
# -*- coding: utf8
from gb.randomkit.random import RNG
from gb.samplers import BaseSampler
from gb.samplers import CollapsedGibbsSampler
from gb.stamps import Timestamps
from gb.sloppy import SloppyCounter
from numpy.testing import assert_equal
import numpy as np
def test_get_probability():
d = {}
d[0] = [1, 2, 3, 4, 5, 6, 7]
d[1] = [11, 12, 13]
stamps = Timestamps(d)
causes = stamps._get_causes(0)
causes[0] = 0
causes[1] = 0
causes[2] = 0
causes[3] = 1
causes[4] = 1
causes[5] = 1
causes[6] = 1
causes = stamps._get_causes(1)
causes[0] = 0
causes[1] = 0
causes[2] = 1
nb = np.array([5, 5], dtype='uint64')
init_state = np.array([[5, 5]], dtype='uint64')
id_ = 0
sloppy = SloppyCounter(1, 9999, nb, init_state)
sampler = CollapsedGibbsSampler(BaseSampler(stamps, sloppy, id_, 0.1,
RNG()), 2)
sampler._set_current_process(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._set_current_process(1)
assert_equal(0.40384615384615385, sampler._get_probability(0))
assert_equal(0.21153846153846154, sampler._get_probability(1))
def test_inc_dec():
d = {}
d[0] = [1, 2, 3, 4, 5, 6, 7]
d[1] = [11, 12, 13]
stamps = Timestamps(d)
causes = stamps._get_causes(0)
causes[0] = 0
causes[1] = 0
causes[2] = 0
causes[3] = 1
causes[4] = 1
causes[5] = 1
causes[6] = 1
causes = stamps._get_causes(1)
causes[0] = 0
causes[1] = 0
causes[2] = 1
nb = np.array([5, 5], dtype='uint64')
init_state = np.array([[5, 5]], dtype='uint64')
id_ = 0
sloppy = SloppyCounter(1, 9999, nb, init_state)
sampler = CollapsedGibbsSampler(BaseSampler(stamps, sloppy, id_, 0.1,
RNG()), 2)
sampler._set_current_process(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._inc_one(0)
assert_equal(0.6612903225806451, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._dec_one(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
| [
"numpy.array",
"gb.sloppy.SloppyCounter",
"gb.randomkit.random.RNG",
"gb.stamps.Timestamps"
] | [((379, 392), 'gb.stamps.Timestamps', 'Timestamps', (['d'], {}), '(d)\n', (389, 392), False, 'from gb.stamps import Timestamps\n'), ((654, 686), 'numpy.array', 'np.array', (['[5, 5]'], {'dtype': '"""uint64"""'}), "([5, 5], dtype='uint64')\n", (662, 686), True, 'import numpy as np\n'), ((704, 738), 'numpy.array', 'np.array', (['[[5, 5]]'], {'dtype': '"""uint64"""'}), "([[5, 5]], dtype='uint64')\n", (712, 738), True, 'import numpy as np\n'), ((764, 802), 'gb.sloppy.SloppyCounter', 'SloppyCounter', (['(1)', '(9999)', 'nb', 'init_state'], {}), '(1, 9999, nb, init_state)\n', (777, 802), False, 'from gb.sloppy import SloppyCounter\n'), ((1378, 1391), 'gb.stamps.Timestamps', 'Timestamps', (['d'], {}), '(d)\n', (1388, 1391), False, 'from gb.stamps import Timestamps\n'), ((1653, 1685), 'numpy.array', 'np.array', (['[5, 5]'], {'dtype': '"""uint64"""'}), "([5, 5], dtype='uint64')\n", (1661, 1685), True, 'import numpy as np\n'), ((1703, 1737), 'numpy.array', 'np.array', (['[[5, 5]]'], {'dtype': '"""uint64"""'}), "([[5, 5]], dtype='uint64')\n", (1711, 1737), True, 'import numpy as np\n'), ((1763, 1801), 'gb.sloppy.SloppyCounter', 'SloppyCounter', (['(1)', '(9999)', 'nb', 'init_state'], {}), '(1, 9999, nb, init_state)\n', (1776, 1801), False, 'from gb.sloppy import SloppyCounter\n'), ((925, 930), 'gb.randomkit.random.RNG', 'RNG', ([], {}), '()\n', (928, 930), False, 'from gb.randomkit.random import RNG\n'), ((1924, 1929), 'gb.randomkit.random.RNG', 'RNG', ([], {}), '()\n', (1927, 1929), False, 'from gb.randomkit.random import RNG\n')] |
import tensorflow as tf
"""Class for KDD10 percent GAN architecture.
Generator and discriminator.
"""
learning_rate = 0.00001
batch_size = 50
layer = 1
latent_dim = 32
dis_inter_layer_dim = 128
init_kernel = tf.contrib.layers.xavier_initializer()
def generator(z_inp, is_training=False, getter=None, reuse=False):
""" Generator architecture in tensorflow
Generates data from the latent space
Args:
z_inp (tensor): variable in the latent space
reuse (bool): sharing variables or not
Returns:
(tensor): last activation layer of the generator
"""
with tf.variable_scope('generator', reuse=reuse, custom_getter=getter):
name_net = 'layer_1'
with tf.variable_scope(name_net):
net = tf.layers.dense(z_inp,
units=64,
kernel_initializer=init_kernel,
name='fc')
net = tf.nn.relu(net, name='relu')
name_net = 'layer_2'
with tf.variable_scope(name_net):
net = tf.layers.dense(net,
units=128,
kernel_initializer=init_kernel,
name='fc')
net = tf.nn.relu(net, name='relu')
name_net = 'layer_4'
with tf.variable_scope(name_net):
net = tf.layers.dense(net,
units=121,
kernel_initializer=init_kernel,
name='fc')
return net
def discriminator(x_inp, is_training=False, getter=None, reuse=False):
""" Discriminator architecture in tensorflow
Discriminates between real data and generated data
Args:
x_inp (tensor): input data for the encoder.
reuse (bool): sharing variables or not
Returns:
logits (tensor): last activation layer of the discriminator (shape 1)
intermediate_layer (tensor): intermediate layer for feature matching
"""
with tf.variable_scope('discriminator', reuse=reuse, custom_getter=getter):
name_net = 'layer_1'
with tf.variable_scope(name_net):
net = tf.layers.dense(x_inp,
units=256,
kernel_initializer=init_kernel,
name='fc')
net = leakyReLu(net)
net = tf.layers.dropout(net, rate=0.2, name='dropout',
training=is_training)
name_net = 'layer_2'
with tf.variable_scope(name_net):
net = tf.layers.dense(net,
units=128,
kernel_initializer=init_kernel,
name='fc')
net = leakyReLu(net)
net = tf.layers.dropout(net, rate=0.2, name='dropout',
training=is_training)
name_net = 'layer_3'
with tf.variable_scope(name_net):
net = tf.layers.dense(net,
units=dis_inter_layer_dim,
kernel_initializer=init_kernel,
name='fc')
net = leakyReLu(net)
net = tf.layers.dropout(net,
rate=0.2,
name='dropout',
training=is_training)
intermediate_layer = net
name_net = 'layer_4'
with tf.variable_scope(name_net):
net = tf.layers.dense(net,
units=1,
kernel_initializer=init_kernel,
name='fc')
net = tf.squeeze(net)
return net, intermediate_layer
def leakyReLu(x, alpha=0.1, name=None):
if name:
with tf.variable_scope(name):
return _leakyReLu_impl(x, alpha)
else:
return _leakyReLu_impl(x, alpha)
def _leakyReLu_impl(x, alpha):
return tf.nn.relu(x) - (alpha * tf.nn.relu(-x)) | [
"tensorflow.variable_scope",
"tensorflow.nn.relu",
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.layers.dropout",
"tensorflow.layers.dense",
"tensorflow.squeeze"
] | [((213, 251), 'tensorflow.contrib.layers.xavier_initializer', 'tf.contrib.layers.xavier_initializer', ([], {}), '()\n', (249, 251), True, 'import tensorflow as tf\n'), ((607, 672), 'tensorflow.variable_scope', 'tf.variable_scope', (['"""generator"""'], {'reuse': 'reuse', 'custom_getter': 'getter'}), "('generator', reuse=reuse, custom_getter=getter)\n", (624, 672), True, 'import tensorflow as tf\n'), ((2064, 2133), 'tensorflow.variable_scope', 'tf.variable_scope', (['"""discriminator"""'], {'reuse': 'reuse', 'custom_getter': 'getter'}), "('discriminator', reuse=reuse, custom_getter=getter)\n", (2081, 2133), True, 'import tensorflow as tf\n'), ((3810, 3825), 'tensorflow.squeeze', 'tf.squeeze', (['net'], {}), '(net)\n', (3820, 3825), True, 'import tensorflow as tf\n'), ((4097, 4110), 'tensorflow.nn.relu', 'tf.nn.relu', (['x'], {}), '(x)\n', (4107, 4110), True, 'import tensorflow as tf\n'), ((717, 744), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (734, 744), True, 'import tensorflow as tf\n'), ((764, 839), 'tensorflow.layers.dense', 'tf.layers.dense', (['z_inp'], {'units': '(64)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(z_inp, units=64, kernel_initializer=init_kernel, name='fc')\n", (779, 839), True, 'import tensorflow as tf\n'), ((960, 988), 'tensorflow.nn.relu', 'tf.nn.relu', (['net'], {'name': '"""relu"""'}), "(net, name='relu')\n", (970, 988), True, 'import tensorflow as tf\n'), ((1032, 1059), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (1049, 1059), True, 'import tensorflow as tf\n'), ((1079, 1153), 'tensorflow.layers.dense', 'tf.layers.dense', (['net'], {'units': '(128)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(net, units=128, kernel_initializer=init_kernel, name='fc')\n", (1094, 1153), True, 'import tensorflow as tf\n'), ((1274, 1302), 'tensorflow.nn.relu', 'tf.nn.relu', (['net'], {'name': '"""relu"""'}), "(net, name='relu')\n", (1284, 1302), True, 'import tensorflow as tf\n'), ((1346, 1373), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (1363, 1373), True, 'import tensorflow as tf\n'), ((1393, 1467), 'tensorflow.layers.dense', 'tf.layers.dense', (['net'], {'units': '(121)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(net, units=121, kernel_initializer=init_kernel, name='fc')\n", (1408, 1467), True, 'import tensorflow as tf\n'), ((2178, 2205), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (2195, 2205), True, 'import tensorflow as tf\n'), ((2225, 2301), 'tensorflow.layers.dense', 'tf.layers.dense', (['x_inp'], {'units': '(256)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(x_inp, units=256, kernel_initializer=init_kernel, name='fc')\n", (2240, 2301), True, 'import tensorflow as tf\n'), ((2455, 2525), 'tensorflow.layers.dropout', 'tf.layers.dropout', (['net'], {'rate': '(0.2)', 'name': '"""dropout"""', 'training': 'is_training'}), "(net, rate=0.2, name='dropout', training=is_training)\n", (2472, 2525), True, 'import tensorflow as tf\n'), ((2603, 2630), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (2620, 2630), True, 'import tensorflow as tf\n'), ((2650, 2724), 'tensorflow.layers.dense', 'tf.layers.dense', (['net'], {'units': '(128)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(net, units=128, kernel_initializer=init_kernel, name='fc')\n", (2665, 2724), True, 'import tensorflow as tf\n'), ((2878, 2948), 'tensorflow.layers.dropout', 'tf.layers.dropout', (['net'], {'rate': '(0.2)', 'name': '"""dropout"""', 'training': 'is_training'}), "(net, rate=0.2, name='dropout', training=is_training)\n", (2895, 2948), True, 'import tensorflow as tf\n'), ((3026, 3053), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (3043, 3053), True, 'import tensorflow as tf\n'), ((3073, 3168), 'tensorflow.layers.dense', 'tf.layers.dense', (['net'], {'units': 'dis_inter_layer_dim', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(net, units=dis_inter_layer_dim, kernel_initializer=\n init_kernel, name='fc')\n", (3088, 3168), True, 'import tensorflow as tf\n'), ((3317, 3387), 'tensorflow.layers.dropout', 'tf.layers.dropout', (['net'], {'rate': '(0.2)', 'name': '"""dropout"""', 'training': 'is_training'}), "(net, rate=0.2, name='dropout', training=is_training)\n", (3334, 3387), True, 'import tensorflow as tf\n'), ((3573, 3600), 'tensorflow.variable_scope', 'tf.variable_scope', (['name_net'], {}), '(name_net)\n', (3590, 3600), True, 'import tensorflow as tf\n'), ((3620, 3692), 'tensorflow.layers.dense', 'tf.layers.dense', (['net'], {'units': '(1)', 'kernel_initializer': 'init_kernel', 'name': '"""fc"""'}), "(net, units=1, kernel_initializer=init_kernel, name='fc')\n", (3635, 3692), True, 'import tensorflow as tf\n'), ((3933, 3956), 'tensorflow.variable_scope', 'tf.variable_scope', (['name'], {}), '(name)\n', (3950, 3956), True, 'import tensorflow as tf\n'), ((4122, 4136), 'tensorflow.nn.relu', 'tf.nn.relu', (['(-x)'], {}), '(-x)\n', (4132, 4136), True, 'import tensorflow as tf\n')] |
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='setuptools-wotmod',
version='0.2',
packages=find_packages(),
description='setuptools integration for creating World of Tanks mods',
long_description=open('README.md').read(),
author='jhakonen',
url='https://github.com/jhakonen/setuptools-wotmod/',
license='MIT License',
setup_requires=['pytest-runner'],
tests_require=[
'mock',
'nose',
'pytest<5',
],
entry_points={
"distutils.commands": [
"bdist_wotmod = setuptools_wotmod.bdist_wotmod:bdist_wotmod",
],
},
)
| [
"setuptools.find_packages"
] | [((137, 152), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (150, 152), False, 'from setuptools import setup, find_packages\n')] |
from django.http import HttpResponse
from django.shortcuts import render, redirect
from lab1.views import login
def docs(request):
if not request.user.is_authenticated:
return redirect(login.login_view)
return render(request, 'docs.html')
| [
"django.shortcuts.render",
"django.shortcuts.redirect"
] | [((229, 257), 'django.shortcuts.render', 'render', (['request', '"""docs.html"""'], {}), "(request, 'docs.html')\n", (235, 257), False, 'from django.shortcuts import render, redirect\n'), ((191, 217), 'django.shortcuts.redirect', 'redirect', (['login.login_view'], {}), '(login.login_view)\n', (199, 217), False, 'from django.shortcuts import render, redirect\n')] |
import unittest
import coverage
from flask_script import Manager
from project import create_app, db
from project.api.models import User
COV = coverage.coverage(
branch=True,
include='project/*',
omit=[
'project/tests/*',
'project/server/config.py',
'project/server/*/__init__.py'
]
)
COV.start()
app = create_app()
manager = Manager(app)
@manager.command
def test():
"""Run the unit tests without code coverage."""
tests = unittest.TestLoader().discover('project/tests', pattern='test*.py')
result = unittest.TextTestRunner(verbosity=2).run(tests)
if result.wasSuccessful():
return 0
return 1
@manager.command
def cov():
"""Run the unit tests with coverage."""
tests = unittest.TestLoader().discover('project/tests')
result = unittest.TextTestRunner(verbosity=2).run(tests)
if result.wasSuccessful():
COV.stop()
COV.save()
print("Coverage summary:")
COV.report()
COV.html_report()
COV.erase()
return 0
return 1
@manager.command
def recreate_db():
"""Recreate a database."""
db.drop_all()
db.create_all()
db.session.commit()
@manager.command
def seed_db():
"""Seed the database."""
db.session.add(User(username='forest', email='<EMAIL>'))
db.session.add(User(username='newuser', email='<EMAIL>'))
db.session.commit()
if __name__ == '__main__':
manager.run()
| [
"project.api.models.User",
"project.db.drop_all",
"project.db.create_all",
"flask_script.Manager",
"project.create_app",
"coverage.coverage",
"unittest.TextTestRunner",
"unittest.TestLoader",
"project.db.session.commit"
] | [((145, 286), 'coverage.coverage', 'coverage.coverage', ([], {'branch': '(True)', 'include': '"""project/*"""', 'omit': "['project/tests/*', 'project/server/config.py', 'project/server/*/__init__.py']"}), "(branch=True, include='project/*', omit=['project/tests/*',\n 'project/server/config.py', 'project/server/*/__init__.py'])\n", (162, 286), False, 'import coverage\n'), ((346, 358), 'project.create_app', 'create_app', ([], {}), '()\n', (356, 358), False, 'from project import create_app, db\n'), ((369, 381), 'flask_script.Manager', 'Manager', (['app'], {}), '(app)\n', (376, 381), False, 'from flask_script import Manager\n'), ((1136, 1149), 'project.db.drop_all', 'db.drop_all', ([], {}), '()\n', (1147, 1149), False, 'from project import create_app, db\n'), ((1154, 1169), 'project.db.create_all', 'db.create_all', ([], {}), '()\n', (1167, 1169), False, 'from project import create_app, db\n'), ((1174, 1193), 'project.db.session.commit', 'db.session.commit', ([], {}), '()\n', (1191, 1193), False, 'from project import create_app, db\n'), ((1384, 1403), 'project.db.session.commit', 'db.session.commit', ([], {}), '()\n', (1401, 1403), False, 'from project import create_app, db\n'), ((1276, 1316), 'project.api.models.User', 'User', ([], {'username': '"""forest"""', 'email': '"""<EMAIL>"""'}), "(username='forest', email='<EMAIL>')\n", (1280, 1316), False, 'from project.api.models import User\n'), ((1337, 1378), 'project.api.models.User', 'User', ([], {'username': '"""newuser"""', 'email': '"""<EMAIL>"""'}), "(username='newuser', email='<EMAIL>')\n", (1341, 1378), False, 'from project.api.models import User\n'), ((477, 498), 'unittest.TestLoader', 'unittest.TestLoader', ([], {}), '()\n', (496, 498), False, 'import unittest\n'), ((558, 594), 'unittest.TextTestRunner', 'unittest.TextTestRunner', ([], {'verbosity': '(2)'}), '(verbosity=2)\n', (581, 594), False, 'import unittest\n'), ((753, 774), 'unittest.TestLoader', 'unittest.TestLoader', ([], {}), '()\n', (772, 774), False, 'import unittest\n'), ((814, 850), 'unittest.TextTestRunner', 'unittest.TextTestRunner', ([], {'verbosity': '(2)'}), '(verbosity=2)\n', (837, 850), False, 'import unittest\n')] |
# -----------------------------------------------------------------------------
# Clorm ORM FactBase implementation. FactBase provides a set-like container
# specifically for storing facts (Predicate instances).
# ------------------------------------------------------------------------------
import abc
import io
import itertools
import sys
from typing import (Any, Callable, Iterable, Iterator, List, Optional, TextIO,
Tuple, Type, Union, cast, overload)
from ._typing import _T0, _T1, _T2, _T3, _T4
from ._queryimpl import UnGroupedQuery
from .core import (Predicate, PredicateDefn, PredicatePath, and_,
validate_root_paths)
from .factcontainers import FactMap, factset_equality
from .query import (QueryExecutor, QuerySpec, make_query_plan, process_orderby,
process_where)
__all__ = [
'FactBase',
'Select',
'Delete',
]
#------------------------------------------------------------------------------
# Global
#------------------------------------------------------------------------------
_Facts = Union[Iterable[Predicate], Callable[[], Iterable[Predicate]]]
#------------------------------------------------------------------------------
# Support function for printing ASP facts: Note: _trim_docstring() is taken from
# PEP 257 (modified for Python 3): https://www.python.org/dev/peps/pep-0257/
# ------------------------------------------------------------------------------
_builtin_sorted=sorted
def _format_asp_facts(iterator,output,width):
tmp1=""
for f in iterator:
fstr="{}.".format(f)
if tmp1 and len(tmp1) + len(fstr) > width:
print(tmp1,file=output)
tmp1 = fstr
else:
tmp1 = tmp1 + " " + fstr if tmp1 else fstr
if tmp1: print(tmp1,file=output)
def _trim_docstring(docstring):
if not docstring:
return ''
# Convert tabs to spaces (following the normal Python rules)
# and split into a list of lines:
lines = docstring.expandtabs().splitlines()
# Determine minimum indentation (first line doesn't count):
indent = sys.maxsize
for line in lines[1:]:
stripped = line.lstrip()
if stripped:
indent = min(indent, len(line) - len(stripped))
# Remove indentation (first line is special):
trimmed = [lines[0].strip()]
if indent < sys.maxsize:
for line in lines[1:]:
trimmed.append(line[indent:].rstrip())
# Strip off trailing and leading blank lines:
while trimmed and not trimmed[-1]:
trimmed.pop()
while trimmed and not trimmed[0]:
trimmed.pop(0)
# Return a single string:
return '\n'.join(trimmed)
def _endstrip(string):
if not string: return
nl=string[-1]=='\n'
tmp=string.rstrip()
return tmp + '\n' if nl else tmp
def _format_docstring(docstring,output):
if not docstring: return
tmp=_trim_docstring(docstring)
tmpstr = "".join(_endstrip("% " + l) for l in tmp.splitlines(True))
if tmpstr:
print("% Description:",file=output)
print(tmpstr,file=output)
def _maxwidth(lines):
return max([len(l) for l in lines])
def _format_commented(fm: FactMap, out: TextIO) -> None:
pm: PredicateDefn = fm.predicate.meta
docstring = _trim_docstring(fm.predicate.__doc__) \
if fm.predicate.__doc__ else ""
indent = " "
if pm.arity == 0:
lines = [ "Unary predicate signature:", indent + pm.name ]
else:
def build_signature(p: Type[Predicate]) -> str:
args = []
for pp in p:
complex = pp.meta.field.complex
args.append(cast(str, pp._pathseq[1]) if not complex else build_signature(complex))
return f"{p.meta.name}({','.join(args)})"
lines = [ "Predicate signature:",
indent + build_signature(fm.predicate) ]
if docstring:
lines.append("Description:")
for l in docstring.splitlines():lines.append(indent + l)
bar = "-" * _maxwidth(lines)
lines.insert(0,bar)
lines.append(bar)
for l in lines:
tmp = l.rstrip()
if tmp: print("% {}".format(tmp),file=out)
else: print("%",file=out)
return
#------------------------------------------------------------------------------
# A FactBase consisting of facts of different types
#------------------------------------------------------------------------------
class FactBase(object):
"""A fact base is a container for facts (i.e., Predicate sub-class instances)
``FactBase`` can be behave like a specialised ``set`` object, but can also
behave like a minimalist database. It stores facts for ``Predicate`` types
(where a predicate type loosely corresponds to a *table* in a database)
and allows for certain fields to be indexed in order to perform more
efficient queries.
The initaliser can be given a collection of predicates. If it is passed
another FactBase then it simply makes a copy (including the indexed fields).
FactBase also has a special mode when it is passed a functor instead of a
collection. In this case it performs a delayed initialisation. This means
that the internal data structures are only populated when the FactBase is
actually used. This mode is particularly useful when extracting facts from
models. Often a program will only want to keep the data from the final model
(for example, with optimisation we often want the best model before a
timeout). Delayed initialisation is useful will save computation as only the
last model will be properly initialised.
Args:
facts([Predicate]|FactBase|callable): a list of facts (predicate
instances), a fact base, or a functor that generates a list of
facts. If a functor is passed then the fact base performs a delayed
initialisation. If a fact base is passed and no index is specified then
an index will be created matching in input fact base.
indexes(Field): a list of fields that are to be indexed.
"""
#--------------------------------------------------------------------------
# Internal member functions
#--------------------------------------------------------------------------
# A special purpose initialiser so that we can delayed initialisation
def _init(self, facts=None, indexes=None):
# flag that initialisation has taken place
self._delayed_init: Optional[Callable[[], None]] = None
# If it is delayed initialisation then get the facts
if facts and callable(facts):
facts = facts()
elif facts and isinstance(facts, FactBase) and indexes is None:
indexes = facts.indexes
if indexes is None: indexes=[]
# Create FactMaps for the predicate types with indexed fields
grouped = {}
self._indexes = tuple(indexes)
for path in self._indexes:
if path.meta.predicate not in grouped: grouped[path.meta.predicate] = []
grouped[path.meta.predicate].append(path)
self._factmaps = { pt : FactMap(pt, idxs) for pt, idxs in grouped.items() }
if facts is None: return
self._add(facts)
# Make sure the FactBase has been initialised
def _check_init(self):
if self._delayed_init: self._delayed_init() # Check for delayed init
#--------------------------------------------------------------------------
#
#--------------------------------------------------------------------------
def _add(self, arg: Union[Predicate, Iterable[Predicate]]) -> None:
if isinstance(arg, Predicate):
ptype = arg.__class__
if not ptype in self._factmaps:
self._factmaps[ptype] = FactMap(ptype)
return self._factmaps[ptype].add_fact(arg)
if isinstance(arg, str) or not isinstance(arg, Iterable):
raise TypeError(f"'{arg}' is not a Predicate instance")
sorted_facts = sorted(arg, key=lambda x: x.__class__.__name__)
for type_, grouped_facts in itertools.groupby(sorted_facts, lambda x: x.__class__):
if not issubclass(type_, Predicate):
raise TypeError(f"{list(grouped_facts)} are not Predicate instances")
if not type_ in self._factmaps:
self._factmaps[type_] = FactMap(type_)
self._factmaps[type_].add_facts(grouped_facts)
return
def _remove(self, fact, raise_on_missing):
ptype = type(fact)
if not isinstance(fact, Predicate) or ptype not in self._factmaps:
raise KeyError(fact)
return self._factmaps[ptype].remove(fact,raise_on_missing)
#--------------------------------------------------------------------------
# Initiliser
#--------------------------------------------------------------------------
def __init__(self, facts: Optional[_Facts] = None, indexes: Optional[Iterable[PredicatePath]] = None) -> None:
self._delayed_init=None
if callable(facts):
def delayed_init():
self._init(facts, indexes)
self._delayed_init=delayed_init
else:
self._init(facts, indexes)
#--------------------------------------------------------------------------
# An internal API for the query mechanism. Not to be called by users.
#--------------------------------------------------------------------------
@property
def factmaps(self):
self._check_init() # Check for delayed init
return self._factmaps
#--------------------------------------------------------------------------
# Set member functions
#--------------------------------------------------------------------------
def add(self, arg: Union[Predicate, Iterable[Predicate]]) -> None:
"""Add a single fact or a collection of facts.
Because a ``FactBase`` can only hold :class:`~Predicate` sub-class
instances this member function has been overloaded to take either a
single :class:`~Predicate` sub-class instance or a collection of
:class:`~Predicate` sub-class instances.
Args:
arg: a single fact or a collection of facts.
"""
self._check_init() # Check for delayed init
return self._add(arg)
def remove(self, arg: Predicate) -> None:
"""Remove a fact from the fact base (raises an exception if no fact). """
self._check_init() # Check for delayed init
return self._remove(arg, raise_on_missing=True)
def discard(self, arg: Predicate) -> None:
"""Remove a fact from the fact base. """
self._check_init() # Check for delayed init
return self._remove(arg, raise_on_missing=False)
def pop(self) -> Predicate:
"""Pop an element from the FactBase. """
self._check_init() # Check for delayed init
for pt, fm in self._factmaps.items():
if fm: return fm.pop()
raise KeyError("pop from an empty FactBase")
def clear(self):
"""Clear the fact base of all facts."""
self._check_init() # Check for delayed init
for pt, fm in self._factmaps.items(): fm.clear()
#--------------------------------------------------------------------------
# Special FactBase member functions
#--------------------------------------------------------------------------
def select(self, root):
"""Define a select query using the old Query API.
.. note::
This interface will eventually be deprecated when the new
:class:`Query API<Query>` is finalised. The entry point to this Query
API is through the :meth:`FactBase.query` method.
Args:
predicate: The predicate to query.
Returns:
Returns a Select query object for specifying a query.
"""
self._check_init() # Check for delayed init
roots = validate_root_paths([root])
ptypes = set([ root.meta.predicate for root in roots])
# Make sure there are factmaps for each referenced predicate type
for ptype in ptypes: self._factmaps.setdefault(ptype, FactMap(ptype))
return SelectImpl(self, QuerySpec(roots=roots))
def delete(self, root):
self._check_init() # Check for delayed init
roots = validate_root_paths([root])
ptypes = set([ root.meta.predicate for root in roots])
# Make sure there are factmaps for each referenced predicate type
for ptype in ptypes: self._factmaps.setdefault(ptype, FactMap(ptype))
return _Delete(self, QuerySpec(roots=roots))
# START OVERLOADED FUNCTIONS self.query;UnGroupedQuery[{0}];1;5;Type;
# code within this block is **programmatically,
# statically generated** by generate_overloads.py
@overload
def query(
self, __ent0: Type[_T0]
) -> 'UnGroupedQuery[_T0]':
...
@overload
def query(
self, __ent0: Type[_T0], __ent1: Type[_T1]
) -> 'UnGroupedQuery[Tuple[_T0, _T1]]':
...
@overload
def query(
self, __ent0: Type[_T0], __ent1: Type[_T1], __ent2: Type[_T2]
) -> 'UnGroupedQuery[Tuple[_T0, _T1, _T2]]':
...
@overload
def query(
self, __ent0: Type[_T0], __ent1: Type[_T1], __ent2: Type[_T2], __ent3: Type[_T3]
) -> 'UnGroupedQuery[Tuple[_T0, _T1, _T2, _T3]]':
...
@overload
def query(
self, __ent0: Type[_T0], __ent1: Type[_T1], __ent2: Type[_T2], __ent3: Type[_T3], __ent4: Type[_T4]
) -> 'UnGroupedQuery[Tuple[_T0, _T1, _T2, _T3, _T4]]':
...
# END OVERLOADED FUNCTIONS self.query
@overload
def query(self, *roots: Any) -> 'UnGroupedQuery[Any]': ...
def query(self, *roots):
"""Define a query using the new Query API :class:`Query`.
The parameters consist of a predicates (or aliases) to query (like an
SQL FROM clause).
Args:
*predicates: predicate or predicate aliases
Returns:
Returns a Query object for specifying a query.
"""
self._check_init() # Check for delayed init
# Make sure there are factmaps for each referenced predicate type
ptypes = set([r.meta.predicate for r in validate_root_paths(roots)])
for ptype in ptypes: self._factmaps.setdefault(ptype, FactMap(ptype))
qspec = QuerySpec(roots=roots)
return UnGroupedQuery(self._factmaps, qspec)
@property
def predicates(self) -> Tuple[Type[Predicate], ...]:
"""Return the list of predicate types that this fact base contains."""
self._check_init() # Check for delayed init
return tuple([pt for pt, fm in self._factmaps.items() if fm])
@property
def indexes(self) -> Tuple[PredicatePath, ...]:
self._check_init() # Check for delayed init
return self._indexes
def facts(self) -> List[Predicate]:
"""Return all facts."""
self._check_init() # Check for delayed init
tmp = [ fm.factset for fm in self._factmaps.values() if fm]
return list(itertools.chain(*tmp))
def asp_str(self, *, width: int = 0, commented: bool = False, sorted: bool = False) -> str:
"""Return a ASP string representation of the fact base.
The generated ASP string representation is syntactically correct ASP
code so is suitable for adding as the input to to an ASP program (or
writing to a file for later use in an ASP program).
By default the order of the facts in the string is arbitrary. Because
`FactBase` is built on a `OrderedDict` (which preserves insertion
order) the order of the facts will be deterministic between runs of the
same program. However two FactBases containing the same facts but
constructed in different ways will not produce the same output
string. In order to guarantee the same output the `sorted` flag can be
specified.
Args:
width: tries to fill to a given width by putting more than one
fact on a line if necessary (default: 0).
commented: produces commented ASP code by adding a predicate
signature and turning the Predicate sub-class docstring
into a ASP comments (default: False).
sorted: sort the output facts, first by predicates (name,arity) and
then by the natural order of the instances for that
predicate (default :False).
"""
self._check_init() # Check for delayed init
out = io.StringIO()
first=True
if sorted:
names = _builtin_sorted(self._factmaps.keys(),key=lambda pt:
(pt.meta.name, pt.meta.arity,pt.__name__))
fms = [self._factmaps[n] for n in names]
else:
fms = self._factmaps.values()
for fm in fms:
if commented:
if first: first=False
else: print("",file=out)
_format_commented(fm,out)
if sorted:
_format_asp_facts(_builtin_sorted(fm.factset),out,width)
else:
_format_asp_facts(fm.factset,out,width)
data = out.getvalue()
out.close()
return data
def __str__(self) -> str:
self._check_init() # Check for delayed init
tmp = ", ".join([str(f) for f in self])
return '{' + tmp + '}'
def __repr__(self):
return self.__str__()
#--------------------------------------------------------------------------
# Special functions to support set and container operations
#--------------------------------------------------------------------------
def __contains__(self, fact):
"""Implemement set 'in' operator."""
self._check_init() # Check for delayed init
if not isinstance(fact,Predicate): return False
ptype = type(fact)
if ptype not in self._factmaps: return False
return fact in self._factmaps[ptype].factset
def __bool__(self):
"""Implemement set bool operator."""
self._check_init() # Check for delayed init
for fm in self._factmaps.values():
if fm: return True
return False
def __len__(self):
self._check_init() # Check for delayed init
return sum([len(fm.factset) for fm in self._factmaps.values()])
def __iter__(self) -> Iterator[Predicate]:
self._check_init() # Check for delayed init
for fm in self._factmaps.values():
for f in fm.factset: yield f
def __eq__(self, other):
"""Overloaded boolean operator."""
# If other is not a FactBase then create one
if not isinstance(other, self.__class__): other=FactBase(other)
self._check_init(); other._check_init() # Check for delayed init
self_fms = { p: fm for p,fm in self._factmaps.items() if fm }
other_fms = { p: fm for p,fm in other._factmaps.items() if fm }
if self_fms.keys() != other_fms.keys(): return False
for p, fm1 in self_fms.items():
fm2 = other_fms[p]
if not factset_equality(fm1.factset,fm2.factset): return False
return True
def __lt__(self,other):
"""Implemement set < operator."""
# If other is not a FactBase then create one
if not isinstance(other, self.__class__): other=FactBase(other)
self._check_init() ; other._check_init() # Check for delayed init
self_fms = { p: fm for p,fm in self._factmaps.items() if fm }
other_fms = { p: fm for p,fm in other._factmaps.items() if fm }
if len(self_fms) > len(other_fms): return False
known_ne=False
for p, spfm in self_fms.items():
if p not in other_fms: return False
opfm = other_fms[p]
if spfm.factset < opfm.factset: known_ne=True
elif spfm.factset > opfm.factset: return False
if known_ne: return True
return False
def __le__(self,other):
"""Implemement set <= operator."""
if not isinstance(other, self.__class__): other=FactBase(other)
self._check_init() ; other._check_init() # Check for delayed init
self_fms = { p: fm for p,fm in self._factmaps.items() if fm }
other_fms = { p: fm for p,fm in other._factmaps.items() if fm }
if len(self_fms) > len(other_fms): return False
for p, spfm in self_fms.items():
if p not in other_fms: return False
opfm = other_fms[p]
if spfm.factset > opfm.factset: return False
return True
def __gt__(self,other):
"""Implemement set > operator."""
if not isinstance(other, self.__class__): other=FactBase(other)
return other.__lt__(self)
def __ge__(self,other):
"""Implemement set >= operator."""
if not isinstance(other, self.__class__): other=FactBase(other)
return other.__le__(self)
def __or__(self,other):
"""Implemement set | operator."""
return self.union(other)
def __and__(self,other):
"""Implemement set & operator."""
return self.intersection(other)
def __sub__(self,other):
"""Implemement set - operator."""
return self.difference(other)
def __xor__(self,other):
"""Implemement set ^ operator."""
return self.symmetric_difference(other)
def __ior__(self,other):
"""Implemement set |= operator."""
self.update(other)
return self
def __iand__(self,other):
"""Implemement set &= operator."""
self.intersection_update(other)
return self
def __isub__(self,other):
"""Implemement set -= operator."""
self.difference_update(other)
return self
def __ixor__(self,other):
"""Implemement set ^= operator."""
self.symmetric_difference_update(other)
return self
def __getstate__(self):
self._check_init()
return self.__dict__
#--------------------------------------------------------------------------
# Set functions
#--------------------------------------------------------------------------
def union(self, *others: _Facts) -> 'FactBase':
"""Implements the set union() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
fb = FactBase()
predicates = set(self._factmaps.keys())
for o in factbases: predicates.update(o._factmaps.keys())
for p in predicates:
pothers = [o._factmaps[p] for o in factbases if p in o._factmaps]
if p in self._factmaps:
fb._factmaps[p] = self._factmaps[p].union(*pothers)
else:
fb._factmaps[p] = FactMap(p).union(*pothers)
return fb
def intersection(self, *others: _Facts) -> 'FactBase':
"""Implements the set intersection() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
fb = FactBase()
predicates = set(self._factmaps.keys())
for fb_ in factbases: predicates.intersection_update(fb_._factmaps.keys())
for p in predicates:
pothers = [o._factmaps[p] for o in factbases if p in o._factmaps]
fb._factmaps[p] = self._factmaps[p].intersection(*pothers)
return fb
def difference(self, *others: _Facts) -> 'FactBase':
"""Implements the set difference() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
fb = FactBase()
predicates = set(self._factmaps.keys())
for p in predicates:
pothers = [o._factmaps[p] for o in factbases if p in o._factmaps]
fb._factmaps[p] = self._factmaps[p].difference(*pothers)
return fb
def symmetric_difference(self, other: _Facts) -> 'FactBase':
"""Implements the set symmetric_difference() function"""
if not isinstance(other, self.__class__): other=FactBase(other)
self._check_init() # Check for delayed init
other._check_init()
fb = FactBase()
predicates = set(self._factmaps.keys())
predicates.update(other._factmaps.keys())
for p in predicates:
in_self = p in self._factmaps ; in_other = p in other._factmaps
if in_self and in_other:
fb._factmaps[p] = self._factmaps[p].symmetric_difference(other._factmaps[p])
elif in_self:
fb._factmaps[p] = self._factmaps[p].copy()
elif in_other:
fb._factmaps[p] = other._factmaps[p].copy()
return fb
def update(self, *others: _Facts) -> None:
"""Implements the set update() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
for fb in factbases:
for p,fm in fb._factmaps.items():
if p in self._factmaps: self._factmaps[p].update(fm)
else: self._factmaps[p] = fm.copy()
def intersection_update(self, *others: _Facts) -> None:
"""Implements the set intersection_update() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
predicates = set(self._factmaps.keys())
for fb in factbases: predicates.intersection_update(fb._factmaps.keys())
pred_to_delete = set(self._factmaps.keys()) - predicates
for p in pred_to_delete: self._factmaps[p].clear()
for p in predicates:
pothers = [o._factmaps[p] for o in factbases if p in o._factmaps]
self._factmaps[p].intersection_update(*pothers)
def difference_update(self, *others: _Facts) -> None:
"""Implements the set difference_update() function"""
factbases = [o if isinstance(o, self.__class__) else FactBase(o) for o in others]
self._check_init() # Check for delayed init
for fb in factbases: fb._check_init()
for p in self._factmaps.keys():
pothers = [o._factmaps[p] for o in factbases if p in o._factmaps]
self._factmaps[p].difference_update(*pothers)
def symmetric_difference_update(self, other: _Facts) -> None:
"""Implements the set symmetric_difference_update() function"""
if not isinstance(other, self.__class__): other=FactBase(other)
self._check_init() # Check for delayed init
other._check_init()
predicates = set(self._factmaps.keys())
predicates.update(other._factmaps.keys())
for p in predicates:
if p in self._factmaps and p in other._factmaps:
self._factmaps[p].symmetric_difference_update(other._factmaps[p])
else:
if p in other._factmaps: self._factmaps[p] = other._factmaps[p].copy()
def copy(self) -> 'FactBase':
"""Implements the set copy() function"""
self._check_init() # Check for delayed init
fb = FactBase()
for p, _ in self._factmaps.items():
fb._factmaps[p] = self._factmaps[p].copy()
return fb
#------------------------------------------------------------------------------
# Select is an interface query over a FactBase.
# ------------------------------------------------------------------------------
class Select(abc.ABC):
"""An abstract class that defines the interface to original Query API.
.. note::
This interface will eventually be deprecated when the new :class:`Query
API<Query>` is finalised.
``Select`` query objects cannot be constructed directly. Instead a
``Select`` object is returned by the :meth:`FactBase.select` function. Given
a ``FactBase`` object ``fb``, a specification is of the form:
``query = fb.select(<predicate>).where(<expression>).order_by(<ordering>)``
where ``<predicate>`` specifies the predicate type to search for,
``<expression>`` specifies the search criteria and ``<ordering>`` specifies
a sort order when returning the results. The ``where()`` and ``order_by()``
clauses are omitted when not required.
"""
@abc.abstractmethod
def where(self, *expressions):
"""Set the select statement's where clause.
The where clause consists of a set of boolean and comparison
expressions. This expression specifies a search criteria for matching
facts within the corresponding ``FactBase``.
Boolean expression are built from other boolean expression or a
comparison expression. Comparison expressions are of the form:
``<PredicatePath> <compop> <value>``
where ``<compop>`` is a comparison operator such as ``==``, ``!=``, or
``<=`` and ``<value>`` is either a Python value or another predicate path
object refering to a field of the same predicate or a placeholder.
A placeholder is a special value that issubstituted when the query is
actually executed. These placeholders are named ``ph1_``, ``ph2_``,
``ph3_``, and ``ph4_`` and correspond to the 1st to 4th arguments of the
``get``, ``get_unique`` or ``count`` function call.
Args:
expressions: one or more comparison expressions.
Returns:
Returns a reference to itself.
"""
@abc.abstractmethod
def order_by(self, *fieldorder):
"""Provide an ordering over the results.
Args:
fieldorder: an ordering over fields
Returns:
Returns a reference to itself.
"""
pass
@abc.abstractmethod
def get(self, *args, **kwargs):
"""Return all matching entries."""
pass
def get_unique(self, *args, **kwargs):
"""Return the unique matching entry (or raise an exception)"""
pass
def count(self, *args, **kwargs):
"""Return the number of matches."""
pass
#------------------------------------------------------------------------------
# Delete is an interface to perform a query delete from a FactBase.
# ------------------------------------------------------------------------------
class Delete(abc.ABC):
"""An abstract class that defines the interface to a original delete query API.
.. note::
This interface will eventually be deprecated when the new :class:`Query
API<Query>` is finalised.
``Delete`` query objects cannot be constructed directly. Instead a
``Delete`` object is returned by the ``FactBase.delete()`` function. Given a
``FactBase`` object ``fb``, a specification is of the form:
``query = fb.delete(<predicate>).where(<expression>)``
where ``<predicate>`` specifies the predicate type to search for,
``<expression>`` specifies the search criteria. The ``where()`` clause can
be omitted in which case all predicates of that type will be deleted.
"""
@abc.abstractmethod
def where(self, *expressions):
"""Set the select statement's where clause.
See the documentation for ``Select.where()`` for further details.
"""
pass
@abc.abstractmethod
def execute(self, *args, **kwargs):
"""Function to execute the delete query"""
pass
#------------------------------------------------------------------------------
# Query API version 1 with new query engine
#------------------------------------------------------------------------------
class SelectImpl(Select):
def __init__(self, factbase, qspec):
self._factbase = factbase
self._qspec = qspec
#--------------------------------------------------------------------------
# Add an order_by expression
#--------------------------------------------------------------------------
def where(self, *expressions):
if self._qspec.where:
raise TypeError("Cannot specify 'where' multiple times")
if not expressions:
raise TypeError("Empty 'where' expression")
try:
if len(expressions) == 1:
where = process_where(expressions[0],self._qspec.roots)
else:
where = process_where(and_(*expressions),self._qspec.roots)
nqspec = self._qspec.newp(where=where)
except ValueError as e:
raise TypeError(str(e)) from None
return SelectImpl(self._factbase,nqspec)
#--------------------------------------------------------------------------
# Add an order_by expression
#--------------------------------------------------------------------------
def order_by(self, *expressions):
if self._qspec.order_by:
raise TypeError("Cannot specify 'order_by' multiple times")
if not expressions:
raise TypeError("Empty 'order_by' expression")
try:
order_by=process_orderby(expressions,self._qspec.roots)
nqspec = self._qspec.newp(order_by=order_by)
except ValueError as e:
raise TypeError(str(e)) from None
return SelectImpl(self._factbase,nqspec)
#--------------------------------------------------------------------------
#
#--------------------------------------------------------------------------
def query_plan(self,*args,**kwargs):
qspec = self._qspec.fill_defaults()
(factsets,factindexes) = \
QueryExecutor.get_factmap_data(self._factbase.factmaps, qspec)
qplan = make_query_plan(factindexes.keys(), qspec)
return qplan.ground(*args,**kwargs)
#--------------------------------------------------------------------------
# Functions currently mirroring the old interface
# --------------------------------------------------------------------------
def get(self, *args, **kwargs):
qspec = self._qspec
if args or kwargs:
if self._qspec.where is None:
raise ValueError(("No where clause to ground"))
qspec = self._qspec.bindp(*args, **kwargs)
qe = QueryExecutor(self._factbase.factmaps, qspec)
return list(qe.all())
def get_unique(self, *args, **kwargs):
qspec = self._qspec
if args or kwargs:
if self._qspec.where is None:
raise ValueError(("No where clause to ground"))
qspec = self._qspec.bindp(*args, **kwargs)
qe = QueryExecutor(self._factbase.factmaps, qspec)
found = None
for out in qe.all():
if found: raise ValueError("Query returned more than a single element")
found = out
return found
def count(self, *args, **kwargs):
qspec = self._qspec
if args or kwargs:
if self._qspec.where is None:
raise ValueError(("No where clause to ground"))
qspec = self._qspec.bindp(*args, **kwargs)
qe = QueryExecutor(self._factbase.factmaps, qspec)
count = 0
for _ in qe.all(): count += 1
return count
#------------------------------------------------------------------------------
# The Delete class
#------------------------------------------------------------------------------
class _Delete(Delete):
def __init__(self, factbase, qspec):
self._factbase = factbase
self._root = qspec.roots[0]
self._select = SelectImpl(factbase,qspec)
self._has_where = False
def where(self, *expressions):
self._has_where = True
self._select = self._select.where(*expressions)
return self
def execute(self, *args, **kwargs):
factmap = self._factbase.factmaps[self._root.meta.predicate]
# If there is no where clause then delete everything
if not self._has_where:
num_deleted = len(factmap.facts())
factmap.clear()
return num_deleted
# Gather all the facts to delete and remove them
to_delete = [ f for f in self._select.get(*args, **kwargs) ]
for fact in to_delete: factmap.remove(fact)
return len(to_delete)
#------------------------------------------------------------------------------
# main
#------------------------------------------------------------------------------
if __name__ == "__main__":
raise RuntimeError('Cannot run modules')
| [
"itertools.chain",
"io.StringIO",
"typing.cast",
"itertools.groupby"
] | [((8102, 8156), 'itertools.groupby', 'itertools.groupby', (['sorted_facts', '(lambda x: x.__class__)'], {}), '(sorted_facts, lambda x: x.__class__)\n', (8119, 8156), False, 'import itertools\n'), ((16691, 16704), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (16702, 16704), False, 'import io\n'), ((15172, 15193), 'itertools.chain', 'itertools.chain', (['*tmp'], {}), '(*tmp)\n', (15187, 15193), False, 'import itertools\n'), ((3661, 3686), 'typing.cast', 'cast', (['str', 'pp._pathseq[1]'], {}), '(str, pp._pathseq[1])\n', (3665, 3686), False, 'from typing import Any, Callable, Iterable, Iterator, List, Optional, TextIO, Tuple, Type, Union, cast, overload\n')] |
# -*- coding: utf-8 -*-
#
# ***** BEGIN GPL LICENSE BLOCK *****
#
# --------------------------------------------------------------------------
# Blender 2.5 Extensions Framework
# --------------------------------------------------------------------------
#
# Authors:
# <NAME>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
# ***** END GPL LICENCE BLOCK *****
#
import time
import bpy
from extensions_framework.ui import EF_OT_msg
bpy.utils.register_class(EF_OT_msg)
del EF_OT_msg
def log(str, popup=False, module_name='EF'):
"""Print a message to the console, prefixed with the module_name
and the current time. If the popup flag is True, the message will
be raised in the UI as a warning using the operator bpy.ops.ef.msg.
"""
print("[%s %s] %s" %
(module_name, time.strftime('%Y-%b-%d %H:%M:%S'), str))
if popup:
bpy.ops.ef.msg(
msg_type='WARNING',
msg_text=str
)
added_property_cache = {}
def init_properties(obj, props, cache=True):
"""Initialise custom properties in the given object or type.
The props list is described in the declarative_property_group
class definition. If the cache flag is False, this function
will attempt to redefine properties even if they have already been
added.
"""
if not obj in added_property_cache.keys():
added_property_cache[obj] = []
for prop in props:
try:
if cache and prop['attr'] in added_property_cache[obj]:
continue
if prop['type'] == 'bool':
t = bpy.props.BoolProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","options","subtype","update"]}
elif prop['type'] == 'bool_vector':
t = bpy.props.BoolVectorProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","options","subtype","size",
"update"]}
elif prop['type'] == 'collection':
t = bpy.props.CollectionProperty
a = {k: v for k,v in prop.items() if k in ["ptype","name",
"description","default","options"]}
a['type'] = a['ptype']
del a['ptype']
elif prop['type'] == 'enum':
t = bpy.props.EnumProperty
a = {k: v for k,v in prop.items() if k in ["items","name",
"description","default","options","update"]}
elif prop['type'] == 'float':
t = bpy.props.FloatProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","min","max","soft_min","soft_max",
"step","precision","options","subtype","unit","update"]}
elif prop['type'] == 'float_vector':
t = bpy.props.FloatVectorProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","min","max","soft_min","soft_max",
"step","precision","options","subtype","size","update"]}
elif prop['type'] == 'int':
t = bpy.props.IntProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","min","max","soft_min","soft_max",
"step","options","subtype","update"]}
elif prop['type'] == 'int_vector':
t = bpy.props.IntVectorProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","min","max","soft_min","soft_max",
"options","subtype","size","update"]}
elif prop['type'] == 'pointer':
t = bpy.props.PointerProperty
a = {k: v for k,v in prop.items() if k in ["ptype", "name",
"description","options","update"]}
a['type'] = a['ptype']
del a['ptype']
elif prop['type'] == 'string':
t = bpy.props.StringProperty
a = {k: v for k,v in prop.items() if k in ["name",
"description","default","maxlen","options","subtype",
"update"]}
else:
continue
setattr(obj, prop['attr'], t(**a))
added_property_cache[obj].append(prop['attr'])
except KeyError:
# Silently skip invalid entries in props
continue
class declarative_property_group(bpy.types.PropertyGroup):
"""A declarative_property_group describes a set of logically
related properties, using a declarative style to list each
property type, name, values, and other relevant information.
The information provided for each property depends on the
property's type.
The properties list attribute in this class describes the
properties present in this group.
Some additional information about the properties in this group
can be specified, so that a UI can be generated to display them.
To that end, the controls list attribute and the visibility dict
attribute are present here, to be read and interpreted by a
property_group_renderer object.
See extensions_framework.ui.property_group_renderer.
"""
ef_initialised = False
"""This property tells extensions_framework which bpy.type(s)
to attach this PropertyGroup to. If left as an empty list,
it will not be attached to any type, but its properties will
still be initialised. The type(s) given in the list should be
a string, such as 'Scene'.
"""
ef_attach_to = []
@classmethod
def initialise_properties(cls):
"""This is a function that should be called on
sub-classes of declarative_property_group in order
to ensure that they are initialised when the addon
is loaded.
the init_properties is called without caching here,
as it is assumed that any addon calling this function
will also call ef_remove_properties when it is
unregistered.
"""
if not cls.ef_initialised:
for property_group_parent in cls.ef_attach_to:
if property_group_parent is not None:
prototype = getattr(bpy.types, property_group_parent)
if not hasattr(prototype, cls.__name__):
init_properties(prototype, [{
'type': 'pointer',
'attr': cls.__name__,
'ptype': cls,
'name': cls.__name__,
'description': cls.__name__
}], cache=False)
init_properties(cls, cls.properties, cache=False)
cls.ef_initialised = True
return cls
@classmethod
def register_initialise_properties(cls):
"""As ef_initialise_properties, but also registers the
class with RNA. Note that this isn't a great idea
because it's non-trivial to unregister the class, unless
you keep track of it yourself.
"""
bpy.utils.register_class(cls)
cls.initialise_properties()
return cls
@classmethod
def remove_properties(cls):
"""This is a function that should be called on
sub-classes of declarative_property_group in order
to ensure that they are un-initialised when the addon
is unloaded.
"""
if cls.ef_initialised:
prototype = getattr(bpy.types, cls.__name__)
for prop in cls.properties:
if hasattr(prototype, prop['attr']):
delattr(prototype, prop['attr'])
for property_group_parent in cls.ef_attach_to:
if property_group_parent is not None:
prototype = getattr(bpy.types, property_group_parent)
if hasattr(prototype, cls.__name__):
delattr(prototype, cls.__name__)
cls.ef_initialised = False
return cls
"""This list controls the order of property layout when rendered
by a property_group_renderer. This can be a nested list, where each
list becomes a row in the panel layout. Nesting may be to any depth.
"""
controls = []
"""The visibility dict controls the visibility of properties based on
the value of other properties. See extensions_framework.validate
for test syntax.
"""
visibility = {}
"""The enabled dict controls the enabled state of properties based on
the value of other properties. See extensions_framework.validate
for test syntax.
"""
enabled = {}
"""The alert dict controls the alert state of properties based on
the value of other properties. See extensions_framework.validate
for test syntax.
"""
alert = {}
"""The properties list describes each property to be created. Each
item should be a dict of args to pass to a
bpy.props.<?>Property function, with the exception of 'type'
which is used and stripped by extensions_framework in order to
determine which Property creation function to call.
Example item:
{
'type': 'int', # bpy.props.IntProperty
'attr': 'threads', # bpy.types.<type>.threads
'name': 'Render Threads', # Rendered next to the UI
'description': 'Number of threads to use', # Tooltip text in the UI
'default': 1,
'min': 1,
'soft_min': 1,
'max': 64,
'soft_max': 64
}
"""
properties = []
def draw_callback(self, context):
"""Sub-classes can override this to get a callback when
rendering is completed by a property_group_renderer sub-class.
"""
pass
@classmethod
def get_exportable_properties(cls):
"""Return a list of properties which have the 'save_in_preset' key
set to True, and hence should be saved into preset files.
"""
out = []
for prop in cls.properties:
if 'save_in_preset' in prop.keys() and prop['save_in_preset']:
out.append(prop)
return out
def reset(self):
"""Reset all properties in this group to the default value,
if specified"""
for prop in self.properties:
pk = prop.keys()
if 'attr' in pk and 'default' in pk and hasattr(self, prop['attr']):
setattr(self, prop['attr'], prop['default'])
class Addon(object):
"""A list of classes registered by this addon"""
static_addon_count = 0
addon_serial = 0
addon_classes = None
bl_info = None
BL_VERSION = None
BL_IDNAME = None
def __init__(self, bl_info=None):
self.addon_classes = []
self.bl_info = bl_info
# Keep a count in case we have to give this addon an anonymous name
self.addon_serial = Addon.static_addon_count
Addon.static_addon_count += 1
if self.bl_info:
self.BL_VERSION = '.'.join(['%s'%v for v in self.bl_info['version']]).lower()
self.BL_IDNAME = self.bl_info['name'].lower() + '-' + self.BL_VERSION
else:
# construct anonymous name
self.BL_VERSION = '0'
self.BL_IDNAME = 'Addon-%03d'%self.addon_serial
def addon_register_class(self, cls):
"""This method is designed to be used as a decorator on RNA-registerable
classes defined by the addon. By using this decorator, this class will
keep track of classes registered by this addon so that they can be
unregistered later in the correct order.
"""
self.addon_classes.append(cls)
return cls
def register(self):
"""This is the register function that should be exposed in the addon's
__init__.
"""
for cls in self.addon_classes:
bpy.utils.register_class(cls)
if hasattr(cls, 'ef_attach_to'): cls.initialise_properties()
def unregister(self):
"""This is the unregister function that should be exposed in the addon's
__init__.
"""
for cls in self.addon_classes[::-1]: # unregister in reverse order
if hasattr(cls, 'ef_attach_to'): cls.remove_properties()
bpy.utils.unregister_class(cls)
def init_functions(self):
"""Returns references to the three functions that this addon needs
for successful class registration management. In the addon's __init__
you would use like this:
addon_register_class, register, unregister = Addon().init_functions()
"""
return self.register, self.unregister
| [
"bpy.utils.unregister_class",
"bpy.ops.ef.msg",
"bpy.utils.register_class",
"time.strftime"
] | [((1023, 1058), 'bpy.utils.register_class', 'bpy.utils.register_class', (['EF_OT_msg'], {}), '(EF_OT_msg)\n', (1047, 1058), False, 'import bpy\n'), ((1450, 1498), 'bpy.ops.ef.msg', 'bpy.ops.ef.msg', ([], {'msg_type': '"""WARNING"""', 'msg_text': 'str'}), "(msg_type='WARNING', msg_text=str)\n", (1464, 1498), False, 'import bpy\n'), ((7812, 7841), 'bpy.utils.register_class', 'bpy.utils.register_class', (['cls'], {}), '(cls)\n', (7836, 7841), False, 'import bpy\n'), ((12675, 12704), 'bpy.utils.register_class', 'bpy.utils.register_class', (['cls'], {}), '(cls)\n', (12699, 12704), False, 'import bpy\n'), ((13076, 13107), 'bpy.utils.unregister_class', 'bpy.utils.unregister_class', (['cls'], {}), '(cls)\n', (13102, 13107), False, 'import bpy\n'), ((1386, 1420), 'time.strftime', 'time.strftime', (['"""%Y-%b-%d %H:%M:%S"""'], {}), "('%Y-%b-%d %H:%M:%S')\n", (1399, 1420), False, 'import time\n')] |
# pylint: disable=invalid-name
'''
Pytests for the common utilities included in this package. Includes:
- conversions.py
- specs.py
- utils.py
To run the tests, type the following in the top level repo directory:
python -m pytest --nat-file [path/to/gribfile] --prs-file [path/to/gribfile]
'''
from inspect import getfullargspec
from string import ascii_letters, digits
import warnings
from matplotlib import cm
from matplotlib import colors as mcolors
from metpy.plots import ctables
import numpy as np
import adb_graphics.conversions as conversions
import adb_graphics.specs as specs
import adb_graphics.utils as utils
import adb_graphics.datahandler.gribdata as gribdata
def test_conversion():
''' Test that conversions return at numpy array for input of np.ndarray,
list, or int '''
a = np.ones([3, 2]) * 300
c = a[0, 0]
# Check for the right answer
assert np.array_equal(conversions.k_to_c(a), a - 273.15)
assert np.array_equal(conversions.k_to_f(a), (a - 273.15) * 9/5 + 32)
assert np.array_equal(conversions.kgm2_to_in(a), a * 0.03937)
assert np.array_equal(conversions.m_to_dm(a), a / 10)
assert np.array_equal(conversions.m_to_in(a), a * 39.3701)
assert np.array_equal(conversions.m_to_kft(a), a / 304.8)
assert np.array_equal(conversions.m_to_mi(a), a / 1609.344)
assert np.array_equal(conversions.ms_to_kt(a), a * 1.9438)
assert np.array_equal(conversions.pa_to_hpa(a), a / 100)
assert np.array_equal(conversions.percent(a), a * 100)
assert np.array_equal(conversions.to_micro(a), a * 1E6)
assert np.array_equal(conversions.vvel_scale(a), a * -10)
assert np.array_equal(conversions.vort_scale(a), a / 1E-05)
assert np.array_equal(conversions.weasd_to_1hsnw(a), a * 10)
functions = [
conversions.k_to_c,
conversions.k_to_f,
conversions.kgm2_to_in,
conversions.m_to_dm,
conversions.m_to_in,
conversions.m_to_kft,
conversions.m_to_mi,
conversions.ms_to_kt,
conversions.pa_to_hpa,
conversions.percent,
conversions.to_micro,
conversions.vvel_scale,
conversions.vort_scale,
conversions.weasd_to_1hsnw,
]
# Check that all functions return a np.ndarray given a collection, or single float
for f in functions:
for collection in [a, c]:
assert isinstance(f(collection), type(collection))
class MockSpecs(specs.VarSpec):
''' Mock class for the VarSpec abstract class '''
@property
def clevs(self):
return np.asarray(range(15))
@property
def vspec(self):
return {}
def test_specs():
''' Test VarSpec properties. '''
config = 'adb_graphics/default_specs.yml'
varspec = MockSpecs(config)
# Ensure correct return type
assert isinstance(varspec.t_colors, np.ndarray)
assert isinstance(varspec.ps_colors, np.ndarray)
assert isinstance(varspec.yml, dict)
# Ensure the appropriate number of colors is returned
assert np.shape(varspec.t_colors) == (len(varspec.clevs), 4)
assert np.shape(varspec.ps_colors) == (105, 4)
def test_utils():
''' Test that utils works appropriately. '''
assert callable(utils.get_func('conversions.k_to_c'))
class TestDefaultSpecs():
''' Test contents of default_specs.yml. '''
config = 'adb_graphics/default_specs.yml'
varspec = MockSpecs(config)
cfg = varspec.yml
@property
def allowable(self):
''' Each entry in the dict names a function that tests a key in
default_specs.yml. '''
return {
'accumulate': self.is_bool,
'annotate': self.is_bool,
'annotate_decimal': self.is_int,
'clevs': self.is_a_clev,
'cmap': self.is_a_cmap,
'colors': self.is_a_color,
'contours': self.is_a_contour_dict,
'hatches': self.is_a_contourf_dict,
'labels': self.is_a_contourf_dict,
'ncl_name': True,
'print_units': True,
'split': self.is_bool,
'ticks': self.is_number,
'title': self.is_string,
'transform': self.check_transform,
'unit': self.is_string,
'vertical_index': self.is_int,
'vertical_level_name': self.is_string,
'wind': self.is_wind,
}
def check_kwargs(self, accepted_args, kwargs):
''' Ensure a dictionary entry matches the kwargs accepted by a function.
'''
assert isinstance(kwargs, dict)
for key, args in kwargs.items():
lev = None
if '_' in key:
short_name, lev = key.split('_')
else:
short_name = key
assert self.is_a_key(short_name)
if lev:
assert self.cfg.get(short_name).get(lev) is not None
for arg in args.keys():
assert arg in accepted_args
return True
def check_transform(self, entry):
'''
Check that the transform entry is either a single transformation
function, a list of transformation functions, or a dictionary containing
the functions list and the kwargs list like so:
transform:
funcs: [list, of, functions]
kwargs:
first_arg: value
sec_arg: value
The functions listed under functions MUST be methods, not attributes!
'''
kwargs = dict()
# Check that each item listed is callable
if isinstance(entry, (list, str)):
assert self.is_callable(entry)
# If the transform entry is a dictionary, check that it has the
# appropriate contents
elif isinstance(entry, dict):
funcs = entry.get('funcs')
assert funcs is not None
# Make sure funcs is a list
funcs = funcs if isinstance(funcs, list) else [funcs]
# Key word arguments may not be present.
kwargs = entry.get('kwargs')
transforms = []
for func in funcs:
callables = self.get_callable(func)
callables = callables if isinstance(callables, list) else \
[callables]
transforms.extend(callables)
# The argspecs bit gives us a list of all the accepted arguments
# for the functions listed in the variable all_params. Test fails
# when provided arguments don't appear in all_params.
# arguments not in that list, we fail.
if kwargs:
argspecs = [getfullargspec(func) for func in transforms if
callable(func)]
all_params = []
for argspec in argspecs:
# Make sure all functions accept key word arguments
assert argspec.varkw is not None
parameters = []
for argtype in [argspec.args, argspec.varargs, argspec.varkw]:
if argtype is not None:
parameters.extend(argtype)
all_params.extend(parameters)
for key in kwargs.keys():
if key not in all_params:
msg = f'Function key {key} is not an expicit parameter \
in any of the transforms: {funcs}!'
warnings.warn(msg, UserWarning)
return True
# pylint: disable=inconsistent-return-statements
def get_callable(self, func):
''' Return the callable function given a function name. '''
if func in dir(self.varspec):
return self.varspec.__getattribute__(func)
# Check datahandler.gribdata objects if a single word is provided
if len(func.split('.')) == 1:
funcs = []
for attr in dir(gribdata):
# pylint: disable=no-member
if func in dir(gribdata.__getattribute__(attr)):
funcs.append(gribdata.__getattribute__(attr).__dict__.get(func))
return funcs
if callable(utils.get_func(func)):
return utils.get_func(func)
raise ValueError('{func} is not a known callable function!')
@staticmethod
def is_a_clev(clev):
''' Returns true for a clev that is a list, a range, or a callable function. '''
if isinstance(clev, (list, np.ndarray)):
return True
if 'range' in clev.split('[')[0]:
clean = lambda x: x.strip().split('-')[-1].replace('.', '1')
items = clev.split(' ', 1)[1].strip('[').strip(']').split(',')
nums = [clean(i).isnumeric() for i in items]
return all(nums)
return callable(utils.get_func(clev))
@staticmethod
def is_a_cmap(cmap):
''' Returns true for a cmap that is a Colormap object. '''
return cmap in dir(cm) + list(ctables.colortables.keys())
def is_a_contour_dict(self, entry):
''' Set up the accepted arguments for plt.contour, and check the given
arguments. '''
args = ['X', 'Y', 'Z', 'levels',
'corner_mask', 'colors', 'alpha', 'cmap', 'norm', 'vmin',
'vmax', 'origin', 'extent', 'locator', 'extend', 'xunits',
'yunits', 'antialiased', 'nchunk', 'linewidths', 'linestyles']
if entry is None:
return True
return self.check_kwargs(args, entry)
def is_a_contourf_dict(self, entry):
''' Set up the accepted arguments for plt.contourf, and check the given
arguments. '''
args = ['X', 'Y', 'Z', 'levels',
'corner_mask', 'colors', 'alpha', 'cmap', 'labels', 'norm', 'vmin',
'vmax', 'origin', 'extent', 'locator', 'extend', 'xunits',
'yunits', 'antialiased', 'nchunk', 'linewidths',
'hatches']
if entry is None:
return True
return self.check_kwargs(args, entry)
def is_a_color(self, color):
''' Returns true if color is contained in the list of recognized colors. '''
colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS,
**ctables.colortables)
if color in colors.keys():
return True
if color in dir(self.varspec):
return True
return False
@staticmethod
def is_a_level(key):
'''
Returns true if the key fits one of the level descriptor formats.
Allowable formats include:
[str_descriptor] e.g. sfc, max, mup
[numeric][lev_type] e.g. 500mb, or 2m
[stat][numeric] e.g. mn02, mx25
'''
allowed_levels = [
'agl', # above ground level
'best', # Best
'bndylay', # boundary layer cld cover
'esbl', # ???
'esblmn', # ???
'high', # high clouds
'int', # vertical integral
'low', # low clouds
'max', # maximum in column
'maxsfc', # max surface value
'mdn', # maximum downward
'mid', # mid-level clouds
'mnsfc', # min surface value
'msl', # mean sea level
'mu', # most unstable
'mul', # most unstable layer
'mup', # maximum upward
'mu', # most unstable
'pw', # wrt precipitable water
'sat', # satellite
'sfc', # surface
'sfclt', # surface (less than)
'top', # nominal top of atmosphere
'total', # total clouds
'ua', # upper air
]
allowed_lev_type = [
'cm', # centimeters
'ds', # difference
'ft', # feet
'km', # kilometers
'm', # meters
'mm', # millimeters
'mb', # milibars
'sr', # storm relative
]
allowed_stat = [
'in', # ???
'ens', # ensemble
'm', # ???
'maxm', # ???
'mn', # minimum
'mx', # maximum
]
# Easy check first -- it is in the allowed_levels list
if key in allowed_levels:
return True
# Check for [numeric][lev_type] or [lev_type][numeric] pattern
# Numbers come at beginning or end, only
numeric = ''.join([c for c in key if c in digits + '.']) in key
# The level is allowed
level_str = [c for c in key if c in ascii_letters]
allowed = ''.join(level_str) in allowed_lev_type + allowed_stat
# Check the other direction - level string contains one of the allowed
# types.
if not allowed:
for lev in allowed_lev_type + allowed_stat:
if lev in level_str:
allowed = True
break
if numeric and allowed:
return True
return False
def is_a_key(self, key):
''' Returns true if key exists as a key in the config file. '''
return self.cfg.get(key) is not None
@staticmethod
def is_bool(k):
''' Returns true if k is a boolean variable. '''
return isinstance(k, bool)
def is_callable(self, funcs):
''' Returns true if func in funcs list is the name of a callable function. '''
funcs = funcs if isinstance(funcs, list) else [funcs]
callables = []
for func in funcs:
callable_ = self.get_callable(func)
callable_ = callable_ if isinstance(callable_, list) else [callable_]
for clbl in callable_:
if isinstance(clbl, np.ndarray):
callables.append(True)
elif callable(clbl):
callables.append(True)
else:
callables.append(False)
return all(callables)
@staticmethod
def is_dict(d):
''' Returns true if d is a dictionary '''
return isinstance(d, dict)
@staticmethod
def is_int(i):
''' Returns true if i is an integer. '''
if isinstance(i, int):
return True
return i.isnumeric() and len(i.split('.')) == 1
@staticmethod
def is_number(i):
''' Returns true if i is a number. '''
if isinstance(i, (int, float)):
return True
return i.isnumeric() and len(i.split('.')) <= 2
@staticmethod
def is_string(s):
''' Returns true if s is a string. '''
return isinstance(s, str)
def is_wind(self, wind):
''' Returns true if wind is a bool or is_a_level. '''
return isinstance(wind, bool) or self.is_a_level(wind)
def check_keys(self, d, depth=0):
''' Helper function that recursively checks the keys in the dictionary by calling the
function defined in allowable. '''
max_depth = 2
# Only proceed if d is a dictionary
if not isinstance(d, dict):
return
# Proceed only up to max depth.
if depth >= max_depth:
return
level = depth+1
for k, v in d.items():
# Check that the key is allowable
assert (k in self.allowable.keys()) or self.is_a_level(k)
# Call a checker if one exists for the key, otherwise descend into
# next level of dict
checker = self.allowable.get(k)
if checker:
if isinstance(checker, bool):
assert checker
else:
assert checker(v)
else:
if isinstance(v, dict):
self.check_keys(v, depth=level)
def test_keys(self):
''' Tests each of top-level variables in the config file by calling the helper function. '''
for short_name, spec in self.cfg.items():
assert '_' not in short_name
self.check_keys(spec)
| [
"adb_graphics.conversions.m_to_mi",
"adb_graphics.conversions.pa_to_hpa",
"inspect.getfullargspec",
"adb_graphics.conversions.m_to_kft",
"adb_graphics.datahandler.gribdata.__getattribute__",
"adb_graphics.conversions.weasd_to_1hsnw",
"adb_graphics.conversions.k_to_f",
"adb_graphics.conversions.ms_to_k... | [((830, 845), 'numpy.ones', 'np.ones', (['[3, 2]'], {}), '([3, 2])\n', (837, 845), True, 'import numpy as np\n'), ((928, 949), 'adb_graphics.conversions.k_to_c', 'conversions.k_to_c', (['a'], {}), '(a)\n', (946, 949), True, 'import adb_graphics.conversions as conversions\n'), ((989, 1010), 'adb_graphics.conversions.k_to_f', 'conversions.k_to_f', (['a'], {}), '(a)\n', (1007, 1010), True, 'import adb_graphics.conversions as conversions\n'), ((1063, 1088), 'adb_graphics.conversions.kgm2_to_in', 'conversions.kgm2_to_in', (['a'], {}), '(a)\n', (1085, 1088), True, 'import adb_graphics.conversions as conversions\n'), ((1129, 1151), 'adb_graphics.conversions.m_to_dm', 'conversions.m_to_dm', (['a'], {}), '(a)\n', (1148, 1151), True, 'import adb_graphics.conversions as conversions\n'), ((1187, 1209), 'adb_graphics.conversions.m_to_in', 'conversions.m_to_in', (['a'], {}), '(a)\n', (1206, 1209), True, 'import adb_graphics.conversions as conversions\n'), ((1250, 1273), 'adb_graphics.conversions.m_to_kft', 'conversions.m_to_kft', (['a'], {}), '(a)\n', (1270, 1273), True, 'import adb_graphics.conversions as conversions\n'), ((1312, 1334), 'adb_graphics.conversions.m_to_mi', 'conversions.m_to_mi', (['a'], {}), '(a)\n', (1331, 1334), True, 'import adb_graphics.conversions as conversions\n'), ((1376, 1399), 'adb_graphics.conversions.ms_to_kt', 'conversions.ms_to_kt', (['a'], {}), '(a)\n', (1396, 1399), True, 'import adb_graphics.conversions as conversions\n'), ((1439, 1463), 'adb_graphics.conversions.pa_to_hpa', 'conversions.pa_to_hpa', (['a'], {}), '(a)\n', (1460, 1463), True, 'import adb_graphics.conversions as conversions\n'), ((1500, 1522), 'adb_graphics.conversions.percent', 'conversions.percent', (['a'], {}), '(a)\n', (1519, 1522), True, 'import adb_graphics.conversions as conversions\n'), ((1559, 1582), 'adb_graphics.conversions.to_micro', 'conversions.to_micro', (['a'], {}), '(a)\n', (1579, 1582), True, 'import adb_graphics.conversions as conversions\n'), ((1619, 1644), 'adb_graphics.conversions.vvel_scale', 'conversions.vvel_scale', (['a'], {}), '(a)\n', (1641, 1644), True, 'import adb_graphics.conversions as conversions\n'), ((1681, 1706), 'adb_graphics.conversions.vort_scale', 'conversions.vort_scale', (['a'], {}), '(a)\n', (1703, 1706), True, 'import adb_graphics.conversions as conversions\n'), ((1745, 1774), 'adb_graphics.conversions.weasd_to_1hsnw', 'conversions.weasd_to_1hsnw', (['a'], {}), '(a)\n', (1771, 1774), True, 'import adb_graphics.conversions as conversions\n'), ((3050, 3076), 'numpy.shape', 'np.shape', (['varspec.t_colors'], {}), '(varspec.t_colors)\n', (3058, 3076), True, 'import numpy as np\n'), ((3115, 3142), 'numpy.shape', 'np.shape', (['varspec.ps_colors'], {}), '(varspec.ps_colors)\n', (3123, 3142), True, 'import numpy as np\n'), ((3246, 3282), 'adb_graphics.utils.get_func', 'utils.get_func', (['"""conversions.k_to_c"""'], {}), "('conversions.k_to_c')\n", (3260, 3282), True, 'import adb_graphics.utils as utils\n'), ((8254, 8274), 'adb_graphics.utils.get_func', 'utils.get_func', (['func'], {}), '(func)\n', (8268, 8274), True, 'import adb_graphics.utils as utils\n'), ((8296, 8316), 'adb_graphics.utils.get_func', 'utils.get_func', (['func'], {}), '(func)\n', (8310, 8316), True, 'import adb_graphics.utils as utils\n'), ((8897, 8917), 'adb_graphics.utils.get_func', 'utils.get_func', (['clev'], {}), '(clev)\n', (8911, 8917), True, 'import adb_graphics.utils as utils\n'), ((9069, 9095), 'metpy.plots.ctables.colortables.keys', 'ctables.colortables.keys', ([], {}), '()\n', (9093, 9095), False, 'from metpy.plots import ctables\n'), ((6705, 6725), 'inspect.getfullargspec', 'getfullargspec', (['func'], {}), '(func)\n', (6719, 6725), False, 'from inspect import getfullargspec\n'), ((8089, 8120), 'adb_graphics.datahandler.gribdata.__getattribute__', 'gribdata.__getattribute__', (['attr'], {}), '(attr)\n', (8114, 8120), True, 'import adb_graphics.datahandler.gribdata as gribdata\n'), ((7531, 7562), 'warnings.warn', 'warnings.warn', (['msg', 'UserWarning'], {}), '(msg, UserWarning)\n', (7544, 7562), False, 'import warnings\n'), ((8156, 8187), 'adb_graphics.datahandler.gribdata.__getattribute__', 'gribdata.__getattribute__', (['attr'], {}), '(attr)\n', (8181, 8187), True, 'import adb_graphics.datahandler.gribdata as gribdata\n')] |
from pyte import tokens, util
from pyte.superclasses import _PyteAugmentedValidator, _PyteOp
from pyte.util import PY36
class FOR_LOOP(_PyteOp):
"""
Represents a for loop.
"""
def __init__(self, iterator: _PyteAugmentedValidator, body: list):
"""
Represents a for operator.
:param iterator: A :class:`.PyteAugmentedValidator` that represents the iterable.
:param body: A list of instructions to execute on each loop.
Parameters:
iterator: _PyteAugmentedValidator
This should be a saved value that is iterable, i.e a saved list or something.
body: list
A list of instructions to execute, similarly to IF.
"""
self.iterator = iterator
self._body = list(util.flatten(body))
def to_bytes_35(self, previous: bytes):
"""
A to-bytes specific to Python 3.5 and below.
"""
# Calculations ahead.
bc = b""
# Calculate the length of the iterator.
it_bc = util.generate_bytecode_from_obb(self.iterator, previous)
bc += it_bc
# Push a get_iter on.
bc += util.generate_bytecode_from_obb(tokens.GET_ITER, b"")
prev_len = len(previous) + len(bc)
# Calculate the bytecode for the body.
body_bc = b""
for op in self._body:
# Add padding bytes to the bytecode to allow if blocks to work.
padded_bc = previous
# Add padding for SETUP_LOOP
padded_bc += b"\x00\x00\x00"
padded_bc += bc
# Add padding for FOR_ITER
padded_bc += b"\x00\x00\x00"
# Add previous body
padded_bc += body_bc
body_bc += util.generate_bytecode_from_obb(op, padded_bc)
# Add a JUMP_ABSOLUTE
body_bc += util.generate_simple_call(tokens.JUMP_ABSOLUTE, prev_len + 3)
# Add a POP_TOP
body_bc += util.generate_bytecode_from_obb(tokens.POP_BLOCK, b"")
# Calculate the right lengths.
# Add a FOR_ITER, using len(body_bc)
body_bc = util.generate_simple_call(tokens.FOR_ITER, len(body_bc) - 1) + body_bc
# Add the SETUP_LOOP call
bc = util.generate_simple_call(tokens.SETUP_LOOP, prev_len + len(body_bc) - 6) + bc + body_bc
return bc
def to_bytes_36(self, previous: bytes):
"""
A to-bytes specific to Python 3.6 and above.
"""
# Calculations ahead.
bc = b""
# Calculate the length of the iterator.
it_bc = util.generate_bytecode_from_obb(self.iterator, previous)
bc += it_bc
bc += util.ensure_instruction(tokens.GET_ITER)
def to_bytes(self, previous: bytes):
# Python 3.6 has slightly different behaviour
if PY36:
return self.to_bytes_36(previous)
else:
return self.to_bytes_35(previous)
| [
"pyte.util.generate_simple_call",
"pyte.util.flatten",
"pyte.util.ensure_instruction",
"pyte.util.generate_bytecode_from_obb"
] | [((1050, 1106), 'pyte.util.generate_bytecode_from_obb', 'util.generate_bytecode_from_obb', (['self.iterator', 'previous'], {}), '(self.iterator, previous)\n', (1081, 1106), False, 'from pyte import tokens, util\n'), ((1172, 1225), 'pyte.util.generate_bytecode_from_obb', 'util.generate_bytecode_from_obb', (['tokens.GET_ITER', "b''"], {}), "(tokens.GET_ITER, b'')\n", (1203, 1225), False, 'from pyte import tokens, util\n'), ((1852, 1913), 'pyte.util.generate_simple_call', 'util.generate_simple_call', (['tokens.JUMP_ABSOLUTE', '(prev_len + 3)'], {}), '(tokens.JUMP_ABSOLUTE, prev_len + 3)\n', (1877, 1913), False, 'from pyte import tokens, util\n'), ((1958, 2012), 'pyte.util.generate_bytecode_from_obb', 'util.generate_bytecode_from_obb', (['tokens.POP_BLOCK', "b''"], {}), "(tokens.POP_BLOCK, b'')\n", (1989, 2012), False, 'from pyte import tokens, util\n'), ((2576, 2632), 'pyte.util.generate_bytecode_from_obb', 'util.generate_bytecode_from_obb', (['self.iterator', 'previous'], {}), '(self.iterator, previous)\n', (2607, 2632), False, 'from pyte import tokens, util\n'), ((2668, 2708), 'pyte.util.ensure_instruction', 'util.ensure_instruction', (['tokens.GET_ITER'], {}), '(tokens.GET_ITER)\n', (2691, 2708), False, 'from pyte import tokens, util\n'), ((795, 813), 'pyte.util.flatten', 'util.flatten', (['body'], {}), '(body)\n', (807, 813), False, 'from pyte import tokens, util\n'), ((1755, 1801), 'pyte.util.generate_bytecode_from_obb', 'util.generate_bytecode_from_obb', (['op', 'padded_bc'], {}), '(op, padded_bc)\n', (1786, 1801), False, 'from pyte import tokens, util\n')] |
# This little bit of magic fills the __all__ list
# with every plugin name, and means that calling:
# from plugins import *
# within inmembrane.py will import every plugin
import pkgutil
__all__ = []
for p in pkgutil.iter_modules(__path__):
__all__.append(p[1])
| [
"pkgutil.iter_modules"
] | [((211, 241), 'pkgutil.iter_modules', 'pkgutil.iter_modules', (['__path__'], {}), '(__path__)\n', (231, 241), False, 'import pkgutil\n')] |
# DomirScire
import math
import os
import random
import re
import sys
import collections
if __name__ == '__main__':
s = sorted(input().strip())
s_counter = collections.Counter(s).most_common()
s_counter = sorted(s_counter, key=lambda x: (x[1] * -1, x[0]))
for i in range(0, 3):
print(s_counter[i][0], s_counter[i][1])
| [
"collections.Counter"
] | [((165, 187), 'collections.Counter', 'collections.Counter', (['s'], {}), '(s)\n', (184, 187), False, 'import collections\n')] |
import math
import torch
import torch.nn as nn
from torch.nn import functional as F
class KLRegression(nn.Module):
"""KL-divergence loss for probabilistic regression.
It is computed using Monte Carlo (MC) samples from an arbitrary distribution."""
def __init__(self, eps=0.0):
super().__init__()
self.eps = eps
def forward(self, scores, sample_density, gt_density, mc_dim=-1):
"""Args:
scores: predicted score values
sample_density: probability density of the sample distribution
gt_density: probability density of the ground truth distribution
mc_dim: dimension of the MC samples"""
exp_val = scores - torch.log(sample_density + self.eps)
L = torch.logsumexp(exp_val, dim=mc_dim) - math.log(scores.shape[mc_dim]) - \
torch.mean(scores * (gt_density / (sample_density + self.eps)), dim=mc_dim)
return L.mean()
class MLRegression(nn.Module):
"""Maximum likelihood loss for probabilistic regression.
It is computed using Monte Carlo (MC) samples from an arbitrary distribution."""
def __init__(self, eps=0.0):
super().__init__()
self.eps = eps
def forward(self, scores, sample_density, gt_density=None, mc_dim=-1):
"""Args:
scores: predicted score values. First sample must be ground-truth
sample_density: probability density of the sample distribution
gt_density: not used
mc_dim: dimension of the MC samples. Only mc_dim=1 supported"""
assert mc_dim == 1
assert (sample_density[:,0,...] == -1).all()
exp_val = scores[:, 1:, ...] - torch.log(sample_density[:, 1:, ...] + self.eps)
L = torch.logsumexp(exp_val, dim=mc_dim) - math.log(scores.shape[mc_dim] - 1) - scores[:, 0, ...]
loss = L.mean()
return loss
class KLRegressionGrid(nn.Module):
"""KL-divergence loss for probabilistic regression.
It is computed using the grid integration strategy."""
def forward(self, scores, gt_density, grid_dim=-1, grid_scale=1.0):
"""Args:
scores: predicted score values
gt_density: probability density of the ground truth distribution
grid_dim: dimension(s) of the grid
grid_scale: area of one grid cell"""
score_corr = grid_scale * torch.sum(scores * gt_density, dim=grid_dim)
L = torch.logsumexp(scores, dim=grid_dim) + math.log(grid_scale) - score_corr
return L.mean()
| [
"torch.log",
"torch.mean",
"math.log",
"torch.sum",
"torch.logsumexp"
] | [((725, 761), 'torch.log', 'torch.log', (['(sample_density + self.eps)'], {}), '(sample_density + self.eps)\n', (734, 761), False, 'import torch\n'), ((864, 939), 'torch.mean', 'torch.mean', (['(scores * (gt_density / (sample_density + self.eps)))'], {'dim': 'mc_dim'}), '(scores * (gt_density / (sample_density + self.eps)), dim=mc_dim)\n', (874, 939), False, 'import torch\n'), ((1727, 1775), 'torch.log', 'torch.log', (['(sample_density[:, 1:, ...] + self.eps)'], {}), '(sample_density[:, 1:, ...] + self.eps)\n', (1736, 1775), False, 'import torch\n'), ((2438, 2482), 'torch.sum', 'torch.sum', (['(scores * gt_density)'], {'dim': 'grid_dim'}), '(scores * gt_density, dim=grid_dim)\n', (2447, 2482), False, 'import torch\n'), ((777, 813), 'torch.logsumexp', 'torch.logsumexp', (['exp_val'], {'dim': 'mc_dim'}), '(exp_val, dim=mc_dim)\n', (792, 813), False, 'import torch\n'), ((816, 846), 'math.log', 'math.log', (['scores.shape[mc_dim]'], {}), '(scores.shape[mc_dim])\n', (824, 846), False, 'import math\n'), ((1791, 1827), 'torch.logsumexp', 'torch.logsumexp', (['exp_val'], {'dim': 'mc_dim'}), '(exp_val, dim=mc_dim)\n', (1806, 1827), False, 'import torch\n'), ((1830, 1864), 'math.log', 'math.log', (['(scores.shape[mc_dim] - 1)'], {}), '(scores.shape[mc_dim] - 1)\n', (1838, 1864), False, 'import math\n'), ((2498, 2535), 'torch.logsumexp', 'torch.logsumexp', (['scores'], {'dim': 'grid_dim'}), '(scores, dim=grid_dim)\n', (2513, 2535), False, 'import torch\n'), ((2538, 2558), 'math.log', 'math.log', (['grid_scale'], {}), '(grid_scale)\n', (2546, 2558), False, 'import math\n')] |
# coding=utf-8
import arrow
from bs4 import BeautifulSoup
from digesters.base_digester import BaseDigester
TEMPLATE = """<html>
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
<title>Atlassian HipChat</title>
</head>
<body style="box-sizing: border-box; height: 100%; width: 100%;">
<table bgcolor="#f5f5f5" border="0" cellpadding="0" cellspacing="0" class="container wrapper_shrink"
style="_padding: 20px; padding: 3%;" width="640">
<tr>
<td valign="top">
<table bgcolor="#ffffff" border="0" cellpadding="0" cellspacing="0" class="inner-container table_shrink"
id="email_content"
style="-khtml-border-radius: 6px; -moz-border-radius: 6px; -webkit-border-radius: 6px; border: 1px solid #dadada; border-radius: 6px; width: 100% !important; margin-top: 15px;"
width="600">
<tr>
<td class="td top-spacer"
style="font-size: 15px; line-height: 4px; padding-left: 20px; padding-right: 10px !important;"
valign="top">
</td>
</tr>
<tr>
<td>
<div class="history_container history_email" id="chats" style="padding-right: 0px !important;">
<InsertHere/>
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>"""
class HipchatNotificationDigester(BaseDigester):
def __init__(self, store_writer):
super(HipchatNotificationDigester, self).__init__()
self.store_writer = store_writer
self.new_message_count = 0
self.new_articles = 0
self.hc_notifications = self.store_writer.get_from_binary("hipchat-notifications")
if self.hc_notifications is None:
self.hc_notifications = {}
self.most_recently_seen = self.store_writer.get_from_binary("most-recently-seen")
if self.most_recently_seen is None:
self.most_recently_seen = 0
self.new_notifications = {}
self.previously_notified_article_count = len(self.hc_notifications)
if self.previously_notified_article_count > 0:
self.previously_notified_article_most_recent = max(self.hc_notifications)
else:
self.previously_notified_article_most_recent = 0
def process_new_notification(self, rfc822content, msg, html_message, text_message):
self.new_message_count += 1
subject = msg['Subject']
if "sent you a 1-1 message" in subject:
room = "Direct Message"
else:
room = "Room: " + subject.split('"')[1]
when = arrow.get(msg['Date'].split(',', 1)[1].strip(), 'D MMM YYYY HH:mm:ss ZZ').timestamp
if html_message:
soup = BeautifulSoup(html_message, 'html.parser')
div = soup.find("div", {"id": "chats"}).find("div")
self.hc_notifications[when] = {
"room": room,
"div": str(div)
}
return True
return False
def rewrite_digest_emails(self, digest_folder_proxy, has_previous_message, previously_seen, sender_to_implicate):
if self.previously_notified_article_count == len(self.hc_notifications):
return
# Deleted email (by the user) means they don't want to see THOSE notifications listed in a Digest again.
if has_previous_message == False:
self.hc_notifications = {}
if has_previous_message == False:
if self.previously_notified_article_count > 0:
self.most_recently_seen = self.previously_notified_article_most_recent
template_end, template_start = self.get_template_start_and_end(TEMPLATE)
past_bookmark = 0
unseen = 0
for when in sorted(iter(self.hc_notifications.keys()), reverse=True):
mostRecentSeen = self.most_recently_seen
if when < mostRecentSeen:
past_bookmark += 1
else:
unseen += 1
if past_bookmark > 30: # only show thirty after the bookmark
self.hc_notifications.pop(when, None)
email_html = self.make_html_payload(template_end, template_start, self.hc_notifications).replace("<br/>","")
# Delete previous email, and write replacement
if has_previous_message:
digest_folder_proxy.delete_previous_message()
digest_folder_proxy.append(self.make_new_raw_so_email(email_html, unseen, sender_to_implicate))
# Save
self.store_writer.store_as_binary("hipchat-notifications", self.hc_notifications)
self.store_writer.store_as_binary("most-recently-seen", self.most_recently_seen)
def matching_incoming_headers(self):
return ["From: HipChat <<EMAIL>>"]
def matching_digest_subject(self):
return 'Notification Digest'
def matching_digest_sender(self):
return "HipChat"
def print_summary(self):
print("Hipchat: New HipChat notifications: " + str(self.new_message_count))
def get_template_start_and_end(self, template):
template_start = template[:template.find("<InsertHere/>")]
template_end = template[template.find("<InsertHere/>") + len("<InsertHere/>"):]
return template_end, template_start
def make_html_payload(self, template_end, template_start, hc_notifications):
email_html = template_start
ix = 0
for anum in sorted(iter(hc_notifications.keys()), reverse=True):
if anum == self.most_recently_seen and ix > 0:
email_html += '<div style="border-bottom: 1.5pt solid red; border-top: 1.5pt solid red;"><center>^ New Questions Since You Last Checked ^</center></div>\n'
email_html += '<div class="ecxhc-chat-from" style="margin-left: 150px;text-align:left;width:200px;padding:10px 0 10px 10px;">' + hc_notifications[anum]["room"] + '</div>\n'
email_html += "<div>\n" + hc_notifications[anum]["div"] + "</div>\n"
ix = + 1
email_html += template_end
return email_html
def make_new_raw_so_email(self, email_html, count, sender_to_implicate):
new_message = 'Subject: ' + self.matching_digest_subject() + ": " + str(count) + ' new notification(s)\n'
new_message += 'From: \"HipChat\" <' + sender_to_implicate + '>\n'
new_message += 'Content-Transfer-Encoding: 8bit\n'
new_message += 'Content-Type: multipart/alternative; boundary="---NOTIFICATION_BOUNDARY' \
+ self.notification_boundary_rand + '"\n'
new_message += 'MIME-Version: 1.0\n'
new_message += 'This is a multi-part message in MIME format.\n'
new_message += '-----NOTIFICATION_BOUNDARY' + self.notification_boundary_rand \
+ '\nContent-Type: text/html; charset="utf-8"\n'
new_message += 'Content-Transfer-Encoding: 8bit\n\n'
new_message += email_html.replace("\n\n\n", "\n").replace("\n\n", "\n")
new_message += '\n\n-----NOTIFICATION_BOUNDARY' + self.notification_boundary_rand
return new_message
| [
"bs4.BeautifulSoup"
] | [((2916, 2958), 'bs4.BeautifulSoup', 'BeautifulSoup', (['html_message', '"""html.parser"""'], {}), "(html_message, 'html.parser')\n", (2929, 2958), False, 'from bs4 import BeautifulSoup\n')] |
import os
import shutil
import tempfile
import numpy as np
from yt.loaders import load, load_uniform_grid
from yt.testing import (
assert_array_equal,
assert_fname,
fake_random_ds,
requires_file,
requires_module,
)
from yt.utilities.answer_testing.framework import data_dir_load
from yt.visualization.plot_window import ProjectionPlot, SlicePlot
ytdata_dir = "ytdata_test"
@requires_module("h5py")
@requires_file(os.path.join(ytdata_dir, "slice.h5"))
@requires_file(os.path.join(ytdata_dir, "proj.h5"))
@requires_file(os.path.join(ytdata_dir, "oas.h5"))
def test_old_plot_data():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
fn = "slice.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_slice = data_dir_load(full_fn)
p = SlicePlot(ds_slice, "z", "density")
fn = p.save()
assert_fname(fn[0])
fn = "proj.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_proj = data_dir_load(full_fn)
p = ProjectionPlot(ds_proj, "z", "density")
fn = p.save()
assert_fname(fn[0])
fn = "oas.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_oas = data_dir_load(full_fn)
p = SlicePlot(ds_oas, [1, 1, 1], "density")
fn = p.save()
assert_fname(fn[0])
os.chdir(curdir)
shutil.rmtree(tmpdir)
@requires_module("h5py")
def test_plot_data():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
ds = fake_random_ds(16)
plot = SlicePlot(ds, "z", "density")
fn = plot.data_source.save_as_dataset("slice.h5")
ds_slice = load(fn)
p = SlicePlot(ds_slice, "z", "density")
fn = p.save()
assert_fname(fn[0])
plot = ProjectionPlot(ds, "z", "density")
fn = plot.data_source.save_as_dataset("proj.h5")
ds_proj = load(fn)
p = ProjectionPlot(ds_proj, "z", "density")
fn = p.save()
assert_fname(fn[0])
plot = SlicePlot(ds, [1, 1, 1], "density")
fn = plot.data_source.save_as_dataset("oas.h5")
ds_oas = load(fn)
p = SlicePlot(ds_oas, [1, 1, 1], "density")
fn = p.save()
assert_fname(fn[0])
os.chdir(curdir)
if tmpdir != ".":
shutil.rmtree(tmpdir)
@requires_module("h5py")
def test_non_square_frb():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
# construct an arbitrary dataset
arr = np.arange(8.0 * 9.0 * 10.0).reshape((8, 9, 10))
data = dict(density=(arr, "g/cm**3"))
bbox = np.array([[-4, 4.0], [-4.5, 4.5], [-5.0, 5]])
ds = load_uniform_grid(
data, arr.shape, length_unit="Mpc", bbox=bbox, periodicity=(False, False, False)
)
# make a slice
slc = ds.slice(axis="z", coord=ds.quan(0.0, "code_length"))
# make a frb and save it to disk
center = (ds.quan(0.0, "code_length"), ds.quan(0.0, "code_length"))
xax, yax = ds.coordinates.x_axis[slc.axis], ds.coordinates.y_axis[slc.axis]
res = [ds.domain_dimensions[xax], ds.domain_dimensions[yax]] # = [8,9]
width = ds.domain_right_edge[xax] - ds.domain_left_edge[xax] # = 8 code_length
height = ds.domain_right_edge[yax] - ds.domain_left_edge[yax] # = 9 code_length
frb = slc.to_frb(width=width, height=height, resolution=res, center=center)
fname = "test_frb_roundtrip.h5"
frb.save_as_dataset(fname, fields=["density"])
expected_vals = arr[:, :, 5].T
print(
"\nConfirmation that initial frb results are expected:",
(expected_vals == frb["density"].v).all(),
"\n",
)
# yt-reload:
reloaded_ds = load(fname)
assert_array_equal(frb["density"].shape, reloaded_ds.data["density"].shape)
assert_array_equal(frb["density"], reloaded_ds.data["density"])
os.chdir(curdir)
if tmpdir != ".":
shutil.rmtree(tmpdir)
| [
"yt.loaders.load_uniform_grid",
"yt.visualization.plot_window.SlicePlot",
"yt.testing.assert_fname",
"yt.testing.assert_array_equal",
"numpy.arange",
"yt.testing.fake_random_ds",
"os.path.join",
"yt.loaders.load",
"os.getcwd",
"os.chdir",
"yt.utilities.answer_testing.framework.data_dir_load",
... | [((399, 422), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (414, 422), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1300, 1323), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (1315, 1323), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((2160, 2183), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (2175, 2183), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((618, 636), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (634, 636), False, 'import tempfile\n'), ((650, 661), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (659, 661), False, 'import os\n'), ((666, 682), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (674, 682), False, 'import os\n'), ((718, 746), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (730, 746), False, 'import os\n'), ((762, 784), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (775, 784), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((793, 828), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_slice', '"""z"""', '"""density"""'], {}), "(ds_slice, 'z', 'density')\n", (802, 828), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((851, 870), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (863, 870), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((905, 933), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (917, 933), False, 'import os\n'), ((948, 970), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (961, 970), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((979, 1018), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds_proj', '"""z"""', '"""density"""'], {}), "(ds_proj, 'z', 'density')\n", (993, 1018), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1041, 1060), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1053, 1060), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1094, 1122), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (1106, 1122), False, 'import os\n'), ((1136, 1158), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (1149, 1158), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((1167, 1206), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_oas', '[1, 1, 1]', '"""density"""'], {}), "(ds_oas, [1, 1, 1], 'density')\n", (1176, 1206), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1229, 1248), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1241, 1248), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1254, 1270), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (1262, 1270), False, 'import os\n'), ((1275, 1296), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (1288, 1296), False, 'import shutil\n'), ((438, 474), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""slice.h5"""'], {}), "(ytdata_dir, 'slice.h5')\n", (450, 474), False, 'import os\n'), ((491, 526), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""proj.h5"""'], {}), "(ytdata_dir, 'proj.h5')\n", (503, 526), False, 'import os\n'), ((543, 577), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""oas.h5"""'], {}), "(ytdata_dir, 'oas.h5')\n", (555, 577), False, 'import os\n'), ((1359, 1377), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (1375, 1377), False, 'import tempfile\n'), ((1391, 1402), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1400, 1402), False, 'import os\n'), ((1407, 1423), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (1415, 1423), False, 'import os\n'), ((1433, 1451), 'yt.testing.fake_random_ds', 'fake_random_ds', (['(16)'], {}), '(16)\n', (1447, 1451), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1464, 1493), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds', '"""z"""', '"""density"""'], {}), "(ds, 'z', 'density')\n", (1473, 1493), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1563, 1571), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1567, 1571), False, 'from yt.loaders import load, load_uniform_grid\n'), ((1580, 1615), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_slice', '"""z"""', '"""density"""'], {}), "(ds_slice, 'z', 'density')\n", (1589, 1615), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1638, 1657), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1650, 1657), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1670, 1704), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds', '"""z"""', '"""density"""'], {}), "(ds, 'z', 'density')\n", (1684, 1704), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1772, 1780), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1776, 1780), False, 'from yt.loaders import load, load_uniform_grid\n'), ((1789, 1828), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds_proj', '"""z"""', '"""density"""'], {}), "(ds_proj, 'z', 'density')\n", (1803, 1828), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1851, 1870), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1863, 1870), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1883, 1918), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds', '[1, 1, 1]', '"""density"""'], {}), "(ds, [1, 1, 1], 'density')\n", (1892, 1918), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1984, 1992), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1988, 1992), False, 'from yt.loaders import load, load_uniform_grid\n'), ((2001, 2040), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_oas', '[1, 1, 1]', '"""density"""'], {}), "(ds_oas, [1, 1, 1], 'density')\n", (2010, 2040), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((2063, 2082), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (2075, 2082), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((2088, 2104), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (2096, 2104), False, 'import os\n'), ((2224, 2242), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (2240, 2242), False, 'import tempfile\n'), ((2256, 2267), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2265, 2267), False, 'import os\n'), ((2272, 2288), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (2280, 2288), False, 'import os\n'), ((2438, 2483), 'numpy.array', 'np.array', (['[[-4, 4.0], [-4.5, 4.5], [-5.0, 5]]'], {}), '([[-4, 4.0], [-4.5, 4.5], [-5.0, 5]])\n', (2446, 2483), True, 'import numpy as np\n'), ((2493, 2596), 'yt.loaders.load_uniform_grid', 'load_uniform_grid', (['data', 'arr.shape'], {'length_unit': '"""Mpc"""', 'bbox': 'bbox', 'periodicity': '(False, False, False)'}), "(data, arr.shape, length_unit='Mpc', bbox=bbox,\n periodicity=(False, False, False))\n", (2510, 2596), False, 'from yt.loaders import load, load_uniform_grid\n'), ((3511, 3522), 'yt.loaders.load', 'load', (['fname'], {}), '(fname)\n', (3515, 3522), False, 'from yt.loaders import load, load_uniform_grid\n'), ((3528, 3603), 'yt.testing.assert_array_equal', 'assert_array_equal', (["frb['density'].shape", "reloaded_ds.data['density'].shape"], {}), "(frb['density'].shape, reloaded_ds.data['density'].shape)\n", (3546, 3603), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((3608, 3671), 'yt.testing.assert_array_equal', 'assert_array_equal', (["frb['density']", "reloaded_ds.data['density']"], {}), "(frb['density'], reloaded_ds.data['density'])\n", (3626, 3671), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((3677, 3693), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (3685, 3693), False, 'import os\n'), ((2135, 2156), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (2148, 2156), False, 'import shutil\n'), ((3724, 3745), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (3737, 3745), False, 'import shutil\n'), ((2337, 2364), 'numpy.arange', 'np.arange', (['(8.0 * 9.0 * 10.0)'], {}), '(8.0 * 9.0 * 10.0)\n', (2346, 2364), True, 'import numpy as np\n')] |
# Generated by Django 3.2.6 on 2021-09-05 19:39
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0011_auto_20210905_1619'),
]
operations = [
migrations.AlterField(
model_name='preco',
name='categoria',
field=models.CharField(choices=[('Premium', 'C'), ('Pro', 'B'), ('Plus', 'A')], max_length=15, verbose_name='categoria'),
),
]
| [
"django.db.models.CharField"
] | [((335, 453), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('Premium', 'C'), ('Pro', 'B'), ('Plus', 'A')]", 'max_length': '(15)', 'verbose_name': '"""categoria"""'}), "(choices=[('Premium', 'C'), ('Pro', 'B'), ('Plus', 'A')],\n max_length=15, verbose_name='categoria')\n", (351, 453), False, 'from django.db import migrations, models\n')] |
#!/usr/bin/env python
import panflute as pf
"""
Pandoc filter that causes emphasis to be rendered using
the custom macro '\myemph{...}' rather than '\emph{...}'
in latex. Other output formats are unaffected.
"""
def latex(s):
return pf.RawInline(s, format='latex')
def myemph(e, doc):
if type(e)==pf.Emph and doc.format=='latex':
return pf.Span(latex('\\myemph{'), *e.items, latex('}'))
if __name__ == "__main__":
pf.toJSONFilter(myemph)
| [
"panflute.RawInline",
"panflute.toJSONFilter"
] | [((241, 272), 'panflute.RawInline', 'pf.RawInline', (['s'], {'format': '"""latex"""'}), "(s, format='latex')\n", (253, 272), True, 'import panflute as pf\n'), ((442, 465), 'panflute.toJSONFilter', 'pf.toJSONFilter', (['myemph'], {}), '(myemph)\n', (457, 465), True, 'import panflute as pf\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2008,2009 <NAME> <<EMAIL>>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at#
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import couchdbkit
from couchdbkit.contrib import WSGIHandler
import json
def app(environ, start_response):
"""Simplest possible application object"""
data = 'Hello, World!\n DB Infos : %s\n' % json.dumps(environ["COUCHDB_INFO"])
status = '200 OK'
response_headers = [
('Content-type','text/plain'),
('Content-Length', len(data))
]
start_response(status, response_headers)
return [data]
def main():
handler = WSGIHandler(app)
handler.run()
if __name__ == "__main__":
main()
| [
"couchdbkit.contrib.WSGIHandler",
"json.dumps"
] | [((1108, 1124), 'couchdbkit.contrib.WSGIHandler', 'WSGIHandler', (['app'], {}), '(app)\n', (1119, 1124), False, 'from couchdbkit.contrib import WSGIHandler\n'), ((848, 883), 'json.dumps', 'json.dumps', (["environ['COUCHDB_INFO']"], {}), "(environ['COUCHDB_INFO'])\n", (858, 883), False, 'import json\n')] |
import json
from .life import BinaryLife
class GOL(object):
team_names: list = []
columns = 0
rows = 0
def __init__(self, **kwargs):
self.load_config(**kwargs)
self.create_life()
def __repr__(self):
s = []
s.append("+" + "-" * (self.columns) + "+")
for i in range(self.rows):
row = "|"
for j in range(self.columns):
if self.life.is_alive(j, i):
color = self.life.get_cell_color(j, i)
if color == 1:
row += "#"
elif color == 2:
row += "o"
else:
row += "?"
else:
row += "."
row += "|"
s.append(row)
s.append("+" + "-" * (self.columns) + "+")
rep = "\n".join(s)
rep += "\n"
livecounts = self.count()
rep += "\nGeneration: %d" % (self.generation)
rep += "\nLive cells, color 1: %d" % (livecounts["liveCells1"])
rep += "\nLive cells, color 2: %d" % (livecounts["liveCells2"])
rep += "\nLive cells, total: %d" % (livecounts["liveCells"])
rep += "\nVictory Percent: %0.1f %%" % (livecounts["victoryPct"])
rep += "\nCoverage: %0.2f %%" % (livecounts["coverage"])
rep += "\nTerritory, color 1: %0.2f %%" % (livecounts["territory1"])
rep += "\nTerritory, color 2: %0.2f %%" % (livecounts["territory2"])
return rep
def load_config(self, **kwargs):
"""Load configuration from user-provided input params"""
if "s1" in kwargs and "s2" in kwargs:
self.ic1 = kwargs["s1"]
self.ic2 = kwargs["s2"]
else:
raise Exception("ERROR: s1 and s2 parameters must both be specified")
if "rows" in kwargs and "columns" in kwargs:
self.rows = kwargs["rows"]
self.columns = kwargs["columns"]
else:
raise Exception(
"ERROR: rows and columns parameters must be provided to GOL constructor"
)
if "team1" in kwargs and "team2" in kwargs:
self.team_names = [kwargs["team1"], kwargs["team2"]]
else:
self.team_names = ["Team 1", "Team 2"]
# Whether to stop when a victor is detected
if "halt" in kwargs:
self.halt = kwargs["halt"]
else:
self.halt = True
self.found_victor = False
# Neighbor color legacy mode was used in Seasons 1-3
if "neighbor_color_legacy_mode" in kwargs:
self.neighbor_color_legacy_mode = kwargs["neighbor_color_legacy_mode"]
else:
self.neighbor_color_legacy_mode = False
def create_life(self):
try:
s1 = json.loads(self.ic1)
except json.decoder.JSONDecodeError:
err = "Error: Could not load data as json:\n"
err += self.ic1
raise Exception(err)
try:
s2 = json.loads(self.ic2)
except json.decoder.JSONDecodeError:
err = "Error: Could not load data as json:\n"
err += self.ic1
raise Exception(err)
self.life = BinaryLife(
s1,
s2,
self.rows,
self.columns,
self.neighbor_color_legacy_mode
)
def next_step(self):
return self.life.next_step()
def count(self):
return self.life.get_stats()
@property
def running(self):
return self.life.running
@property
def generation(self):
return self.life.generation
| [
"json.loads"
] | [((2829, 2849), 'json.loads', 'json.loads', (['self.ic1'], {}), '(self.ic1)\n', (2839, 2849), False, 'import json\n'), ((3045, 3065), 'json.loads', 'json.loads', (['self.ic2'], {}), '(self.ic2)\n', (3055, 3065), False, 'import json\n')] |
from django.core.management.base import BaseCommand
from django.db import connection
class Command(BaseCommand):
help = "Add missing id column for hostingstats."
def handle(self, *args, **options):
with connection.cursor() as cursor:
self.cursor = cursor
self.cursor.execute(
"""
START TRANSACTION;
CREATE TABLE `hostingproviders_stats_copy` (
`id` INT(11) primary key Not null auto_increment,
`id_hp` Int( 11 ) NOT NULL,
`green_checks` Int( 11 ) NOT NULL,
`green_domains` Int( 11 ) NOT NULL,
CONSTRAINT `id_hp` UNIQUE( `id_hp` ) )
CHARACTER SET = latin1
COLLATE = latin1_swedish_ci
ENGINE = InnoDB;
-------------------------------------------------------------
INSERT into hostingproviders_stats_copy(id_hp, green_checks, green_domains)
SELECT id_hp, green_checks, green_domains FROM hostingproviders_stats;
DROP table hostingproviders_stats;
ALTER table hostingproviders_stats_copy rename to hostingproviders_stats;
COMMIT;
"""
)
| [
"django.db.connection.cursor"
] | [((222, 241), 'django.db.connection.cursor', 'connection.cursor', ([], {}), '()\n', (239, 241), False, 'from django.db import connection\n')] |
import numba as nb
import numpy as np
import scipy.stats
@nb.njit(parallel=True)
def tiecorrect(rankvals):
"""
parallelized version of scipy.stats.tiecorrect
:param rankvals: p x n array of ranked data (output of rankdata function)
"""
tc = np.ones(rankvals.shape[1], dtype=np.float64)
for j in nb.prange(rankvals.shape[1]):
arr = np.sort(np.ravel(rankvals[:, j]))
idx = np.nonzero(
np.concatenate((np.array([True]), arr[1:] != arr[:-1], np.array([True])))
)[0]
t_k = np.diff(idx).astype(np.float64)
size = np.float64(arr.size)
if size >= 2:
tc[j] = 1.0 - (t_k ** 3 - t_k).sum() / (size ** 3 - size)
return tc
@nb.njit(parallel=True)
def rankdata(data):
"""
parallelized version of scipy.stats.rankdata
:param data: p x n array of data to rank, column-wise
"""
ranked = np.empty(data.shape, dtype=np.float64)
for j in nb.prange(data.shape[1]):
arr = np.ravel(data[:, j])
sorter = np.argsort(arr)
arr = arr[sorter]
obs = np.concatenate((np.array([True]), arr[1:] != arr[:-1]))
dense = np.empty(obs.size, dtype=np.int64)
dense[sorter] = obs.cumsum()
# cumulative counts of each unique value
count = np.concatenate((np.nonzero(obs)[0], np.array([len(obs)])))
ranked[:, j] = 0.5 * (count[dense] + count[dense - 1] + 1)
return ranked
def mannwhitneyu(x, y, use_continuity=True):
"""Version of Mann-Whitney U-test that runs in parallel on 2d arrays
This is the two-sided test, asymptotic algo only. Returns log p-values
"""
x = np.asarray(x)
y = np.asarray(y)
assert x.shape[1] == y.shape[1]
n1 = x.shape[0]
n2 = y.shape[0]
ranked = rankdata(np.concatenate((x, y)))
rankx = ranked[:n1, :] # get the x-ranks
u1 = n1 * n2 + (n1 * (n1 + 1)) / 2.0 - np.sum(rankx, axis=0) # calc U for x
u2 = n1 * n2 - u1 # remainder is U for y
T = tiecorrect(ranked)
# if *everything* is identical we'll raise an error, not otherwise
if np.all(T == 0):
raise ValueError("All numbers are identical in mannwhitneyu")
sd = np.sqrt(T * n1 * n2 * (n1 + n2 + 1) / 12.0)
meanrank = n1 * n2 / 2.0 + 0.5 * use_continuity
bigu = np.maximum(u1, u2)
with np.errstate(divide="ignore", invalid="ignore"):
z = (bigu - meanrank) / sd
logp = np.minimum(scipy.stats.norm.logsf(z) + np.log(2), 0)
return u2, logp
| [
"numpy.sqrt",
"numpy.ones",
"numpy.float64",
"numpy.log",
"numba.njit",
"numpy.asarray",
"numpy.diff",
"numpy.argsort",
"numpy.sum",
"numpy.errstate",
"numpy.array",
"numpy.empty",
"numpy.concatenate",
"numpy.nonzero",
"numpy.maximum",
"numba.prange",
"numpy.all",
"numpy.ravel"
] | [((60, 82), 'numba.njit', 'nb.njit', ([], {'parallel': '(True)'}), '(parallel=True)\n', (67, 82), True, 'import numba as nb\n'), ((718, 740), 'numba.njit', 'nb.njit', ([], {'parallel': '(True)'}), '(parallel=True)\n', (725, 740), True, 'import numba as nb\n'), ((264, 308), 'numpy.ones', 'np.ones', (['rankvals.shape[1]'], {'dtype': 'np.float64'}), '(rankvals.shape[1], dtype=np.float64)\n', (271, 308), True, 'import numpy as np\n'), ((322, 350), 'numba.prange', 'nb.prange', (['rankvals.shape[1]'], {}), '(rankvals.shape[1])\n', (331, 350), True, 'import numba as nb\n'), ((898, 936), 'numpy.empty', 'np.empty', (['data.shape'], {'dtype': 'np.float64'}), '(data.shape, dtype=np.float64)\n', (906, 936), True, 'import numpy as np\n'), ((950, 974), 'numba.prange', 'nb.prange', (['data.shape[1]'], {}), '(data.shape[1])\n', (959, 974), True, 'import numba as nb\n'), ((1653, 1666), 'numpy.asarray', 'np.asarray', (['x'], {}), '(x)\n', (1663, 1666), True, 'import numpy as np\n'), ((1675, 1688), 'numpy.asarray', 'np.asarray', (['y'], {}), '(y)\n', (1685, 1688), True, 'import numpy as np\n'), ((2092, 2106), 'numpy.all', 'np.all', (['(T == 0)'], {}), '(T == 0)\n', (2098, 2106), True, 'import numpy as np\n'), ((2187, 2230), 'numpy.sqrt', 'np.sqrt', (['(T * n1 * n2 * (n1 + n2 + 1) / 12.0)'], {}), '(T * n1 * n2 * (n1 + n2 + 1) / 12.0)\n', (2194, 2230), True, 'import numpy as np\n'), ((2295, 2313), 'numpy.maximum', 'np.maximum', (['u1', 'u2'], {}), '(u1, u2)\n', (2305, 2313), True, 'import numpy as np\n'), ((587, 607), 'numpy.float64', 'np.float64', (['arr.size'], {}), '(arr.size)\n', (597, 607), True, 'import numpy as np\n'), ((990, 1010), 'numpy.ravel', 'np.ravel', (['data[:, j]'], {}), '(data[:, j])\n', (998, 1010), True, 'import numpy as np\n'), ((1028, 1043), 'numpy.argsort', 'np.argsort', (['arr'], {}), '(arr)\n', (1038, 1043), True, 'import numpy as np\n'), ((1158, 1192), 'numpy.empty', 'np.empty', (['obs.size'], {'dtype': 'np.int64'}), '(obs.size, dtype=np.int64)\n', (1166, 1192), True, 'import numpy as np\n'), ((1789, 1811), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (1803, 1811), True, 'import numpy as np\n'), ((1902, 1923), 'numpy.sum', 'np.sum', (['rankx'], {'axis': '(0)'}), '(rankx, axis=0)\n', (1908, 1923), True, 'import numpy as np\n'), ((2324, 2370), 'numpy.errstate', 'np.errstate', ([], {'divide': '"""ignore"""', 'invalid': '"""ignore"""'}), "(divide='ignore', invalid='ignore')\n", (2335, 2370), True, 'import numpy as np\n'), ((374, 398), 'numpy.ravel', 'np.ravel', (['rankvals[:, j]'], {}), '(rankvals[:, j])\n', (382, 398), True, 'import numpy as np\n'), ((2458, 2467), 'numpy.log', 'np.log', (['(2)'], {}), '(2)\n', (2464, 2467), True, 'import numpy as np\n'), ((539, 551), 'numpy.diff', 'np.diff', (['idx'], {}), '(idx)\n', (546, 551), True, 'import numpy as np\n'), ((1101, 1117), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (1109, 1117), True, 'import numpy as np\n'), ((1312, 1327), 'numpy.nonzero', 'np.nonzero', (['obs'], {}), '(obs)\n', (1322, 1327), True, 'import numpy as np\n'), ((454, 470), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (462, 470), True, 'import numpy as np\n'), ((493, 509), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (501, 509), True, 'import numpy as np\n')] |
#!/usr/bin/env python3
import codekit.pygithub
import github
import itertools
import pytest
@pytest.fixture
def git_author():
return github.InputGitAuthor(name='foo', email='<EMAIL>')
def test_init(git_author):
"""Test TargetTag object instantiation"""
t_tag = codekit.pygithub.TargetTag(
name='foo',
sha='bar',
message='baz',
tagger=git_author,
)
assert isinstance(t_tag, codekit.pygithub.TargetTag), type(t_tag)
def test_attributes(git_author):
"""Test TargetTag attributes"""
t_tag = codekit.pygithub.TargetTag(
name='foo',
sha='bar',
message='baz',
tagger=git_author,
)
assert t_tag.name == 'foo'
assert t_tag.sha == 'bar'
assert t_tag.message == 'baz'
assert isinstance(t_tag.tagger, github.InputGitAuthor), type(t_tag.tagger)
def test_init_required_args(git_author):
"""TargetTag requires named args"""
all_args = dict(
name='foo',
sha='bar',
message='baz',
tagger=git_author,
)
args = {}
# try all named args but one
for k, v in itertools.islice(all_args.items(), len(all_args) - 1):
args[k] = v
with pytest.raises(KeyError):
codekit.pygithub.TargetTag(**args)
def test_init_tagger_type():
"""TargetTag tagger named arg must be correct type"""
with pytest.raises(AssertionError):
codekit.pygithub.TargetTag(
name='foo',
sha='bar',
message='baz',
tagger='bonk',
)
| [
"github.InputGitAuthor",
"pytest.raises"
] | [((140, 190), 'github.InputGitAuthor', 'github.InputGitAuthor', ([], {'name': '"""foo"""', 'email': '"""<EMAIL>"""'}), "(name='foo', email='<EMAIL>')\n", (161, 190), False, 'import github\n'), ((1377, 1406), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1390, 1406), False, 'import pytest\n'), ((1207, 1230), 'pytest.raises', 'pytest.raises', (['KeyError'], {}), '(KeyError)\n', (1220, 1230), False, 'import pytest\n')] |
import functools
def parse_input() -> list[list[str]]:
groups = [[]]
with open("input.txt") as file:
for line in file:
line_ = line.rstrip()
if len(line_) > 0:
groups[-1].append(line_)
else:
if not groups[-1] == []:
groups.append([])
return groups
def solve_p1(groups: list[list[str]]) -> int:
def count(group: list[str]) -> int:
chars = set()
for line in group:
for char in line:
chars.add(char)
return len(chars)
return sum(map(count, groups))
def solve_p2(groups: list[list[str]]) -> int:
def count_intersection(group: list[str]) -> int:
sets = []
for line in group:
new_set = set()
for char in line:
new_set.add(char)
sets.append(new_set)
result_set = functools.reduce(set.intersection, sets)
return len(result_set)
return sum(map(count_intersection, groups))
GROUPS = parse_input()
print(solve_p1(GROUPS))
print(solve_p2(GROUPS))
| [
"functools.reduce"
] | [((915, 955), 'functools.reduce', 'functools.reduce', (['set.intersection', 'sets'], {}), '(set.intersection, sets)\n', (931, 955), False, 'import functools\n')] |
import box
from typing import Text
import yaml
def load_config(config_path: Text) -> box.ConfigBox:
"""Loads yaml config in instance of box.ConfigBox.
Args:
config_path {Text}: path to config
Returns:
box.ConfigBox
"""
with open(config_path) as config_file:
config = yaml.safe_load(config_file)
config = box.ConfigBox(config)
return config
| [
"box.ConfigBox",
"yaml.safe_load"
] | [((315, 342), 'yaml.safe_load', 'yaml.safe_load', (['config_file'], {}), '(config_file)\n', (329, 342), False, 'import yaml\n'), ((360, 381), 'box.ConfigBox', 'box.ConfigBox', (['config'], {}), '(config)\n', (373, 381), False, 'import box\n')] |
import boto3
from botocore.exceptions import ClientError
import datetime
import pytest
from moto import mock_sagemaker
from moto.sts.models import ACCOUNT_ID
FAKE_ROLE_ARN = "arn:aws:iam::{}:role/FakeRole".format(ACCOUNT_ID)
TEST_REGION_NAME = "us-east-1"
class MyProcessingJobModel(object):
def __init__(
self,
processing_job_name,
role_arn,
container=None,
bucket=None,
prefix=None,
app_specification=None,
network_config=None,
processing_inputs=None,
processing_output_config=None,
processing_resources=None,
stopping_condition=None,
):
self.processing_job_name = processing_job_name
self.role_arn = role_arn
self.container = (
container
or "683313688378.dkr.ecr.us-east-1.amazonaws.com/sagemaker-scikit-learn:0.23-1-cpu-py3"
)
self.bucket = bucket or "my-bucket"
self.prefix = prefix or "sagemaker"
self.app_specification = app_specification or {
"ImageUri": self.container,
"ContainerEntrypoint": ["python3",],
}
self.network_config = network_config or {
"EnableInterContainerTrafficEncryption": False,
"EnableNetworkIsolation": False,
}
self.processing_inputs = processing_inputs or [
{
"InputName": "input",
"AppManaged": False,
"S3Input": {
"S3Uri": "s3://{}/{}/processing/".format(self.bucket, self.prefix),
"LocalPath": "/opt/ml/processing/input",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"S3DataDistributionType": "FullyReplicated",
"S3CompressionType": "None",
},
}
]
self.processing_output_config = processing_output_config or {
"Outputs": [
{
"OutputName": "output",
"S3Output": {
"S3Uri": "s3://{}/{}/processing/".format(
self.bucket, self.prefix
),
"LocalPath": "/opt/ml/processing/output",
"S3UploadMode": "EndOfJob",
},
"AppManaged": False,
}
]
}
self.processing_resources = processing_resources or {
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.large",
"VolumeSizeInGB": 10,
},
}
self.stopping_condition = stopping_condition or {
"MaxRuntimeInSeconds": 3600,
}
def save(self):
sagemaker = boto3.client("sagemaker", region_name=TEST_REGION_NAME)
params = {
"AppSpecification": self.app_specification,
"NetworkConfig": self.network_config,
"ProcessingInputs": self.processing_inputs,
"ProcessingJobName": self.processing_job_name,
"ProcessingOutputConfig": self.processing_output_config,
"ProcessingResources": self.processing_resources,
"RoleArn": self.role_arn,
"StoppingCondition": self.stopping_condition,
}
return sagemaker.create_processing_job(**params)
@mock_sagemaker
def test_create_processing_job():
sagemaker = boto3.client("sagemaker", region_name=TEST_REGION_NAME)
processing_job_name = "MyProcessingJob"
role_arn = "arn:aws:iam::{}:role/FakeRole".format(ACCOUNT_ID)
container = "382416733822.dkr.ecr.us-east-1.amazonaws.com/linear-learner:1"
bucket = "my-bucket"
prefix = "my-prefix"
app_specification = {
"ImageUri": container,
"ContainerEntrypoint": ["python3", "app.py"],
}
processing_resources = {
"ClusterConfig": {
"InstanceCount": 2,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20,
},
}
stopping_condition = {"MaxRuntimeInSeconds": 60 * 60}
job = MyProcessingJobModel(
processing_job_name,
role_arn,
container=container,
bucket=bucket,
prefix=prefix,
app_specification=app_specification,
processing_resources=processing_resources,
stopping_condition=stopping_condition,
)
resp = job.save()
resp["ProcessingJobArn"].should.match(
r"^arn:aws:sagemaker:.*:.*:processing-job/{}$".format(processing_job_name)
)
resp = sagemaker.describe_processing_job(ProcessingJobName=processing_job_name)
resp["ProcessingJobName"].should.equal(processing_job_name)
resp["ProcessingJobArn"].should.match(
r"^arn:aws:sagemaker:.*:.*:processing-job/{}$".format(processing_job_name)
)
assert "python3" in resp["AppSpecification"]["ContainerEntrypoint"]
assert "app.py" in resp["AppSpecification"]["ContainerEntrypoint"]
assert resp["RoleArn"] == role_arn
assert resp["ProcessingJobStatus"] == "Completed"
assert isinstance(resp["CreationTime"], datetime.datetime)
assert isinstance(resp["LastModifiedTime"], datetime.datetime)
@mock_sagemaker
def test_list_processing_jobs():
client = boto3.client("sagemaker", region_name="us-east-1")
name = "blah"
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar"
test_processing_job = MyProcessingJobModel(processing_job_name=name, role_arn=arn)
test_processing_job.save()
processing_jobs = client.list_processing_jobs()
assert len(processing_jobs["ProcessingJobSummaries"]).should.equal(1)
assert processing_jobs["ProcessingJobSummaries"][0][
"ProcessingJobName"
].should.equal(name)
assert processing_jobs["ProcessingJobSummaries"][0][
"ProcessingJobArn"
].should.match(r"^arn:aws:sagemaker:.*:.*:processing-job/{}$".format(name))
assert processing_jobs.get("NextToken") is None
@mock_sagemaker
def test_list_processing_jobs_multiple():
client = boto3.client("sagemaker", region_name="us-east-1")
name_job_1 = "blah"
arn_job_1 = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar"
test_processing_job_1 = MyProcessingJobModel(
processing_job_name=name_job_1, role_arn=arn_job_1
)
test_processing_job_1.save()
name_job_2 = "blah2"
arn_job_2 = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar2"
test_processing_job_2 = MyProcessingJobModel(
processing_job_name=name_job_2, role_arn=arn_job_2
)
test_processing_job_2.save()
processing_jobs_limit = client.list_processing_jobs(MaxResults=1)
assert len(processing_jobs_limit["ProcessingJobSummaries"]).should.equal(1)
processing_jobs = client.list_processing_jobs()
assert len(processing_jobs["ProcessingJobSummaries"]).should.equal(2)
assert processing_jobs.get("NextToken").should.be.none
@mock_sagemaker
def test_list_processing_jobs_none():
client = boto3.client("sagemaker", region_name="us-east-1")
processing_jobs = client.list_processing_jobs()
assert len(processing_jobs["ProcessingJobSummaries"]).should.equal(0)
@mock_sagemaker
def test_list_processing_jobs_should_validate_input():
client = boto3.client("sagemaker", region_name="us-east-1")
junk_status_equals = "blah"
with pytest.raises(ClientError) as ex:
client.list_processing_jobs(StatusEquals=junk_status_equals)
expected_error = f"1 validation errors detected: Value '{junk_status_equals}' at 'statusEquals' failed to satisfy constraint: Member must satisfy enum value set: ['Completed', 'Stopped', 'InProgress', 'Stopping', 'Failed']"
assert ex.value.response["Error"]["Code"] == "ValidationException"
assert ex.value.response["Error"]["Message"] == expected_error
junk_next_token = "<PASSWORD>"
with pytest.raises(ClientError) as ex:
client.list_processing_jobs(NextToken=junk_next_token)
assert ex.value.response["Error"]["Code"] == "ValidationException"
assert (
ex.value.response["Error"]["Message"]
== 'Invalid pagination token because "{0}".'
)
@mock_sagemaker
def test_list_processing_jobs_with_name_filters():
client = boto3.client("sagemaker", region_name="us-east-1")
for i in range(5):
name = "xgboost-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
for i in range(5):
name = "vgg-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/barfoo-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
xgboost_processing_jobs = client.list_processing_jobs(NameContains="xgboost")
assert len(xgboost_processing_jobs["ProcessingJobSummaries"]).should.equal(5)
processing_jobs_with_2 = client.list_processing_jobs(NameContains="2")
assert len(processing_jobs_with_2["ProcessingJobSummaries"]).should.equal(2)
@mock_sagemaker
def test_list_processing_jobs_paginated():
client = boto3.client("sagemaker", region_name="us-east-1")
for i in range(5):
name = "xgboost-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
xgboost_processing_job_1 = client.list_processing_jobs(
NameContains="xgboost", MaxResults=1
)
assert len(xgboost_processing_job_1["ProcessingJobSummaries"]).should.equal(1)
assert xgboost_processing_job_1["ProcessingJobSummaries"][0][
"ProcessingJobName"
].should.equal("xgboost-0")
assert xgboost_processing_job_1.get("NextToken").should_not.be.none
xgboost_processing_job_next = client.list_processing_jobs(
NameContains="xgboost",
MaxResults=1,
NextToken=xgboost_processing_job_1.get("NextToken"),
)
assert len(xgboost_processing_job_next["ProcessingJobSummaries"]).should.equal(1)
assert xgboost_processing_job_next["ProcessingJobSummaries"][0][
"ProcessingJobName"
].should.equal("xgboost-1")
assert xgboost_processing_job_next.get("NextToken").should_not.be.none
@mock_sagemaker
def test_list_processing_jobs_paginated_with_target_in_middle():
client = boto3.client("sagemaker", region_name="us-east-1")
for i in range(5):
name = "xgboost-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
for i in range(5):
name = "vgg-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/barfoo-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
vgg_processing_job_1 = client.list_processing_jobs(NameContains="vgg", MaxResults=1)
assert len(vgg_processing_job_1["ProcessingJobSummaries"]).should.equal(0)
assert vgg_processing_job_1.get("NextToken").should_not.be.none
vgg_processing_job_6 = client.list_processing_jobs(NameContains="vgg", MaxResults=6)
assert len(vgg_processing_job_6["ProcessingJobSummaries"]).should.equal(1)
assert vgg_processing_job_6["ProcessingJobSummaries"][0][
"ProcessingJobName"
].should.equal("vgg-0")
assert vgg_processing_job_6.get("NextToken").should_not.be.none
vgg_processing_job_10 = client.list_processing_jobs(
NameContains="vgg", MaxResults=10
)
assert len(vgg_processing_job_10["ProcessingJobSummaries"]).should.equal(5)
assert vgg_processing_job_10["ProcessingJobSummaries"][-1][
"ProcessingJobName"
].should.equal("vgg-4")
assert vgg_processing_job_10.get("NextToken").should.be.none
@mock_sagemaker
def test_list_processing_jobs_paginated_with_fragmented_targets():
client = boto3.client("sagemaker", region_name="us-east-1")
for i in range(5):
name = "xgboost-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/foobar-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
for i in range(5):
name = "vgg-{}".format(i)
arn = "arn:aws:sagemaker:us-east-1:000000000000:x-x/barfoo-{}".format(i)
MyProcessingJobModel(processing_job_name=name, role_arn=arn).save()
processing_jobs_with_2 = client.list_processing_jobs(NameContains="2", MaxResults=8)
assert len(processing_jobs_with_2["ProcessingJobSummaries"]).should.equal(2)
assert processing_jobs_with_2.get("NextToken").should_not.be.none
processing_jobs_with_2_next = client.list_processing_jobs(
NameContains="2",
MaxResults=1,
NextToken=processing_jobs_with_2.get("NextToken"),
)
assert len(processing_jobs_with_2_next["ProcessingJobSummaries"]).should.equal(0)
assert processing_jobs_with_2_next.get("NextToken").should_not.be.none
processing_jobs_with_2_next_next = client.list_processing_jobs(
NameContains="2",
MaxResults=1,
NextToken=processing_jobs_with_2_next.get("NextToken"),
)
assert len(processing_jobs_with_2_next_next["ProcessingJobSummaries"]).should.equal(
0
)
assert processing_jobs_with_2_next_next.get("NextToken").should.be.none
| [
"boto3.client",
"pytest.raises"
] | [((3482, 3537), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': 'TEST_REGION_NAME'}), "('sagemaker', region_name=TEST_REGION_NAME)\n", (3494, 3537), False, 'import boto3\n'), ((5306, 5356), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (5318, 5356), False, 'import boto3\n'), ((6083, 6133), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (6095, 6133), False, 'import boto3\n'), ((7026, 7076), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (7038, 7076), False, 'import boto3\n'), ((7289, 7339), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (7301, 7339), False, 'import boto3\n'), ((8263, 8313), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (8275, 8313), False, 'import boto3\n'), ((9141, 9191), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (9153, 9191), False, 'import boto3\n'), ((10373, 10423), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (10385, 10423), False, 'import boto3\n'), ((11919, 11969), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': '"""us-east-1"""'}), "('sagemaker', region_name='us-east-1')\n", (11931, 11969), False, 'import boto3\n'), ((2822, 2877), 'boto3.client', 'boto3.client', (['"""sagemaker"""'], {'region_name': 'TEST_REGION_NAME'}), "('sagemaker', region_name=TEST_REGION_NAME)\n", (2834, 2877), False, 'import boto3\n'), ((7381, 7407), 'pytest.raises', 'pytest.raises', (['ClientError'], {}), '(ClientError)\n', (7394, 7407), False, 'import pytest\n'), ((7895, 7921), 'pytest.raises', 'pytest.raises', (['ClientError'], {}), '(ClientError)\n', (7908, 7921), False, 'import pytest\n')] |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'direction_sprite_widget.ui'
#
# Created: Wed Jul 30 18:37:40 2014
# by: PyQt4 UI code generator 4.10.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_direction_sprite_widget(object):
def setupUi(self, direction_sprite_widget):
direction_sprite_widget.setObjectName(_fromUtf8("direction_sprite_widget"))
direction_sprite_widget.resize(566, 457)
self.verticalLayoutWidget = QtGui.QWidget(direction_sprite_widget)
self.verticalLayoutWidget.setGeometry(QtCore.QRect(0, 0, 561, 451))
self.verticalLayoutWidget.setObjectName(_fromUtf8("verticalLayoutWidget"))
self.layout_main = QtGui.QVBoxLayout(self.verticalLayoutWidget)
self.layout_main.setMargin(5)
self.layout_main.setObjectName(_fromUtf8("layout_main"))
self.layout_sprite_info = QtGui.QHBoxLayout()
self.layout_sprite_info.setMargin(2)
self.layout_sprite_info.setObjectName(_fromUtf8("layout_sprite_info"))
self.gb_sprite = QtGui.QGroupBox(self.verticalLayoutWidget)
self.gb_sprite.setMinimumSize(QtCore.QSize(250, 110))
self.gb_sprite.setObjectName(_fromUtf8("gb_sprite"))
self.formLayoutWidget = QtGui.QWidget(self.gb_sprite)
self.formLayoutWidget.setGeometry(QtCore.QRect(20, 20, 191, 74))
self.formLayoutWidget.setObjectName(_fromUtf8("formLayoutWidget"))
self.formLayout = QtGui.QFormLayout(self.formLayoutWidget)
self.formLayout.setMargin(0)
self.formLayout.setObjectName(_fromUtf8("formLayout"))
self.lbl_name = QtGui.QLabel(self.formLayoutWidget)
self.lbl_name.setObjectName(_fromUtf8("lbl_name"))
self.formLayout.setWidget(0, QtGui.QFormLayout.LabelRole, self.lbl_name)
self.le_name = QtGui.QLineEdit(self.formLayoutWidget)
self.le_name.setObjectName(_fromUtf8("le_name"))
self.formLayout.setWidget(0, QtGui.QFormLayout.FieldRole, self.le_name)
self.lbl_width = QtGui.QLabel(self.formLayoutWidget)
self.lbl_width.setObjectName(_fromUtf8("lbl_width"))
self.formLayout.setWidget(1, QtGui.QFormLayout.LabelRole, self.lbl_width)
self.le_width = QtGui.QLineEdit(self.formLayoutWidget)
self.le_width.setObjectName(_fromUtf8("le_width"))
self.formLayout.setWidget(1, QtGui.QFormLayout.FieldRole, self.le_width)
self.lbl_height = QtGui.QLabel(self.formLayoutWidget)
self.lbl_height.setObjectName(_fromUtf8("lbl_height"))
self.formLayout.setWidget(2, QtGui.QFormLayout.LabelRole, self.lbl_height)
self.le_height = QtGui.QLineEdit(self.formLayoutWidget)
self.le_height.setObjectName(_fromUtf8("le_height"))
self.formLayout.setWidget(2, QtGui.QFormLayout.FieldRole, self.le_height)
self.layout_sprite_info.addWidget(self.gb_sprite)
self.gb_preview = QtGui.QGroupBox(self.verticalLayoutWidget)
self.gb_preview.setMinimumSize(QtCore.QSize(120, 0))
self.gb_preview.setObjectName(_fromUtf8("gb_preview"))
self.horizontalLayoutWidget = QtGui.QWidget(self.gb_preview)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(10, 20, 121, 80))
self.horizontalLayoutWidget.setObjectName(_fromUtf8("horizontalLayoutWidget"))
self.layout_preview = QtGui.QHBoxLayout(self.horizontalLayoutWidget)
self.layout_preview.setMargin(0)
self.layout_preview.setObjectName(_fromUtf8("layout_preview"))
self.lbl_preview = QtGui.QLabel(self.horizontalLayoutWidget)
self.lbl_preview.setObjectName(_fromUtf8("lbl_preview"))
self.layout_preview.addWidget(self.lbl_preview)
self.sp_fps = QtGui.QSpinBox(self.horizontalLayoutWidget)
self.sp_fps.setMinimumSize(QtCore.QSize(40, 20))
self.sp_fps.setMaximumSize(QtCore.QSize(40, 20))
self.sp_fps.setMinimum(15)
self.sp_fps.setMaximum(150)
self.sp_fps.setObjectName(_fromUtf8("sp_fps"))
self.layout_preview.addWidget(self.sp_fps)
self.layout_sprite_info.addWidget(self.gb_preview)
self.btn_add_frame = QtGui.QPushButton(self.verticalLayoutWidget)
self.btn_add_frame.setMinimumSize(QtCore.QSize(120, 0))
self.btn_add_frame.setObjectName(_fromUtf8("btn_add_frame"))
self.layout_sprite_info.addWidget(self.btn_add_frame)
self.layout_main.addLayout(self.layout_sprite_info)
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.lbl_frames = QtGui.QLabel(self.verticalLayoutWidget)
self.lbl_frames.setObjectName(_fromUtf8("lbl_frames"))
self.horizontalLayout.addWidget(self.lbl_frames)
self.formLayout_2 = QtGui.QFormLayout()
self.formLayout_2.setFieldGrowthPolicy(QtGui.QFormLayout.AllNonFixedFieldsGrow)
self.formLayout_2.setObjectName(_fromUtf8("formLayout_2"))
self.cb_direction = QtGui.QComboBox(self.verticalLayoutWidget)
self.cb_direction.setObjectName(_fromUtf8("cb_direction"))
self.formLayout_2.setWidget(0, QtGui.QFormLayout.FieldRole, self.cb_direction)
self.lbl_direction = QtGui.QLabel(self.verticalLayoutWidget)
self.lbl_direction.setObjectName(_fromUtf8("lbl_direction"))
self.formLayout_2.setWidget(0, QtGui.QFormLayout.LabelRole, self.lbl_direction)
self.horizontalLayout.addLayout(self.formLayout_2)
self.layout_main.addLayout(self.horizontalLayout)
self.sa_frames = QtGui.QScrollArea(self.verticalLayoutWidget)
self.sa_frames.setWidgetResizable(True)
self.sa_frames.setAlignment(QtCore.Qt.AlignJustify|QtCore.Qt.AlignVCenter)
self.sa_frames.setObjectName(_fromUtf8("sa_frames"))
self.scrollAreaWidgetContents = QtGui.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 549, 289))
self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
self.sa_frames.setWidget(self.scrollAreaWidgetContents)
self.layout_main.addWidget(self.sa_frames)
self.retranslateUi(direction_sprite_widget)
QtCore.QMetaObject.connectSlotsByName(direction_sprite_widget)
def retranslateUi(self, direction_sprite_widget):
direction_sprite_widget.setWindowTitle(_translate("direction_sprite_widget", "Form", None))
self.gb_sprite.setTitle(_translate("direction_sprite_widget", "Sprite Information", None))
self.lbl_name.setText(_translate("direction_sprite_widget", "Name :", None))
self.lbl_width.setText(_translate("direction_sprite_widget", "Width :", None))
self.le_width.setText(_translate("direction_sprite_widget", "0", None))
self.lbl_height.setText(_translate("direction_sprite_widget", "Height :", None))
self.le_height.setText(_translate("direction_sprite_widget", "0", None))
self.gb_preview.setTitle(_translate("direction_sprite_widget", "Preview", None))
self.lbl_preview.setText(_translate("direction_sprite_widget", "P", None))
self.btn_add_frame.setText(_translate("direction_sprite_widget", "Add a frame...", None))
self.lbl_frames.setText(_translate("direction_sprite_widget", "Frame(s)", None))
self.lbl_direction.setText(_translate("direction_sprite_widget", "Direction :", None))
| [
"PyQt4.QtCore.QSize",
"PyQt4.QtGui.QWidget",
"PyQt4.QtGui.QScrollArea",
"PyQt4.QtGui.QFormLayout",
"PyQt4.QtGui.QSpinBox",
"PyQt4.QtCore.QMetaObject.connectSlotsByName",
"PyQt4.QtGui.QLabel",
"PyQt4.QtGui.QPushButton",
"PyQt4.QtGui.QComboBox",
"PyQt4.QtCore.QRect",
"PyQt4.QtGui.QVBoxLayout",
"... | [((498, 562), 'PyQt4.QtGui.QApplication.translate', 'QtGui.QApplication.translate', (['context', 'text', 'disambig', '_encoding'], {}), '(context, text, disambig, _encoding)\n', (526, 562), False, 'from PyQt4 import QtCore, QtGui\n'), ((960, 998), 'PyQt4.QtGui.QWidget', 'QtGui.QWidget', (['direction_sprite_widget'], {}), '(direction_sprite_widget)\n', (973, 998), False, 'from PyQt4 import QtCore, QtGui\n'), ((1185, 1229), 'PyQt4.QtGui.QVBoxLayout', 'QtGui.QVBoxLayout', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (1202, 1229), False, 'from PyQt4 import QtCore, QtGui\n'), ((1367, 1386), 'PyQt4.QtGui.QHBoxLayout', 'QtGui.QHBoxLayout', ([], {}), '()\n', (1384, 1386), False, 'from PyQt4 import QtCore, QtGui\n'), ((1536, 1578), 'PyQt4.QtGui.QGroupBox', 'QtGui.QGroupBox', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (1551, 1578), False, 'from PyQt4 import QtCore, QtGui\n'), ((1734, 1763), 'PyQt4.QtGui.QWidget', 'QtGui.QWidget', (['self.gb_sprite'], {}), '(self.gb_sprite)\n', (1747, 1763), False, 'from PyQt4 import QtCore, QtGui\n'), ((1938, 1978), 'PyQt4.QtGui.QFormLayout', 'QtGui.QFormLayout', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (1955, 1978), False, 'from PyQt4 import QtCore, QtGui\n'), ((2103, 2138), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (2115, 2138), False, 'from PyQt4 import QtCore, QtGui\n'), ((2302, 2340), 'PyQt4.QtGui.QLineEdit', 'QtGui.QLineEdit', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (2317, 2340), False, 'from PyQt4 import QtCore, QtGui\n'), ((2503, 2538), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (2515, 2538), False, 'from PyQt4 import QtCore, QtGui\n'), ((2706, 2744), 'PyQt4.QtGui.QLineEdit', 'QtGui.QLineEdit', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (2721, 2744), False, 'from PyQt4 import QtCore, QtGui\n'), ((2911, 2946), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (2923, 2946), False, 'from PyQt4 import QtCore, QtGui\n'), ((3118, 3156), 'PyQt4.QtGui.QLineEdit', 'QtGui.QLineEdit', (['self.formLayoutWidget'], {}), '(self.formLayoutWidget)\n', (3133, 3156), False, 'from PyQt4 import QtCore, QtGui\n'), ((3384, 3426), 'PyQt4.QtGui.QGroupBox', 'QtGui.QGroupBox', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (3399, 3426), False, 'from PyQt4 import QtCore, QtGui\n'), ((3589, 3619), 'PyQt4.QtGui.QWidget', 'QtGui.QWidget', (['self.gb_preview'], {}), '(self.gb_preview)\n', (3602, 3619), False, 'from PyQt4 import QtCore, QtGui\n'), ((3816, 3862), 'PyQt4.QtGui.QHBoxLayout', 'QtGui.QHBoxLayout', (['self.horizontalLayoutWidget'], {}), '(self.horizontalLayoutWidget)\n', (3833, 3862), False, 'from PyQt4 import QtCore, QtGui\n'), ((4002, 4043), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.horizontalLayoutWidget'], {}), '(self.horizontalLayoutWidget)\n', (4014, 4043), False, 'from PyQt4 import QtCore, QtGui\n'), ((4187, 4230), 'PyQt4.QtGui.QSpinBox', 'QtGui.QSpinBox', (['self.horizontalLayoutWidget'], {}), '(self.horizontalLayoutWidget)\n', (4201, 4230), False, 'from PyQt4 import QtCore, QtGui\n'), ((4610, 4654), 'PyQt4.QtGui.QPushButton', 'QtGui.QPushButton', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (4627, 4654), False, 'from PyQt4 import QtCore, QtGui\n'), ((4942, 4961), 'PyQt4.QtGui.QHBoxLayout', 'QtGui.QHBoxLayout', ([], {}), '()\n', (4959, 4961), False, 'from PyQt4 import QtCore, QtGui\n'), ((5063, 5102), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (5075, 5102), False, 'from PyQt4 import QtCore, QtGui\n'), ((5251, 5270), 'PyQt4.QtGui.QFormLayout', 'QtGui.QFormLayout', ([], {}), '()\n', (5268, 5270), False, 'from PyQt4 import QtCore, QtGui\n'), ((5454, 5496), 'PyQt4.QtGui.QComboBox', 'QtGui.QComboBox', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (5469, 5496), False, 'from PyQt4 import QtCore, QtGui\n'), ((5680, 5719), 'PyQt4.QtGui.QLabel', 'QtGui.QLabel', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (5692, 5719), False, 'from PyQt4 import QtCore, QtGui\n'), ((6019, 6063), 'PyQt4.QtGui.QScrollArea', 'QtGui.QScrollArea', (['self.verticalLayoutWidget'], {}), '(self.verticalLayoutWidget)\n', (6036, 6063), False, 'from PyQt4 import QtCore, QtGui\n'), ((6296, 6311), 'PyQt4.QtGui.QWidget', 'QtGui.QWidget', ([], {}), '()\n', (6309, 6311), False, 'from PyQt4 import QtCore, QtGui\n'), ((6659, 6721), 'PyQt4.QtCore.QMetaObject.connectSlotsByName', 'QtCore.QMetaObject.connectSlotsByName', (['direction_sprite_widget'], {}), '(direction_sprite_widget)\n', (6696, 6721), False, 'from PyQt4 import QtCore, QtGui\n'), ((646, 699), 'PyQt4.QtGui.QApplication.translate', 'QtGui.QApplication.translate', (['context', 'text', 'disambig'], {}), '(context, text, disambig)\n', (674, 699), False, 'from PyQt4 import QtCore, QtGui\n'), ((1045, 1073), 'PyQt4.QtCore.QRect', 'QtCore.QRect', (['(0)', '(0)', '(561)', '(451)'], {}), '(0, 0, 561, 451)\n', (1057, 1073), False, 'from PyQt4 import QtCore, QtGui\n'), ((1617, 1639), 'PyQt4.QtCore.QSize', 'QtCore.QSize', (['(250)', '(110)'], {}), '(250, 110)\n', (1629, 1639), False, 'from PyQt4 import QtCore, QtGui\n'), ((1806, 1835), 'PyQt4.QtCore.QRect', 'QtCore.QRect', (['(20)', '(20)', '(191)', '(74)'], {}), '(20, 20, 191, 74)\n', (1818, 1835), False, 'from PyQt4 import QtCore, QtGui\n'), ((3466, 3486), 'PyQt4.QtCore.QSize', 'QtCore.QSize', (['(120)', '(0)'], {}), '(120, 0)\n', (3478, 3486), False, 'from PyQt4 import QtCore, QtGui\n'), ((3668, 3697), 'PyQt4.QtCore.QRect', 'QtCore.QRect', (['(10)', '(20)', '(121)', '(80)'], {}), '(10, 20, 121, 80)\n', (3680, 3697), False, 'from PyQt4 import QtCore, QtGui\n'), ((4266, 4286), 'PyQt4.QtCore.QSize', 'QtCore.QSize', (['(40)', '(20)'], {}), '(40, 20)\n', (4278, 4286), False, 'from PyQt4 import QtCore, QtGui\n'), ((4323, 4343), 'PyQt4.QtCore.QSize', 'QtCore.QSize', (['(40)', '(20)'], {}), '(40, 20)\n', (4335, 4343), False, 'from PyQt4 import QtCore, QtGui\n'), ((4697, 4717), 'PyQt4.QtCore.QSize', 'QtCore.QSize', (['(120)', '(0)'], {}), '(120, 0)\n', (4709, 4717), False, 'from PyQt4 import QtCore, QtGui\n'), ((6362, 6390), 'PyQt4.QtCore.QRect', 'QtCore.QRect', (['(0)', '(0)', '(549)', '(289)'], {}), '(0, 0, 549, 289)\n', (6374, 6390), False, 'from PyQt4 import QtCore, QtGui\n')] |
import nltk
import string
import argparse
parser = argparse.ArgumentParser(description='.')
parser.add_argument('-text', help='')
parser.add_argument('-meta', help='')
parser.add_argument('-output', help='')
args = parser.parse_args()
# parser.add_argument('-iter', dest='iter', type=int,
# default=max_iter)
text_docs = {}
with open(args.text, 'r') as f:
with open(args.output + 'd_prel.txt', 'w+') as g:
idx = 0
for line in f:
tokens = [w.lower().replace('###', '_') for w in line.strip('\r\n').split(' ')]
stopwords = nltk.corpus.stopwords.words('english')
tokens = [w for w in tokens if w not in stopwords]
line = str(idx) + '\t' + ';'.join(tokens) + ';\n'
g.write(line)
idx += 1
with open(args.output + 'l_prel.txt', 'w+') as g:
g.write('0 * \n')
with open(args.meta, 'r') as f:
idx = 0
for line in f:
idx += 1
path = line.strip('\r\n')
value = path.split('|')[-1]
g.write(str(idx) + '\t' + path + '\t' + value + '\n')
# prel => parse_flat => run.sh
# ==> evaluate.py | [
"nltk.corpus.stopwords.words",
"argparse.ArgumentParser"
] | [((53, 93), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""."""'}), "(description='.')\n", (76, 93), False, 'import argparse\n'), ((558, 596), 'nltk.corpus.stopwords.words', 'nltk.corpus.stopwords.words', (['"""english"""'], {}), "('english')\n", (585, 596), False, 'import nltk\n')] |
from collections import deque
import numpy as np
import os
from abc import ABCMeta, abstractmethod
import random
random.seed(42)
from common import config, VehicleState
from helper import Helper
INFO = """Average merging time: {} s
Traffic flow: {} vehicle/s
Average speed: {} km/h
Average fuel consumption: {} ml/vehicle"""
class Vehicle(object):
"""docstring for Vehicle"""
def __init__(self, builder):
super(Vehicle, self).__init__()
self.ID = builder.ID
self.size = builder.size
self.speed = builder.speed
self.acceleration = builder.acceleration
self.max_speed = builder.max_speed
self.min_speed = builder.min_speed
self.max_acc = builder.max_acc
self.lane = builder.lane
self.position = builder.position
class VehicleBuilder(object):
"""docstring for VehicleBuilder"""
def __init__(self, ID):
super(VehicleBuilder, self).__init__()
self.ID = ID
self.max_acc = config.max_acc
self.max_speed = config.max_speed
self.min_speed = config.min_speed
self.size = config.size
def setSpeed(self, speed):
self.speed = speed
return self
def setPosition(self, position):
self.position = position
return self
def setLane(self, lane):
self.lane = lane
return self
def setAcceleration(self, acceleration):
self.acceleration = acceleration
return self
def build(self):
return Vehicle(self)
class OnBoardVehicle(object):
"""docstring for OnBoardVehicle"""
def __init__(self, vehicle, t0, min_pass_time=config.min_pass_time):
self.vehicle = vehicle
self.t0 = t0
self.tm = float('Inf')
self.position_history = [vehicle.position]
self.speed_history = [vehicle.speed]
self.acc_history = [vehicle.acceleration]
self.fuel_history = [0]
self.time_steps = [t0]
self.ParaV = None
self.min_pass_time = min_pass_time
self.state = VehicleState.PENDING
@property
def v0(self):
return self.speed_history[0]
@property
def p0(self):
return self.position_history[0]
@property
def merge_time(self):
return self.time_steps[-1] - self.time_steps[0]
@property
def tf(self):
return self.time_steps[-1]
@property
def average_speed(self):
return np.array(self.speed_history).mean()
@property
def fuel_consumption(self):
return self.fuel_history[-1]
class VehicleGeneratorBase(metaclass=ABCMeta):
"""docstring for VehicleGeneratorBase"""
def __init__(self):
self.schedule = deque()
self.buildSchedule()
@abstractmethod
def buildSchedule(self):
pass
def getAtTime(self, ctime):
vehicle_to_add = []
while self.hasVehicle() and self.schedule[0].t0 <= ctime:
vehicle_to_add.append(self.schedule.popleft())
return vehicle_to_add
def hasVehicle(self):
return len(self.schedule) > 0
def FIFOIDAssigner(self):
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0))
for i, ove in enumerate(self.schedule):
ove.vehicle.ID = i
def SpeedIDAssigner(self):
for ove in self.schedule:
ove.min_pass_time = Helper.getTmOptimal2(ove.v0, config.case_speed['speed_merge'],
-config.control_len, 0)
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0 + x.min_pass_time))
for i, ove in enumerate(self.schedule):
ove.vehicle.ID = i
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0))
class Case1VehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self):
super(Case1VehicleGenerator, self).__init__()
def buildSchedule(self):
for i in range(config.case1['total_cars']):
v = VehicleBuilder(i)\
.setSpeed(config.case1['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = 10.0 if (i < 2) else 15.0
# self.schedule.append(OnBoardVehicle(v, t, config.control_len / config.case1['speed']))
tm = Helper.getTmOptimal2(config.case1['speed'], config.case_speed['speed_merge'],
-config.control_len, 0) if i == 0 else 0
self.schedule.append(OnBoardVehicle(v, t, tm))
# self.schedule.sort(key=lambda x: x.vehicle.ID)
class Case2VehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self):
super(Case2VehicleGenerator, self).__init__()
def buildSchedule(self):
tnum = config.case2['total_cars']
# Randomly generate tnum//2 cars on each lane, with time span 10~50
# This does not ensure feasibility at initial state
t0_lane0 = np.random.rand(tnum//2) * 40.0 + 10.0
t0_lane1 = np.random.rand(tnum//2) * 40.0 + 10.0
for i in range(tnum):
v = VehicleBuilder(-1)\
.setSpeed(config.case2['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = t0_lane0[i//2] if (i % 2 == 0) else t0_lane1[i//2]
self.schedule.append(OnBoardVehicle(v, t, config.control_len / config.case2['speed']))
self.FIFOIDAssigner()
class MainHigherSpeedVG(VehicleGeneratorBase):
def __init__(self):
super(MainHigherSpeedVG, self).__init__()
def buildSchedule(self):
# lane0 (main road)
t0_lane0 = np.arange(10, 30.1, 2.0)
t0_lane1 = np.arange(9, 30.1, 3.1)
v0_lane0 = 25.0
v0_lane1 = 15.0
for ti0 in t0_lane0:
v = VehicleBuilder(-1)\
.setSpeed(v0_lane0)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(0).build()
self.schedule.append(OnBoardVehicle(v, ti0, Helper.getTc(v)))
for ti0 in t0_lane1:
v = VehicleBuilder(-1)\
.setSpeed(v0_lane1)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(1).build()
self.schedule.append(OnBoardVehicle(v, ti0, Helper.getTc(v)))
self.FIFOIDAssigner()
# self.SpeedIDAssigner()
class PoissonVehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self, tnum_lane0, tnum_lane1):
self.tnum_lane0 = tnum_lane0
self.tnum_lane1 = tnum_lane1
super(PoissonVehicleGenerator, self).__init__()
def buildSchedule(self):
speed_lane0 = config.case_speed['speed_init_lane0']
speed_lane1 = config.case_speed['speed_init_lane1']
t0_lane0 = [0]
t0_lane1 = [0]
tsp_lane0 = (config.delta) / speed_lane0
tsp_lane1 = (config.delta) / speed_lane1
for i in range(self.tnum_lane0):
t0_lane0.append(t0_lane0[-1] + tsp_lane0 + np.random.exponential(5.0))
for i in range(self.tnum_lane1):
t0_lane1.append(t0_lane1[-1] + tsp_lane1 + np.random.exponential(5.0))
t0_lane0 = np.array(t0_lane0[1:])
t0_lane1 = np.array(t0_lane1[1:])
for i in range(self.tnum_lane0):
speed_v = speed_lane0 + np.random.randn()
v = VehicleBuilder(-1)\
.setSpeed(speed_v)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(0).build()
t = t0_lane0[i]
self.schedule.append(OnBoardVehicle(v, t, Helper.getTc(v)))
for i in range(self.tnum_lane1):
speed_v = speed_lane1 + np.random.randn()
v = VehicleBuilder(-1)\
.setSpeed(speed_v)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(1).build()
t = t0_lane1[i]
self.schedule.append(OnBoardVehicle(v, t, Helper.getTc(v)))
self.FIFOIDAssigner()
# self.SpeedIDAssigner()
class APPVehicleGenerator(VehicleGeneratorBase):
def __init__(self, tnum, id_assigner, min_pass_time):
self.tnum = tnum
self.ida = id_assigner
self.mpt = min_pass_time
super(APPVehicleGenerator, self).__init__()
def buildSchedule(self):
tnum = self.tnum
t0_lane0 = np.random.rand(tnum//2) * 40.0 + 10.0
t0_lane1 = np.random.rand(tnum//2) * 40.0 + 10.0
for i in range(tnum):
v = VehicleBuilder(-1)\
.setSpeed(config.case2['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = t0_lane0[i//2] if (i % 2 == 0) else t0_lane1[i//2]
self.schedule.append(OnBoardVehicle(v, t, self.mpt))
if self.ida == 'FIFO':
self.FIFOIDAssigner()
elif self.ida == 'main':
self.MainRoadFirstIDAssigner()
class GameLoop(object):
"""docstring for GameLoop"""
def __init__(self, vscd):
super(GameLoop, self).__init__()
self.ctime = 0
self.vscd = vscd
self.on_board_vehicles = deque()
self.finished_vehicels = deque()
def isOver(self):
if self.ctime >= config.max_sim_time:
print("Simulation time out.")
return True
return (not self.vscd.hasVehicle()) and self.isEmpty()
def isEmpty(self):
return len(self.on_board_vehicles) == 0
def nextStep(self):
self.ctime += config.time_meta
t = self.ctime
ove_t = self.vscd.getAtTime(t)
for v in ove_t:
if v.vehicle.ID == 0:
# v.tm = v.t0 + max(config.min_pass_time, v.min_pass_time)
v.tm = v.t0 + Helper.getTmOptimal2(v.v0, config.speed_merge, v.p0, 0)
elif len(self.on_board_vehicles) > 0:
v.tm = Helper.getTm(v, self.on_board_vehicles[-1])
else:
v.tm = Helper.getTm(v, self.finished_vehicels[-1])
self.on_board_vehicles.append(v)
TimeM = Helper.getTimeMatrix(t, v.tm)
ConfV = Helper.getConfigVec(v)
v.ParaV = np.dot(np.linalg.inv(TimeM), ConfV)
v.state = VehicleState.ON_RAMP
for v in self.on_board_vehicles:
Helper.updateAVP(v, t)
if v.vehicle.position >= 0:
v.state = VehicleState.ON_MERGING
while not self.isEmpty() and self.on_board_vehicles[0].vehicle.position >= config.merging_len:
self.on_board_vehicles[0].state = VehicleState.FINISHED
self.finished_vehicels.append((self.on_board_vehicles.popleft()))
def play(self):
while not self.isOver():
self.nextStep()
self.measure()
def measure(self):
# Measure average merging time
AMT = np.array([v.merge_time for v in self.finished_vehicels]).mean()
# Measure traffic flow
TF = len(self.finished_vehicels) / (self.finished_vehicels[-1].tf - self.finished_vehicels[0].t0)
# Measure average speed
AS = 1 / np.array([1 / v.average_speed for v in self.finished_vehicels]).mean() * 3.6
# Measure average fuel consumption
AFC = np.array([v.fuel_consumption for v in self.finished_vehicels]).mean()
print(INFO.format(AMT, TF, AS, AFC))
def draw_result_pyplot(self, file_path=None):
import matplotlib.pyplot as plt
plt.figure(1)
plt.subplot(221)
plt.xlabel('time')
plt.ylabel('position')
plt.title('positions')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.position_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "position.pdf"), format="pdf")
plt.subplot(222)
plt.xlabel('time')
plt.ylabel('speed')
plt.title('speeds')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.speed_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "speed.pdf"), format="pdf")
plt.subplot(223)
plt.xlabel('time')
plt.ylabel('acceleration')
plt.title('accelerations')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.acc_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "acc.pdf"), format="pdf")
plt.subplot(224)
plt.xlabel('time')
plt.ylabel('fuel')
plt.title('fuels')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.fuel_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "fuel.pdf"), format="pdf")
if not file_path:
plt.subplots_adjust(top=0.92, bottom=-0.35, left=0.10, right=1.35, hspace=0.35,
wspace=0.35)
plt.show()
def draw_result(self, file_path):
from bokeh.layouts import gridplot
from bokeh.plotting import figure, output_file, show
output_file(file_path)
TOOLS = "pan,wheel_zoom,box_zoom,reset,save,box_select,lasso_select"
s1 = figure(tools=TOOLS, title="positions", x_axis_label="time", y_axis_label="position")
for tv in self.finished_vehicels:
s1.line(tv.time_steps, tv.position_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s1.xgrid.minor_grid_line_color = 'navy'
s1.xgrid.minor_grid_line_alpha = 0.1
s1.ygrid.minor_grid_line_color = 'navy'
s1.ygrid.minor_grid_line_alpha = 0.1
s2 = figure(tools=TOOLS, title="speed", x_axis_label="time", y_axis_label="speed",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s2.line(tv.time_steps, tv.speed_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s2.xgrid.minor_grid_line_color = 'navy'
s2.xgrid.minor_grid_line_alpha = 0.1
s2.ygrid.minor_grid_line_color = 'navy'
s2.ygrid.minor_grid_line_alpha = 0.1
s3 = figure(tools=TOOLS, title="acceleration", x_axis_label="time", y_axis_label="acceleration",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s3.line(tv.time_steps, tv.acc_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s3.xgrid.minor_grid_line_color = 'navy'
s3.xgrid.minor_grid_line_alpha = 0.1
s3.ygrid.minor_grid_line_color = 'navy'
s3.ygrid.minor_grid_line_alpha = 0.1
s4 = figure(tools=TOOLS, title="fuel consumption", x_axis_label="time", y_axis_label="fuel",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s4.line(tv.time_steps, tv.fuel_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s4.xgrid.minor_grid_line_color = 'navy'
s4.xgrid.minor_grid_line_alpha = 0.1
s4.ygrid.minor_grid_line_color = 'navy'
s4.ygrid.minor_grid_line_alpha = 0.1
p = gridplot([[s1, s2, s3, s4]])
try:
show(p)
except Exception as e:
pass
show(p)
class SpeedGameLoop(GameLoop):
"""docstring for SpeedGameLoop"""
def __init__(self, vscd):
super(SpeedGameLoop, self).__init__(vscd)
self.on_board_vehicles = []
def nextStep(self):
self.ctime += config.time_meta
t = self.ctime
ove_t = self.vscd.getAtTime(t)
for v in ove_t:
tmp_v_stack = []
while len(self.on_board_vehicles) > 0 and self.on_board_vehicles[-1].vehicle.ID > v.vehicle.ID:
tmpv = self.on_board_vehicles.pop()
# tmpv.t0 = t
# tmpv.min_pass_time = max(tmpv.min_pass_time, Helper.getTmOptimal2(tmpv.vehicle.speed,
# config.case_speed['speed_merge'], tmpv.vehicle.position, 0))
tmp_v_stack.append(tmpv)
# Get t_m
if len(self.on_board_vehicles) == 0 and len(self.finished_vehicels) == 0:
v.tm = v.t0 + max(config.min_pass_time, v.min_pass_time)
elif len(self.on_board_vehicles) > 0:
v.tm = Helper.getTm(v, self.on_board_vehicles[-1])
else:
v.tm = Helper.getTm(v, self.finished_vehicels[-1])
tmp_v_stack.append(v)
prevve = None
for i in reversed(range(len(tmp_v_stack))):
ve = tmp_v_stack[i]
if prevve is not None:
ve.tm = Helper.getTm(ve, prevve)
self.on_board_vehicles.append(ve)
TimeM = Helper.getTimeMatrix(t, ve.tm)
ConfV = Helper.getConfigVec(ve)
# from IPython import embed; embed()
ve.ParaV = np.dot(np.linalg.inv(TimeM), ConfV)
ve.state = VehicleState.ON_RAMP
prevve = ve
# print("ID {}".format(prevve.vehicle.ID))
for v in self.on_board_vehicles:
Helper.updateAVP(v, t)
if v.vehicle.position >= 0:
v.state = VehicleState.ON_MERGING
while not self.isEmpty() and self.on_board_vehicles[0].vehicle.position >= config.merging_len:
self.on_board_vehicles[0].state = VehicleState.FINISHED
self.finished_vehicels.append((self.on_board_vehicles.pop(0)))
def main():
# vehicle_generator = Case1VehicleGenerator()
# game = GameLoop(vehicle_generator)
# game.play()
# game.draw_result_pyplot("case1")
vehicle_generator = MainHigherSpeedVG()
game = GameLoop(vehicle_generator)
# game = SpeedGameLoop(vehicle_generator)
game.play()
game.draw_result_pyplot("case2")
# vehicle_generator = APPVehicleGenerator(12, 'FIFO', 16.9)
# vehicle_generator = PoissonVehicleGenerator(config.case_speed['tnum_lane0'],
# config.case_speed['tnum_lane1'])
# ggame = GameLoop(vehicle_generator)
# ggame.play()
# # ggame.draw_result("result.html")
# ggame.draw_result_pyplot(".")
if __name__ == '__main__':
main() | [
"matplotlib.pyplot.grid",
"bokeh.plotting.figure",
"helper.Helper.getTmOptimal2",
"matplotlib.pyplot.ylabel",
"numpy.random.rand",
"helper.Helper.getConfigVec",
"numpy.random.exponential",
"numpy.array",
"numpy.arange",
"helper.Helper.getTc",
"helper.Helper.getTimeMatrix",
"collections.deque",... | [((118, 133), 'random.seed', 'random.seed', (['(42)'], {}), '(42)\n', (129, 133), False, 'import random\n'), ((2806, 2813), 'collections.deque', 'deque', ([], {}), '()\n', (2811, 2813), False, 'from collections import deque\n'), ((5912, 5936), 'numpy.arange', 'np.arange', (['(10)', '(30.1)', '(2.0)'], {}), '(10, 30.1, 2.0)\n', (5921, 5936), True, 'import numpy as np\n'), ((5957, 5980), 'numpy.arange', 'np.arange', (['(9)', '(30.1)', '(3.1)'], {}), '(9, 30.1, 3.1)\n', (5966, 5980), True, 'import numpy as np\n'), ((7571, 7593), 'numpy.array', 'np.array', (['t0_lane0[1:]'], {}), '(t0_lane0[1:])\n', (7579, 7593), True, 'import numpy as np\n'), ((7614, 7636), 'numpy.array', 'np.array', (['t0_lane1[1:]'], {}), '(t0_lane1[1:])\n', (7622, 7636), True, 'import numpy as np\n'), ((9689, 9696), 'collections.deque', 'deque', ([], {}), '()\n', (9694, 9696), False, 'from collections import deque\n'), ((9731, 9738), 'collections.deque', 'deque', ([], {}), '()\n', (9736, 9738), False, 'from collections import deque\n'), ((12048, 12061), 'matplotlib.pyplot.figure', 'plt.figure', (['(1)'], {}), '(1)\n', (12058, 12061), True, 'import matplotlib.pyplot as plt\n'), ((12071, 12087), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(221)'], {}), '(221)\n', (12082, 12087), True, 'import matplotlib.pyplot as plt\n'), ((12097, 12115), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (12107, 12115), True, 'import matplotlib.pyplot as plt\n'), ((12125, 12147), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""position"""'], {}), "('position')\n", (12135, 12147), True, 'import matplotlib.pyplot as plt\n'), ((12157, 12179), 'matplotlib.pyplot.title', 'plt.title', (['"""positions"""'], {}), "('positions')\n", (12166, 12179), True, 'import matplotlib.pyplot as plt\n'), ((12420, 12434), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (12428, 12434), True, 'import matplotlib.pyplot as plt\n'), ((12549, 12565), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(222)'], {}), '(222)\n', (12560, 12565), True, 'import matplotlib.pyplot as plt\n'), ((12575, 12593), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (12585, 12593), True, 'import matplotlib.pyplot as plt\n'), ((12603, 12622), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""speed"""'], {}), "('speed')\n", (12613, 12622), True, 'import matplotlib.pyplot as plt\n'), ((12632, 12651), 'matplotlib.pyplot.title', 'plt.title', (['"""speeds"""'], {}), "('speeds')\n", (12641, 12651), True, 'import matplotlib.pyplot as plt\n'), ((12889, 12903), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (12897, 12903), True, 'import matplotlib.pyplot as plt\n'), ((13015, 13031), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(223)'], {}), '(223)\n', (13026, 13031), True, 'import matplotlib.pyplot as plt\n'), ((13041, 13059), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (13051, 13059), True, 'import matplotlib.pyplot as plt\n'), ((13069, 13095), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""acceleration"""'], {}), "('acceleration')\n", (13079, 13095), True, 'import matplotlib.pyplot as plt\n'), ((13105, 13131), 'matplotlib.pyplot.title', 'plt.title', (['"""accelerations"""'], {}), "('accelerations')\n", (13114, 13131), True, 'import matplotlib.pyplot as plt\n'), ((13367, 13381), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (13375, 13381), True, 'import matplotlib.pyplot as plt\n'), ((13491, 13507), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(224)'], {}), '(224)\n', (13502, 13507), True, 'import matplotlib.pyplot as plt\n'), ((13517, 13535), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (13527, 13535), True, 'import matplotlib.pyplot as plt\n'), ((13545, 13563), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""fuel"""'], {}), "('fuel')\n", (13555, 13563), True, 'import matplotlib.pyplot as plt\n'), ((13573, 13591), 'matplotlib.pyplot.title', 'plt.title', (['"""fuels"""'], {}), "('fuels')\n", (13582, 13591), True, 'import matplotlib.pyplot as plt\n'), ((13828, 13842), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (13836, 13842), True, 'import matplotlib.pyplot as plt\n'), ((14280, 14302), 'bokeh.plotting.output_file', 'output_file', (['file_path'], {}), '(file_path)\n', (14291, 14302), False, 'from bokeh.plotting import figure, output_file, show\n'), ((14395, 14484), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""positions"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""position"""'}), "(tools=TOOLS, title='positions', x_axis_label='time', y_axis_label=\n 'position')\n", (14401, 14484), False, 'from bokeh.plotting import figure, output_file, show\n'), ((14927, 15029), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""speed"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""speed"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='speed', x_axis_label='time', y_axis_label=\n 'speed', x_range=s1.x_range)\n", (14933, 15029), False, 'from bokeh.plotting import figure, output_file, show\n'), ((15482, 15598), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""acceleration"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""acceleration"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='acceleration', x_axis_label='time', y_axis_label\n ='acceleration', x_range=s1.x_range)\n", (15488, 15598), False, 'from bokeh.plotting import figure, output_file, show\n'), ((16049, 16160), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""fuel consumption"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""fuel"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='fuel consumption', x_axis_label='time',\n y_axis_label='fuel', x_range=s1.x_range)\n", (16055, 16160), False, 'from bokeh.plotting import figure, output_file, show\n'), ((16612, 16640), 'bokeh.layouts.gridplot', 'gridplot', (['[[s1, s2, s3, s4]]'], {}), '([[s1, s2, s3, s4]])\n', (16620, 16640), False, 'from bokeh.layouts import gridplot\n'), ((16735, 16742), 'bokeh.plotting.show', 'show', (['p'], {}), '(p)\n', (16739, 16742), False, 'from bokeh.plotting import figure, output_file, show\n'), ((3490, 3581), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (['ove.v0', "config.case_speed['speed_merge']", '(-config.control_len)', '(0)'], {}), "(ove.v0, config.case_speed['speed_merge'], -config.\n control_len, 0)\n", (3510, 3581), False, 'from helper import Helper\n'), ((10645, 10674), 'helper.Helper.getTimeMatrix', 'Helper.getTimeMatrix', (['t', 'v.tm'], {}), '(t, v.tm)\n', (10665, 10674), False, 'from helper import Helper\n'), ((10696, 10718), 'helper.Helper.getConfigVec', 'Helper.getConfigVec', (['v'], {}), '(v)\n', (10715, 10718), False, 'from helper import Helper\n'), ((10879, 10901), 'helper.Helper.updateAVP', 'Helper.updateAVP', (['v', 't'], {}), '(v, t)\n', (10895, 10901), False, 'from helper import Helper\n'), ((13984, 14080), 'matplotlib.pyplot.subplots_adjust', 'plt.subplots_adjust', ([], {'top': '(0.92)', 'bottom': '(-0.35)', 'left': '(0.1)', 'right': '(1.35)', 'hspace': '(0.35)', 'wspace': '(0.35)'}), '(top=0.92, bottom=-0.35, left=0.1, right=1.35, hspace=\n 0.35, wspace=0.35)\n', (14003, 14080), True, 'import matplotlib.pyplot as plt\n'), ((14111, 14121), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (14119, 14121), True, 'import matplotlib.pyplot as plt\n'), ((16668, 16675), 'bokeh.plotting.show', 'show', (['p'], {}), '(p)\n', (16672, 16675), False, 'from bokeh.plotting import figure, output_file, show\n'), ((18658, 18680), 'helper.Helper.updateAVP', 'Helper.updateAVP', (['v', 't'], {}), '(v, t)\n', (18674, 18680), False, 'from helper import Helper\n'), ((2534, 2562), 'numpy.array', 'np.array', (['self.speed_history'], {}), '(self.speed_history)\n', (2542, 2562), True, 'import numpy as np\n'), ((4488, 4594), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (["config.case1['speed']", "config.case_speed['speed_merge']", '(-config.control_len)', '(0)'], {}), "(config.case1['speed'], config.case_speed['speed_merge'\n ], -config.control_len, 0)\n", (4508, 4594), False, 'from helper import Helper\n'), ((5158, 5183), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (5172, 5183), True, 'import numpy as np\n'), ((5216, 5241), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (5230, 5241), True, 'import numpy as np\n'), ((7718, 7735), 'numpy.random.randn', 'np.random.randn', ([], {}), '()\n', (7733, 7735), True, 'import numpy as np\n'), ((8120, 8137), 'numpy.random.randn', 'np.random.randn', ([], {}), '()\n', (8135, 8137), True, 'import numpy as np\n'), ((8844, 8869), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (8858, 8869), True, 'import numpy as np\n'), ((8902, 8927), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (8916, 8927), True, 'import numpy as np\n'), ((10749, 10769), 'numpy.linalg.inv', 'np.linalg.inv', (['TimeM'], {}), '(TimeM)\n', (10762, 10769), True, 'import numpy as np\n'), ((11439, 11495), 'numpy.array', 'np.array', (['[v.merge_time for v in self.finished_vehicels]'], {}), '([v.merge_time for v in self.finished_vehicels])\n', (11447, 11495), True, 'import numpy as np\n'), ((11829, 11891), 'numpy.array', 'np.array', (['[v.fuel_consumption for v in self.finished_vehicels]'], {}), '([v.fuel_consumption for v in self.finished_vehicels])\n', (11837, 11891), True, 'import numpy as np\n'), ((12483, 12522), 'os.path.join', 'os.path.join', (['file_path', '"""position.pdf"""'], {}), "(file_path, 'position.pdf')\n", (12495, 12522), False, 'import os\n'), ((12952, 12988), 'os.path.join', 'os.path.join', (['file_path', '"""speed.pdf"""'], {}), "(file_path, 'speed.pdf')\n", (12964, 12988), False, 'import os\n'), ((13430, 13464), 'os.path.join', 'os.path.join', (['file_path', '"""acc.pdf"""'], {}), "(file_path, 'acc.pdf')\n", (13442, 13464), False, 'import os\n'), ((13891, 13926), 'os.path.join', 'os.path.join', (['file_path', '"""fuel.pdf"""'], {}), "(file_path, 'fuel.pdf')\n", (13903, 13926), False, 'import os\n'), ((18265, 18295), 'helper.Helper.getTimeMatrix', 'Helper.getTimeMatrix', (['t', 've.tm'], {}), '(t, ve.tm)\n', (18285, 18295), False, 'from helper import Helper\n'), ((18321, 18344), 'helper.Helper.getConfigVec', 'Helper.getConfigVec', (['ve'], {}), '(ve)\n', (18340, 18344), False, 'from helper import Helper\n'), ((6320, 6335), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (6332, 6335), False, 'from helper import Helper\n'), ((6627, 6642), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (6639, 6642), False, 'from helper import Helper\n'), ((7397, 7423), 'numpy.random.exponential', 'np.random.exponential', (['(5.0)'], {}), '(5.0)\n', (7418, 7423), True, 'import numpy as np\n'), ((7523, 7549), 'numpy.random.exponential', 'np.random.exponential', (['(5.0)'], {}), '(5.0)\n', (7544, 7549), True, 'import numpy as np\n'), ((8021, 8036), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (8033, 8036), False, 'from helper import Helper\n'), ((8423, 8438), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (8435, 8438), False, 'from helper import Helper\n'), ((10316, 10371), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (['v.v0', 'config.speed_merge', 'v.p0', '(0)'], {}), '(v.v0, config.speed_merge, v.p0, 0)\n', (10336, 10371), False, 'from helper import Helper\n'), ((10447, 10490), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.on_board_vehicles[-1]'], {}), '(v, self.on_board_vehicles[-1])\n', (10459, 10490), False, 'from helper import Helper\n'), ((10534, 10577), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.finished_vehicels[-1]'], {}), '(v, self.finished_vehicels[-1])\n', (10546, 10577), False, 'from helper import Helper\n'), ((17808, 17851), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.on_board_vehicles[-1]'], {}), '(v, self.on_board_vehicles[-1])\n', (17820, 17851), False, 'from helper import Helper\n'), ((17895, 17938), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.finished_vehicels[-1]'], {}), '(v, self.finished_vehicels[-1])\n', (17907, 17938), False, 'from helper import Helper\n'), ((18164, 18188), 'helper.Helper.getTm', 'Helper.getTm', (['ve', 'prevve'], {}), '(ve, prevve)\n', (18176, 18188), False, 'from helper import Helper\n'), ((18434, 18454), 'numpy.linalg.inv', 'np.linalg.inv', (['TimeM'], {}), '(TimeM)\n', (18447, 18454), True, 'import numpy as np\n'), ((11693, 11758), 'numpy.array', 'np.array', (['[(1 / v.average_speed) for v in self.finished_vehicels]'], {}), '([(1 / v.average_speed) for v in self.finished_vehicels])\n', (11701, 11758), True, 'import numpy as np\n')] |
import pytest
import datetime
import json
import functools
from urllib.parse import urlencode, parse_qs
from descarteslabs.common.graft import client as graft_client
from ... import types
from .. import tile_url
def test_url():
base = "foo"
base_q = base + "?"
url = functools.partial(tile_url.tile_url, base, types.Image.from_id(""))
assert url() == base
assert url(session_id="foo") == base_q + urlencode({"session_id": "foo"})
assert url(colormap="foo") == base_q + urlencode({"colormap": "foo"})
assert url(colormap="") == base_q + urlencode({"colormap": ""})
assert url(reduction="mean") == base_q + urlencode({"reduction": "mean"})
assert url(checkerboard=True) == base_q + urlencode({"checkerboard": "true"})
assert url(checkerboard=False) == base_q + urlencode({"checkerboard": "false"})
assert url(bands=["red"]) == base_q + urlencode({"band": "red"})
assert url(bands=["red", "green"]) == base_q + urlencode(
{"band": ["red", "green"]}, doseq=True
)
with pytest.raises(ValueError, match="Up to 3 bands may be specified, not 4"):
url(bands=["a", "b", "c", "d"])
# 1-band scales are normalized
assert url(scales=[0, 1]) == base_q + urlencode({"scales": "[[0.0, 1.0]]"})
# If all none scales, not included
assert url(scales=[None, None]) == base_q + urlencode({"scales": "null"})
# test everything gets added together correctly
got_base, params = url(
session_id="foo", colormap="bar", bands=["red", "green"]
).split("?")
assert got_base == base
query = parse_qs(params, strict_parsing=True, keep_blank_values=True)
assert query == {
# `parse_qs` returns all values wrapped in lists
"session_id": ["foo"],
"colormap": ["bar"],
"band": ["red", "green"],
}
@pytest.mark.parametrize(
"args",
[
{
"p1": "2021-01-20",
"p2": 2.2,
"p3": 1,
},
{
"p1": datetime.datetime(2020, 1, 20),
"p2": types.Float(1.1) + 1,
"p3": 1,
},
{
"p1": types.Datetime(2021, 1, 20),
"p2": types.Float(1.1) + 1,
"p3": types.Int(1),
},
],
)
def test_url_arguments(args):
func = types.Function[
dict(p1=types.Datetime, p2=types.Float, p3=types.Int), types.Image
]("x")
base = "http://base.net"
url = functools.partial(tile_url.tile_url, base, func)
with pytest.raises(TypeError, match="missing a required argument"):
url()
with pytest.raises(TypeError, match="got an unexpected keyword argument 'blah'"):
url(**args, blah="bad")
with graft_client.consistent_guid():
got_base, params = url(**args).split("?")
assert got_base == base
query = parse_qs(params, strict_parsing=True, keep_blank_values=True)
assert query.keys() == args.keys()
with graft_client.consistent_guid():
p1_graft = types.Datetime._promote(args["p1"]).graft
assert query["p1"] == [json.dumps(p1_graft)]
if isinstance(args["p2"], float):
assert query["p2"] == ["2.2"]
else:
assert query["p2"] == [json.dumps(args["p2"].graft)]
assert query["p3"] == ["1"]
def test_no_url_for_positional_only_function():
with pytest.raises(
TypeError, match="cannot use Functions with positional-only arguments"
):
tile_url.tile_url("", types.Function[types.Int, {}, types.Image]("x"))
def test_validate_scales():
assert tile_url.validate_scales([[0.0, 1.0], [0.0, 2.0], [-1.0, 1.0]]) == [
[0.0, 1.0],
[0.0, 2.0],
[-1.0, 1.0],
]
assert tile_url.validate_scales([[0.0, 1.0]]) == [[0.0, 1.0]]
# ints -> floats
assert tile_url.validate_scales([[0, 1]]) == [[0.0, 1.0]]
# 1-band convenience
assert tile_url.validate_scales([0, 1]) == [[0.0, 1.0]]
# no scalings
assert tile_url.validate_scales(None) == []
assert tile_url.validate_scales([]) == []
with pytest.raises(TypeError, match="Expected a list or tuple of scales"):
tile_url.validate_scales(0)
with pytest.raises(TypeError, match="Expected a list or tuple of scales"):
tile_url.validate_scales("foo")
with pytest.raises(TypeError, match="Scaling 0: expected a 2-item list or tuple"):
tile_url.validate_scales([1, 2, 3])
with pytest.raises(TypeError, match="Scaling 0: items in scaling must be numbers"):
tile_url.validate_scales([1, "foo"])
with pytest.raises(ValueError, match="expected up to 3 scales, but got 4"):
tile_url.validate_scales([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]])
with pytest.raises(ValueError, match="but length was 3"):
tile_url.validate_scales([[0.0, 1.0, 2.0]])
with pytest.raises(ValueError, match="but length was 1"):
tile_url.validate_scales([[0.0]])
with pytest.raises(ValueError, match="one number and one None in scales"):
tile_url.validate_scales([[None, 1.0]])
| [
"datetime.datetime",
"descarteslabs.common.graft.client.consistent_guid",
"json.dumps",
"urllib.parse.parse_qs",
"functools.partial",
"pytest.raises",
"urllib.parse.urlencode"
] | [((1587, 1648), 'urllib.parse.parse_qs', 'parse_qs', (['params'], {'strict_parsing': '(True)', 'keep_blank_values': '(True)'}), '(params, strict_parsing=True, keep_blank_values=True)\n', (1595, 1648), False, 'from urllib.parse import urlencode, parse_qs\n'), ((2434, 2482), 'functools.partial', 'functools.partial', (['tile_url.tile_url', 'base', 'func'], {}), '(tile_url.tile_url, base, func)\n', (2451, 2482), False, 'import functools\n'), ((2821, 2882), 'urllib.parse.parse_qs', 'parse_qs', (['params'], {'strict_parsing': '(True)', 'keep_blank_values': '(True)'}), '(params, strict_parsing=True, keep_blank_values=True)\n', (2829, 2882), False, 'from urllib.parse import urlencode, parse_qs\n'), ((1037, 1109), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""Up to 3 bands may be specified, not 4"""'}), "(ValueError, match='Up to 3 bands may be specified, not 4')\n", (1050, 1109), False, 'import pytest\n'), ((2493, 2554), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""missing a required argument"""'}), "(TypeError, match='missing a required argument')\n", (2506, 2554), False, 'import pytest\n'), ((2579, 2654), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""got an unexpected keyword argument \'blah\'"""'}), '(TypeError, match="got an unexpected keyword argument \'blah\'")\n', (2592, 2654), False, 'import pytest\n'), ((2698, 2728), 'descarteslabs.common.graft.client.consistent_guid', 'graft_client.consistent_guid', ([], {}), '()\n', (2726, 2728), True, 'from descarteslabs.common.graft import client as graft_client\n'), ((2932, 2962), 'descarteslabs.common.graft.client.consistent_guid', 'graft_client.consistent_guid', ([], {}), '()\n', (2960, 2962), True, 'from descarteslabs.common.graft import client as graft_client\n'), ((3314, 3404), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""cannot use Functions with positional-only arguments"""'}), "(TypeError, match=\n 'cannot use Functions with positional-only arguments')\n", (3327, 3404), False, 'import pytest\n'), ((4027, 4095), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""Expected a list or tuple of scales"""'}), "(TypeError, match='Expected a list or tuple of scales')\n", (4040, 4095), False, 'import pytest\n'), ((4142, 4210), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""Expected a list or tuple of scales"""'}), "(TypeError, match='Expected a list or tuple of scales')\n", (4155, 4210), False, 'import pytest\n'), ((4261, 4337), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""Scaling 0: expected a 2-item list or tuple"""'}), "(TypeError, match='Scaling 0: expected a 2-item list or tuple')\n", (4274, 4337), False, 'import pytest\n'), ((4392, 4469), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""Scaling 0: items in scaling must be numbers"""'}), "(TypeError, match='Scaling 0: items in scaling must be numbers')\n", (4405, 4469), False, 'import pytest\n'), ((4525, 4594), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""expected up to 3 scales, but got 4"""'}), "(ValueError, match='expected up to 3 scales, but got 4')\n", (4538, 4594), False, 'import pytest\n'), ((4688, 4739), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""but length was 3"""'}), "(ValueError, match='but length was 3')\n", (4701, 4739), False, 'import pytest\n'), ((4802, 4853), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""but length was 1"""'}), "(ValueError, match='but length was 1')\n", (4815, 4853), False, 'import pytest\n'), ((4906, 4974), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""one number and one None in scales"""'}), "(ValueError, match='one number and one None in scales')\n", (4919, 4974), False, 'import pytest\n'), ((424, 456), 'urllib.parse.urlencode', 'urlencode', (["{'session_id': 'foo'}"], {}), "({'session_id': 'foo'})\n", (433, 456), False, 'from urllib.parse import urlencode, parse_qs\n'), ((500, 530), 'urllib.parse.urlencode', 'urlencode', (["{'colormap': 'foo'}"], {}), "({'colormap': 'foo'})\n", (509, 530), False, 'from urllib.parse import urlencode, parse_qs\n'), ((571, 598), 'urllib.parse.urlencode', 'urlencode', (["{'colormap': ''}"], {}), "({'colormap': ''})\n", (580, 598), False, 'from urllib.parse import urlencode, parse_qs\n'), ((644, 676), 'urllib.parse.urlencode', 'urlencode', (["{'reduction': 'mean'}"], {}), "({'reduction': 'mean'})\n", (653, 676), False, 'from urllib.parse import urlencode, parse_qs\n'), ((723, 758), 'urllib.parse.urlencode', 'urlencode', (["{'checkerboard': 'true'}"], {}), "({'checkerboard': 'true'})\n", (732, 758), False, 'from urllib.parse import urlencode, parse_qs\n'), ((806, 842), 'urllib.parse.urlencode', 'urlencode', (["{'checkerboard': 'false'}"], {}), "({'checkerboard': 'false'})\n", (815, 842), False, 'from urllib.parse import urlencode, parse_qs\n'), ((886, 912), 'urllib.parse.urlencode', 'urlencode', (["{'band': 'red'}"], {}), "({'band': 'red'})\n", (895, 912), False, 'from urllib.parse import urlencode, parse_qs\n'), ((964, 1013), 'urllib.parse.urlencode', 'urlencode', (["{'band': ['red', 'green']}"], {'doseq': '(True)'}), "({'band': ['red', 'green']}, doseq=True)\n", (973, 1013), False, 'from urllib.parse import urlencode, parse_qs\n'), ((1229, 1266), 'urllib.parse.urlencode', 'urlencode', (["{'scales': '[[0.0, 1.0]]'}"], {}), "({'scales': '[[0.0, 1.0]]'})\n", (1238, 1266), False, 'from urllib.parse import urlencode, parse_qs\n'), ((1354, 1383), 'urllib.parse.urlencode', 'urlencode', (["{'scales': 'null'}"], {}), "({'scales': 'null'})\n", (1363, 1383), False, 'from urllib.parse import urlencode, parse_qs\n'), ((3052, 3072), 'json.dumps', 'json.dumps', (['p1_graft'], {}), '(p1_graft)\n', (3062, 3072), False, 'import json\n'), ((1999, 2029), 'datetime.datetime', 'datetime.datetime', (['(2020)', '(1)', '(20)'], {}), '(2020, 1, 20)\n', (2016, 2029), False, 'import datetime\n'), ((3192, 3220), 'json.dumps', 'json.dumps', (["args['p2'].graft"], {}), "(args['p2'].graft)\n", (3202, 3220), False, 'import json\n')] |
# Generated by Django 3.0.2 on 2020-01-31 20:33
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('collections', '0002_auto_20200109_1348'),
]
operations = [
migrations.AlterField(
model_name='collection',
name='comment',
field=models.CharField(help_text='Comment for collection.', max_length=256, verbose_name='Comment'),
),
migrations.AlterField(
model_name='collection',
name='expired_on',
field=models.DateTimeField(help_text='An expiration date of collection.', verbose_name='An expiration date'),
),
migrations.AlterField(
model_name='collection',
name='public',
field=models.BooleanField(default=False, help_text='Make public.', verbose_name='Public'),
),
migrations.AlterField(
model_name='collection',
name='query',
field=models.CharField(help_text='Query for collection.', max_length=256, verbose_name='Query'),
),
]
| [
"django.db.models.DateTimeField",
"django.db.models.CharField",
"django.db.models.BooleanField"
] | [((345, 442), 'django.db.models.CharField', 'models.CharField', ([], {'help_text': '"""Comment for collection."""', 'max_length': '(256)', 'verbose_name': '"""Comment"""'}), "(help_text='Comment for collection.', max_length=256,\n verbose_name='Comment')\n", (361, 442), False, 'from django.db import migrations, models\n'), ((568, 674), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'help_text': '"""An expiration date of collection."""', 'verbose_name': '"""An expiration date"""'}), "(help_text='An expiration date of collection.',\n verbose_name='An expiration date')\n", (588, 674), False, 'from django.db import migrations, models\n'), ((796, 884), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)', 'help_text': '"""Make public."""', 'verbose_name': '"""Public"""'}), "(default=False, help_text='Make public.', verbose_name=\n 'Public')\n", (815, 884), False, 'from django.db import migrations, models\n'), ((1004, 1097), 'django.db.models.CharField', 'models.CharField', ([], {'help_text': '"""Query for collection."""', 'max_length': '(256)', 'verbose_name': '"""Query"""'}), "(help_text='Query for collection.', max_length=256,\n verbose_name='Query')\n", (1020, 1097), False, 'from django.db import migrations, models\n')] |
# -*- coding: utf-8 -*-
import os
import torch
from torch.autograd import Variable
import numpy as np
import scipy
import matplotlib.pyplot as plt
import cv2
import scipy.ndimage
import shutil
import scipy.misc as misc
from PIL import Image
def mkdirs(folders, erase=False):
if type(folders) is not list:
folders = [folders]
for fold in folders:
if not os.path.exists(fold):
os.makedirs(fold)
else:
if erase:
shutil.rmtree(fold)
os.makedirs(fold)
def normalize_img(X):
min_, max_ = np.min(X), np.max(X)
X = (X - min_) / (max_ - min_ + 1e-9)
X = X * 255
return X.astype(np.uint8)
def imread(imgfile):
assert os.path.exists(imgfile), '{} does not exist!'.format(imgfile)
srcBGR = cv2.imread(imgfile)
destRGB = cv2.cvtColor(srcBGR, cv2.COLOR_BGR2RGB)
return destRGB
def writeImg(array, savepath):
scipy.misc.imsave(savepath, array)
def imresize(img, resizeratio=1):
'''Take care of cv2 reshape squeeze behevaior'''
if resizeratio == 1:
return img
outshape = (int(img.shape[1] * resizeratio), int(img.shape[0] * resizeratio))
# temp = cv2.resize(img, outshape).astype(float)
temp = misc.imresize(img, size=outshape).astype(float)
if len(img.shape) == 3 and img.shape[2] == 1:
temp = np.reshape(temp, temp.shape + (1,))
return temp
def imresize_shape(img, outshape):
if len(img.shape) == 3:
if img.shape[0] == 1 or img.shape[0] == 3:
transpose_img = np.transpose(img, (1, 2, 0))
_img = imresize_shape(transpose_img, outshape)
return np.transpose(_img, (2, 0, 1))
if len(img.shape) == 4:
img_out = []
for this_img in img:
img_out.append(imresize_shape(this_img, outshape))
return np.stack(img_out, axis=0)
img = img.astype(np.float32)
outshape = (int(outshape[1]), int(outshape[0]))
# temp = cv2.resize(img, outshape).astype(float)
temp = misc.imresize(img, size=outshape, interp='bilinear').astype(float)
if len(img.shape) == 3 and img.shape[2] == 1:
temp = np.reshape(temp, temp.shape + (1,))
return temp
def imshow(img, size=None):
if size is not None:
plt.figure(figsize=size)
else:
plt.figure()
plt.imshow(img)
plt.show()
def Indexflow(Totalnum, batch_size, random=True):
numberofchunk = int(Totalnum + batch_size - 1) // int(batch_size) # the floor
# Chunkfile = np.zeros((batch_size, row*col*channel))
totalIndx = np.arange(Totalnum).astype(np.int)
if random is True:
totalIndx = np.random.permutation(totalIndx)
chunkstart = 0
for chunkidx in range(int(numberofchunk)):
thisnum = min(batch_size, Totalnum - chunkidx * batch_size)
thisInd = totalIndx[chunkstart: chunkstart + thisnum]
chunkstart += thisnum
yield thisInd
def IndexH5(h5_array, indices):
read_list = []
for idx in indices:
read_list.append(h5_array[idx])
return np.stack(read_list, 0)
def ensure_dir(path):
if not os.path.exists(path):
os.makedirs(path)
def word_list(word_idx_list, vocab):
"""Take a list of word ids and a vocabulary from a dataset as inputs
and return the corresponding words as a list.
"""
word_list = []
for i in range(len(word_idx_list)):
vocab_id = word_idx_list[i]
word = vocab.idx2word[vocab_id]
if word == vocab.end_word:
break
if word != vocab.start_word:
word_list.append(word)
return word_list
def clean_sentence(word_idx_list, vocab):
"""Take a list of word ids and a vocabulary from a dataset as inputs
and return the corresponding sentence (as a single Python string).
"""
sentence = []
for i in range(len(word_idx_list)):
vocab_id = word_idx_list[i]
word = vocab.idx2word[vocab_id]
if word == vocab.end_word:
break
if word != vocab.start_word:
sentence.append(word)
sentence = " ".join(sentence)
return sentence
def get_end_symbol_index(caption_list):
if 1 in caption_list:
return caption_list.index(1) + 1
else:
return len(caption_list)
def get_caption_lengths(captions_list):
caption_lengths = [get_end_symbol_index(caption) for caption in captions_list]
caption_lengths.sort(reverse=True)
batch_captions = torch.zeros(len(captions_list), max(caption_lengths)).long()
caption_lengths = torch.LongTensor(caption_lengths)
for i, cap in enumerate(captions_list):
end = caption_lengths[i]
batch_captions[i, :end] = torch.tensor(cap[:end]).long()
if torch.cuda.is_available():
batch_captions = batch_captions.cuda()
caption_lengths = caption_lengths.cuda()
return batch_captions, caption_lengths
def to_numpy(src):
if type(src) == np.ndarray:
return src
elif type(src) == Variable:
x = src.data
else:
x = src
return x.detach().cpu().numpy()
def tensor2im(input_image, imtype=np.uint8):
""""Converts a Tensor array into a numpy image array.
Parameters:
input_image (tensor) -- the input image tensor array
imtype (type) -- the desired type of the converted numpy array
"""
if not isinstance(input_image, np.ndarray):
if isinstance(input_image, torch.Tensor): # get the data from a variable
image_tensor = input_image.data
else:
return input_image
image_numpy = image_tensor[0].cpu().float().numpy() # convert it into a numpy array
if image_numpy.shape[0] == 1: # grayscale to RGB
image_numpy = np.tile(image_numpy, (3, 1, 1))
image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0 # post-processing: tranpose and scaling
else: # if it is a numpy array, do nothing
image_numpy = input_image
return image_numpy.astype(imtype)
def diagnose_network(net, name='network'):
"""Calculate and print the mean of average absolute(gradients)
Parameters:
net (torch network) -- Torch network
name (str) -- the name of the network
"""
mean = 0.0
count = 0
for param in net.parameters():
if param.grad is not None:
mean += torch.mean(torch.abs(param.grad.data))
count += 1
if count > 0:
mean = mean / count
print(name)
print(mean)
def save_image(image_numpy, image_path):
"""Save a numpy image to the disk
Parameters:
image_numpy (numpy array) -- input numpy array
image_path (str) -- the path of the image
"""
image_pil = Image.fromarray(image_numpy)
image_pil.save(image_path)
def print_numpy(x, val=True, shp=False):
"""Print the mean, min, max, median, std, and size of a numpy array
Parameters:
val (bool) -- if print the values of the numpy array
shp (bool) -- if print the shape of the numpy array
"""
x = x.astype(np.float64)
if shp:
print('shape,', x.shape)
if val:
x = x.flatten()
print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x)))
def mkdirs(paths):
"""create empty directories if they don't exist
Parameters:
paths (str list) -- a list of directory paths
"""
if isinstance(paths, list) and not isinstance(paths, str):
for path in paths:
mkdir(path)
else:
mkdir(paths)
def mkdir(path):
"""create a single empty directory if it didn't exist
Parameters:
path (str) -- a single directory path
"""
if not os.path.exists(path):
os.makedirs(path)
def convert_back_to_text(word_idx_array, vocab):
from itertools import takewhile
blacklist = [vocab.word2idx[word] for word in [vocab.start_word]]
predicate = lambda word_id: vocab.idx2word[word_id] != vocab.end_word
sampled_caption = [vocab.idx2word[word_id] for word_id in takewhile(predicate, word_idx_array) if word_id not in blacklist]
sentence = '-'.join(sampled_caption)
return sentence | [
"torch.LongTensor",
"torch.cuda.is_available",
"scipy.misc.imresize",
"numpy.arange",
"matplotlib.pyplot.imshow",
"os.path.exists",
"numpy.mean",
"numpy.reshape",
"scipy.misc.imsave",
"numpy.max",
"numpy.stack",
"numpy.min",
"numpy.random.permutation",
"numpy.tile",
"torch.abs",
"itert... | [((724, 747), 'os.path.exists', 'os.path.exists', (['imgfile'], {}), '(imgfile)\n', (738, 747), False, 'import os\n'), ((799, 818), 'cv2.imread', 'cv2.imread', (['imgfile'], {}), '(imgfile)\n', (809, 818), False, 'import cv2\n'), ((833, 872), 'cv2.cvtColor', 'cv2.cvtColor', (['srcBGR', 'cv2.COLOR_BGR2RGB'], {}), '(srcBGR, cv2.COLOR_BGR2RGB)\n', (845, 872), False, 'import cv2\n'), ((929, 963), 'scipy.misc.imsave', 'scipy.misc.imsave', (['savepath', 'array'], {}), '(savepath, array)\n', (946, 963), False, 'import scipy\n'), ((2330, 2345), 'matplotlib.pyplot.imshow', 'plt.imshow', (['img'], {}), '(img)\n', (2340, 2345), True, 'import matplotlib.pyplot as plt\n'), ((2350, 2360), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (2358, 2360), True, 'import matplotlib.pyplot as plt\n'), ((3058, 3080), 'numpy.stack', 'np.stack', (['read_list', '(0)'], {}), '(read_list, 0)\n', (3066, 3080), True, 'import numpy as np\n'), ((4542, 4575), 'torch.LongTensor', 'torch.LongTensor', (['caption_lengths'], {}), '(caption_lengths)\n', (4558, 4575), False, 'import torch\n'), ((4726, 4751), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (4749, 4751), False, 'import torch\n'), ((6739, 6767), 'PIL.Image.fromarray', 'Image.fromarray', (['image_numpy'], {}), '(image_numpy)\n', (6754, 6767), False, 'from PIL import Image\n'), ((581, 590), 'numpy.min', 'np.min', (['X'], {}), '(X)\n', (587, 590), True, 'import numpy as np\n'), ((592, 601), 'numpy.max', 'np.max', (['X'], {}), '(X)\n', (598, 601), True, 'import numpy as np\n'), ((1356, 1391), 'numpy.reshape', 'np.reshape', (['temp', '(temp.shape + (1,))'], {}), '(temp, temp.shape + (1,))\n', (1366, 1391), True, 'import numpy as np\n'), ((1845, 1870), 'numpy.stack', 'np.stack', (['img_out'], {'axis': '(0)'}), '(img_out, axis=0)\n', (1853, 1870), True, 'import numpy as np\n'), ((2155, 2190), 'numpy.reshape', 'np.reshape', (['temp', '(temp.shape + (1,))'], {}), '(temp, temp.shape + (1,))\n', (2165, 2190), True, 'import numpy as np\n'), ((2270, 2294), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'size'}), '(figsize=size)\n', (2280, 2294), True, 'import matplotlib.pyplot as plt\n'), ((2313, 2325), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (2323, 2325), True, 'import matplotlib.pyplot as plt\n'), ((2648, 2680), 'numpy.random.permutation', 'np.random.permutation', (['totalIndx'], {}), '(totalIndx)\n', (2669, 2680), True, 'import numpy as np\n'), ((3116, 3136), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (3130, 3136), False, 'import os\n'), ((3146, 3163), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (3157, 3163), False, 'import os\n'), ((7781, 7801), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (7795, 7801), False, 'import os\n'), ((7811, 7828), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (7822, 7828), False, 'import os\n'), ((382, 402), 'os.path.exists', 'os.path.exists', (['fold'], {}), '(fold)\n', (396, 402), False, 'import os\n'), ((416, 433), 'os.makedirs', 'os.makedirs', (['fold'], {}), '(fold)\n', (427, 433), False, 'import os\n'), ((1243, 1276), 'scipy.misc.imresize', 'misc.imresize', (['img'], {'size': 'outshape'}), '(img, size=outshape)\n', (1256, 1276), True, 'import scipy.misc as misc\n'), ((1552, 1580), 'numpy.transpose', 'np.transpose', (['img', '(1, 2, 0)'], {}), '(img, (1, 2, 0))\n', (1564, 1580), True, 'import numpy as np\n'), ((1659, 1688), 'numpy.transpose', 'np.transpose', (['_img', '(2, 0, 1)'], {}), '(_img, (2, 0, 1))\n', (1671, 1688), True, 'import numpy as np\n'), ((2022, 2074), 'scipy.misc.imresize', 'misc.imresize', (['img'], {'size': 'outshape', 'interp': '"""bilinear"""'}), "(img, size=outshape, interp='bilinear')\n", (2035, 2074), True, 'import scipy.misc as misc\n'), ((2570, 2589), 'numpy.arange', 'np.arange', (['Totalnum'], {}), '(Totalnum)\n', (2579, 2589), True, 'import numpy as np\n'), ((5746, 5777), 'numpy.tile', 'np.tile', (['image_numpy', '(3, 1, 1)'], {}), '(image_numpy, (3, 1, 1))\n', (5753, 5777), True, 'import numpy as np\n'), ((8122, 8158), 'itertools.takewhile', 'takewhile', (['predicate', 'word_idx_array'], {}), '(predicate, word_idx_array)\n', (8131, 8158), False, 'from itertools import takewhile\n'), ((486, 505), 'shutil.rmtree', 'shutil.rmtree', (['fold'], {}), '(fold)\n', (499, 505), False, 'import shutil\n'), ((522, 539), 'os.makedirs', 'os.makedirs', (['fold'], {}), '(fold)\n', (533, 539), False, 'import os\n'), ((4687, 4710), 'torch.tensor', 'torch.tensor', (['cap[:end]'], {}), '(cap[:end])\n', (4699, 4710), False, 'import torch\n'), ((6375, 6401), 'torch.abs', 'torch.abs', (['param.grad.data'], {}), '(param.grad.data)\n', (6384, 6401), False, 'import torch\n'), ((5801, 5837), 'numpy.transpose', 'np.transpose', (['image_numpy', '(1, 2, 0)'], {}), '(image_numpy, (1, 2, 0))\n', (5813, 5837), True, 'import numpy as np\n'), ((7267, 7277), 'numpy.mean', 'np.mean', (['x'], {}), '(x)\n', (7274, 7277), True, 'import numpy as np\n'), ((7279, 7288), 'numpy.min', 'np.min', (['x'], {}), '(x)\n', (7285, 7288), True, 'import numpy as np\n'), ((7290, 7299), 'numpy.max', 'np.max', (['x'], {}), '(x)\n', (7296, 7299), True, 'import numpy as np\n'), ((7301, 7313), 'numpy.median', 'np.median', (['x'], {}), '(x)\n', (7310, 7313), True, 'import numpy as np\n'), ((7315, 7324), 'numpy.std', 'np.std', (['x'], {}), '(x)\n', (7321, 7324), True, 'import numpy as np\n')] |
from flask import render_template
from app import app, html_generator
import app.calculator.calculator as calc
from app.route_helpers import units_from_form, options_from_form, options_list, flash_errors
from app.forms import InputForm
from collections import defaultdict
@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
def index():
form = InputForm()
if form.validate_on_submit():
attacker, defender = units_from_form(form)
options = options_from_form(form)
outcomes = calc.calculate(attacker, defender, options, test=False)
defaults = form
checkboxes = defaultdict(lambda: "")
for opt in options.keys():
checkboxes[opt] = "checked" if options[opt] else ""
hidden = defaultdict(lambda: False)
for opt in options.keys():
if "hide" in opt:
if "att_" in opt and not options["att_faction"].lower().split("-")[0] in opt:
hidden[opt] = True
if "def_" in opt and not options["def_faction"].lower().split("-")[0] in opt:
hidden[opt] = True
boxes = html_generator.make_boxes(checkboxes, hidden)
return render_template('index.html', outcomes=outcomes, form=form, defaults=defaults, checkboxes=checkboxes,
boxes=boxes)
else:
print("in else")
flash_errors(form)
outcomes = [0, 0, 0]
defaults = defaultdict(lambda: {"data": "0"})
checkboxes = defaultdict(lambda: "")
checkboxes["att_riskdirecthit"] = "checked"
checkboxes["def_riskdirecthit"] = "checked"
hidden = defaultdict(lambda: False)
for opt in options_list():
if "hide" in opt:
hidden[opt] = True
boxes = html_generator.make_boxes(checkboxes, hidden)
return render_template('index.html', outcomes=outcomes, form=form, defaults=defaults, checkboxes=checkboxes,
boxes=boxes)
| [
"flask.render_template",
"app.route_helpers.units_from_form",
"app.html_generator.make_boxes",
"app.forms.InputForm",
"app.route_helpers.options_list",
"app.calculator.calculator.calculate",
"collections.defaultdict",
"app.app.route",
"app.route_helpers.flash_errors",
"app.route_helpers.options_fr... | [((275, 314), 'app.app.route', 'app.route', (['"""/"""'], {'methods': "['GET', 'POST']"}), "('/', methods=['GET', 'POST'])\n", (284, 314), False, 'from app import app, html_generator\n'), ((316, 360), 'app.app.route', 'app.route', (['"""/index"""'], {'methods': "['GET', 'POST']"}), "('/index', methods=['GET', 'POST'])\n", (325, 360), False, 'from app import app, html_generator\n'), ((385, 396), 'app.forms.InputForm', 'InputForm', ([], {}), '()\n', (394, 396), False, 'from app.forms import InputForm\n'), ((1472, 1507), 'collections.defaultdict', 'defaultdict', (["(lambda : {'data': '0'})"], {}), "(lambda : {'data': '0'})\n", (1483, 1507), False, 'from collections import defaultdict\n'), ((1525, 1549), 'collections.defaultdict', 'defaultdict', (["(lambda : '')"], {}), "(lambda : '')\n", (1536, 1549), False, 'from collections import defaultdict\n'), ((1659, 1686), 'collections.defaultdict', 'defaultdict', (['(lambda : False)'], {}), '(lambda : False)\n', (1670, 1686), False, 'from collections import defaultdict\n'), ((1701, 1715), 'app.route_helpers.options_list', 'options_list', ([], {}), '()\n', (1713, 1715), False, 'from app.route_helpers import units_from_form, options_from_form, options_list, flash_errors\n'), ((1787, 1832), 'app.html_generator.make_boxes', 'html_generator.make_boxes', (['checkboxes', 'hidden'], {}), '(checkboxes, hidden)\n', (1812, 1832), False, 'from app import app, html_generator\n'), ((1845, 1964), 'flask.render_template', 'render_template', (['"""index.html"""'], {'outcomes': 'outcomes', 'form': 'form', 'defaults': 'defaults', 'checkboxes': 'checkboxes', 'boxes': 'boxes'}), "('index.html', outcomes=outcomes, form=form, defaults=\n defaults, checkboxes=checkboxes, boxes=boxes)\n", (1860, 1964), False, 'from flask import render_template\n'), ((460, 481), 'app.route_helpers.units_from_form', 'units_from_form', (['form'], {}), '(form)\n', (475, 481), False, 'from app.route_helpers import units_from_form, options_from_form, options_list, flash_errors\n'), ((500, 523), 'app.route_helpers.options_from_form', 'options_from_form', (['form'], {}), '(form)\n', (517, 523), False, 'from app.route_helpers import units_from_form, options_from_form, options_list, flash_errors\n'), ((543, 598), 'app.calculator.calculator.calculate', 'calc.calculate', (['attacker', 'defender', 'options'], {'test': '(False)'}), '(attacker, defender, options, test=False)\n', (557, 598), True, 'import app.calculator.calculator as calc\n'), ((645, 669), 'collections.defaultdict', 'defaultdict', (["(lambda : '')"], {}), "(lambda : '')\n", (656, 669), False, 'from collections import defaultdict\n'), ((786, 813), 'collections.defaultdict', 'defaultdict', (['(lambda : False)'], {}), '(lambda : False)\n', (797, 813), False, 'from collections import defaultdict\n'), ((1161, 1206), 'app.html_generator.make_boxes', 'html_generator.make_boxes', (['checkboxes', 'hidden'], {}), '(checkboxes, hidden)\n', (1186, 1206), False, 'from app import app, html_generator\n'), ((1223, 1342), 'flask.render_template', 'render_template', (['"""index.html"""'], {'outcomes': 'outcomes', 'form': 'form', 'defaults': 'defaults', 'checkboxes': 'checkboxes', 'boxes': 'boxes'}), "('index.html', outcomes=outcomes, form=form, defaults=\n defaults, checkboxes=checkboxes, boxes=boxes)\n", (1238, 1342), False, 'from flask import render_template\n'), ((1412, 1430), 'app.route_helpers.flash_errors', 'flash_errors', (['form'], {}), '(form)\n', (1424, 1430), False, 'from app.route_helpers import units_from_form, options_from_form, options_list, flash_errors\n')] |
import re
def find_indices():
return [m.start(0) for m in re.finditer(reg, content)]
def find_content():
return re.findall(reg, content)
if __name__ == "__main__":
content = 'an example word:cat and word:dog'
reg = r'word:\w'
print(find_indices())
print(find_content())
| [
"re.findall",
"re.finditer"
] | [((124, 148), 're.findall', 're.findall', (['reg', 'content'], {}), '(reg, content)\n', (134, 148), False, 'import re\n'), ((64, 89), 're.finditer', 're.finditer', (['reg', 'content'], {}), '(reg, content)\n', (75, 89), False, 'import re\n')] |
import smart_imports
smart_imports.all()
class AccountPrototypeTests(utils_testcase.TestCase, personal_messages_helpers.Mixin):
def setUp(self):
super(AccountPrototypeTests, self).setUp()
self.place_1, self.place_2, self.place_3 = game_logic.create_test_map()
self.account = self.accounts_factory.create_account()
self.fast_account = self.accounts_factory.create_account(is_fast=True)
personal_messages_tt_services.personal_messages.cmd_debug_clear_service()
def test_create(self):
self.assertTrue(self.account.active_end_at > datetime.datetime.now() + datetime.timedelta(seconds=conf.settings.ACTIVE_STATE_TIMEOUT - 60))
def test_get_achievement_type_value(self):
for achievement_type in achievements_relations.ACHIEVEMENT_TYPE.records:
if achievement_type.source.is_GAME_OBJECT:
continue
if achievement_type.source.is_NONE:
continue
self.account.get_achievement_type_value(achievement_type)
@mock.patch('the_tale.accounts.conf.settings.ACTIVE_STATE_REFRESH_PERIOD', 0)
def test_update_active_state__expired(self):
self.assertTrue(self.account.is_update_active_state_needed)
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as cmd_mark_hero_as_active:
self.account.update_active_state()
self.assertEqual(cmd_mark_hero_as_active.call_count, 1)
def test_update_active_state__not_expired(self):
self.assertFalse(self.account.is_update_active_state_needed)
def test_change_credentials(self):
self.assertTrue(prototypes.AccountPrototype.get_by_id(self.fast_account.id).is_fast)
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as fake_cmd:
with mock.patch('the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method') as cmd_run_account_method:
self.fast_account.change_credentials(new_email='<EMAIL>', new_password=django_auth_hashers.make_password('<PASSWORD>'), new_nick='test_nick')
self.assertEqual(cmd_run_account_method.call_count, 0)
self.assertEqual(django_auth.authenticate(nick='test_nick', password='<PASSWORD>').id, self.fast_account.id)
self.assertFalse(prototypes.AccountPrototype.get_by_id(self.fast_account.id).is_fast)
self.assertEqual(fake_cmd.call_count, 1)
self.assertFalse(fake_cmd.call_args[1]['is_fast'])
def test_change_credentials__with_referral(self):
self.fast_account._model.referral_of = self.account._model
self.fast_account.save()
self.assertTrue(prototypes.AccountPrototype.get_by_id(self.fast_account.id).is_fast)
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as fake_cmd:
with mock.patch('the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method') as cmd_run_account_method:
self.fast_account.change_credentials(new_email='<EMAIL>', new_password=django_auth_hashers.make_password('<PASSWORD>'), new_nick='test_nick')
self.assertEqual(cmd_run_account_method.call_count, 1)
self.assertEqual(cmd_run_account_method.call_args, mock.call(account_id=self.account.id,
method_name=prototypes.AccountPrototype.update_referrals_number.__name__,
data={}))
self.assertEqual(django_auth.authenticate(nick='test_nick', password='<PASSWORD>').id, self.fast_account.id)
self.assertFalse(prototypes.AccountPrototype.get_by_id(self.fast_account.id).is_fast)
self.assertEqual(fake_cmd.call_count, 1)
self.assertFalse(fake_cmd.call_args[1]['is_fast'])
def test_change_credentials_password(self):
nick = self.account.nick
email = self.account.email
self.account.change_credentials(new_password=django_auth_hashers.make_password('<PASSWORD>'))
self.assertEqual(post_service_models.Message.objects.all().count(), 0)
self.assertEqual(self.account.email, email)
user = django_auth.authenticate(nick=nick, password='<PASSWORD>')
self.assertEqual(user.id, self.account.id)
def test_change_credentials_nick(self):
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as fake_cmd:
self.account.change_credentials(new_nick='test_nick')
self.assertEqual(post_service_models.Message.objects.all().count(), 0)
self.assertEqual(fake_cmd.call_count, 0)
self.assertEqual(django_auth.authenticate(nick='test_nick', password='<PASSWORD>').id, self.account.id)
def test_change_credentials_email(self):
nick = self.account.nick
self.account.change_credentials(new_email='<EMAIL>')
self.assertEqual(post_service_models.Message.objects.all().count(), 0)
self.assertEqual(self.account.email, '<EMAIL>')
self.assertEqual(django_auth.authenticate(nick=nick, password='<PASSWORD>').id, self.account.id)
self.assertEqual(django_auth.authenticate(nick=nick, password='<PASSWORD>').nick, nick)
def test_prolong_premium__for_new_premium(self):
self.account._model.premium_end_at = datetime.datetime.now() - datetime.timedelta(days=100)
self.account.prolong_premium(days=30)
self.assertTrue(datetime.datetime.now() + datetime.timedelta(days=29) < self.account.premium_end_at)
self.assertTrue(datetime.datetime.now() + datetime.timedelta(days=31) > self.account.premium_end_at)
def test_prolong_premium__for_existed_premium(self):
self.account._model.premium_end_at = datetime.datetime.now() + datetime.timedelta(days=100)
self.account.prolong_premium(days=30)
self.assertTrue(datetime.datetime.now() + datetime.timedelta(days=129) < self.account.premium_end_at)
self.assertTrue(datetime.datetime.now() + datetime.timedelta(days=131) > self.account.premium_end_at)
def test_is_premium(self):
self.assertFalse(self.account.is_premium)
self.account.prolong_premium(days=1)
self.assertTrue(self.account.is_premium)
def test_notify_about_premium_expiration(self):
with self.check_new_message(self.account.id, [logic.get_system_user_id()]):
self.account.notify_about_premium_expiration()
def test_send_premium_expired_notifications(self):
with self.check_new_message(self.account.id, [logic.get_system_user_id()]):
account_1 = self.account
account_2 = self.accounts_factory.create_account()
account_3 = self.accounts_factory.create_account()
account_4 = self.accounts_factory.create_account()
account_1.prolong_premium(conf.settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days - 1)
account_1.save()
account_3.prolong_premium(conf.settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days - 1)
account_3.save()
account_4.prolong_premium(conf.settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days + 1)
account_4.save()
zero_time = datetime.datetime.fromtimestamp(0)
self.assertEqual(account_1._model.premium_expired_notification_send_at, zero_time)
self.assertEqual(account_2._model.premium_expired_notification_send_at, zero_time)
self.assertEqual(account_3._model.premium_expired_notification_send_at, zero_time)
self.assertEqual(account_4._model.premium_expired_notification_send_at, zero_time)
prototypes.AccountPrototype.send_premium_expired_notifications()
account_1.reload()
account_2.reload()
account_3.reload()
account_4.reload()
self.assertNotEqual(account_1._model.premium_expired_notification_send_at, zero_time)
self.assertEqual(account_2._model.premium_expired_notification_send_at, zero_time)
self.assertNotEqual(account_3._model.premium_expired_notification_send_at, zero_time)
self.assertEqual(account_4._model.premium_expired_notification_send_at, zero_time)
current_time = datetime.datetime.now()
self.assertTrue(current_time - datetime.timedelta(seconds=60) < account_1._model.premium_expired_notification_send_at < current_time)
self.assertTrue(current_time - datetime.timedelta(seconds=60) < account_3._model.premium_expired_notification_send_at < current_time)
def test_ban_game(self):
self.assertFalse(self.account.is_ban_game)
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data') as cmd_update_hero_with_account_data:
self.account.ban_game(days=1)
self.assertEqual(cmd_update_hero_with_account_data.call_count, 1)
self.assertEqual(cmd_update_hero_with_account_data.call_args[1]['ban_end_at'], self.account.ban_game_end_at)
self.assertTrue(self.account.is_ban_game)
self.account._model.ban_game_end_at = datetime.datetime.now()
self.assertFalse(self.account.is_ban_game)
def test_ban_forum(self):
self.assertFalse(self.account.is_ban_forum)
self.account.ban_forum(days=1)
self.assertTrue(self.account.is_ban_forum)
self.account._model.ban_forum_end_at = datetime.datetime.now()
self.assertFalse(self.account.is_ban_forum)
def test_bank_account__not_created(self):
bank_account = self.account.bank_account
self.assertTrue(bank_account.is_fake)
self.assertEqual(bank_account.amount, 0)
def test_update_referrals(self):
account_2 = self.accounts_factory.create_account(referral_of_id=self.account.id)
account_3 = self.accounts_factory.create_account(referral_of_id=self.account.id, is_fast=True)
self.account.update_referrals_number()
self.fast_account.update_referrals_number()
self.assertEqual(self.account.referrals_number, 1)
self.assertEqual(self.fast_account.referrals_number, 0)
def test_referral_removing(self):
account_2 = self.accounts_factory.create_account(referral_of_id=self.account.id, is_fast=True)
self.account.remove()
# child account must not be removed
self.assertEqual(prototypes.AccountPrototype.get_by_id(account_2.id).referral_of_id, None)
def test_set_might(self):
with mock.patch('the_tale.accounts.achievements.storage.AchievementsStorage.verify_achievements') as verify_achievements:
self.account.set_might(666)
self.assertEqual(verify_achievements.call_args_list, [mock.call(account_id=self.account.id,
type=achievements_relations.ACHIEVEMENT_TYPE.KEEPER_MIGHT,
old_value=0,
new_value=666)])
@mock.patch('the_tale.game.bills.conf.settings.MIN_VOTES_PERCENT', 0.6)
@mock.patch('the_tale.game.bills.prototypes.BillPrototype.time_before_voting_end', datetime.timedelta(seconds=0))
# fixt segmentation fault when testing with sqlite
def test_1_update_actual_bills(self):
forum_category = forum_models.Category.objects.create(caption='category-1', slug='category-1')
forum_models.SubCategory.objects.create(caption=bills_conf.settings.FORUM_CATEGORY_UID + '-caption',
uid=bills_conf.settings.FORUM_CATEGORY_UID,
category=forum_category)
self.account.update_actual_bills()
self.assertEqual(self.account.actual_bills, [])
bill_data = bills_bills.place_change_modifier.PlaceModifier(place_id=self.place_1.id,
modifier_id=places_modifiers.CITY_MODIFIERS.TRADE_CENTER,
modifier_name=places_modifiers.CITY_MODIFIERS.TRADE_CENTER.text,
old_modifier_name=None)
bill = bills_prototypes.BillPrototype.create(self.account, 'bill-1-caption', bill_data, chronicle_on_accepted='chronicle-on-accepted')
self.account.update_actual_bills()
self.assertEqual(self.account.actual_bills, [])
data = bill.user_form_initials
data['approved'] = True
form = bills_bills.place_change_modifier.PlaceModifier.ModeratorForm(data)
self.assertTrue(form.is_valid())
bill.update_by_moderator(form)
bill.apply()
self.account.update_actual_bills()
self.assertEqual(self.account.actual_bills, [time.mktime(bill.voting_end_at.timetuple())])
class AccountPrototypeBanTests(utils_testcase.TestCase):
def setUp(self):
super(AccountPrototypeBanTests, self).setUp()
game_logic.create_test_map()
self.account = self.accounts_factory.create_account()
def test_ban_game(self):
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.ban_game(2)
self.assertEqual(cmd_update_hero.call_count, 1)
self.account.reload()
self.assertTrue(self.account.is_ban_game)
self.assertTrue(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_forum)
self.assertTrue(datetime.timedelta(days=1) < self.account._model.ban_game_end_at - datetime.datetime.now() < datetime.timedelta(days=3))
def test_ban_game__extend(self):
self.account.ban_game(3)
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.ban_game(2)
self.assertEqual(cmd_update_hero.call_count, 1)
self.account.reload()
self.assertTrue(self.account.is_ban_game)
self.assertTrue(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_forum)
self.assertTrue(datetime.timedelta(days=4) < self.account._model.ban_game_end_at - datetime.datetime.now() < datetime.timedelta(days=6))
def test_ban_game__reset(self):
self.account.ban_game(2)
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.reset_ban_game()
self.assertEqual(cmd_update_hero.call_count, 1)
self.account.reload()
self.assertFalse(self.account.is_ban_game)
self.assertFalse(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_forum)
self.assertTrue(self.account._model.ban_game_end_at < datetime.datetime.now())
def test_ban_forum(self):
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.ban_forum(2)
self.assertEqual(cmd_update_hero.call_count, 0)
self.account.reload()
self.assertTrue(self.account.is_ban_forum)
self.assertTrue(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_game)
self.assertTrue(datetime.timedelta(days=1) < self.account._model.ban_forum_end_at - datetime.datetime.now() < datetime.timedelta(days=3))
def test_ban_forum__extend(self):
self.account.ban_forum(3)
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.ban_forum(2)
self.assertEqual(cmd_update_hero.call_count, 0)
self.account.reload()
self.assertTrue(self.account.is_ban_forum)
self.assertTrue(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_game)
self.assertTrue(datetime.timedelta(days=4) < self.account._model.ban_forum_end_at - datetime.datetime.now() < datetime.timedelta(days=6))
def test_ban_forum__reset(self):
self.account.ban_forum(2)
with mock.patch('the_tale.accounts.prototypes.AccountPrototype.cmd_update_hero') as cmd_update_hero:
self.account.reset_ban_forum()
self.assertEqual(cmd_update_hero.call_count, 0)
self.account.reload()
self.assertFalse(self.account.is_ban_forum)
self.assertFalse(self.account.is_ban_any)
self.assertFalse(self.account.is_ban_game)
self.assertTrue(self.account._model.ban_forum_end_at < datetime.datetime.now())
| [
"smart_imports.all"
] | [((23, 42), 'smart_imports.all', 'smart_imports.all', ([], {}), '()\n', (40, 42), False, 'import smart_imports\n')] |
#!/usr/bin/env python3
import json
import time
from run_common import AWSCli
from run_common import print_message
from run_create_codebuild_common import create_base_iam_policy
from run_create_codebuild_common import create_iam_service_role
from run_create_codebuild_common import create_managed_secret_iam_policy
from run_create_codebuild_common import create_notification_rule
from run_create_codebuild_common import get_notification_rule
from run_create_codebuild_common import have_parameter_store
from run_create_codebuild_common import update_notification_rule
def run_create_default_project(name, settings):
aws_cli = AWSCli(settings['AWS_REGION'])
git_branch = settings['BRANCH']
build_spec = settings['BUILD_SPEC']
build_timeout = settings['BUILD_TIMEOUT']
compute_type = settings['ENV_COMPUTE_TYPE']
description = settings['DESCRIPTION']
git_repo = settings['GITHUB_REPO']
image = settings['IMAGE']
################################################################################
print_message('check previous version')
cmd = ['codebuild', 'list-projects']
result = aws_cli.run(cmd)
need_update = name in result['projects']
################################################################################
print_message('create iam service role')
service_role_name = create_iam_service_role(aws_cli, name)
create_base_iam_policy(aws_cli, name, settings, service_role_name)
if have_parameter_store(settings):
create_managed_secret_iam_policy(aws_cli, name, settings, service_role_name)
time.sleep(10)
service_role_arn = aws_cli.get_role_arn(service_role_name)
################################################################################
print_message('set environment variable')
env_list = []
for pp in settings['ENV_VARIABLES']:
if 'PARAMETER_STORE' == pp['type']:
nn = f"/CodeBuild/{name}/{pp['name']}"
cmd = ['ssm', 'get-parameter', '--name', nn]
aws_cli.run(cmd)
pp['value'] = nn
env_list.append(pp)
################################################################################
config = {
"name": name,
"description": description,
"source": {
"type": "GITHUB",
"location": git_repo,
"gitCloneDepth": 0,
"buildspec": build_spec,
"auth": {
"type": "OAUTH"
},
"insecureSsl": True,
"sourceIdentifier": git_branch
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"cache": {
"type": "NO_CACHE"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": image,
"computeType": compute_type,
"environmentVariables": env_list
},
"serviceRole": service_role_arn,
"timeoutInMinutes": build_timeout,
"badgeEnabled": True
}
config = json.dumps(config)
if need_update:
print_message(f'update project: {name}')
cmd = ['codebuild', 'update-project', '--cli-input-json', config, '--source-version', git_branch]
aws_cli.run(cmd)
else:
print_message(f'create project: {name}')
cmd = ['codebuild', 'create-project', '--cli-input-json', config, '--source-version', git_branch]
aws_cli.run(cmd)
################################################################################
print_message('create slack notification')
project_arn = result['project']['arn']
notification_rule_arn = get_notification_rule(aws_cli, project_arn)
if not notification_rule_arn:
create_notification_rule(aws_cli, name, project_arn)
else:
update_notification_rule(aws_cli, name, notification_rule_arn)
| [
"run_common.AWSCli",
"run_create_codebuild_common.create_managed_secret_iam_policy",
"run_common.print_message",
"json.dumps",
"run_create_codebuild_common.create_notification_rule",
"run_create_codebuild_common.get_notification_rule",
"time.sleep",
"run_create_codebuild_common.update_notification_rul... | [((632, 662), 'run_common.AWSCli', 'AWSCli', (["settings['AWS_REGION']"], {}), "(settings['AWS_REGION'])\n", (638, 662), False, 'from run_common import AWSCli\n'), ((1035, 1074), 'run_common.print_message', 'print_message', (['"""check previous version"""'], {}), "('check previous version')\n", (1048, 1074), False, 'from run_common import print_message\n'), ((1282, 1322), 'run_common.print_message', 'print_message', (['"""create iam service role"""'], {}), "('create iam service role')\n", (1295, 1322), False, 'from run_common import print_message\n'), ((1348, 1386), 'run_create_codebuild_common.create_iam_service_role', 'create_iam_service_role', (['aws_cli', 'name'], {}), '(aws_cli, name)\n', (1371, 1386), False, 'from run_create_codebuild_common import create_iam_service_role\n'), ((1391, 1457), 'run_create_codebuild_common.create_base_iam_policy', 'create_base_iam_policy', (['aws_cli', 'name', 'settings', 'service_role_name'], {}), '(aws_cli, name, settings, service_role_name)\n', (1413, 1457), False, 'from run_create_codebuild_common import create_base_iam_policy\n'), ((1466, 1496), 'run_create_codebuild_common.have_parameter_store', 'have_parameter_store', (['settings'], {}), '(settings)\n', (1486, 1496), False, 'from run_create_codebuild_common import have_parameter_store\n'), ((1588, 1602), 'time.sleep', 'time.sleep', (['(10)'], {}), '(10)\n', (1598, 1602), False, 'import time\n'), ((1756, 1797), 'run_common.print_message', 'print_message', (['"""set environment variable"""'], {}), "('set environment variable')\n", (1769, 1797), False, 'from run_common import print_message\n'), ((3017, 3035), 'json.dumps', 'json.dumps', (['config'], {}), '(config)\n', (3027, 3035), False, 'import json\n'), ((3517, 3559), 'run_common.print_message', 'print_message', (['"""create slack notification"""'], {}), "('create slack notification')\n", (3530, 3559), False, 'from run_common import print_message\n'), ((3633, 3676), 'run_create_codebuild_common.get_notification_rule', 'get_notification_rule', (['aws_cli', 'project_arn'], {}), '(aws_cli, project_arn)\n', (3654, 3676), False, 'from run_create_codebuild_common import get_notification_rule\n'), ((1506, 1582), 'run_create_codebuild_common.create_managed_secret_iam_policy', 'create_managed_secret_iam_policy', (['aws_cli', 'name', 'settings', 'service_role_name'], {}), '(aws_cli, name, settings, service_role_name)\n', (1538, 1582), False, 'from run_create_codebuild_common import create_managed_secret_iam_policy\n'), ((3065, 3105), 'run_common.print_message', 'print_message', (['f"""update project: {name}"""'], {}), "(f'update project: {name}')\n", (3078, 3105), False, 'from run_common import print_message\n'), ((3255, 3295), 'run_common.print_message', 'print_message', (['f"""create project: {name}"""'], {}), "(f'create project: {name}')\n", (3268, 3295), False, 'from run_common import print_message\n'), ((3720, 3772), 'run_create_codebuild_common.create_notification_rule', 'create_notification_rule', (['aws_cli', 'name', 'project_arn'], {}), '(aws_cli, name, project_arn)\n', (3744, 3772), False, 'from run_create_codebuild_common import create_notification_rule\n'), ((3791, 3853), 'run_create_codebuild_common.update_notification_rule', 'update_notification_rule', (['aws_cli', 'name', 'notification_rule_arn'], {}), '(aws_cli, name, notification_rule_arn)\n', (3815, 3853), False, 'from run_create_codebuild_common import update_notification_rule\n')] |
import typing as t
from pylogview import datefinder
from pylogview.record import LogRecord
if t.TYPE_CHECKING:
from pylogview.window import Window
class LogReader:
__slots__ = [
"_window",
"filename",
"_lines",
"records",
"_record_prefix_length",
"_fd",
"_buffer",
]
def __init__(self, window: "Window", filename: str):
self._window = window
self.filename = filename
self._lines = 0 # file line count
self.records: t.List[LogRecord] = []
self._record_prefix_length: t.Union[
str, None
] = None # pattern that starts record
self._fd = None
self._buffer = bytes() # byte buffer for file data
self._open()
def __del__(self):
if self._fd:
try:
self._fd.close()
except:
pass
@property
def isOpen(self) -> bool:
if self._fd is not None:
return not self._fd.closed
return False
@property
def lines(self) -> int:
return self._lines
def preload(self) -> t.List[LogRecord]:
self._get_line_count()
self._read_last()
return self.read(0)
def read(self, records: int = 1) -> t.List[LogRecord]:
"""Read to end of file and parse next line"""
self._read()
return self._get_records(records)
##### Internal Methods #####
def _open(self):
try:
self._fd = open(self.filename, "rb")
except IOError as err:
self._window.log.append(
f"Failed to open '{self.filename}': [{err.errno}] {err.strerror}"
)
self._fd = None
def _read(self):
if self.isOpen:
try:
data = self._fd.read()
self._lines += data.count(b"\n")
self._buffer += data
except IOError as err:
self._window.log.append(
f"Error while reading '{self.filename}': [{err.errno}] {err.strerror}"
)
def _get_line_count(self):
if not self.isOpen:
return
try:
self._fd.seek(0, 0)
self._lines = 0
for line in self._fd: # pylint: disable=unused-variable
self._lines += 1
except IOError as err:
self._fd = None
self._lines = 0
self._window.log.append(
f"Error while reading '{self.filename}': [{err.errno}] {err.strerror}"
)
def _read_last(self):
"""Read last ``lines`` of file, like 'tail -n'"""
if not self.isOpen:
return
try:
last_read_block = self._fd.tell()
block_end_byte = last_read_block
BLOCK_SIZE = min(block_end_byte, 1024)
remain_lines = self._window.config.lines
block_num = -1
blocks = []
while remain_lines > 0 and block_end_byte > 0:
if block_end_byte - BLOCK_SIZE > 0:
self._fd.seek(block_num * BLOCK_SIZE, 2)
blocks.append(self._fd.read(BLOCK_SIZE))
else:
self._fd.seek(0, 0)
blocks.append(self._fd.read(block_end_byte))
remain_lines -= blocks[-1].count(b"\n")
block_end_byte -= BLOCK_SIZE
block_num -= 1
self._fd.seek(last_read_block, 0)
except IOError as err:
self._fd = None
self._window.log.append(
f"Error while reading '{self.filename}': [{err.errno}] {err.strerror}"
)
else:
for block in blocks[::-1]:
self._buffer += block
def _find_record_prefix_length(self):
"""
Rudamentary prefix length finder. Looks for repeated same number of chars
between newline/file-start and timestamp.
"""
prefix_lengths = []
last_end = 1
buffer_string = self._buffer.decode()
for result in datefinder.find_dates(buffer_string, source=True, index=True):
if self._record_prefix_length is not None:
break
elif len(result[1]) < 6:
# skip matches too short, probably just numbers not a timestamp
continue
timestamp_end = result[2][1]
timestamp_start = timestamp_end - len(result[1]) - 1
prefix_lengths.append(
len(
buffer_string[
timestamp_start
- buffer_string[last_end:timestamp_start][::-1].find(
"\n"
) : timestamp_start
]
)
)
last_end = buffer_string.find("\n", timestamp_end)
for length in prefix_lengths:
if prefix_lengths.count(length) > 3:
self._record_prefix_length = length
break
def _get_records(self, count) -> t.List[LogRecord]:
# make sure we have a lock on the prefix before parsing anything
if self._record_prefix_length is None:
self._find_record_prefix_length()
if self._record_prefix_length is None:
return []
# find timestamps in buffer
buffer_string = self._buffer.decode()
timestamp_match = datefinder.find_dates(buffer_string, source=True, index=True)
this_result = next(timestamp_match, None)
match_offset = 0
new_records = 0
while True:
if len(self._buffer) == 0:
break
if this_result is None:
# if no timestamps found, read to the end of the buffer
this_start = len(self._buffer)
else:
# skip if this match is too short, sometimes numbers will match
if len(this_result[1]) < 8:
this_result = next(timestamp_match, None)
continue
# this should always work out to 0, anything else means there is
# data in the buffer that belongs to the previous record
this_start = (
this_result[2][1]
- match_offset
- len(this_result[1])
- 1
- self._record_prefix_length
)
if this_start != 0:
# make sure this match is a record
if this_result is not None and buffer_string[this_start - 1] != "\n":
this_result = next(timestamp_match, None)
continue
# something left in the buffer before the this record start
# append it to the last record and search again
if self.records:
# only keep if there is at least one record, anything else is
# a partial record from tail-ing the file
self.records[-1].append(buffer_string[:this_start].split("\n"))
self._buffer = self._buffer[len(buffer_string[:this_start].encode()) :]
buffer_string = buffer_string[this_start:]
match_offset += this_start
this_start -= match_offset
while True:
next_result = next(timestamp_match, None)
if next_result is None:
# no second timestamp found, read to the end of the buffer
next_start = len(self._buffer)
else:
# if len(next_result[1]) < 8:
# continue
next_start = (
next_result[2][1]
- match_offset
- len(next_result[1])
- 1
- self._record_prefix_length
)
if next_result is None or buffer_string[next_start - 1] == "\n":
self.records.append(
LogRecord(
self._window,
buffer_string[:next_start].split("\n"),
)
)
self._buffer = self._buffer[
len(buffer_string[:next_start].encode()) :
]
buffer_string = buffer_string[next_start:]
match_offset += next_start
new_records += 1
break
if next_result is None or new_records == count:
break
else:
this_result = next_result
self.records = self.records[0 - self._window.config.lines :]
return self.records[0 - new_records :] if new_records else []
| [
"pylogview.datefinder.find_dates"
] | [((4113, 4174), 'pylogview.datefinder.find_dates', 'datefinder.find_dates', (['buffer_string'], {'source': '(True)', 'index': '(True)'}), '(buffer_string, source=True, index=True)\n', (4134, 4174), False, 'from pylogview import datefinder\n'), ((5490, 5551), 'pylogview.datefinder.find_dates', 'datefinder.find_dates', (['buffer_string'], {'source': '(True)', 'index': '(True)'}), '(buffer_string, source=True, index=True)\n', (5511, 5551), False, 'from pylogview import datefinder\n')] |
from mailmerge import MailMerge
import re
import os.path
from ElvantoAPIExtensions import Enums, Helpers
from modules.__stub__ import ModuleStub
class Module(ModuleStub):
__VERSION__ = "1.0"
__NAME__ = "bulletinGenerator_Kingsgrove"
# __executeTime__ = "16:00"
# __executeDay__ = "thursday"
settings = {
"general": {
"template": "",
"serviceName": "",
"pastorName": "",
"pastorTelephone": "",
"pastorEmail": "",
},
}
def validate(self):
self._baseFolder = os.path.join("files", self.__NAME__)
_templateFile = os.path.join(self._baseFolder, self.settings["general"]["template"])
if not os.path.isfile(_templateFile):
raise self.ModuleException("Invalid template file path")
self._templateFile = _templateFile
def run(self):
_serviceDate = Helpers.NextDate(Enums.Days.SUNDAY)
import math
weekNumber = int(math.ceil(_serviceDate.day / 7))
try:
thisWeekServices = Helpers.ServicesOnDate(self.conn, _serviceDate, ["volunteers", "plans"])
thisWeekService = next(
filter(lambda _: _.name == self.settings["general"]["serviceName"], thisWeekServices))
except Exception as e:
if e.__class__.__name__ == "ConnectionError":
print("Couldn't connect to Elvanto API")
return False
if type(e) == StopIteration:
print("Couldn't find an upcoming service called \"%s\"" % self.settings["general"]["serviceName"])
return False
print("An error occured:", e)
def getWeeklyConfession(week: int):
assert 1 <= week <= 5
confessionOne = """
Almighty and most merciful Father,
You have loved us with an everlasting love,
But we have gone our own way
And have rejected you in thought, word, and deed.
We are sorry for our sins
And turn away from them
For the sake of your Son who died for us,
Forgive us, cleanse us and change us.
By your Holy Spirit, enable us to live for you,
And to please you more and more;
Through Jesus Christ our Lord.
Amen.
"""
confessionTwo = """
Most merciful God,
we humbly admit that we need your help.
We confess that we have wandered from your way:
We have done wrong, and we have failed to do what is right.
You alone can save us.
Have mercy on us:
Wipe out our sins and teach us to forgive others.
Bring forth in us the fruit of the Spirit
That we may live as disciples of Christ.
This we ask in the name of Jesus our Saviour.
Amen.
"""
confessionThree = """
Heavenly Father,
We praise you for adopting us as your children
And making us heirs of eternal life.
In your mercy you have washed us from our sins
And made us clean in your sight.
Yet we still fail to love you as we should and serve you as we ought.
Forgive us our sins and renew us by your grace,
That we may continue to grow as members of Christ,
In whom alone is our salvation.
Amen.
"""
confessionFour = """
Merciful God, our maker and our judge, we have sinned against you in thought, word, and deed:
we have not loved you with our whole heart, we have not loved our neighbours as ourselves:
we repent, and are sorry for all our sins.
Father, forgive us.
Strengthen us to love and obey you in newness of life;
through Jesus Christ our Lord.
Amen
"""
confessionFive = """
Lord God,
we have sinned against you;
we have done evil in your sight.
We are sorry and repent.
Have mercy on us according to your love.
Wash away our wrongdoing and cleanse us from our sin.
Renew a right spirit within us
and restore us to the joy of your salvation,
through Jesus Christ our Lord. Amen.
"""
return [None, confessionOne, confessionTwo, confessionThree, confessionFour, confessionFive][
week].strip()
stringify = lambda volunteerArray: ", ".join(map(repr, volunteerArray))
replacements = {
"prettyDate": _serviceDate.strftime("%A, %#d %B %Y"),
"branch": self.settings["general"]["serviceName"],
"weeklyConfession": getWeeklyConfession(weekNumber),
"pastorName": self.settings["general"]["pastorName"],
"pastorTelephone": self.settings["general"]["pastorTelephone"],
"pastorEmail": self.settings["general"]["pastorEmail"],
"scripturePassage": None,
"sermonPassage": None,
"speaker": None,
}
map(print, thisWeekService.plan)
scripturePassageItem = next(filter(lambda _: _.title.startswith("Bible Reading") and not _.title.startswith("Bible Reading (Sermon)"), thisWeekService.plan))
_scripturePassageItem = re.search('^Bible Reading (?:- )?(.*)$', scripturePassageItem.title)
if _scripturePassageItem:
replacements["scripturePassage"] = _scripturePassageItem.group(1)
else:
replacements["scripturePassage"] = re.sub('<.*?>', "", scripturePassageItem.description).strip()
# Details in the title
sermonPassageItem = next(filter(lambda _: _.title.startswith("Bible Reading (Sermon"), thisWeekService.plan))
replacements["sermonPassage"] = re.sub('<.*?>', "", sermonPassageItem.description).strip()
replacements["speaker"] = stringify(thisWeekService.volunteers.byPositionName("Speaker"))
with MailMerge(self._templateFile) as document:
document.merge(**replacements)
filePath = os.path.join(self._baseFolder, "SWEC %s - Bulletin %s.docx"
% (self.settings["general"]["serviceName"], _serviceDate.strftime("%#d %B %Y")))
document.write(filePath)
| [
"re.search",
"math.ceil",
"re.sub",
"ElvantoAPIExtensions.Helpers.NextDate",
"ElvantoAPIExtensions.Helpers.ServicesOnDate",
"mailmerge.MailMerge"
] | [((903, 938), 'ElvantoAPIExtensions.Helpers.NextDate', 'Helpers.NextDate', (['Enums.Days.SUNDAY'], {}), '(Enums.Days.SUNDAY)\n', (919, 938), False, 'from ElvantoAPIExtensions import Enums, Helpers\n'), ((5204, 5272), 're.search', 're.search', (['"""^Bible Reading (?:- )?(.*)$"""', 'scripturePassageItem.title'], {}), "('^Bible Reading (?:- )?(.*)$', scripturePassageItem.title)\n", (5213, 5272), False, 'import re\n'), ((984, 1015), 'math.ceil', 'math.ceil', (['(_serviceDate.day / 7)'], {}), '(_serviceDate.day / 7)\n', (993, 1015), False, 'import math\n'), ((1062, 1134), 'ElvantoAPIExtensions.Helpers.ServicesOnDate', 'Helpers.ServicesOnDate', (['self.conn', '_serviceDate', "['volunteers', 'plans']"], {}), "(self.conn, _serviceDate, ['volunteers', 'plans'])\n", (1084, 1134), False, 'from ElvantoAPIExtensions import Enums, Helpers\n'), ((5871, 5900), 'mailmerge.MailMerge', 'MailMerge', (['self._templateFile'], {}), '(self._templateFile)\n', (5880, 5900), False, 'from mailmerge import MailMerge\n'), ((5699, 5749), 're.sub', 're.sub', (['"""<.*?>"""', '""""""', 'sermonPassageItem.description'], {}), "('<.*?>', '', sermonPassageItem.description)\n", (5705, 5749), False, 'import re\n'), ((5446, 5499), 're.sub', 're.sub', (['"""<.*?>"""', '""""""', 'scripturePassageItem.description'], {}), "('<.*?>', '', scripturePassageItem.description)\n", (5452, 5499), False, 'import re\n')] |
"""plot.py: Utility builder class for ML plots.
Uses scikit-learn code samples and framework
"""
__author__ = "<NAME>"
__license__ = "BSD"
__email__ = "<EMAIL>"
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import randomcolor
import math
from sklearn.metrics import confusion_matrix
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
from .image import Image
class PlotBuilder:
def __init__(self):
self.__figures = []
self._subplot_idx = None
self._subplot_size = [1, 1]
self._current_subplot = None
self._next_plot = True
def show(self, close=True):
plt.show()
if close:
self.close()
def close(self):
for fig in self.__figures:
plt.close(fig)
self.__figures = []
self._subplot_idx = None
self._subplot_size = [1, 1]
def same(self):
self._next_plot = False
return self
@staticmethod
def get_plot():
return plt
def create_subplots(self, rows, cols, fig_size=(18, 18)):
self.__figures.append(plt.figure(figsize=fig_size))
self._subplot_idx = 0
self._subplot_size = [rows, cols]
return self
def _get_next_plot(self, **kwargs):
if not self._next_plot:
self._next_plot = False
return self._current_subplot
if self._subplot_idx is not None and self._subplot_idx >= (self._subplot_size[0] * self._subplot_size[1]):
self._subplot_idx = None
self._subplot_size = [1, 1]
if self._subplot_idx is None:
self.__figures.append(plt.figure(**kwargs))
self._current_subplot = self.__figures[-1].add_subplot(1, 1, 1)
return self._current_subplot
self._subplot_idx += 1
self._current_subplot = self.__figures[-1].add_subplot(*self._subplot_size, self._subplot_idx, **kwargs)
return self._current_subplot
def create_plot(self, title, x_data, *args):
"""
Plot a series of graphs on X axis points given by x_data
and Y axis by tuples of (y_values, y_title) in args
"""
sp = self._get_next_plot()
rand_color = randomcolor.RandomColor()
limits = [[100000, -100000], [100000, -100000], [100000, -100000]]
x_values, x_label = x_data
limits[0][0] = min(limits[0][0], min(x_values))
limits[0][1] = max(limits[0][1], max(x_values))
for data in args:
color = rand_color.generate()[0]
if isinstance(data, list):
i = 0
for y_values in data:
i += 1
limits[1][0] = min(limits[1][0], min(y_values))
limits[1][1] = max(limits[1][1], max(y_values))
sp.plot(x_values, y_values, color=color, linewidth=2,
linestyle='--' if i % 2 else '-')
else:
y_values, y_title = data
limits[1][0] = min(limits[1][0], min(y_values))
limits[1][1] = max(limits[1][1], max(y_values))
sp.plot(x_values, y_values, label=y_title, color=color, linewidth=2, linestyle='-')
sp.set_xlim(limits[0])
sp.set_xlabel(x_label)
sp.set_ylim(limits[1])
sp.legend(loc='upper right')
sp.set_title(title)
return self
def create_horizontal_line(self, *args, **kwargs):
sp = self._get_next_plot()
rand_color = randomcolor.RandomColor()
y_limits = list(sp.get_ylim())
for data in args:
y_value, y_title = data
y_limits[0] = min(y_limits[0], y_value)
y_limits[1] = max(y_limits[1], y_value)
sp.plot(sp.get_xlim(), [y_value, y_value], label=y_title, color=rand_color.generate()[0], **kwargs)
sp.set_ylim([y_limits[0] * 0.9, y_limits[1] * 1.1])
sp.legend(loc='upper right')
return self
def create_scatter_plot(self, title, axis_labels, *args):
"""
Plot a series of graphs of scatter points given by the
list of tuples (x, y, data_label)
"""
markers = ['o', '*', '+', 'P', 'X', 'D']
is_3d = len(axis_labels) == 3
sp = self._get_next_plot(projection='3d') if is_3d else self._get_next_plot()
rand_color = randomcolor.RandomColor()
limits = [[100000, -100000], [100000, -100000], [100000, -100000]]
marker_id = 0
for data in args:
data = list(data)
values = data[:-1]
label = data[-1]
color = rand_color.generate()[0]
for i, v in enumerate(values):
limits[i][0] = min(limits[i][0], min(v))
limits[i][1] = max(limits[i][1], max(v))
sp.scatter(*values, label=label, color=color, marker=markers[marker_id % len(markers)])
marker_id += 1
if is_3d:
x_label, y_label, z_label = axis_labels
else:
x_label, y_label = axis_labels
sp.set_xlim(limits[0])
sp.set_xlabel(x_label)
sp.set_ylim(limits[1])
sp.set_ylabel(y_label)
if is_3d:
sp.set_zlim(limits[2])
sp.set_zlabel(z_label)
sp.legend(loc='upper right')
sp.set_title(title)
return self
def create_histograms(self, pd_categoricals, titles, bins='auto', fig_size=(13, 6)):
"""
Creates a histogram based on x_data
"""
fig, ax = plt.subplots(figsize=fig_size)
self.__figures.append(fig)
subplot_no = len(pd_categoricals)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
colors = {}
for i in range(len(pd_categoricals)):
data = pd_categoricals[i]
if isinstance(data, pd.core.series.Series):
data = data[data.isnull() == False].value_counts()
else:
data, labels = data
class_id, data = np.unique(data, return_counts=True)
sort_freq = np.argsort(-data)
data = dict(zip([labels[c] for c in class_id[sort_freq]], data[sort_freq]))
labels = [name for name in data.keys()]
data = [data[name] for name in labels]
if len(colors) != len(labels):
colors = dict(zip(labels, randomcolor.RandomColor().generate(count=len(labels))))
sp = fig.add_subplot(1, subplot_no, i + 1)
plt.bar(labels, data, color=[colors[l] for l in labels])
plt.xticks(labels, rotation=90)
sp.set_title(titles[i])
plt.tight_layout()
return self
def create_images(self, images, titles, **kwargs):
"""
Creates a grid of images
"""
subplot_cols = min(len(images), 6)
subplot_rows = math.ceil(len(images) / subplot_cols)
fig_size = kwargs.pop('figsize', 3)
dpi = kwargs.pop('dpi', 80)
fig = plt.figure(figsize=(subplot_cols * fig_size, subplot_rows * fig_size), dpi=dpi)
self.__figures.append(fig)
if len(images) != len(titles):
raise(Exception("Image and title list must be the same"))
for i in range(len(images)):
sp = fig.add_subplot(subplot_rows, subplot_cols, i + 1)
sp.set_title(titles[i])
image = images[i]
if isinstance(image, str):
image = Image.load(image)
plt.imshow(Image.to_image(image), **kwargs)
sp.axes.get_xaxis().set_visible(False)
sp.axes.get_yaxis().set_visible(False)
sp.grid(None)
plt.tight_layout()
return self
# https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html
def create_confusion_matrix(self, y_true, y_pred, classes, title=None,
x_label='Predicted class', y_label='True class', normalize=False, cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
fig, ax = plt.subplots(figsize=(8, 8))
self.__figures.append(fig)
if not title:
if normalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred, labels=np.array(range(len(classes))))
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
# ax.figure.colorbar(im, ax=ax)
# We want to show all ticks...and label them with the respective list entries
ax.set(xticks=np.arange(cm.shape[1]),
yticks=np.arange(cm.shape[0]),
xticklabels=classes, yticklabels=classes,
title=title,
ylabel=y_label,
xlabel=x_label)
# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
ax.spines['bottom'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.tick_params(axis='both', which='major', pad=10)
# Loop over data dimensions and create text annotations.
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], fmt),
ha="center", va="center",
color="green" if i == j else "white" if cm[i, j] > thresh else "black")
fig.tight_layout()
return self
# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html
def create_roc_curve_multiclass(self, y_true_labels, y_predicted_scores, classes, plot_mask=False):
"""
Compute ROC curve and ROC area for each class
classes contains a list of target label names in the multiclass clasification
plot_mask can contain a list of True/False values for each of the above class to be predicted
"""
fpr = dict()
tpr = dict()
roc_auc = dict()
if not plot_mask:
plot_mask = classes != None
for i in range(len(classes)):
if plot_mask[i]:
fpr[i], tpr[i], _ = roc_curve(y_true_labels, y_predicted_scores[:, i], pos_label=i)
roc_auc[i] = auc(fpr[i], tpr[i])
# https://datascience.stackexchange.com/questions/15989/micro-average-vs-macro-average-performance-in-a-multiclass-classification-settin
# Compute micro-average ROC curve and ROC area for all classes
y_true_micro = np.array([], dtype=np.int32)
y_scores_micro = np.array([], dtype=np.float64)
for i in range(len(classes)):
if plot_mask[i]:
y_true_micro = np.append(y_true_micro, y_true_labels == i)
y_scores_micro = np.append(y_scores_micro, y_predicted_scores[:, i])
fpr["micro"], tpr["micro"], _ = roc_curve(y_true_micro, y_scores_micro)
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
self.__plot_roc_curve(fpr, tpr, roc_auc, classes)
return self
def __plot_roc_curve(self, fpr, tpr, roc_auc, classes):
self.__figures.append(plt.figure(figsize=(15, 15)))
rand_color = randomcolor.RandomColor()
for i, c in enumerate(classes):
if i in fpr:
plt.plot(fpr[i], tpr[i], label='ROC curve [class=%s] (area = %0.2f)' % (c, roc_auc[i]),
color=rand_color.generate()[0], linewidth=2)
if 'micro' in fpr:
plt.plot(fpr['micro'], tpr['micro'], label='ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'],
color='deeppink', linewidth=4, linestyle=':')
if 'macro' in fpr:
plt.plot(fpr['macro'], tpr['macro'], label='ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'],
color='darkorange', linewidth=4, linestyle=':')
plt.plot([0, 1], [0, 1], color='navy', linewidth=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Recall (False Positive Rate)')
plt.ylabel('Precision (True Positive Rate)')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
| [
"matplotlib.pyplot.ylabel",
"sklearn.metrics.auc",
"numpy.argsort",
"numpy.array",
"sklearn.metrics.roc_curve",
"randomcolor.RandomColor",
"numpy.arange",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xticks",
"m... | [((697, 707), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (705, 707), True, 'import matplotlib.pyplot as plt\n'), ((2273, 2298), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (2296, 2298), False, 'import randomcolor\n'), ((3572, 3597), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (3595, 3597), False, 'import randomcolor\n'), ((4421, 4446), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (4444, 4446), False, 'import randomcolor\n'), ((5593, 5623), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': 'fig_size'}), '(figsize=fig_size)\n', (5605, 5623), True, 'import matplotlib.pyplot as plt\n'), ((7098, 7177), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(subplot_cols * fig_size, subplot_rows * fig_size)', 'dpi': 'dpi'}), '(figsize=(subplot_cols * fig_size, subplot_rows * fig_size), dpi=dpi)\n', (7108, 7177), True, 'import matplotlib.pyplot as plt\n'), ((7768, 7786), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (7784, 7786), True, 'import matplotlib.pyplot as plt\n'), ((8266, 8294), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': '(8, 8)'}), '(figsize=(8, 8))\n', (8278, 8294), True, 'import matplotlib.pyplot as plt\n'), ((10963, 10991), 'numpy.array', 'np.array', (['[]'], {'dtype': 'np.int32'}), '([], dtype=np.int32)\n', (10971, 10991), True, 'import numpy as np\n'), ((11017, 11047), 'numpy.array', 'np.array', (['[]'], {'dtype': 'np.float64'}), '([], dtype=np.float64)\n', (11025, 11047), True, 'import numpy as np\n'), ((11316, 11355), 'sklearn.metrics.roc_curve', 'roc_curve', (['y_true_micro', 'y_scores_micro'], {}), '(y_true_micro, y_scores_micro)\n', (11325, 11355), False, 'from sklearn.metrics import roc_curve\n'), ((11383, 11414), 'sklearn.metrics.auc', 'auc', (["fpr['micro']", "tpr['micro']"], {}), "(fpr['micro'], tpr['micro'])\n", (11386, 11414), False, 'from sklearn.metrics import auc\n'), ((11638, 11663), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (11661, 11663), False, 'import randomcolor\n'), ((12335, 12402), 'matplotlib.pyplot.plot', 'plt.plot', (['[0, 1]', '[0, 1]'], {'color': '"""navy"""', 'linewidth': '(2)', 'linestyle': '"""--"""'}), "([0, 1], [0, 1], color='navy', linewidth=2, linestyle='--')\n", (12343, 12402), True, 'import matplotlib.pyplot as plt\n'), ((12411, 12431), 'matplotlib.pyplot.xlim', 'plt.xlim', (['[0.0, 1.0]'], {}), '([0.0, 1.0])\n', (12419, 12431), True, 'import matplotlib.pyplot as plt\n'), ((12440, 12461), 'matplotlib.pyplot.ylim', 'plt.ylim', (['[0.0, 1.05]'], {}), '([0.0, 1.05])\n', (12448, 12461), True, 'import matplotlib.pyplot as plt\n'), ((12470, 12512), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Recall (False Positive Rate)"""'], {}), "('Recall (False Positive Rate)')\n", (12480, 12512), True, 'import matplotlib.pyplot as plt\n'), ((12521, 12565), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Precision (True Positive Rate)"""'], {}), "('Precision (True Positive Rate)')\n", (12531, 12565), True, 'import matplotlib.pyplot as plt\n'), ((12574, 12620), 'matplotlib.pyplot.title', 'plt.title', (['"""Receiver operating characteristic"""'], {}), "('Receiver operating characteristic')\n", (12583, 12620), True, 'import matplotlib.pyplot as plt\n'), ((12629, 12658), 'matplotlib.pyplot.legend', 'plt.legend', ([], {'loc': '"""lower right"""'}), "(loc='lower right')\n", (12639, 12658), True, 'import matplotlib.pyplot as plt\n'), ((820, 834), 'matplotlib.pyplot.close', 'plt.close', (['fig'], {}), '(fig)\n', (829, 834), True, 'import matplotlib.pyplot as plt\n'), ((1157, 1185), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'fig_size'}), '(figsize=fig_size)\n', (1167, 1185), True, 'import matplotlib.pyplot as plt\n'), ((6597, 6653), 'matplotlib.pyplot.bar', 'plt.bar', (['labels', 'data'], {'color': '[colors[l] for l in labels]'}), '(labels, data, color=[colors[l] for l in labels])\n', (6604, 6653), True, 'import matplotlib.pyplot as plt\n'), ((6666, 6697), 'matplotlib.pyplot.xticks', 'plt.xticks', (['labels'], {'rotation': '(90)'}), '(labels, rotation=90)\n', (6676, 6697), True, 'import matplotlib.pyplot as plt\n'), ((6746, 6764), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (6762, 6764), True, 'import matplotlib.pyplot as plt\n'), ((11586, 11614), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 15)'}), '(figsize=(15, 15))\n', (11596, 11614), True, 'import matplotlib.pyplot as plt\n'), ((11943, 12102), 'matplotlib.pyplot.plot', 'plt.plot', (["fpr['micro']", "tpr['micro']"], {'label': "('ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'])", 'color': '"""deeppink"""', 'linewidth': '(4)', 'linestyle': '""":"""'}), "(fpr['micro'], tpr['micro'], label=\n 'ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'], color=\n 'deeppink', linewidth=4, linestyle=':')\n", (11951, 12102), True, 'import matplotlib.pyplot as plt\n'), ((12153, 12314), 'matplotlib.pyplot.plot', 'plt.plot', (["fpr['macro']", "tpr['macro']"], {'label': "('ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'])", 'color': '"""darkorange"""', 'linewidth': '(4)', 'linestyle': '""":"""'}), "(fpr['macro'], tpr['macro'], label=\n 'ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'], color=\n 'darkorange', linewidth=4, linestyle=':')\n", (12161, 12314), True, 'import matplotlib.pyplot as plt\n'), ((1696, 1716), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '(**kwargs)\n', (1706, 1716), True, 'import matplotlib.pyplot as plt\n'), ((6110, 6145), 'numpy.unique', 'np.unique', (['data'], {'return_counts': '(True)'}), '(data, return_counts=True)\n', (6119, 6145), True, 'import numpy as np\n'), ((6174, 6191), 'numpy.argsort', 'np.argsort', (['(-data)'], {}), '(-data)\n', (6184, 6191), True, 'import numpy as np\n'), ((8940, 8962), 'numpy.arange', 'np.arange', (['cm.shape[1]'], {}), '(cm.shape[1])\n', (8949, 8962), True, 'import numpy as np\n'), ((8986, 9008), 'numpy.arange', 'np.arange', (['cm.shape[0]'], {}), '(cm.shape[0])\n', (8995, 9008), True, 'import numpy as np\n'), ((10610, 10673), 'sklearn.metrics.roc_curve', 'roc_curve', (['y_true_labels', 'y_predicted_scores[:, i]'], {'pos_label': 'i'}), '(y_true_labels, y_predicted_scores[:, i], pos_label=i)\n', (10619, 10673), False, 'from sklearn.metrics import roc_curve\n'), ((10703, 10722), 'sklearn.metrics.auc', 'auc', (['fpr[i]', 'tpr[i]'], {}), '(fpr[i], tpr[i])\n', (10706, 10722), False, 'from sklearn.metrics import auc\n'), ((11146, 11189), 'numpy.append', 'np.append', (['y_true_micro', '(y_true_labels == i)'], {}), '(y_true_micro, y_true_labels == i)\n', (11155, 11189), True, 'import numpy as np\n'), ((11223, 11274), 'numpy.append', 'np.append', (['y_scores_micro', 'y_predicted_scores[:, i]'], {}), '(y_scores_micro, y_predicted_scores[:, i])\n', (11232, 11274), True, 'import numpy as np\n'), ((6473, 6498), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (6496, 6498), False, 'import randomcolor\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*
import collections
from census_data_downloader.core.tables import BaseTableConfig
from census_data_downloader.core.decorators import register
@register
class MedianAgeDownloader(BaseTableConfig):
PROCESSED_TABLE_NAME = 'medianage'
UNIVERSE = "total population"
RAW_TABLE_NAME = 'B01002'
RAW_FIELD_CROSSWALK = collections.OrderedDict({
"001": "median",
"002": "male",
"003": "female"
})
| [
"collections.OrderedDict"
] | [((373, 447), 'collections.OrderedDict', 'collections.OrderedDict', (["{'001': 'median', '002': 'male', '003': 'female'}"], {}), "({'001': 'median', '002': 'male', '003': 'female'})\n", (396, 447), False, 'import collections\n')] |
# Copyright 2018 Bloomberg Finance L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from prometheus_client import Counter
from powerfulseal.metriccollectors import AbstractCollector
from powerfulseal.metriccollectors.collector import NODE_SOURCE, POD_SOURCE
STATUS_SUCCESS = 'success'
STATUS_FAILURE = 'failure'
# Define Prometheus metrics to be stored in the default registry
POD_KILLS_METRIC_NAME = 'seal_pod_kills_total'
POD_KILLS = Counter(POD_KILLS_METRIC_NAME,
'Number of pods killed (including failures)',
['status', 'namespace', 'name'])
NODE_STOPS_METRIC_NAME = 'seal_nodes_stopped_total'
NODE_STOPS = Counter(NODE_STOPS_METRIC_NAME,
'Number of nodes stopped (including failures)',
['status', 'uid', 'name'])
EXECUTE_FAILED_METRIC_NAME = 'seal_execute_failed_total'
EXECUTE_FAILURES = Counter(EXECUTE_FAILED_METRIC_NAME,
'Increasing counter for command execution failures',
['uid', 'name'])
FILTERED_TO_EMPTY_SET_METRIC_NAME = 'seal_empty_filter_total'
FILTERED_TO_EMPTY_SET = Counter(FILTERED_TO_EMPTY_SET_METRIC_NAME,
'Increasing counter for cases where filtering '
'returns an empty result')
PROBABILITY_FILTER_NOT_PASSED_METRIC_NAME = 'seal_probability_filter_not_passed_total'
PROBABILITY_FILTER_NOT_PASSED = Counter(PROBABILITY_FILTER_NOT_PASSED_METRIC_NAME,
'Increasing counter for cases where the'
' probability filter does not pass any '
'nodes')
MATCHED_TO_EMPTY_SET_METRIC_NAME = 'seal_empty_match_total'
MATCHED_TO_EMPTY_SET = Counter(MATCHED_TO_EMPTY_SET_METRIC_NAME,
'Increasing counter for cases where matching '
'returns an empty result',
['source'])
class PrometheusCollector(AbstractCollector):
def __init__(self):
# Export 0 for time series metrics which have labels which can have default
# values filled to avoid missing metrics. The Prometheus Python library
# already exports 0 for metrics which do not have any labels.
MATCHED_TO_EMPTY_SET.labels(NODE_SOURCE).inc(0)
MATCHED_TO_EMPTY_SET.labels(POD_SOURCE).inc(0)
def add_pod_killed_metric(self, pod):
POD_KILLS.labels(STATUS_SUCCESS, pod.namespace, pod.name).inc()
def add_pod_kill_failed_metric(self, pod):
POD_KILLS.labels(STATUS_FAILURE, pod.namespace, pod.name).inc()
def add_node_stopped_metric(self, node):
NODE_STOPS.labels(STATUS_SUCCESS, node.uid, node.name).inc()
def add_node_stop_failed_metric(self, node):
NODE_STOPS.labels(STATUS_FAILURE, node.uid, node.name).inc()
def add_execute_failed_metric(self, node):
EXECUTE_FAILURES.labels(node.uid, node.name).inc()
def add_filtered_to_empty_set_metric(self):
FILTERED_TO_EMPTY_SET.inc()
def add_probability_filter_passed_no_nodes_filter(self):
PROBABILITY_FILTER_NOT_PASSED.inc()
def add_matched_to_empty_set_metric(self, source):
MATCHED_TO_EMPTY_SET.labels(source).inc()
| [
"prometheus_client.Counter"
] | [((943, 1056), 'prometheus_client.Counter', 'Counter', (['POD_KILLS_METRIC_NAME', '"""Number of pods killed (including failures)"""', "['status', 'namespace', 'name']"], {}), "(POD_KILLS_METRIC_NAME, 'Number of pods killed (including failures)',\n ['status', 'namespace', 'name'])\n", (950, 1056), False, 'from prometheus_client import Counter\n'), ((1159, 1269), 'prometheus_client.Counter', 'Counter', (['NODE_STOPS_METRIC_NAME', '"""Number of nodes stopped (including failures)"""', "['status', 'uid', 'name']"], {}), "(NODE_STOPS_METRIC_NAME,\n 'Number of nodes stopped (including failures)', ['status', 'uid', 'name'])\n", (1166, 1269), False, 'from prometheus_client import Counter\n'), ((1385, 1494), 'prometheus_client.Counter', 'Counter', (['EXECUTE_FAILED_METRIC_NAME', '"""Increasing counter for command execution failures"""', "['uid', 'name']"], {}), "(EXECUTE_FAILED_METRIC_NAME,\n 'Increasing counter for command execution failures', ['uid', 'name'])\n", (1392, 1494), False, 'from prometheus_client import Counter\n'), ((1632, 1750), 'prometheus_client.Counter', 'Counter', (['FILTERED_TO_EMPTY_SET_METRIC_NAME', '"""Increasing counter for cases where filtering returns an empty result"""'], {}), "(FILTERED_TO_EMPTY_SET_METRIC_NAME,\n 'Increasing counter for cases where filtering returns an empty result')\n", (1639, 1750), False, 'from prometheus_client import Counter\n'), ((1934, 2078), 'prometheus_client.Counter', 'Counter', (['PROBABILITY_FILTER_NOT_PASSED_METRIC_NAME', '"""Increasing counter for cases where the probability filter does not pass any nodes"""'], {}), "(PROBABILITY_FILTER_NOT_PASSED_METRIC_NAME,\n 'Increasing counter for cases where the probability filter does not pass any nodes'\n )\n", (1941, 2078), False, 'from prometheus_client import Counter\n'), ((2280, 2412), 'prometheus_client.Counter', 'Counter', (['MATCHED_TO_EMPTY_SET_METRIC_NAME', '"""Increasing counter for cases where matching returns an empty result"""', "['source']"], {}), "(MATCHED_TO_EMPTY_SET_METRIC_NAME,\n 'Increasing counter for cases where matching returns an empty result',\n ['source'])\n", (2287, 2412), False, 'from prometheus_client import Counter\n')] |
import dectate
import pytest
from kaybee.plugins.widgets.directive import WidgetDirective
from kaybee.plugins.widgets.action import WidgetAction
class Dummy:
pass
@pytest.fixture()
def widgets_kb_app():
class widgets_kb_app(dectate.App):
widget = dectate.directive(WidgetAction)
yield widgets_kb_app
@pytest.fixture()
def dummy_props():
class DummyProps:
template = 'foo'
label = 'somelabel'
yield DummyProps
@pytest.fixture()
def dummy_widget_class(dummy_props):
class DummyWidget:
def __init__(self, docname, wtype, yaml_content, rst_content=None):
self.docname = docname
self.wtype = wtype
self.content = yaml_content
self.props = dummy_props()
self.name = docname + '-somename'
yield DummyWidget
@pytest.fixture()
def dummy_directive_class():
class DummyDirective(WidgetDirective):
name = 'dummy_directive'
yield DummyDirective
@pytest.fixture()
def dummy_directive(dummy_directive_class):
bd = dummy_directive_class(
dummy_directive_class.name, [], dict(), '', 0, 0, '', {}, {})
bd.state = Dummy()
bd.state.document = Dummy()
bd.state.document.settings = Dummy()
bd.state.document.settings.env = Dummy()
bd.state.document.settings.env.docname = 'somedoc'
bd.state.document.settings.env.widgets = dict()
yield bd
@pytest.fixture()
def widgets_sphinx_app(sphinx_app):
sphinx_app.env.widgets = dict()
sphinx_app.env.resources = dict()
sphinx_app.env.references = dict()
yield sphinx_app
| [
"pytest.fixture",
"dectate.directive"
] | [((173, 189), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (187, 189), False, 'import pytest\n'), ((329, 345), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (343, 345), False, 'import pytest\n'), ((465, 481), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (479, 481), False, 'import pytest\n'), ((836, 852), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (850, 852), False, 'import pytest\n'), ((987, 1003), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (1001, 1003), False, 'import pytest\n'), ((1415, 1431), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (1429, 1431), False, 'import pytest\n'), ((268, 299), 'dectate.directive', 'dectate.directive', (['WidgetAction'], {}), '(WidgetAction)\n', (285, 299), False, 'import dectate\n')] |
import os
import time
import random
import scipy.sparse as sp
import numpy as np
import tensorflow as tf
import argparse
from models import SpHGAT
from utils import process
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', help='Dataset.', default='imdb', type=str)
parser.add_argument('--epochs', help='Epochs.', default=100000, type=int)
parser.add_argument('--patience', help='Patience for early stopping.', default=100, type=int)
parser.add_argument('--lr', help='Learning rate.', default=0.005, type=float)
parser.add_argument('--l2_coef', help='Weight decay.', default=0.0005, type=float)
parser.add_argument('--dropout', help='Dropout.', default=0.6, type=float)
parser.add_argument('--train_rate', help='Label rate for training.', default=0.1, type=float)
parser.add_argument('--seed', help='Random seed for data splitting.', default=None, type=int)
parser.add_argument('--layers', help='Number of layers.', default=2, type=int)
parser.add_argument('--hid', help='Number of hidden units per head in each layer.',
nargs='*', default=[8, 8], type=int)
parser.add_argument('--heads', help='Number of attention heads in each layer.',
nargs='*', default=[8, 1], type=int)
parser.add_argument('--residue', help='Using residue.', action='store_true')
parser.add_argument('--repeat', help='Repeat.', default=10, type=int)
parser.add_argument('--random_feature', help='Random features', action='store_true')
parser.add_argument('--target_node', help='index of target nodes for classification.',
nargs='*', default=[0, 1], type=int)
parser.add_argument('--target_is_multilabels', help='each type of target node for classification is multi-labels or not.(0 means not else means yes)',
nargs='*', default=[0, 1], type=int)
parser.add_argument('--saved_model_suffix', help='to splite checkpoint by suffix', default="", type=str)
parser.add_argument('--no_attn_reg', help='Do not use edge direction regularization', action='store_true')
parser.add_argument('--simple_inner', help='Use original inner product', action='store_true')
parser.add_argument('--loop_coef', help='Coefficient for regularization.', default=1e-3, type=float)
parser.add_argument('--inv_coef', help='Coefficient for regularization.', default=1e-3, type=float)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
args= parser.parse_args()
dataset = args.dataset
checkpt_file = 'pre_trained/{}/{}/{}.ckpt'.format(dataset, args.saved_model_suffix, dataset)
checkpt_file = checkpt_file.replace('//', '/')
process.mkdir(os.path.split(checkpt_file)[0])
# training params
batch_size = 1
train_rate = args.train_rate
seed = args.seed
nb_epochs = args.epochs
patience = args.patience
lr = args.lr # learning rate
l2_coef = args.l2_coef # weight decay
dropout = args.dropout
repeat = args.repeat
random_feature = args.random_feature
target_node = args.target_node
is_multilabel = [False if t==0 else True for t in args.target_is_multilabels]
loop_coef = args.loop_coef
inv_coef = args.inv_coef
layers = args.layers
hid = args.hid
if len(hid) == 1:
hid_units = hid * layers
elif len(hid) == layers:
hid_units = hid
heads = args.heads
if len(heads) == 1:
n_heads = heads * layers
elif len(heads) == 2:
n_heads = [heads[0]] * (layers - 1) + [heads[1]]
elif len(heads) == layers:
n_heads = heads
residual = args.residue # False
nonlinearity = tf.nn.elu
model = SpHGAT
no_attn_reg = args.no_attn_reg
simple_inner = args.simple_inner
random.seed(seed) # random seed for random data split only
print('Dataset: ' + dataset)
print('Train rate: ' + str(train_rate))
print('----- Opt. hyperparams -----')
print('lr: ' + str(lr))
print('l2_coef: ' + str(l2_coef))
print('----- Archi. hyperparams -----')
print('nb. layers: ' + str(len(hid_units)))
print('nb. units per layer: ' + str(hid_units))
print('nb. attention heads: ' + str(n_heads))
print('residual: ' + str(residual))
print('nonlinearity: ' + str(nonlinearity))
print('model: ' + str(model))
print('target nodes: ', target_node)
print('is_multilabel: ', is_multilabel)
print('loop_coef:', loop_coef)
print('inv_coef:', inv_coef)
sparse = True
metr_num = 2
total_vl_acc = np.array([0.]*(len(target_node)*metr_num)) # should be array
total_ts_acc = np.array([0.]*(len(target_node)*metr_num)) # should be array
def get_loss_acc(logits, labels, msk, is_multilabel=False):
global model
class_num = labels.shape[-1]
log_resh = tf.reshape(logits, [-1, class_num])
lab_resh = tf.reshape(labels, [-1, class_num])
msk_resh = tf.reshape(msk, [-1])
if is_multilabel:
loss = model.masked_sigmoid_cross_entropy(log_resh, lab_resh, msk_resh)
accuracy = [model.micro_f1(log_resh, lab_resh, msk_resh), model.macro_f1(log_resh, lab_resh, msk_resh)]
acc_name = ['if1', 'af1']
acc_full_name = ['micro f1', 'macro f1']
else:
loss = model.masked_softmax_cross_entropy(log_resh, lab_resh, msk_resh)
accuracy = [model.micro_f1_onelabel(log_resh, lab_resh, msk_resh), model.macro_f1_onelabel(log_resh, lab_resh, msk_resh)]
acc_name = ['if1', 'af1']
acc_full_name = ['micro f1', 'macro f1']
return loss, accuracy, acc_name, acc_full_name
def print_eachclass_info(train_loss_each, train_acc_each, val_loss_each, val_acc_each, acc_name):
tl_average = np.mean(np.array(train_loss_each), axis=0)
ta_average = np.mean(np.array(train_acc_each), axis=0)
vl_average = np.mean(np.array(val_loss_each), axis=0)
va_average = np.mean(np.array(val_acc_each), axis=0)
metric_num = int(len(ta_average)/len(tl_average))
for i in range(len(tl_average)):
line = '\t\t target %s: loss = %.3f, ' % (i, tl_average[i])
for j in range(metric_num):
line += '%s = %.5f, ' % (acc_name[i*metric_num+j], ta_average[i*metric_num+j])
line += '| Val: loss = %.3f, ' % (vl_average[i])
for j in range(metric_num):
line += '%s = %.5f, ' % (acc_name[i*metric_num+j], va_average[i*metric_num+j])
print(line)
for repeat_i in range(repeat):
print('Run #' + str(repeat_i) + ':')
adj, adj_type, edge_list, features, y_train, y_val, y_test,\
train_mask, val_mask, test_mask = process.load_heterogeneous_data(dataset, train_rate=train_rate, target_node=target_node)
features = [process.preprocess_features(feature)[0] for feature in features]
nb_nodes = [feature.shape[0] for feature in features]
ft_size = [feature.shape[1] for feature in features]
nb_classes = [y.shape[1] for y in y_train]
features = [feature[np.newaxis] for feature in features]
y_train = [y[np.newaxis] for y in y_train]
y_val = [y[np.newaxis] for y in y_val]
y_test = [y[np.newaxis] for y in y_test]
train_mask = [m[np.newaxis] for m in train_mask]
val_mask = [m[np.newaxis] for m in val_mask]
test_mask = [m[np.newaxis] for m in test_mask]
if random_feature:
features[0] = np.random.standard_normal(features[0].shape)
if sparse:
biases = [process.preprocess_adj_hete(a) for a in adj] # transposed here
else:
biases = []
for a in adj:
a = a.todense()
a = a[np.newaxis]
if no_attn_reg:
edge_list = [(i,) for i in range(len(adj_type))]
if simple_inner:
edge_list = []
with tf.Graph().as_default():
with tf.name_scope('input'):
ftr_in = [tf.placeholder(dtype=tf.float32,
shape=(batch_size, nb, ft)) for nb, ft in zip(nb_nodes, ft_size)]
if sparse:
bias_in = [tf.sparse_placeholder(dtype=tf.float32) for _ in biases]
else:
bias_in = None
lbl_in = [tf.placeholder(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]], nb_classes[i])) for i in range(len(nb_classes))]
msk_in = [tf.placeholder(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]])) for i in range(len(nb_classes))]
attn_drop = tf.placeholder(dtype=tf.float32, shape=())
ffd_drop = tf.placeholder(dtype=tf.float32, shape=())
is_train = tf.placeholder(dtype=tf.bool, shape=())
logits = model.inference(ftr_in, nb_classes, nb_nodes, is_train,
attn_drop, ffd_drop, target_nodes=target_node,
bias_mat=bias_in, adj_type=adj_type,
edge_list=edge_list,
hid_units=hid_units, n_heads=n_heads,
residual=residual, activation=nonlinearity)
with tf.name_scope('loss_acc'):
loss, accuracy, acc_name, acc_full_name = [], [], [], []
all_class_loss = 0.0
for tn in range(len(target_node)):
tn_logits = logits[tn]
tn_labels = lbl_in[tn]
tn_masks = msk_in[tn]
tn_is_multilabel = is_multilabel[tn]
tn_loss, tn_accuracy, tn_acc_name, tn_acc_full_name = get_loss_acc(tn_logits, tn_labels, tn_masks, is_multilabel=tn_is_multilabel)
loss.append(tn_loss)
accuracy.extend(tn_accuracy)
acc_name.extend(tn_acc_name)
acc_full_name.extend(tn_acc_full_name)
all_class_loss += tn_loss
loss_loop = tf.add_n(tf.get_collection('loss_loop')) * loop_coef
loss_inv= tf.add_n(tf.get_collection('loss_inv')) * inv_coef
train_op = model.training(all_class_loss + loss_loop + loss_inv, lr, l2_coef)
saver = tf.train.Saver()
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
vlss_mn = np.inf
vacc_mx = 0.0
curr_step = 0
with tf.Session(config=config) as sess:
sess.run(init_op)
vacc_early_model = 0.0
vlss_early_model = 0.0
vacc_each_early_model = np.array([0.]*(len(target_node)*metr_num))
for epoch in range(nb_epochs):
# summary information
train_loss_avg = 0
train_acc_avg = 0
val_loss_avg = 0
val_acc_avg = 0
# for each class information
train_loss_each = []
train_acc_each = []
val_loss_each = []
val_acc_each = []
tr_step = 0
tr_size = features[0].shape[0]
while tr_step * batch_size < tr_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[tr_step * batch_size:(tr_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[tr_step * batch_size:(tr_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[tr_step*batch_size:(tr_step+1)*batch_size] for i, d in zip(lbl_in, y_train)})
fd.update({i:d[tr_step*batch_size:(tr_step+1)*batch_size] for i, d in zip(msk_in, train_mask)})
fd.update({is_train: True})
fd.update({attn_drop: dropout, ffd_drop:dropout})
_, loss_list_tr, acc_list_tr, loss_loop_tr, loss_inv_tr = sess.run([train_op, loss, accuracy, loss_loop, loss_inv], feed_dict=fd)
train_loss_each.append(np.array(loss_list_tr))
train_acc_each.append(np.array(acc_list_tr))
train_loss_avg += np.sum(np.array(loss_list_tr))
train_acc_avg += np.sum(np.array(acc_list_tr))
tr_step += 1
vl_step = 0
vl_size = features[0].shape[0]
while vl_step * batch_size < vl_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[vl_step * batch_size:(vl_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[vl_step * batch_size:(vl_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[vl_step*batch_size:(vl_step+1)*batch_size] for i, d in zip(lbl_in, y_val)})
fd.update({i:d[vl_step*batch_size:(vl_step+1)*batch_size] for i, d in zip(msk_in, val_mask)})
fd.update({is_train: False})
fd.update({attn_drop: 0.0, ffd_drop:0.0})
loss_list_vl, acc_list_vl = sess.run([loss, accuracy], feed_dict=fd)
acc_list_vl = [0. if np.isnan(acc_vl) else acc_vl for acc_vl in acc_list_vl]
val_loss_each.append(np.array(loss_list_vl))
val_acc_each.append(np.array(acc_list_vl))
val_loss_avg += np.sum(np.array(loss_list_vl))
val_acc_avg += np.sum(np.array(acc_list_vl))
vl_step += 1
print('Training %s: loss = %.5f, %s = %.5f, loss_loop = %.5f, loss_inv = %.5f | Val: loss = %.5f, %s = %.5f' %
(epoch, train_loss_avg/tr_step, 'acc/F1', train_acc_avg/tr_step,
loss_loop_tr, loss_inv_tr,
val_loss_avg/vl_step, 'acc/F1', val_acc_avg/vl_step))
print_eachclass_info(train_loss_each, train_acc_each, val_loss_each, val_acc_each, acc_name)
if val_acc_avg/vl_step > vacc_mx or val_loss_avg/vl_step < vlss_mn:
if val_acc_avg/vl_step > vacc_mx and val_loss_avg/vl_step < vlss_mn:
vacc_early_model = val_acc_avg/vl_step
vlss_early_model = val_loss_avg/vl_step
vacc_each_early_model = np.mean(np.array(val_acc_each), axis=0)
saver.save(sess, checkpt_file)
print("saved model as %s"%checkpt_file)
vacc_mx = np.max((val_acc_avg/vl_step, vacc_mx))
vlss_mn = np.min((val_loss_avg/vl_step, vlss_mn))
curr_step = 0
else:
curr_step += 1
if curr_step == patience:
print('Early stop! Min loss: ', vlss_mn,
', Max', 'acc/F1', ': ', vacc_mx)
print('Early stop model validation loss: ', vlss_early_model,
', ', 'acc/F1', ': ', vacc_early_model)
total_vl_acc += vacc_each_early_model
break
if curr_step < patience:
print('Min loss: ', vlss_mn, ', Max', 'acc/F1', ': ', vacc_mx)
print('model validation loss: ', vlss_early_model, ', ', 'acc/F1', ': ', vacc_early_model)
total_vl_acc += vacc_each_early_model
saver.restore(sess, checkpt_file)
ts_size = features[0].shape[0]
ts_step = 0
test_loss_each = []
test_acc_each = []
while ts_step * batch_size < ts_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[ts_step * batch_size:(ts_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[ts_step * batch_size:(ts_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[ts_step*batch_size:(ts_step+1)*batch_size] for i, d in zip(lbl_in, y_test)})
fd.update({i:d[ts_step*batch_size:(ts_step+1)*batch_size] for i, d in zip(msk_in, test_mask)})
fd.update({is_train: False})
fd.update({attn_drop: 0.0, ffd_drop:0.0})
loss_list_ts, acc_list_ts = sess.run([loss, accuracy], feed_dict=fd)
test_loss_each.append(np.array(loss_list_ts))
test_acc_each.append(np.array(acc_list_ts))
ts_step += 1
test_loss_each = np.mean(np.array(test_loss_each), axis=0)
test_acc_each = np.mean(np.array(test_acc_each), axis=0)
print('*'*10,'Test information:', '*'*10)
for e in range(len(target_node)):
print('target %s: loss: %.3f, %s:%.5f, %s:%.5f' % (e, test_loss_each[e], acc_full_name[e*metr_num], test_acc_each[e*metr_num], acc_full_name[e*metr_num+1], test_acc_each[e*metr_num+1]))
total_ts_acc += test_acc_each
sess.close()
print('Validation:', total_vl_acc/repeat, 'Test:', total_ts_acc/repeat)
| [
"tensorflow.local_variables_initializer",
"numpy.random.standard_normal",
"tensorflow.sparse_placeholder",
"utils.process.load_heterogeneous_data",
"numpy.array",
"utils.process.preprocess_features",
"tensorflow.Graph",
"argparse.ArgumentParser",
"tensorflow.placeholder",
"tensorflow.Session",
"... | [((184, 209), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (207, 209), False, 'import argparse\n'), ((2336, 2377), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {'allow_soft_placement': '(True)'}), '(allow_soft_placement=True)\n', (2350, 2377), True, 'import tensorflow as tf\n'), ((3550, 3567), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (3561, 3567), False, 'import random\n'), ((4509, 4544), 'tensorflow.reshape', 'tf.reshape', (['logits', '[-1, class_num]'], {}), '(logits, [-1, class_num])\n', (4519, 4544), True, 'import tensorflow as tf\n'), ((4560, 4595), 'tensorflow.reshape', 'tf.reshape', (['labels', '[-1, class_num]'], {}), '(labels, [-1, class_num])\n', (4570, 4595), True, 'import tensorflow as tf\n'), ((4611, 4632), 'tensorflow.reshape', 'tf.reshape', (['msk', '[-1]'], {}), '(msk, [-1])\n', (4621, 4632), True, 'import tensorflow as tf\n'), ((6293, 6386), 'utils.process.load_heterogeneous_data', 'process.load_heterogeneous_data', (['dataset'], {'train_rate': 'train_rate', 'target_node': 'target_node'}), '(dataset, train_rate=train_rate, target_node\n =target_node)\n', (6324, 6386), False, 'from utils import process\n'), ((2621, 2648), 'os.path.split', 'os.path.split', (['checkpt_file'], {}), '(checkpt_file)\n', (2634, 2648), False, 'import os\n'), ((5414, 5439), 'numpy.array', 'np.array', (['train_loss_each'], {}), '(train_loss_each)\n', (5422, 5439), True, 'import numpy as np\n'), ((5474, 5498), 'numpy.array', 'np.array', (['train_acc_each'], {}), '(train_acc_each)\n', (5482, 5498), True, 'import numpy as np\n'), ((5533, 5556), 'numpy.array', 'np.array', (['val_loss_each'], {}), '(val_loss_each)\n', (5541, 5556), True, 'import numpy as np\n'), ((5591, 5613), 'numpy.array', 'np.array', (['val_acc_each'], {}), '(val_acc_each)\n', (5599, 5613), True, 'import numpy as np\n'), ((7034, 7078), 'numpy.random.standard_normal', 'np.random.standard_normal', (['features[0].shape'], {}), '(features[0].shape)\n', (7059, 7078), True, 'import numpy as np\n'), ((9690, 9706), 'tensorflow.train.Saver', 'tf.train.Saver', ([], {}), '()\n', (9704, 9706), True, 'import tensorflow as tf\n'), ((6398, 6434), 'utils.process.preprocess_features', 'process.preprocess_features', (['feature'], {}), '(feature)\n', (6425, 6434), False, 'from utils import process\n'), ((7117, 7147), 'utils.process.preprocess_adj_hete', 'process.preprocess_adj_hete', (['a'], {}), '(a)\n', (7144, 7147), False, 'from utils import process\n'), ((7476, 7498), 'tensorflow.name_scope', 'tf.name_scope', (['"""input"""'], {}), "('input')\n", (7489, 7498), True, 'import tensorflow as tf\n'), ((8096, 8138), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '()'}), '(dtype=tf.float32, shape=())\n', (8110, 8138), True, 'import tensorflow as tf\n'), ((8162, 8204), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '()'}), '(dtype=tf.float32, shape=())\n', (8176, 8204), True, 'import tensorflow as tf\n'), ((8228, 8267), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.bool', 'shape': '()'}), '(dtype=tf.bool, shape=())\n', (8242, 8267), True, 'import tensorflow as tf\n'), ((8722, 8747), 'tensorflow.name_scope', 'tf.name_scope', (['"""loss_acc"""'], {}), "('loss_acc')\n", (8735, 8747), True, 'import tensorflow as tf\n'), ((9739, 9772), 'tensorflow.global_variables_initializer', 'tf.global_variables_initializer', ([], {}), '()\n', (9770, 9772), True, 'import tensorflow as tf\n'), ((9774, 9806), 'tensorflow.local_variables_initializer', 'tf.local_variables_initializer', ([], {}), '()\n', (9804, 9806), True, 'import tensorflow as tf\n'), ((9900, 9925), 'tensorflow.Session', 'tf.Session', ([], {'config': 'config'}), '(config=config)\n', (9910, 9925), True, 'import tensorflow as tf\n'), ((7438, 7448), 'tensorflow.Graph', 'tf.Graph', ([], {}), '()\n', (7446, 7448), True, 'import tensorflow as tf\n'), ((7522, 7582), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '(batch_size, nb, ft)'}), '(dtype=tf.float32, shape=(batch_size, nb, ft))\n', (7536, 7582), True, 'import tensorflow as tf\n'), ((7815, 7910), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.int32', 'shape': '(batch_size, nb_nodes[target_node[i]], nb_classes[i])'}), '(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]],\n nb_classes[i]))\n', (7829, 7910), True, 'import tensorflow as tf\n'), ((7962, 8038), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.int32', 'shape': '(batch_size, nb_nodes[target_node[i]])'}), '(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]]))\n', (7976, 8038), True, 'import tensorflow as tf\n'), ((16595, 16619), 'numpy.array', 'np.array', (['test_loss_each'], {}), '(test_loss_each)\n', (16603, 16619), True, 'import numpy as np\n'), ((16665, 16688), 'numpy.array', 'np.array', (['test_acc_each'], {}), '(test_acc_each)\n', (16673, 16688), True, 'import numpy as np\n'), ((7687, 7726), 'tensorflow.sparse_placeholder', 'tf.sparse_placeholder', ([], {'dtype': 'tf.float32'}), '(dtype=tf.float32)\n', (7708, 7726), True, 'import tensorflow as tf\n'), ((9471, 9501), 'tensorflow.get_collection', 'tf.get_collection', (['"""loss_loop"""'], {}), "('loss_loop')\n", (9488, 9501), True, 'import tensorflow as tf\n'), ((9546, 9575), 'tensorflow.get_collection', 'tf.get_collection', (['"""loss_inv"""'], {}), "('loss_inv')\n", (9563, 9575), True, 'import tensorflow as tf\n'), ((14392, 14432), 'numpy.max', 'np.max', (['(val_acc_avg / vl_step, vacc_mx)'], {}), '((val_acc_avg / vl_step, vacc_mx))\n', (14398, 14432), True, 'import numpy as np\n'), ((14461, 14502), 'numpy.min', 'np.min', (['(val_loss_avg / vl_step, vlss_mn)'], {}), '((val_loss_avg / vl_step, vlss_mn))\n', (14467, 14502), True, 'import numpy as np\n'), ((16445, 16467), 'numpy.array', 'np.array', (['loss_list_ts'], {}), '(loss_list_ts)\n', (16453, 16467), True, 'import numpy as np\n'), ((16506, 16527), 'numpy.array', 'np.array', (['acc_list_ts'], {}), '(acc_list_ts)\n', (16514, 16527), True, 'import numpy as np\n'), ((11684, 11706), 'numpy.array', 'np.array', (['loss_list_tr'], {}), '(loss_list_tr)\n', (11692, 11706), True, 'import numpy as np\n'), ((11750, 11771), 'numpy.array', 'np.array', (['acc_list_tr'], {}), '(acc_list_tr)\n', (11758, 11771), True, 'import numpy as np\n'), ((11818, 11840), 'numpy.array', 'np.array', (['loss_list_tr'], {}), '(loss_list_tr)\n', (11826, 11840), True, 'import numpy as np\n'), ((11886, 11907), 'numpy.array', 'np.array', (['acc_list_tr'], {}), '(acc_list_tr)\n', (11894, 11907), True, 'import numpy as np\n'), ((13138, 13160), 'numpy.array', 'np.array', (['loss_list_vl'], {}), '(loss_list_vl)\n', (13146, 13160), True, 'import numpy as np\n'), ((13202, 13223), 'numpy.array', 'np.array', (['acc_list_vl'], {}), '(acc_list_vl)\n', (13210, 13223), True, 'import numpy as np\n'), ((13268, 13290), 'numpy.array', 'np.array', (['loss_list_vl'], {}), '(loss_list_vl)\n', (13276, 13290), True, 'import numpy as np\n'), ((13334, 13355), 'numpy.array', 'np.array', (['acc_list_vl'], {}), '(acc_list_vl)\n', (13342, 13355), True, 'import numpy as np\n'), ((13041, 13057), 'numpy.isnan', 'np.isnan', (['acc_vl'], {}), '(acc_vl)\n', (13049, 13057), True, 'import numpy as np\n'), ((14211, 14233), 'numpy.array', 'np.array', (['val_acc_each'], {}), '(val_acc_each)\n', (14219, 14233), True, 'import numpy as np\n')] |
from django import forms
from .models import Problem
class ProblemForm(forms.ModelForm):
options = (
('A', 'A'),
('B', 'B'),
('C', 'C'),
('D', 'D'),
)
choice = forms.ChoiceField(choices=options)
class Meta:
model = Problem
fields = '__all__'
# exclude = ['answer']
widgets = {
'answer': forms.HiddenInput(),
'description': forms.Textarea(attrs={'readonly':'readonly', 'style': 'border: None'}),
'opt1': forms.TextInput(attrs={'readonly':'readonly'}),
'opt2': forms.TextInput(attrs={'readonly':'readonly'}),
'opt3': forms.TextInput(attrs={'readonly':'readonly'}),
'opt4': forms.TextInput(attrs={'readonly':'readonly'}),
'difficulty': forms.TextInput(attrs={'readonly':'readonly'}),
}
| [
"django.forms.ChoiceField",
"django.forms.HiddenInput",
"django.forms.Textarea",
"django.forms.TextInput"
] | [((172, 206), 'django.forms.ChoiceField', 'forms.ChoiceField', ([], {'choices': 'options'}), '(choices=options)\n', (189, 206), False, 'from django import forms\n'), ((311, 330), 'django.forms.HiddenInput', 'forms.HiddenInput', ([], {}), '()\n', (328, 330), False, 'from django import forms\n'), ((350, 421), 'django.forms.Textarea', 'forms.Textarea', ([], {'attrs': "{'readonly': 'readonly', 'style': 'border: None'}"}), "(attrs={'readonly': 'readonly', 'style': 'border: None'})\n", (364, 421), False, 'from django import forms\n'), ((433, 480), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'readonly': 'readonly'}"}), "(attrs={'readonly': 'readonly'})\n", (448, 480), False, 'from django import forms\n'), ((492, 539), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'readonly': 'readonly'}"}), "(attrs={'readonly': 'readonly'})\n", (507, 539), False, 'from django import forms\n'), ((551, 598), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'readonly': 'readonly'}"}), "(attrs={'readonly': 'readonly'})\n", (566, 598), False, 'from django import forms\n'), ((610, 657), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'readonly': 'readonly'}"}), "(attrs={'readonly': 'readonly'})\n", (625, 657), False, 'from django import forms\n'), ((675, 722), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'readonly': 'readonly'}"}), "(attrs={'readonly': 'readonly'})\n", (690, 722), False, 'from django import forms\n')] |
#!/usr/bin/env python
"""
Create a spreadsheet with two tables, using some named ranges.
"""
import os
from odfdo import Document, Table
if __name__ == "__main__":
document = Document('spreadsheet')
body = document.body
table = Table("First Table")
body.append(table)
# populate the table :
for i in range(10):
table.set_value((1, i), (i + 1)**2)
table.set_value("A11", "Total:")
# lets define a named range for the 10 values :
crange = "B1:B10"
name = "squares_values"
table_name = table.name
table.set_named_range(name, crange, table_name)
# we can define a single cell range, using notation "B11" or (1, 10) :
table.set_named_range('total', (1, 10), table_name)
# get named range values :
values = table.get_named_range('squares_values').get_values(flat=True)
# set named range value :
result = sum(values)
table.get_named_range('total').set_value(result)
# lets use the named ranges from a second table :
table2 = Table("Second Table")
body.append(table2)
named_range1 = table2.get_named_range('total')
table2.set_value('A1', "name:")
table2.set_value('B1', named_range1.name)
table2.set_value('A2', "range:")
table2.set_value('B2', str(named_range1.crange))
table2.set_value('A3', "from table:")
table2.set_value('B3', named_range1.table_name)
table2.set_value('A4', "content:")
table2.set_value('B4', named_range1.get_value())
named_range2 = table2.get_named_range('squares_values')
table2.set_value('D1', "name:")
table2.set_value('E1', named_range2.name)
table2.set_value('D2', "range:")
table2.set_value('E2', str(named_range2.crange))
table2.set_value('D3', "from table:")
table2.set_value('E3', named_range2.table_name)
table2.set_value('D4', "content:")
# using "E4:4" notaion is a little hack for the area starting at E4 on row 4
table2.set_values(
values=[named_range2.get_values(flat=True)], coord='E4:4')
print("Content of the table1:")
print(table.name)
print(table.to_csv())
print(table2.name)
print(table2.to_csv())
# of course named ranges are stored in the document :
if not os.path.exists('test_output'):
os.mkdir('test_output')
output = os.path.join('test_output', "my_spreadsheet_with_named_range.ods")
document.save(target=output, pretty=True)
| [
"os.path.exists",
"odfdo.Document",
"os.path.join",
"os.mkdir",
"odfdo.Table"
] | [((181, 204), 'odfdo.Document', 'Document', (['"""spreadsheet"""'], {}), "('spreadsheet')\n", (189, 204), False, 'from odfdo import Document, Table\n'), ((242, 262), 'odfdo.Table', 'Table', (['"""First Table"""'], {}), "('First Table')\n", (247, 262), False, 'from odfdo import Document, Table\n'), ((1017, 1038), 'odfdo.Table', 'Table', (['"""Second Table"""'], {}), "('Second Table')\n", (1022, 1038), False, 'from odfdo import Document, Table\n'), ((2291, 2357), 'os.path.join', 'os.path.join', (['"""test_output"""', '"""my_spreadsheet_with_named_range.ods"""'], {}), "('test_output', 'my_spreadsheet_with_named_range.ods')\n", (2303, 2357), False, 'import os\n'), ((2215, 2244), 'os.path.exists', 'os.path.exists', (['"""test_output"""'], {}), "('test_output')\n", (2229, 2244), False, 'import os\n'), ((2254, 2277), 'os.mkdir', 'os.mkdir', (['"""test_output"""'], {}), "('test_output')\n", (2262, 2277), False, 'import os\n')] |
from nltk.corpus.reader import CategorizedPlaintextCorpusReader
from nltk.tokenize.casual import TweetTokenizer
from nltk.classify.scikitlearn import SklearnClassifier
from sklearn.naive_bayes import BernoulliNB, MultinomialNB
from sklearn.svm import SVC, LinearSVC, NuSVC, LinearSVR, NuSVR
from sklearn.linear_model import LogisticRegression, LinearRegression, Perceptron
from featureExtractors import unigramsFeatures, bigramsFeatures, mpqaSubjectivityWordsCountFeatures, \
extraTwitterFeaturesCount, mpqaSentimentWordsCountFeatures
from lexicons.mpqa.mpqaDictionary import MpqaDictionaryWrapper
from normalization import normalizeTwitterWordsWithNegationHandle, normalizeTwitterWordsWithExtraFeatures
from utils import precision_recall_2step
import nltk, pickle
import csv
from itertools import product
tweetTokenizer = TweetTokenizer(reduce_len=True, preserve_case=True, strip_handles=False)
testcorpus = CategorizedPlaintextCorpusReader('corpus/standford/test', r'(pos|neg|neu)-tweet[0-9]+\.txt', cat_pattern=r'(\w+)-tweet[0-9]+\.txt', word_tokenizer=tweetTokenizer)
def performTestValidation(testset, polarClassifierName, sentiClassifierName):
with open(polarClassifierName, 'rb') as fileout:
polarClassifier = pickle.load(fileout)
with open(sentiClassifierName, 'rb') as fileout:
sentiClassifier = pickle.load(fileout)
labels = ['pos', 'neg', 'neu']
precisions, recalls, fscores, accuracy = precision_recall_2step(polarClassifier, sentiClassifier, testset, labels)
print("Test accuracy: {0:.3f}".format(accuracy))
measures = {label: (precision, recall, fscore) for label, precision, recall, fscore in zip(labels, precisions, recalls, fscores)}
for label, (prec, recall, fscore) in measures.items():
print("Precision for {0}: {1:.3f}".format(label, prec))
print("Recall for {0}: {1:.3f}".format(label, recall))
print("F measure for {0}: {1:.3f}".format(label, fscore))
return fscores, accuracy
def getfeaturesTest(normalizedWords, extraNormalizedWords):
features = {}
wordsTagged = nltk.pos_tag(normalizedWords)
features.update(unigramsFeatures(normalizedWords))
features.update(bigramsFeatures(normalizedWords))
features.update(mpqaSentimentWordsCountFeatures(wordsTagged, mpqaDictionary))
# features.update(mpqaSubjectivityWordsCountFeatures(wordsTagged, mpqaDictionary))
features.update(extraTwitterFeaturesCount(extraNormalizedWords))
return features
mpqaDictionary = MpqaDictionaryWrapper()
normalizationFunction = normalizeTwitterWordsWithNegationHandle
testfeatureset = []
with open("dumps/2step/polar/logreg/70pct/uni-bi-extra-mpqa-senti", 'rb') as fileout:
polarClassifier = pickle.load(fileout)
with open("dumps/2step/sentiment/logreg/80pct/uni-bi-extra-mpqa-senti", 'rb') as fileout:
sentiClassifier = pickle.load(fileout)
for category in testcorpus.categories():
for fileid in testcorpus.fileids(category):
words = testcorpus.words(fileids=[fileid])
normalizedWords = normalizationFunction(words)
extraNormalizedWords = normalizeTwitterWordsWithExtraFeatures(words)
testfeatures = getfeaturesTest(normalizedWords, extraNormalizedWords=extraNormalizedWords)
dec = polarClassifier.classify(testfeatures)
if dec == 'polar':
observed = sentiClassifier.classify(testfeatures)
else:
observed = 'neu'
real = testcorpus.categories(fileids=[fileid])
if real[0] != observed:
print(testcorpus.raw(fileids=[fileid]))
print("REAL: {}".format(real))
print("PREDICTED: {}".format(observed))
# performTestValidation(testfeatureset, "dumps/2step/polar/multiNB/uni-bi-extra-mpqa-subj", "dumps/2step/sentiment/multiNB/uni-bi-extra-mpqa-subj")
# performTestValidation(testfeatureset, "dumps/2step/polar/multiNB/uni-bi-extra-mpqa-subj", "dumps/2step/sentiment/logreg/uni-bi-extra-mpqa-subj")
# performTestValidation(testfeatureset, "dumps/2step/polar/logreg/uni-bi-extra-mpqa-subj", "dumps/2step/sentiment/multiNB/uni-bi-extra-mpqa-subj")
# performTestValidation(testfeatureset, "dumps/2step/polar/logreg/uni-bi-extra-mpqa-subj", "dumps/2step/sentiment/logreg/uni-bi-extra-mpqa-subj")
# with open("results2.csv", 'w') as csvfile:
# csvwriter = csv.writer(csvfile)
# csvwriter.writerow(('features', 'polar classifier', 'sentiment classifier', 'test accuracy', 'f score for pos', 'f score for neg', 'f score for neu'))
#
# polarDir = "dumps/2step/polar/"
# sentimentDir = "dumps/2step/sentiment"
# versionsSet = ['multiNB/60pct', 'multiNB/70pct', 'multiNB/80pct', 'logreg/60pct', 'logreg/70pct', 'logreg/80pct']
# for featuresVersion in ['uni-bi-extra-mpqa-senti']:
#
# tuples = product(versionsSet, versionsSet)
# for tuple in tuples:
# # print("CLASSIFIERS:")
# # print("Polar: " + tuple[0])
# # print("Sentiment: " + tuple[1])
# polarClassifierPath = polarDir + '/' + tuple[0] + '/' + featuresVersion
# sentimentClassifierPath = sentimentDir + '/' + tuple[1] + '/' + featuresVersion
# fscores, accuracy = performTestValidation(testfeatureset, polarClassifierPath, sentimentClassifierPath)
# csvwriter.writerow((featuresVersion, tuple[0], tuple[1], accuracy, fscores[0], fscores[1], fscores[2]))
# # print("\n\n") | [
"nltk.pos_tag",
"utils.precision_recall_2step",
"nltk.corpus.reader.CategorizedPlaintextCorpusReader",
"featureExtractors.unigramsFeatures",
"featureExtractors.bigramsFeatures",
"pickle.load",
"lexicons.mpqa.mpqaDictionary.MpqaDictionaryWrapper",
"normalization.normalizeTwitterWordsWithExtraFeatures",... | [((831, 903), 'nltk.tokenize.casual.TweetTokenizer', 'TweetTokenizer', ([], {'reduce_len': '(True)', 'preserve_case': '(True)', 'strip_handles': '(False)'}), '(reduce_len=True, preserve_case=True, strip_handles=False)\n', (845, 903), False, 'from nltk.tokenize.casual import TweetTokenizer\n'), ((917, 1089), 'nltk.corpus.reader.CategorizedPlaintextCorpusReader', 'CategorizedPlaintextCorpusReader', (['"""corpus/standford/test"""', '"""(pos|neg|neu)-tweet[0-9]+\\\\.txt"""'], {'cat_pattern': '"""(\\\\w+)-tweet[0-9]+\\\\.txt"""', 'word_tokenizer': 'tweetTokenizer'}), "('corpus/standford/test',\n '(pos|neg|neu)-tweet[0-9]+\\\\.txt', cat_pattern=\n '(\\\\w+)-tweet[0-9]+\\\\.txt', word_tokenizer=tweetTokenizer)\n", (949, 1089), False, 'from nltk.corpus.reader import CategorizedPlaintextCorpusReader\n'), ((2549, 2572), 'lexicons.mpqa.mpqaDictionary.MpqaDictionaryWrapper', 'MpqaDictionaryWrapper', ([], {}), '()\n', (2570, 2572), False, 'from lexicons.mpqa.mpqaDictionary import MpqaDictionaryWrapper\n'), ((1464, 1537), 'utils.precision_recall_2step', 'precision_recall_2step', (['polarClassifier', 'sentiClassifier', 'testset', 'labels'], {}), '(polarClassifier, sentiClassifier, testset, labels)\n', (1486, 1537), False, 'from utils import precision_recall_2step\n'), ((2133, 2162), 'nltk.pos_tag', 'nltk.pos_tag', (['normalizedWords'], {}), '(normalizedWords)\n', (2145, 2162), False, 'import nltk, pickle\n'), ((2768, 2788), 'pickle.load', 'pickle.load', (['fileout'], {}), '(fileout)\n', (2779, 2788), False, 'import nltk, pickle\n'), ((2901, 2921), 'pickle.load', 'pickle.load', (['fileout'], {}), '(fileout)\n', (2912, 2921), False, 'import nltk, pickle\n'), ((1246, 1266), 'pickle.load', 'pickle.load', (['fileout'], {}), '(fileout)\n', (1257, 1266), False, 'import nltk, pickle\n'), ((1354, 1374), 'pickle.load', 'pickle.load', (['fileout'], {}), '(fileout)\n', (1365, 1374), False, 'import nltk, pickle\n'), ((2183, 2216), 'featureExtractors.unigramsFeatures', 'unigramsFeatures', (['normalizedWords'], {}), '(normalizedWords)\n', (2199, 2216), False, 'from featureExtractors import unigramsFeatures, bigramsFeatures, mpqaSubjectivityWordsCountFeatures, extraTwitterFeaturesCount, mpqaSentimentWordsCountFeatures\n'), ((2238, 2270), 'featureExtractors.bigramsFeatures', 'bigramsFeatures', (['normalizedWords'], {}), '(normalizedWords)\n', (2253, 2270), False, 'from featureExtractors import unigramsFeatures, bigramsFeatures, mpqaSubjectivityWordsCountFeatures, extraTwitterFeaturesCount, mpqaSentimentWordsCountFeatures\n'), ((2292, 2352), 'featureExtractors.mpqaSentimentWordsCountFeatures', 'mpqaSentimentWordsCountFeatures', (['wordsTagged', 'mpqaDictionary'], {}), '(wordsTagged, mpqaDictionary)\n', (2323, 2352), False, 'from featureExtractors import unigramsFeatures, bigramsFeatures, mpqaSubjectivityWordsCountFeatures, extraTwitterFeaturesCount, mpqaSentimentWordsCountFeatures\n'), ((2461, 2508), 'featureExtractors.extraTwitterFeaturesCount', 'extraTwitterFeaturesCount', (['extraNormalizedWords'], {}), '(extraNormalizedWords)\n', (2486, 2508), False, 'from featureExtractors import unigramsFeatures, bigramsFeatures, mpqaSubjectivityWordsCountFeatures, extraTwitterFeaturesCount, mpqaSentimentWordsCountFeatures\n'), ((3149, 3194), 'normalization.normalizeTwitterWordsWithExtraFeatures', 'normalizeTwitterWordsWithExtraFeatures', (['words'], {}), '(words)\n', (3187, 3194), False, 'from normalization import normalizeTwitterWordsWithNegationHandle, normalizeTwitterWordsWithExtraFeatures\n')] |
# # ⚠ Warning
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
# LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
# NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# [🥭 Mango Markets](https://mango.markets/) support is available at:
# [Docs](https://docs.mango.markets/)
# [Discord](https://discord.gg/67jySBhxrg)
# [Twitter](https://twitter.com/mangomarkets)
# [Github](https://github.com/blockworks-foundation)
# [Email](mailto:<EMAIL>)
import construct
import time
import typing
from decimal import Decimal
from solana.publickey import PublicKey
from .accountinfo import AccountInfo
from .addressableaccount import AddressableAccount
from .aggregator import Aggregator
from .baskettoken import BasketToken
from .context import Context
from .index import Index
from .layouts import layouts
from .mangoaccountflags import MangoAccountFlags
from .marketmetadata import MarketMetadata
from .market import MarketLookup
from .token import SolToken, Token, TokenLookup
from .tokenvalue import TokenValue
from .version import Version
# # 🥭 Group class
#
# The `Group` class encapsulates the data for the Mango Group - the cross-margined basket
# of tokens with lending.
class Group(AddressableAccount):
def __init__(self, account_info: AccountInfo, version: Version, name: str,
account_flags: MangoAccountFlags, basket_tokens: typing.List[BasketToken],
markets: typing.List[MarketMetadata],
signer_nonce: Decimal, signer_key: PublicKey, dex_program_id: PublicKey,
total_deposits: typing.List[TokenValue], total_borrows: typing.List[TokenValue],
maint_coll_ratio: Decimal, init_coll_ratio: Decimal, srm_vault: PublicKey,
admin: PublicKey, borrow_limits: typing.List[TokenValue]):
super().__init__(account_info)
self.version: Version = version
self.name: str = name
self.account_flags: MangoAccountFlags = account_flags
self.basket_tokens: typing.List[BasketToken] = basket_tokens
self.markets: typing.List[MarketMetadata] = markets
self.signer_nonce: Decimal = signer_nonce
self.signer_key: PublicKey = signer_key
self.dex_program_id: PublicKey = dex_program_id
self.total_deposits: typing.List[TokenValue] = total_deposits
self.total_borrows: typing.List[TokenValue] = total_borrows
self.maint_coll_ratio: Decimal = maint_coll_ratio
self.init_coll_ratio: Decimal = init_coll_ratio
self.srm_vault: PublicKey = srm_vault
self.admin: PublicKey = admin
self.borrow_limits: typing.List[TokenValue] = borrow_limits
@property
def shared_quote_token(self) -> BasketToken:
return self.basket_tokens[-1]
@property
def base_tokens(self) -> typing.List[BasketToken]:
return self.basket_tokens[:-1]
# When loading from a layout, we ignore mint_decimals. In this Discord from Daffy:
# https://discord.com/channels/791995070613159966/818978757648842782/851481660049850388
# he says it's:
# > same as what is stored on on chain Mint
# > Cached on the group so we don't have to pass in the mint every time
#
# Since we already have that value from our `Token` we don't need to use it and we can
# stick with passing around `Token` objects.
#
@staticmethod
def from_layout(layout: construct.Struct, name: str, account_info: AccountInfo, version: Version, token_lookup: TokenLookup, market_lookup: MarketLookup) -> "Group":
account_flags: MangoAccountFlags = MangoAccountFlags.from_layout(layout.account_flags)
basket_tokens: typing.List[BasketToken] = []
total_deposits: typing.List[TokenValue] = []
total_borrows: typing.List[TokenValue] = []
borrow_limits: typing.List[TokenValue] = []
for index, token_address in enumerate(layout.tokens):
static_token_data = token_lookup.find_by_mint(token_address)
if static_token_data is None:
raise Exception(f"Could not find token with mint '{token_address}'.")
# We create a new Token object here specifically to force the use of our own decimals
token = Token(static_token_data.symbol, static_token_data.name, token_address, layout.mint_decimals[index])
token_index = Index.from_layout(layout.indexes[index], token)
basket_token = BasketToken(token, layout.vaults[index], token_index)
basket_tokens += [basket_token]
total_deposits += [TokenValue(token, token.shift_to_decimals(layout.total_deposits[index]))]
total_borrows += [TokenValue(token, token.shift_to_decimals(layout.total_borrows[index]))]
borrow_limits += [TokenValue(token, token.shift_to_decimals(layout.borrow_limits[index]))]
markets: typing.List[MarketMetadata] = []
for index, market_address in enumerate(layout.spot_markets):
spot_market = market_lookup.find_by_address(market_address)
if spot_market is None:
raise Exception(f"Could not find spot market with address '{market_address}'.")
base_token = BasketToken.find_by_mint(basket_tokens, spot_market.base.mint)
quote_token = BasketToken.find_by_mint(basket_tokens, spot_market.quote.mint)
market = MarketMetadata(spot_market.symbol, market_address, base_token, quote_token,
spot_market, layout.oracles[index], layout.oracle_decimals[index])
markets += [market]
maint_coll_ratio = layout.maint_coll_ratio.quantize(Decimal('.01'))
init_coll_ratio = layout.init_coll_ratio.quantize(Decimal('.01'))
return Group(account_info, version, name, account_flags, basket_tokens, markets,
layout.signer_nonce, layout.signer_key, layout.dex_program_id, total_deposits,
total_borrows, maint_coll_ratio, init_coll_ratio, layout.srm_vault,
layout.admin, borrow_limits)
@staticmethod
def parse(context: Context, account_info: AccountInfo) -> "Group":
data = account_info.data
if len(data) == layouts.GROUP_V1.sizeof():
layout = layouts.GROUP_V1.parse(data)
version: Version = Version.V1
elif len(data) == layouts.GROUP_V2.sizeof():
version = Version.V2
layout = layouts.GROUP_V2.parse(data)
else:
raise Exception(
f"Group data length ({len(data)}) does not match expected size ({layouts.GROUP_V1.sizeof()} or {layouts.GROUP_V2.sizeof()})")
return Group.from_layout(layout, context.group_name, account_info, version, context.token_lookup, context.market_lookup)
@staticmethod
def load(context: Context):
account_info = AccountInfo.load(context, context.group_id)
if account_info is None:
raise Exception(f"Group account not found at address '{context.group_id}'")
return Group.parse(context, account_info)
def price_index_of_token(self, token: Token) -> int:
for index, existing in enumerate(self.basket_tokens):
if existing.token == token:
return index
return -1
def fetch_token_prices(self, context: Context) -> typing.List[TokenValue]:
started_at = time.time()
# Note: we can just load the oracle data in a simpler way, with:
# oracles = map(lambda market: Aggregator.load(context, market.oracle), self.markets)
# but that makes a network request for every oracle. We can reduce that to just one request
# if we use AccountInfo.load_multiple() and parse the data ourselves.
#
# This seems to halve the time this function takes.
oracle_addresses = list([market.oracle for market in self.markets])
oracle_account_infos = AccountInfo.load_multiple(context, oracle_addresses)
oracles = map(lambda oracle_account_info: Aggregator.parse(context, oracle_account_info), oracle_account_infos)
prices = list(map(lambda oracle: oracle.price, oracles)) + [Decimal(1)]
token_prices = []
for index, price in enumerate(prices):
token_prices += [TokenValue(self.basket_tokens[index].token, price)]
time_taken = time.time() - started_at
self.logger.info(f"Fetching prices complete. Time taken: {time_taken:.2f} seconds.")
return token_prices
@staticmethod
def load_with_prices(context: Context) -> typing.Tuple["Group", typing.List[TokenValue]]:
group = Group.load(context)
prices = group.fetch_token_prices(context)
return group, prices
def fetch_balances(self, context: Context, root_address: PublicKey) -> typing.List[TokenValue]:
balances: typing.List[TokenValue] = []
sol_balance = context.fetch_sol_balance(root_address)
balances += [TokenValue(SolToken, sol_balance)]
for basket_token in self.basket_tokens:
balance = TokenValue.fetch_total_value(context, root_address, basket_token.token)
balances += [balance]
return balances
def __str__(self) -> str:
total_deposits = "\n ".join(map(str, self.total_deposits))
total_borrows = "\n ".join(map(str, self.total_borrows))
borrow_limits = "\n ".join(map(str, self.borrow_limits))
shared_quote_token = str(self.shared_quote_token).replace("\n", "\n ")
base_tokens = "\n ".join([f"{tok}".replace("\n", "\n ") for tok in self.base_tokens])
markets = "\n ".join([f"{mkt}".replace("\n", "\n ") for mkt in self.markets])
return f"""
« Group [{self.version} - {self.name}] {self.address}:
Flags: {self.account_flags}
Base Tokens:
{base_tokens}
Quote Token:
{shared_quote_token}
Markets:
{markets}
DEX Program ID: « {self.dex_program_id} »
SRM Vault: « {self.srm_vault} »
Admin: « {self.admin} »
Signer Nonce: {self.signer_nonce}
Signer Key: « {self.signer_key} »
Initial Collateral Ratio: {self.init_coll_ratio}
Maintenance Collateral Ratio: {self.maint_coll_ratio}
Total Deposits:
{total_deposits}
Total Borrows:
{total_borrows}
Borrow Limits:
{borrow_limits}
»
"""
| [
"time.time",
"decimal.Decimal"
] | [((7684, 7695), 'time.time', 'time.time', ([], {}), '()\n', (7693, 7695), False, 'import time\n'), ((5951, 5965), 'decimal.Decimal', 'Decimal', (['""".01"""'], {}), "('.01')\n", (5958, 5965), False, 'from decimal import Decimal\n'), ((6025, 6039), 'decimal.Decimal', 'Decimal', (['""".01"""'], {}), "('.01')\n", (6032, 6039), False, 'from decimal import Decimal\n'), ((8650, 8661), 'time.time', 'time.time', ([], {}), '()\n', (8659, 8661), False, 'import time\n'), ((8462, 8472), 'decimal.Decimal', 'Decimal', (['(1)'], {}), '(1)\n', (8469, 8472), False, 'from decimal import Decimal\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : yag8009
# @FileName : md5_hede
# @Time : 2020/3/18
import hashlib
import time
def md5_hede(md5data):
md5 = hashlib.md5() # 使用MD5加密模式
md5.update(md5data.encode("utf8")) # 将参数字符串传入
sign = md5.hexdigest()
return sign
if __name__ == '__main__':
data = "brand=华为&channelType=227&city=北京&color=白&imei=123456789012345&model=mate9&name=张三&phone=17066668888&price=3999&saleman=售货员A&store=旗舰店×tamp=1496566760204&key=<KEY>"
md = md5_hede(data).upper()
print(md)
timestamp = int(time.time()*1000)
print(timestamp)
| [
"time.time",
"hashlib.md5"
] | [((177, 190), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (188, 190), False, 'import hashlib\n'), ((573, 584), 'time.time', 'time.time', ([], {}), '()\n', (582, 584), False, 'import time\n')] |
import os
import datetime
from dateutil.parser import parse as dateutil_parser
from jinja2 import Environment, PackageLoader
from kinto_http import cli_utils
from . import constants
from .logger import logger
JSON_DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
COLLECTION_FORMAT = '/buckets/{bucket_id}/collections/{collection_id}'
def iso2human(value):
date = dateutil_parser(value)
return date.strftime('%b %d, %Y')
def get_template(name):
loader = PackageLoader('amo2kinto', 'templates')
env = Environment(loader=loader)
env.filters['datetime'] = iso2human
return env.get_template(name)
def generate_index(records, template, target_dir):
def sort_records(record):
return record['details']['created'], record['last_modified']
records = sorted(records, key=sort_records, reverse=True)
res = template.render(records=records)
filename = os.path.join(target_dir, 'index.html')
logger.info('Writing %s' % filename)
with open(filename, 'w', encoding='utf-8') as f:
f.write(res)
def generate_record(record, template, target_dir, get_filename):
res = template.render(record=record)
filename = os.path.join(target_dir, get_filename(record))
logger.info('Writing %s' % filename)
# This needs to be able to write to S3
with open(filename, 'w', encoding='utf-8') as f:
f.write(res)
def get_record_filename(record):
return '%s.html' % record.get('blockID', record['id'])
def generate(client, collections, target_dir, collection_template, record_template):
logger.info('Reading data from Kinto %s...' % client.session.server_url)
records = []
for collection_uri in collections:
parts = collection_uri.strip('/').split('/')
bucket_id = parts[1]
collection_id = parts[3]
logger.warn('Reading records from %s...' % collection_uri)
response = client.get_records(bucket=bucket_id, collection=collection_id)
for record in response:
record.setdefault('details', {})
if 'created' not in record['details']:
date = datetime.date.fromtimestamp(record['last_modified'] / 1000)
record['details']['created'] = date.strftime(JSON_DATE_FORMAT)
records.append(record)
if not os.path.exists(target_dir):
os.makedirs(target_dir)
col_tpl = get_template(collection_template)
rec_tpl = get_template(record_template)
logger.warn('Generating index...')
generate_index(records, col_tpl, target_dir)
logger.warn('Generating records files...')
for record in records:
generate_record(record, rec_tpl, target_dir, get_record_filename)
def main(args=None):
parser = cli_utils.add_parser_options(
description='Generate blocked item description files.',
default_collection=None,
default_bucket=constants.DESTINATION_BUCKET,
default_server=constants.KINTO_SERVER,
default_auth=constants.AUTH,
include_collection=False)
parser.add_argument('--addons-collection',
help='Collection name for addon',
type=str, default=constants.ADDONS_COLLECTION)
parser.add_argument('--plugins-collection',
help='Collection name for plugin',
type=str, default=constants.PLUGINS_COLLECTION)
parser.add_argument('-d', '--target-dir',
help='Destination directory to write files in.',
type=str, default=constants.TARGET_DIR)
args = parser.parse_args(args=args)
cli_utils.setup_logger(logger, args)
kinto_client = cli_utils.create_client_from_args(args)
collections = [
COLLECTION_FORMAT.format(bucket_id=args.bucket,
collection_id=args.addons_collection),
COLLECTION_FORMAT.format(bucket_id=args.bucket,
collection_id=args.plugins_collection),
]
generate(kinto_client, collections, args.target_dir, 'collection.tpl', 'record.tpl')
| [
"dateutil.parser.parse",
"os.path.exists",
"jinja2.Environment",
"os.makedirs",
"os.path.join",
"kinto_http.cli_utils.add_parser_options",
"datetime.date.fromtimestamp",
"kinto_http.cli_utils.create_client_from_args",
"kinto_http.cli_utils.setup_logger",
"jinja2.PackageLoader"
] | [((359, 381), 'dateutil.parser.parse', 'dateutil_parser', (['value'], {}), '(value)\n', (374, 381), True, 'from dateutil.parser import parse as dateutil_parser\n'), ((459, 498), 'jinja2.PackageLoader', 'PackageLoader', (['"""amo2kinto"""', '"""templates"""'], {}), "('amo2kinto', 'templates')\n", (472, 498), False, 'from jinja2 import Environment, PackageLoader\n'), ((509, 535), 'jinja2.Environment', 'Environment', ([], {'loader': 'loader'}), '(loader=loader)\n', (520, 535), False, 'from jinja2 import Environment, PackageLoader\n'), ((884, 922), 'os.path.join', 'os.path.join', (['target_dir', '"""index.html"""'], {}), "(target_dir, 'index.html')\n", (896, 922), False, 'import os\n'), ((2713, 2975), 'kinto_http.cli_utils.add_parser_options', 'cli_utils.add_parser_options', ([], {'description': '"""Generate blocked item description files."""', 'default_collection': 'None', 'default_bucket': 'constants.DESTINATION_BUCKET', 'default_server': 'constants.KINTO_SERVER', 'default_auth': 'constants.AUTH', 'include_collection': '(False)'}), "(description=\n 'Generate blocked item description files.', default_collection=None,\n default_bucket=constants.DESTINATION_BUCKET, default_server=constants.\n KINTO_SERVER, default_auth=constants.AUTH, include_collection=False)\n", (2741, 2975), False, 'from kinto_http import cli_utils\n'), ((3597, 3633), 'kinto_http.cli_utils.setup_logger', 'cli_utils.setup_logger', (['logger', 'args'], {}), '(logger, args)\n', (3619, 3633), False, 'from kinto_http import cli_utils\n'), ((3654, 3693), 'kinto_http.cli_utils.create_client_from_args', 'cli_utils.create_client_from_args', (['args'], {}), '(args)\n', (3687, 3693), False, 'from kinto_http import cli_utils\n'), ((2286, 2312), 'os.path.exists', 'os.path.exists', (['target_dir'], {}), '(target_dir)\n', (2300, 2312), False, 'import os\n'), ((2322, 2345), 'os.makedirs', 'os.makedirs', (['target_dir'], {}), '(target_dir)\n', (2333, 2345), False, 'import os\n'), ((2100, 2159), 'datetime.date.fromtimestamp', 'datetime.date.fromtimestamp', (["(record['last_modified'] / 1000)"], {}), "(record['last_modified'] / 1000)\n", (2127, 2159), False, 'import datetime\n')] |
"""Make some fields on Chart and Table nullable
We want to copy chart and table data across to these tables but have no way to add a
classification for each one, so we'll have to live with some nulls in here.
Revision ID: 2019_03_04_make_fields_nullable
Revises: 2019_03_04_chart_table_settings
Create Date: 2019-03-05 16:38:12.835894
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = "2019_03_04_make_fields_nullable"
down_revision = "2019_03_04_chart_table_settings"
branch_labels = None
depends_on = None
def upgrade():
op.alter_column("dimension_chart", "classification_id", existing_type=sa.VARCHAR(length=255), nullable=True)
op.alter_column("dimension_chart", "includes_all", existing_type=sa.BOOLEAN(), nullable=True)
op.alter_column("dimension_chart", "includes_parents", existing_type=sa.BOOLEAN(), nullable=True)
op.alter_column("dimension_chart", "includes_unknown", existing_type=sa.BOOLEAN(), nullable=True)
op.alter_column("dimension_table", "classification_id", existing_type=sa.VARCHAR(length=255), nullable=True)
op.alter_column("dimension_table", "includes_all", existing_type=sa.BOOLEAN(), nullable=True)
op.alter_column("dimension_table", "includes_parents", existing_type=sa.BOOLEAN(), nullable=True)
op.alter_column("dimension_table", "includes_unknown", existing_type=sa.BOOLEAN(), nullable=True)
def downgrade():
op.alter_column("dimension_table", "includes_unknown", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_table", "includes_parents", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_table", "includes_all", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_table", "classification_id", existing_type=sa.VARCHAR(length=255), nullable=False)
op.alter_column("dimension_chart", "includes_unknown", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_chart", "includes_parents", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_chart", "includes_all", existing_type=sa.BOOLEAN(), nullable=False)
op.alter_column("dimension_chart", "classification_id", existing_type=sa.VARCHAR(length=255), nullable=False)
| [
"sqlalchemy.VARCHAR",
"sqlalchemy.BOOLEAN"
] | [((657, 679), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {'length': '(255)'}), '(length=255)\n', (667, 679), True, 'import sqlalchemy as sa\n'), ((765, 777), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (775, 777), True, 'import sqlalchemy as sa\n'), ((867, 879), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (877, 879), True, 'import sqlalchemy as sa\n'), ((969, 981), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (979, 981), True, 'import sqlalchemy as sa\n'), ((1072, 1094), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {'length': '(255)'}), '(length=255)\n', (1082, 1094), True, 'import sqlalchemy as sa\n'), ((1180, 1192), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1190, 1192), True, 'import sqlalchemy as sa\n'), ((1282, 1294), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1292, 1294), True, 'import sqlalchemy as sa\n'), ((1384, 1396), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1394, 1396), True, 'import sqlalchemy as sa\n'), ((1505, 1517), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1515, 1517), True, 'import sqlalchemy as sa\n'), ((1608, 1620), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1618, 1620), True, 'import sqlalchemy as sa\n'), ((1707, 1719), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1717, 1719), True, 'import sqlalchemy as sa\n'), ((1811, 1833), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {'length': '(255)'}), '(length=255)\n', (1821, 1833), True, 'import sqlalchemy as sa\n'), ((1924, 1936), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (1934, 1936), True, 'import sqlalchemy as sa\n'), ((2027, 2039), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (2037, 2039), True, 'import sqlalchemy as sa\n'), ((2126, 2138), 'sqlalchemy.BOOLEAN', 'sa.BOOLEAN', ([], {}), '()\n', (2136, 2138), True, 'import sqlalchemy as sa\n'), ((2230, 2252), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {'length': '(255)'}), '(length=255)\n', (2240, 2252), True, 'import sqlalchemy as sa\n')] |
from django.contrib import admin
from .models import ContactForm
class ContactFormAdmin(admin.ModelAdmin):
class Meta:
model = ContactForm
admin.site.register(ContactForm, ContactFormAdmin)
| [
"django.contrib.admin.site.register"
] | [((154, 204), 'django.contrib.admin.site.register', 'admin.site.register', (['ContactForm', 'ContactFormAdmin'], {}), '(ContactForm, ContactFormAdmin)\n', (173, 204), False, 'from django.contrib import admin\n')] |
import numpy as np
import h5py
import os
import sys
from copy import deepcopy
#handle .(period) and slash specially since it is part of path
#replace with \period or \slash-forward when store, recover later
#not using '\forward-slash' is because \f is a special character
PERIOD='\period'
SLASH='\slash-forward'
'''
This function will save a python dictionary with format {'key':vector} to hdf5 format
target_dict is the target dictionary
f_name is the HDF5 file name including path to it
mode is file open mode, 'a' for append is the default setting
output file is a HDF5 file which the keys of HDF5 are keys of target dict
dataset is corresponding array of each key in target dict
'''
def dict2hdf5(target_dict, f_name, sub_group='/', mode='a'):
print ('Saving In HDF5 Format...')
index_count=0
bar_count=0
total=len(target_dict)
if total<50:
total=50
#open HDF5 file
f = h5py.File(f_name, mode)
for key in target_dict:
######### print progress #############
index_count +=1
if index_count % (total/50) ==0:
sys.stdout.write('\r'),
bar_count += 1
sys.stdout.write("[%-50s] %d%% %d/%d" % ('#'*bar_count, 2*bar_count, index_count, total))
sys.stdout.flush()
######### end print progress #########
#print os.path.join(sub_group,key)
#sys.stdout.flush()
#replace special handled chars, will not change string if / is not in it
dataset_key=key.replace('.',PERIOD).replace('/',SLASH)
f.create_dataset(os.path.join(sub_group,dataset_key), data=target_dict[key])
f.close()
'''
This function will convert saved hdf5 file from previous function back to {'key':vector} dictionary
f_name is the HDF5 file name including path to it
'''
def hdf52dict(f_name, sub_group='/' ):
rv=dict()
#open HDF5 file
f = h5py.File(f_name, 'r')
group=f[sub_group]
for key in group:
#replace back special handled chars
key=key.replace(PERIOD, '.').replace(SLASH,'/')
rv[key]=np.array(group[key])
f.close()
return rv
def main():
d=dict()
d['hello']=[1,0,0,0,0,0,0,0,0,0,0]
d['world']=[0,1,0,0,0,0,0,0,0,0,0]
dict2hdf5(target_dict=d, f_name='test')
rv=hdf52dict('test')
print (rv)
if __name__ == '__main__':
main()
| [
"os.path.join",
"h5py.File",
"numpy.array",
"sys.stdout.flush",
"sys.stdout.write"
] | [((892, 915), 'h5py.File', 'h5py.File', (['f_name', 'mode'], {}), '(f_name, mode)\n', (901, 915), False, 'import h5py\n'), ((1759, 1781), 'h5py.File', 'h5py.File', (['f_name', '"""r"""'], {}), "(f_name, 'r')\n", (1768, 1781), False, 'import h5py\n'), ((1923, 1943), 'numpy.array', 'np.array', (['group[key]'], {}), '(group[key])\n', (1931, 1943), True, 'import numpy as np\n'), ((1085, 1182), 'sys.stdout.write', 'sys.stdout.write', (["('[%-50s] %d%% %d/%d' % ('#' * bar_count, 2 * bar_count, index_count, total))"], {}), "('[%-50s] %d%% %d/%d' % ('#' * bar_count, 2 * bar_count,\n index_count, total))\n", (1101, 1182), False, 'import sys\n'), ((1178, 1196), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (1194, 1196), False, 'import sys\n'), ((1453, 1489), 'os.path.join', 'os.path.join', (['sub_group', 'dataset_key'], {}), '(sub_group, dataset_key)\n', (1465, 1489), False, 'import os\n'), ((1040, 1062), 'sys.stdout.write', 'sys.stdout.write', (["'\\r'"], {}), "('\\r')\n", (1056, 1062), False, 'import sys\n')] |
import re
import string
from libs.dataset.core import SampleEntry, oov_replacement_vocabulary, letter_replacements
__word_start_regex = f'[ \t\n]|^|[{string.punctuation}]'
__word_end_regex = f'[ \t\n]|$|[{string.punctuation}]'
def does_not_have_numbers(s: SampleEntry):
return not any(char.isdigit() for char in s.text)
def waveform_not_longer_than(target_length):
def step(s: SampleEntry):
return s.duration < target_length
return step
def waveform_not_shorter_than(target_length):
def step(s: SampleEntry):
return s.duration > target_length
return step
def replace_oov(line):
for symbol, replacement in oov_replacement_vocabulary.items():
line = re.sub(fr"{symbol}", replacement, line)
line = re.sub(r"[ ]{2,}", ' ', line)
line = re.sub(r"\n\s*\n", r'\n', line)
return line
def test_replace_oov():
assert replace_oov("vien_as") == "vien as"
assert replace_oov("vien«as") == "vienas"
assert replace_oov("vien\xadas") == "vienas"
assert replace_oov("vien®as") == "vienas"
assert replace_oov("vien°as") == "vienas"
assert replace_oov("vien²as") == "vienas"
assert replace_oov("vien»as") == "vienas"
assert replace_oov("vienʼas") == "vien'as"
assert replace_oov("vien˚as") == "vienas"
assert replace_oov("vien‒as") == "vien-as"
assert replace_oov("vien–as") == "vien-as"
assert replace_oov("vien—as") == "vien-as"
assert replace_oov("vien‘as") == "vien'as"
assert replace_oov("vien’as") == "vien'as"
assert replace_oov("vien“as") == 'vien"as'
assert replace_oov("vien”as") == 'vien"as'
assert replace_oov("vien„as") == 'vien"as'
assert replace_oov("vien\\as") == "vienas"
assert replace_oov("vien,,as") == 'vien"as'
def replace_letter_to_sound(line):
for letter, sound in letter_replacements.items():
line = re.sub(fr"({__word_start_regex})[{letter.lower()}{letter.upper()}]+({__word_end_regex})", fr"\1{sound}\2", line)
return line
def test_replace_letter_to_sound():
assert replace_letter_to_sound("aAa b C d e f g h I J k L M n") == "aã bė̃ cė̃ dė̃ eẽ ef̃ gė̃ hãš iĩ jòt kã el̃ em̃ eñ"
assert replace_letter_to_sound("vienas du aaaa") == "vienas du aã"
| [
"re.sub",
"libs.dataset.core.oov_replacement_vocabulary.items",
"libs.dataset.core.letter_replacements.items"
] | [((656, 690), 'libs.dataset.core.oov_replacement_vocabulary.items', 'oov_replacement_vocabulary.items', ([], {}), '()\n', (688, 690), False, 'from libs.dataset.core import SampleEntry, oov_replacement_vocabulary, letter_replacements\n'), ((758, 786), 're.sub', 're.sub', (['"""[ ]{2,}"""', '""" """', 'line'], {}), "('[ ]{2,}', ' ', line)\n", (764, 786), False, 'import re\n'), ((799, 832), 're.sub', 're.sub', (['"""\\\\n\\\\s*\\\\n"""', '"""\\\\n"""', 'line'], {}), "('\\\\n\\\\s*\\\\n', '\\\\n', line)\n", (805, 832), False, 'import re\n'), ((1825, 1852), 'libs.dataset.core.letter_replacements.items', 'letter_replacements.items', ([], {}), '()\n', (1850, 1852), False, 'from libs.dataset.core import SampleEntry, oov_replacement_vocabulary, letter_replacements\n'), ((707, 745), 're.sub', 're.sub', (['f"""{symbol}"""', 'replacement', 'line'], {}), "(f'{symbol}', replacement, line)\n", (713, 745), False, 'import re\n')] |
import unittest
import silasdk
from tests.test_config import (
app, eth_private_key, eth_private_key_4, instant_ach_handle, user_handle)
class Test007CheckInstantAchTest(unittest.TestCase):
def test_check_instant_ach(self):
payload = {
"user_handle": instant_ach_handle,
"account_name": "default_plaid"
}
response = silasdk.User.check_instant_ach(
app, payload, eth_private_key_4)
self.assertIsNotNone(response["status"])
self.assertIsNotNone(response["message"])
if __name__ == '__main__':
unittest.main()
| [
"unittest.main",
"silasdk.User.check_instant_ach"
] | [((601, 616), 'unittest.main', 'unittest.main', ([], {}), '()\n', (614, 616), False, 'import unittest\n'), ((376, 439), 'silasdk.User.check_instant_ach', 'silasdk.User.check_instant_ach', (['app', 'payload', 'eth_private_key_4'], {}), '(app, payload, eth_private_key_4)\n', (406, 439), False, 'import silasdk\n')] |
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import bigbench.api.model as model
import bigbench.api.util as util
import numpy as np
import scipy.special
class DummyModel(model.Model):
def generate_text(
self, inputs, max_length=100, stop_string=None, output_regex=None
):
dummy_text = "dummy text, 123. Easy peasy lemon squeezy."
if isinstance(inputs, str):
text = dummy_text
elif isinstance(inputs, list):
text = [f"{i}_{dummy_text}" for i, _ in enumerate(inputs)]
else:
raise ValueError("inputs has unexpected type %s" % type(inputs))
text = util.postprocess_output(text, max_length, stop_string, output_regex)
return text
def cond_log_prob(self, inputs, targets, absolute_normalization=False):
def generate_dummy_scores(inpt, tgts):
unnorm_log_probs = [np.log(1 / (i + 1)) for i, _ in enumerate(tgts)]
if len(unnorm_log_probs) > 1:
# we want to make sure tasks can correctly handle responses which are
# assigned zero probability
unnorm_log_probs[0] = -np.inf
if absolute_normalization:
log_probs = unnorm_log_probs
else:
log_normalizer = scipy.special.logsumexp(unnorm_log_probs)
log_probs = [lp - log_normalizer for lp in unnorm_log_probs]
return log_probs
if isinstance(inputs, str):
return generate_dummy_scores(inputs, targets)
elif isinstance(inputs, list):
return [
generate_dummy_scores(inpt, tgts) for inpt, tgts in zip(inputs, targets)
]
else:
raise ValueError("inputs has unexpected type %s" % type(inputs))
| [
"bigbench.api.util.postprocess_output",
"numpy.log"
] | [((1171, 1239), 'bigbench.api.util.postprocess_output', 'util.postprocess_output', (['text', 'max_length', 'stop_string', 'output_regex'], {}), '(text, max_length, stop_string, output_regex)\n', (1194, 1239), True, 'import bigbench.api.util as util\n'), ((1417, 1436), 'numpy.log', 'np.log', (['(1 / (i + 1))'], {}), '(1 / (i + 1))\n', (1423, 1436), True, 'import numpy as np\n')] |
"""Click parameter types for osxphotos CLI"""
import datetime
import os
import pathlib
import re
import bitmath
import click
import pytimeparse2
from osxphotos.export_db_utils import export_db_get_version
from osxphotos.photoinfo import PhotoInfoNone
from osxphotos.phototemplate import PhotoTemplate, RenderOptions
from osxphotos.timeutils import time_string_to_datetime, utc_offset_string_to_seconds
from osxphotos.timezones import Timezone
from osxphotos.utils import expand_and_validate_filepath, load_function
__all__ = [
"BitMathSize",
"DateOffset",
"DateTimeISO8601",
"ExportDBType",
"FunctionCall",
"TemplateString",
"TimeISO8601",
"TimeOffset",
"TimeString",
"UTCOffset",
]
class DateTimeISO8601(click.ParamType):
name = "DATETIME"
def convert(self, value, param, ctx):
try:
return datetime.datetime.fromisoformat(value)
except Exception:
self.fail(
f"Invalid datetime format {value}. "
"Valid format: YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]"
)
class BitMathSize(click.ParamType):
name = "BITMATH"
def convert(self, value, param, ctx):
try:
value = bitmath.parse_string(value)
except ValueError:
# no units specified
try:
value = int(value)
value = bitmath.Byte(value)
except ValueError as e:
self.fail(
f"{value} must be specified as bytes or using SI/NIST units. "
+ "For example, the following are all valid and equivalent sizes: '1048576' '1.048576MB', '1 MiB'."
)
return value
class TimeISO8601(click.ParamType):
name = "TIME"
def convert(self, value, param, ctx):
try:
return datetime.time.fromisoformat(value).replace(tzinfo=None)
except Exception:
self.fail(
f"Invalid time format {value}. "
"Valid format: HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]] "
"however, note that timezone will be ignored."
)
class FunctionCall(click.ParamType):
name = "FUNCTION"
def convert(self, value, param, ctx):
if "::" not in value:
self.fail(
f"Could not parse function name from '{value}'. "
"Valid format filename.py::function"
)
filename, funcname = value.split("::")
filename_validated = expand_and_validate_filepath(filename)
if not filename_validated:
self.fail(f"'{filename}' does not appear to be a file")
try:
function = load_function(filename_validated, funcname)
except Exception as e:
self.fail(f"Could not load function {funcname} from {filename_validated}")
return (function, value)
class ExportDBType(click.ParamType):
name = "EXPORTDB"
def convert(self, value, param, ctx):
try:
export_db_name = pathlib.Path(value)
if export_db_name.is_dir():
raise click.BadParameter(f"{value} is a directory")
if export_db_name.is_file():
# verify it's actually an osxphotos export_db
# export_db_get_version will raise an error if it's not valid
osxphotos_ver, export_db_ver = export_db_get_version(value)
return value
except Exception:
self.fail(f"{value} exists but is not a valid osxphotos export database. ")
class TemplateString(click.ParamType):
"""Validate an osxphotos template language (OTL) template string"""
name = "OTL_TEMPLATE"
def convert(self, value, param, ctx):
try:
cwd = os.getcwd()
_, unmatched = PhotoTemplate(photo=PhotoInfoNone()).render(
value,
options=RenderOptions(export_dir=cwd, dest_path=cwd, filepath=cwd),
)
if unmatched:
self.fail(f"Template '{value}' contains unknown field(s): {unmatched}")
return value
except ValueError as e:
self.fail(e)
class TimeString(click.ParamType):
"""A timestring in format HH:MM:SS, HH:MM:SS.fff, HH:MM"""
name = "TIMESTRING"
def convert(self, value, param, ctx):
try:
return time_string_to_datetime(value)
except ValueError:
self.fail(
f"Invalid time format: {value}. "
"Valid format for time: 'HH:MM:SS', 'HH:MM:SS.fff', 'HH:MM'"
)
class DateOffset(click.ParamType):
"""A date offset string in the format ±D days, ±W weeks, ±Y years, ±D where D is days"""
name = "DATEOFFSET"
def convert(self, value, param, ctx):
# if it's a single number treat it as days
# but pytimeparse2 treats is as seconds so need to verify it's just a number and if so,
# convert it to seconds
value = value.strip()
if re.match(r"^[+-]?\s*?\d+$", value):
# just a number
# strip any whitespace, e.g. for "+ 1" or "- 1"
value = "".join(value.split())
try:
return datetime.timedelta(days=int(value))
except ValueError:
self.fail(
f"Invalid date offset format: {value}. "
"Valid format for date/time offset: '±D days', '±W weeks', '±M months', '±D' where D is days "
)
offset = pytimeparse2.parse(value)
if offset is not None:
offset = offset / 86400
return datetime.timedelta(days=offset)
self.fail(
f"Invalid date offset format: {value}. "
"Valid format for date/time offset: '±D days', '±W weeks', '±M months', '±D' where D is days "
)
class TimeOffset(click.ParamType):
"""A time offset string in the format [+-]HH:MM[:SS[.fff[fff]]] or +1 days, -2 hours, -18000, etc"""
name = "TIMEOFFSET"
def convert(self, value, param, ctx):
offset = pytimeparse2.parse(value)
if offset is not None:
return datetime.timedelta(seconds=offset)
self.fail(
f"Invalid time offset format: {value}. "
"Valid format for date/time offset: '±HH:MM:SS', '±H hours' (or hr), '±M minutes' (or min), '±S seconds' (or sec), '±S' (where S is seconds)"
)
class UTCOffset(click.ParamType):
"""A UTC offset timezone in format ±[hh]:[mm], ±[h]:[mm], or ±[hh][mm]"""
name = "UTC_OFFSET"
def convert(self, value, param, ctx):
try:
offset_seconds = utc_offset_string_to_seconds(value)
return Timezone(offset_seconds)
except Exception:
self.fail(
f"Invalid timezone format: {value}. "
"Valid format for timezone offset: '±HH:MM', '±H:MM', or '±HHMM'"
)
| [
"osxphotos.photoinfo.PhotoInfoNone",
"osxphotos.utils.expand_and_validate_filepath",
"osxphotos.utils.load_function",
"pytimeparse2.parse",
"pathlib.Path",
"re.match",
"os.getcwd",
"click.BadParameter",
"bitmath.Byte",
"osxphotos.phototemplate.RenderOptions",
"osxphotos.timeutils.time_string_to_... | [((2547, 2585), 'osxphotos.utils.expand_and_validate_filepath', 'expand_and_validate_filepath', (['filename'], {}), '(filename)\n', (2575, 2585), False, 'from osxphotos.utils import expand_and_validate_filepath, load_function\n'), ((5048, 5083), 're.match', 're.match', (['"""^[+-]?\\\\s*?\\\\d+$"""', 'value'], {}), "('^[+-]?\\\\s*?\\\\d+$', value)\n", (5056, 5083), False, 'import re\n'), ((5561, 5586), 'pytimeparse2.parse', 'pytimeparse2.parse', (['value'], {}), '(value)\n', (5579, 5586), False, 'import pytimeparse2\n'), ((6122, 6147), 'pytimeparse2.parse', 'pytimeparse2.parse', (['value'], {}), '(value)\n', (6140, 6147), False, 'import pytimeparse2\n'), ((866, 904), 'datetime.datetime.fromisoformat', 'datetime.datetime.fromisoformat', (['value'], {}), '(value)\n', (897, 904), False, 'import datetime\n'), ((1248, 1275), 'bitmath.parse_string', 'bitmath.parse_string', (['value'], {}), '(value)\n', (1268, 1275), False, 'import bitmath\n'), ((2726, 2769), 'osxphotos.utils.load_function', 'load_function', (['filename_validated', 'funcname'], {}), '(filename_validated, funcname)\n', (2739, 2769), False, 'from osxphotos.utils import expand_and_validate_filepath, load_function\n'), ((3069, 3088), 'pathlib.Path', 'pathlib.Path', (['value'], {}), '(value)\n', (3081, 3088), False, 'import pathlib\n'), ((3807, 3818), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (3816, 3818), False, 'import os\n'), ((4408, 4438), 'osxphotos.timeutils.time_string_to_datetime', 'time_string_to_datetime', (['value'], {}), '(value)\n', (4431, 4438), False, 'from osxphotos.timeutils import time_string_to_datetime, utc_offset_string_to_seconds\n'), ((5673, 5704), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': 'offset'}), '(days=offset)\n', (5691, 5704), False, 'import datetime\n'), ((6198, 6232), 'datetime.timedelta', 'datetime.timedelta', ([], {'seconds': 'offset'}), '(seconds=offset)\n', (6216, 6232), False, 'import datetime\n'), ((6694, 6729), 'osxphotos.timeutils.utc_offset_string_to_seconds', 'utc_offset_string_to_seconds', (['value'], {}), '(value)\n', (6722, 6729), False, 'from osxphotos.timeutils import time_string_to_datetime, utc_offset_string_to_seconds\n'), ((6749, 6773), 'osxphotos.timezones.Timezone', 'Timezone', (['offset_seconds'], {}), '(offset_seconds)\n', (6757, 6773), False, 'from osxphotos.timezones import Timezone\n'), ((3151, 3196), 'click.BadParameter', 'click.BadParameter', (['f"""{value} is a directory"""'], {}), "(f'{value} is a directory')\n", (3169, 3196), False, 'import click\n'), ((3425, 3453), 'osxphotos.export_db_utils.export_db_get_version', 'export_db_get_version', (['value'], {}), '(value)\n', (3446, 3453), False, 'from osxphotos.export_db_utils import export_db_get_version\n'), ((1412, 1431), 'bitmath.Byte', 'bitmath.Byte', (['value'], {}), '(value)\n', (1424, 1431), False, 'import bitmath\n'), ((1869, 1903), 'datetime.time.fromisoformat', 'datetime.time.fromisoformat', (['value'], {}), '(value)\n', (1896, 1903), False, 'import datetime\n'), ((3938, 3996), 'osxphotos.phototemplate.RenderOptions', 'RenderOptions', ([], {'export_dir': 'cwd', 'dest_path': 'cwd', 'filepath': 'cwd'}), '(export_dir=cwd, dest_path=cwd, filepath=cwd)\n', (3951, 3996), False, 'from osxphotos.phototemplate import PhotoTemplate, RenderOptions\n'), ((3866, 3881), 'osxphotos.photoinfo.PhotoInfoNone', 'PhotoInfoNone', ([], {}), '()\n', (3879, 3881), False, 'from osxphotos.photoinfo import PhotoInfoNone\n')] |
# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Removing unique constraint on 'Licence', fields ['sn']
db.delete_unique('ralph_assets_licence', ['sn'])
# Adding model 'TransitionsHistory'
db.create_table('ralph_assets_transitionshistory', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('created', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('modified', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('cache_version', self.gf('django.db.models.fields.PositiveIntegerField')(default=0)),
('transition', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['ralph_assets.Transition'])),
('logged_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name=u'logged user', to=orm['auth.User'])),
('affected_user', self.gf('django.db.models.fields.related.ForeignKey')(related_name=u'affected user', to=orm['auth.User'])),
('report_filename', self.gf('django.db.models.fields.CharField')(max_length=256, null=True, blank=True)),
('uid', self.gf('django.db.models.fields.CharField')(max_length=36)),
('report_file', self.gf('django.db.models.fields.files.FileField')(max_length=100)),
))
db.send_create_signal('ralph_assets', ['TransitionsHistory'])
# Adding M2M table for field assets on 'TransitionsHistory'
db.create_table('ralph_assets_transitionshistory_assets', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('transitionshistory', models.ForeignKey(orm['ralph_assets.transitionshistory'], null=False)),
('asset', models.ForeignKey(orm['ralph_assets.asset'], null=False))
))
db.create_unique('ralph_assets_transitionshistory_assets', ['transitionshistory_id', 'asset_id'])
# Adding model 'Attachment'
db.create_table('ralph_assets_attachment', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('created', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('modified', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('cache_version', self.gf('django.db.models.fields.PositiveIntegerField')(default=0)),
('original_filename', self.gf('django.db.models.fields.CharField')(max_length=255)),
('file', self.gf('django.db.models.fields.files.FileField')(max_length=100, null=True)),
('uploaded_by', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True, blank=True)),
))
db.send_create_signal('ralph_assets', ['Attachment'])
# Adding model 'CoaOemOs'
db.create_table('ralph_assets_coaoemos', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=75, db_index=True)),
))
db.send_create_signal('ralph_assets', ['CoaOemOs'])
# Adding model 'Action'
db.create_table('ralph_assets_action', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=75, db_index=True)),
))
db.send_create_signal('ralph_assets', ['Action'])
# Adding model 'ReportOdtSource'
db.create_table('ralph_assets_reportodtsource', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=75, db_index=True)),
('created', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('modified', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('cache_version', self.gf('django.db.models.fields.PositiveIntegerField')(default=0)),
('slug', self.gf('django.db.models.fields.SlugField')(unique=True, max_length=100)),
('template', self.gf('django.db.models.fields.files.FileField')(max_length=100)),
))
db.send_create_signal('ralph_assets', ['ReportOdtSource'])
# Adding model 'Service'
db.create_table('ralph_assets_service', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=75, db_index=True)),
('created', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('modified', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('cache_version', self.gf('django.db.models.fields.PositiveIntegerField')(default=0)),
('profit_center', self.gf('django.db.models.fields.CharField')(max_length=1024, blank=True)),
('cost_center', self.gf('django.db.models.fields.CharField')(max_length=1024, blank=True)),
))
db.send_create_signal('ralph_assets', ['Service'])
# Adding model 'Transition'
db.create_table('ralph_assets_transition', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=75, db_index=True)),
('created', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('modified', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('cache_version', self.gf('django.db.models.fields.PositiveIntegerField')(default=0)),
('slug', self.gf('django.db.models.fields.SlugField')(unique=True, max_length=100)),
('from_status', self.gf('django.db.models.fields.PositiveSmallIntegerField')(null=True, blank=True)),
('to_status', self.gf('django.db.models.fields.PositiveSmallIntegerField')()),
))
db.send_create_signal('ralph_assets', ['Transition'])
# Adding M2M table for field actions on 'Transition'
db.create_table('ralph_assets_transition_actions', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('transition', models.ForeignKey(orm['ralph_assets.transition'], null=False)),
('action', models.ForeignKey(orm['ralph_assets.action'], null=False))
))
db.create_unique('ralph_assets_transition_actions', ['transition_id', 'action_id'])
# Adding model 'LicenceHistoryChange'
db.create_table('ralph_assets_licencehistorychange', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('date', self.gf('django.db.models.fields.DateTimeField')(default=datetime.datetime.now)),
('licence', self.gf('django.db.models.fields.related.ForeignKey')(default=None, to=orm['ralph_assets.Licence'], null=True, on_delete=models.SET_NULL, blank=True)),
('user', self.gf('django.db.models.fields.related.ForeignKey')(default=None, to=orm['auth.User'], null=True, on_delete=models.SET_NULL, blank=True)),
('field_name', self.gf('django.db.models.fields.CharField')(default=u'', max_length=64)),
('old_value', self.gf('django.db.models.fields.CharField')(default=u'', max_length=255)),
('new_value', self.gf('django.db.models.fields.CharField')(default=u'', max_length=255)),
))
db.send_create_signal('ralph_assets', ['LicenceHistoryChange'])
# Adding model 'ImportProblem'
db.create_table('ralph_assets_importproblem', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('content_type', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['contenttypes.ContentType'])),
('object_id', self.gf('django.db.models.fields.PositiveIntegerField')()),
('severity', self.gf('django.db.models.fields.PositiveSmallIntegerField')()),
('message', self.gf('django.db.models.fields.TextField')()),
))
db.send_create_signal('ralph_assets', ['ImportProblem'])
# Deleting field 'Licence.bought_date'
db.delete_column('ralph_assets_licence', 'bought_date')
# Deleting field 'Licence.used'
db.delete_column('ralph_assets_licence', 'used')
# Adding field 'Licence.invoice_date'
db.add_column('ralph_assets_licence', 'invoice_date',
self.gf('django.db.models.fields.DateField')(null=True, blank=True),
keep_default=False)
# Adding field 'Licence.provider'
db.add_column('ralph_assets_licence', 'provider',
self.gf('django.db.models.fields.CharField')(max_length=100, null=True, blank=True),
keep_default=False)
# Adding field 'Licence.invoice_no'
db.add_column('ralph_assets_licence', 'invoice_no',
self.gf('django.db.models.fields.CharField')(db_index=True, max_length=128, null=True, blank=True),
keep_default=False)
# Adding M2M table for field assets on 'Licence'
db.create_table('ralph_assets_licence_assets', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('licence', models.ForeignKey(orm['ralph_assets.licence'], null=False)),
('asset', models.ForeignKey(orm['ralph_assets.asset'], null=False))
))
db.create_unique('ralph_assets_licence_assets', ['licence_id', 'asset_id'])
# Adding M2M table for field users on 'Licence'
db.create_table('ralph_assets_licence_users', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('licence', models.ForeignKey(orm['ralph_assets.licence'], null=False)),
('user', models.ForeignKey(orm['auth.user'], null=False))
))
db.create_unique('ralph_assets_licence_users', ['licence_id', 'user_id'])
# Adding M2M table for field attachments on 'Licence'
db.create_table('ralph_assets_licence_attachments', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('licence', models.ForeignKey(orm['ralph_assets.licence'], null=False)),
('attachment', models.ForeignKey(orm['ralph_assets.attachment'], null=False))
))
db.create_unique('ralph_assets_licence_attachments', ['licence_id', 'attachment_id'])
# Changing field 'Licence.niw'
db.alter_column('ralph_assets_licence', 'niw', self.gf('django.db.models.fields.CharField')(default='N/A', unique=True, max_length=50))
# Adding unique constraint on 'Licence', fields ['niw']
db.create_unique('ralph_assets_licence', ['niw'])
# Changing field 'Licence.price'
db.alter_column('ralph_assets_licence', 'price', self.gf('django.db.models.fields.DecimalField')(null=True, max_digits=10, decimal_places=2))
# Changing field 'Licence.sn'
db.alter_column('ralph_assets_licence', 'sn', self.gf('django.db.models.fields.TextField')(null=True))
# Deleting field 'Asset.category'
db.delete_column('ralph_assets_asset', 'category_id')
# Adding field 'Asset.location'
db.add_column('ralph_assets_asset', 'location',
self.gf('django.db.models.fields.CharField')(max_length=128, null=True, blank=True),
keep_default=False)
# Adding field 'Asset.service_name'
db.add_column('ralph_assets_asset', 'service_name',
self.gf('django.db.models.fields.related.ForeignKey')(to=orm['ralph_assets.Service'], null=True, blank=True),
keep_default=False)
# Adding field 'Asset.loan_end_date'
db.add_column('ralph_assets_asset', 'loan_end_date',
self.gf('django.db.models.fields.DateField')(default=None, null=True, blank=True),
keep_default=False)
# Adding field 'Asset.note'
db.add_column('ralph_assets_asset', 'note',
self.gf('django.db.models.fields.CharField')(default='', max_length=1024, blank=True),
keep_default=False)
# Adding M2M table for field attachments on 'Asset'
db.create_table('ralph_assets_asset_attachments', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('asset', models.ForeignKey(orm['ralph_assets.asset'], null=False)),
('attachment', models.ForeignKey(orm['ralph_assets.attachment'], null=False))
))
db.create_unique('ralph_assets_asset_attachments', ['asset_id', 'attachment_id'])
# Changing field 'Asset.support_period'
db.alter_column('ralph_assets_asset', 'support_period', self.gf('django.db.models.fields.PositiveSmallIntegerField')(null=True))
# Changing field 'Asset.source'
db.alter_column('ralph_assets_asset', 'source', self.gf('django.db.models.fields.PositiveIntegerField')(null=True))
# Changing field 'Asset.status'
db.alter_column('ralph_assets_asset', 'status', self.gf('django.db.models.fields.PositiveSmallIntegerField')(null=True))
# Changing field 'Asset.price'
db.alter_column('ralph_assets_asset', 'price', self.gf('django.db.models.fields.DecimalField')(null=True, max_digits=10, decimal_places=2))
# Changing field 'Asset.niw'
db.alter_column('ralph_assets_asset', 'niw', self.gf('django.db.models.fields.CharField')(max_length=200, null=True))
# Deleting field 'OfficeInfo.version'
db.delete_column('ralph_assets_officeinfo', 'version')
# Deleting field 'OfficeInfo.last_logged_user'
db.delete_column('ralph_assets_officeinfo', 'last_logged_user')
# Deleting field 'OfficeInfo.date_of_last_inventory'
db.delete_column('ralph_assets_officeinfo', 'date_of_last_inventory')
# Deleting field 'OfficeInfo.attachment'
db.delete_column('ralph_assets_officeinfo', 'attachment')
# Deleting field 'OfficeInfo.license_type'
db.delete_column('ralph_assets_officeinfo', 'license_type')
# Adding field 'OfficeInfo.coa_number'
db.add_column('ralph_assets_officeinfo', 'coa_number',
self.gf('django.db.models.fields.CharField')(max_length=256, null=True, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.coa_oem_os'
db.add_column('ralph_assets_officeinfo', 'coa_oem_os',
self.gf('django.db.models.fields.related.ForeignKey')(to=orm['ralph_assets.CoaOemOs'], null=True, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.imei'
db.add_column('ralph_assets_officeinfo', 'imei',
self.gf('django.db.models.fields.CharField')(max_length=18, unique=True, null=True, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.purpose'
db.add_column('ralph_assets_officeinfo', 'purpose',
self.gf('django.db.models.fields.PositiveSmallIntegerField')(default=None, null=True, blank=True),
keep_default=False)
# Changing field 'OfficeInfo.license_key'
db.alter_column('ralph_assets_officeinfo', 'license_key', self.gf('django.db.models.fields.TextField')(null=True))
def backwards(self, orm):
# Removing unique constraint on 'Licence', fields ['niw']
db.delete_unique('ralph_assets_licence', ['niw'])
# Deleting model 'TransitionsHistory'
db.delete_table('ralph_assets_transitionshistory')
# Removing M2M table for field assets on 'TransitionsHistory'
db.delete_table('ralph_assets_transitionshistory_assets')
# Deleting model 'Attachment'
db.delete_table('ralph_assets_attachment')
# Deleting model 'CoaOemOs'
db.delete_table('ralph_assets_coaoemos')
# Deleting model 'Action'
db.delete_table('ralph_assets_action')
# Deleting model 'ReportOdtSource'
db.delete_table('ralph_assets_reportodtsource')
# Deleting model 'Service'
db.delete_table('ralph_assets_service')
# Deleting model 'Transition'
db.delete_table('ralph_assets_transition')
# Removing M2M table for field actions on 'Transition'
db.delete_table('ralph_assets_transition_actions')
# Deleting model 'LicenceHistoryChange'
db.delete_table('ralph_assets_licencehistorychange')
# Deleting model 'ImportProblem'
db.delete_table('ralph_assets_importproblem')
# Adding field 'Licence.bought_date'
db.add_column('ralph_assets_licence', 'bought_date',
self.gf('django.db.models.fields.DateField')(default=None),
keep_default=False)
# Adding field 'Licence.used'
db.add_column('ralph_assets_licence', 'used',
self.gf('django.db.models.fields.IntegerField')(default=0),
keep_default=False)
# Deleting field 'Licence.invoice_date'
db.delete_column('ralph_assets_licence', 'invoice_date')
# Deleting field 'Licence.provider'
db.delete_column('ralph_assets_licence', 'provider')
# Deleting field 'Licence.invoice_no'
db.delete_column('ralph_assets_licence', 'invoice_no')
# Removing M2M table for field assets on 'Licence'
db.delete_table('ralph_assets_licence_assets')
# Removing M2M table for field users on 'Licence'
db.delete_table('ralph_assets_licence_users')
# Removing M2M table for field attachments on 'Licence'
db.delete_table('ralph_assets_licence_attachments')
# Changing field 'Licence.niw'
db.alter_column('ralph_assets_licence', 'niw', self.gf('django.db.models.fields.CharField')(max_length=50, null=True))
# Changing field 'Licence.price'
db.alter_column('ralph_assets_licence', 'price', self.gf('django.db.models.fields.DecimalField')(max_digits=10, decimal_places=2))
# Changing field 'Licence.sn'
db.alter_column('ralph_assets_licence', 'sn', self.gf('django.db.models.fields.CharField')(unique=True, max_length=200, null=True))
# Adding unique constraint on 'Licence', fields ['sn']
db.create_unique('ralph_assets_licence', ['sn'])
# Adding field 'Asset.category'
db.add_column('ralph_assets_asset', 'category',
self.gf('django.db.models.fields.related.ForeignKey')(to=orm['ralph_assets.AssetCategory'], null=True, blank=True),
keep_default=False)
# Deleting field 'Asset.location'
db.delete_column('ralph_assets_asset', 'location')
# Deleting field 'Asset.service_name'
db.delete_column('ralph_assets_asset', 'service_name_id')
# Deleting field 'Asset.loan_end_date'
db.delete_column('ralph_assets_asset', 'loan_end_date')
# Deleting field 'Asset.note'
db.delete_column('ralph_assets_asset', 'note')
# Removing M2M table for field attachments on 'Asset'
db.delete_table('ralph_assets_asset_attachments')
# Changing field 'Asset.support_period'
db.alter_column('ralph_assets_asset', 'support_period', self.gf('django.db.models.fields.PositiveSmallIntegerField')())
# Changing field 'Asset.source'
db.alter_column('ralph_assets_asset', 'source', self.gf('django.db.models.fields.PositiveIntegerField')(default=None))
# Changing field 'Asset.status'
db.alter_column('ralph_assets_asset', 'status', self.gf('django.db.models.fields.PositiveSmallIntegerField')())
# Changing field 'Asset.price'
db.alter_column('ralph_assets_asset', 'price', self.gf('django.db.models.fields.DecimalField')(max_digits=10, decimal_places=2))
# Changing field 'Asset.niw'
db.alter_column('ralph_assets_asset', 'niw', self.gf('django.db.models.fields.CharField')(max_length=50, null=True))
# Adding field 'OfficeInfo.version'
db.add_column('ralph_assets_officeinfo', 'version',
self.gf('django.db.models.fields.CharField')(default='', max_length=50, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.last_logged_user'
db.add_column('ralph_assets_officeinfo', 'last_logged_user',
self.gf('django.db.models.fields.CharField')(max_length=100, null=True, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.date_of_last_inventory'
db.add_column('ralph_assets_officeinfo', 'date_of_last_inventory',
self.gf('django.db.models.fields.DateField')(null=True, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.attachment'
db.add_column('ralph_assets_officeinfo', 'attachment',
self.gf('django.db.models.fields.files.FileField')(default=None, max_length=100, blank=True),
keep_default=False)
# Adding field 'OfficeInfo.license_type'
db.add_column('ralph_assets_officeinfo', 'license_type',
self.gf('django.db.models.fields.IntegerField')(null=True, blank=True),
keep_default=False)
# Deleting field 'OfficeInfo.coa_number'
db.delete_column('ralph_assets_officeinfo', 'coa_number')
# Deleting field 'OfficeInfo.coa_oem_os'
db.delete_column('ralph_assets_officeinfo', 'coa_oem_os_id')
# Deleting field 'OfficeInfo.imei'
db.delete_column('ralph_assets_officeinfo', 'imei')
# Deleting field 'OfficeInfo.purpose'
db.delete_column('ralph_assets_officeinfo', 'purpose')
# Changing field 'OfficeInfo.license_key'
db.alter_column('ralph_assets_officeinfo', 'license_key', self.gf('django.db.models.fields.CharField')(default='', max_length=255))
models = {
'account.profile': {
'Meta': {'object_name': 'Profile'},
'activation_token': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '40', 'blank': 'True'}),
'birth_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'city': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'company': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'cost_center': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'country': ('django.db.models.fields.PositiveIntegerField', [], {'default': '153'}),
'department': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'employee_id': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'gender': ('django.db.models.fields.PositiveIntegerField', [], {'default': '2'}),
'home_page': (u'dj.choices.fields.ChoiceField', [], {'unique': 'False', 'primary_key': 'False', 'db_column': 'None', 'blank': 'False', u'default': '1', 'null': 'False', '_in_south': 'True', 'db_index': 'False'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_active': ('django.db.models.fields.DateTimeField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
'location': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
'manager': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'nick': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '30', 'blank': 'True'}),
'profit_center': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'time_zone': ('django.db.models.fields.FloatField', [], {'default': '1.0'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'})
},
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('<PASSWORD>', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ralph_assets.action': {
'Meta': {'object_name': 'Action'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.asset': {
'Meta': {'object_name': 'Asset'},
'attachments': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ralph_assets.Attachment']", 'null': 'True', 'blank': 'True'}),
'barcode': ('django.db.models.fields.CharField', [], {'default': 'None', 'max_length': '200', 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
'delivery_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'deprecation_rate': ('django.db.models.fields.DecimalField', [], {'default': '25', 'max_digits': '5', 'decimal_places': '2', 'blank': 'True'}),
'device_info': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ralph_assets.DeviceInfo']", 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'force_deprecation': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'invoice_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'invoice_no': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '128', 'null': 'True', 'blank': 'True'}),
'loan_end_date': ('django.db.models.fields.DateField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
'location': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}),
'model': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetModel']", 'on_delete': 'models.PROTECT'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'modified_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'niw': ('django.db.models.fields.CharField', [], {'default': 'None', 'max_length': '200', 'null': 'True', 'blank': 'True'}),
'note': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'office_info': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ralph_assets.OfficeInfo']", 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'order_no': ('django.db.models.fields.CharField', [], {'max_length': '50', 'null': 'True', 'blank': 'True'}),
'owner': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "u'owner'", 'null': 'True', 'to': "orm['auth.User']"}),
'part_info': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ralph_assets.PartInfo']", 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'price': ('django.db.models.fields.DecimalField', [], {'default': '0', 'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'production_use_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'production_year': ('django.db.models.fields.PositiveSmallIntegerField', [], {'null': 'True', 'blank': 'True'}),
'property_of': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetOwner']", 'null': 'True', 'on_delete': 'models.PROTECT', 'blank': 'True'}),
'provider': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'provider_order_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'remarks': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'request_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'service_name': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.Service']", 'null': 'True', 'blank': 'True'}),
'slots': ('django.db.models.fields.FloatField', [], {'default': '0', 'max_length': '64'}),
'sn': ('django.db.models.fields.CharField', [], {'max_length': '200', 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'source': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'status': ('django.db.models.fields.PositiveSmallIntegerField', [], {'default': '1', 'null': 'True', 'blank': 'True'}),
'support_period': ('django.db.models.fields.PositiveSmallIntegerField', [], {'default': '0', 'null': 'True', 'blank': 'True'}),
'support_price': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'support_type': ('django.db.models.fields.CharField', [], {'max_length': '150', 'blank': 'True'}),
'support_void_reporting': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'db_index': 'True'}),
'task_url': ('django.db.models.fields.URLField', [], {'max_length': '2048', 'null': 'True', 'blank': 'True'}),
'type': ('django.db.models.fields.PositiveSmallIntegerField', [], {}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "u'user'", 'null': 'True', 'to': "orm['auth.User']"}),
'warehouse': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.Warehouse']", 'on_delete': 'models.PROTECT'})
},
'ralph_assets.assetcategory': {
'Meta': {'object_name': 'AssetCategory'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'is_blade': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'level': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'lft': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'modified_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
'parent': ('mptt.fields.TreeForeignKey', [], {'blank': 'True', 'related_name': "u'children'", 'null': 'True', 'to': "orm['ralph_assets.AssetCategory']"}),
'rght': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100', 'primary_key': 'True'}),
'tree_id': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'type': ('django.db.models.fields.PositiveIntegerField', [], {})
},
'ralph_assets.assethistorychange': {
'Meta': {'object_name': 'AssetHistoryChange'},
'asset': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['ralph_assets.Asset']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
'comment': ('django.db.models.fields.TextField', [], {'null': 'True'}),
'date': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'device_info': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['ralph_assets.DeviceInfo']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
'field_name': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '64'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'new_value': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255'}),
'office_info': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['ralph_assets.OfficeInfo']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
'old_value': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255'}),
'part_info': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['ralph_assets.PartInfo']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['auth.User']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'})
},
'ralph_assets.assetmanufacturer': {
'Meta': {'object_name': 'AssetManufacturer'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'modified_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.assetmodel': {
'Meta': {'object_name': 'AssetModel'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'category': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetCategory']", 'null': 'True', 'blank': 'True'}),
'cores_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'height_of_device': ('django.db.models.fields.FloatField', [], {'default': '0', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'manufacturer': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetManufacturer']", 'null': 'True', 'on_delete': 'models.PROTECT', 'blank': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'modified_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'}),
'power_consumption': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
'type': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True'})
},
'ralph_assets.assetowner': {
'Meta': {'object_name': 'AssetOwner'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.attachment': {
'Meta': {'object_name': 'Attachment'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'file': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'original_filename': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'uploaded_by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'})
},
'ralph_assets.coaoemos': {
'Meta': {'object_name': 'CoaOemOs'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.deviceinfo': {
'Meta': {'object_name': 'DeviceInfo'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'rack': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'ralph_device_id': ('django.db.models.fields.IntegerField', [], {'default': 'None', 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'u_height': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'u_level': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'})
},
'ralph_assets.importproblem': {
'Meta': {'object_name': 'ImportProblem'},
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'message': ('django.db.models.fields.TextField', [], {}),
'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
'severity': ('django.db.models.fields.PositiveSmallIntegerField', [], {})
},
'ralph_assets.licence': {
'Meta': {'object_name': 'Licence'},
'accounting_id': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'asset_type': ('django.db.models.fields.PositiveSmallIntegerField', [], {}),
'assets': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ralph_assets.Asset']", 'symmetrical': 'False'}),
'attachments': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ralph_assets.Attachment']", 'null': 'True', 'blank': 'True'}),
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'invoice_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'invoice_no': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '128', 'null': 'True', 'blank': 'True'}),
'level': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'lft': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'licence_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.LicenceType']", 'on_delete': 'models.PROTECT'}),
'manufacturer': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetManufacturer']", 'null': 'True', 'on_delete': 'models.PROTECT', 'blank': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'niw': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '50'}),
'number_bought': ('django.db.models.fields.IntegerField', [], {}),
'order_no': ('django.db.models.fields.CharField', [], {'max_length': '50', 'null': 'True', 'blank': 'True'}),
'parent': ('mptt.fields.TreeForeignKey', [], {'blank': 'True', 'related_name': "u'children'", 'null': 'True', 'to': "orm['ralph_assets.Licence']"}),
'price': ('django.db.models.fields.DecimalField', [], {'default': '0', 'null': 'True', 'max_digits': '10', 'decimal_places': '2', 'blank': 'True'}),
'property_of': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.AssetOwner']", 'null': 'True', 'on_delete': 'models.PROTECT'}),
'provider': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'rght': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'sn': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'software_category': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.SoftwareCategory']", 'on_delete': 'models.PROTECT'}),
'tree_id': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
'users': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.User']", 'symmetrical': 'False'}),
'valid_thru': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'ralph_assets.licencehistorychange': {
'Meta': {'object_name': 'LicenceHistoryChange'},
'date': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'field_name': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '64'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'licence': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['ralph_assets.Licence']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
'new_value': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255'}),
'old_value': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['auth.User']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'})
},
'ralph_assets.licencetype': {
'Meta': {'object_name': 'LicenceType'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.officeinfo': {
'Meta': {'object_name': 'OfficeInfo'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'coa_number': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'coa_oem_os': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.CoaOemOs']", 'null': 'True', 'blank': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'imei': ('django.db.models.fields.CharField', [], {'max_length': '18', 'unique': 'True', 'null': 'True', 'blank': 'True'}),
'license_key': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'purpose': ('django.db.models.fields.PositiveSmallIntegerField', [], {'default': 'None', 'null': 'True', 'blank': 'True'})
},
'ralph_assets.partinfo': {
'Meta': {'object_name': 'PartInfo'},
'barcode_salvaged': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
'device': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "u'device'", 'null': 'True', 'to': "orm['ralph_assets.Asset']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'source_device': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "u'source_device'", 'null': 'True', 'to': "orm['ralph_assets.Asset']"})
},
'ralph_assets.reportodtsource': {
'Meta': {'object_name': 'ReportOdtSource'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100'}),
'template': ('django.db.models.fields.files.FileField', [], {'max_length': '100'})
},
'ralph_assets.service': {
'Meta': {'object_name': 'Service'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'cost_center': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'}),
'profit_center': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'})
},
'ralph_assets.softwarecategory': {
'Meta': {'object_name': 'SoftwareCategory'},
'asset_type': ('django.db.models.fields.PositiveSmallIntegerField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
},
'ralph_assets.transition': {
'Meta': {'object_name': 'Transition'},
'actions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ralph_assets.Action']", 'symmetrical': 'False'}),
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'from_status': ('django.db.models.fields.PositiveSmallIntegerField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100'}),
'to_status': ('django.db.models.fields.PositiveSmallIntegerField', [], {})
},
'ralph_assets.transitionshistory': {
'Meta': {'ordering': "[u'-created']", 'object_name': 'TransitionsHistory'},
'affected_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'affected user'", 'to': "orm['auth.User']"}),
'assets': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ralph_assets.Asset']", 'symmetrical': 'False'}),
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'logged_user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'logged user'", 'to': "orm['auth.User']"}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'report_file': ('django.db.models.fields.files.FileField', [], {'max_length': '100'}),
'report_filename': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'transition': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ralph_assets.Transition']"}),
'uid': ('django.db.models.fields.CharField', [], {'max_length': '36'})
},
'ralph_assets.warehouse': {
'Meta': {'object_name': 'Warehouse'},
'cache_version': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'modified_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'+'", 'on_delete': 'models.SET_NULL', 'default': 'None', 'to': "orm['account.Profile']", 'blank': 'True', 'null': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '75', 'db_index': 'True'})
}
}
complete_apps = ['ralph_assets']
| [
"south.db.db.delete_column",
"south.db.db.send_create_signal",
"south.db.db.delete_unique",
"django.db.models.ForeignKey",
"south.db.db.create_unique",
"django.db.models.AutoField",
"south.db.db.delete_table"
] | [((269, 317), 'south.db.db.delete_unique', 'db.delete_unique', (['"""ralph_assets_licence"""', "['sn']"], {}), "('ralph_assets_licence', ['sn'])\n", (285, 317), False, 'from south.db import db\n'), ((1526, 1587), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['TransitionsHistory']"], {}), "('ralph_assets', ['TransitionsHistory'])\n", (1547, 1587), False, 'from south.db import db\n'), ((2025, 2127), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_transitionshistory_assets"""', "['transitionshistory_id', 'asset_id']"], {}), "('ralph_assets_transitionshistory_assets', [\n 'transitionshistory_id', 'asset_id'])\n", (2041, 2127), False, 'from south.db import db\n'), ((2954, 3007), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['Attachment']"], {}), "('ralph_assets', ['Attachment'])\n", (2975, 3007), False, 'from south.db import db\n'), ((3308, 3359), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['CoaOemOs']"], {}), "('ralph_assets', ['CoaOemOs'])\n", (3329, 3359), False, 'from south.db import db\n'), ((3656, 3705), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['Action']"], {}), "('ralph_assets', ['Action'])\n", (3677, 3705), False, 'from south.db import db\n'), ((4523, 4581), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['ReportOdtSource']"], {}), "('ralph_assets', ['ReportOdtSource'])\n", (4544, 4581), False, 'from south.db import db\n'), ((5402, 5452), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['Service']"], {}), "('ralph_assets', ['Service'])\n", (5423, 5452), False, 'from south.db import db\n'), ((6371, 6424), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['Transition']"], {}), "('ralph_assets', ['Transition'])\n", (6392, 6424), False, 'from south.db import db\n'), ((6834, 6921), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_transition_actions"""', "['transition_id', 'action_id']"], {}), "('ralph_assets_transition_actions', ['transition_id',\n 'action_id'])\n", (6850, 6921), False, 'from south.db import db\n'), ((7878, 7941), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['LicenceHistoryChange']"], {}), "('ralph_assets', ['LicenceHistoryChange'])\n", (7899, 7941), False, 'from south.db import db\n'), ((8511, 8567), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""ralph_assets"""', "['ImportProblem']"], {}), "('ralph_assets', ['ImportProblem'])\n", (8532, 8567), False, 'from south.db import db\n'), ((8624, 8679), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_licence"""', '"""bought_date"""'], {}), "('ralph_assets_licence', 'bought_date')\n", (8640, 8679), False, 'from south.db import db\n'), ((8729, 8777), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_licence"""', '"""used"""'], {}), "('ralph_assets_licence', 'used')\n", (8745, 8777), False, 'from south.db import db\n'), ((9932, 10007), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_licence_assets"""', "['licence_id', 'asset_id']"], {}), "('ralph_assets_licence_assets', ['licence_id', 'asset_id'])\n", (9948, 10007), False, 'from south.db import db\n'), ((10389, 10462), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_licence_users"""', "['licence_id', 'user_id']"], {}), "('ralph_assets_licence_users', ['licence_id', 'user_id'])\n", (10405, 10462), False, 'from south.db import db\n'), ((10876, 10965), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_licence_attachments"""', "['licence_id', 'attachment_id']"], {}), "('ralph_assets_licence_attachments', ['licence_id',\n 'attachment_id'])\n", (10892, 10965), False, 'from south.db import db\n'), ((11218, 11267), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_licence"""', "['niw']"], {}), "('ralph_assets_licence', ['niw'])\n", (11234, 11267), False, 'from south.db import db\n'), ((11660, 11713), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_asset"""', '"""category_id"""'], {}), "('ralph_assets_asset', 'category_id')\n", (11676, 11713), False, 'from south.db import db\n'), ((13138, 13223), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_asset_attachments"""', "['asset_id', 'attachment_id']"], {}), "('ralph_assets_asset_attachments', ['asset_id',\n 'attachment_id'])\n", (13154, 13223), False, 'from south.db import db\n'), ((14148, 14202), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""version"""'], {}), "('ralph_assets_officeinfo', 'version')\n", (14164, 14202), False, 'from south.db import db\n'), ((14267, 14330), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""last_logged_user"""'], {}), "('ralph_assets_officeinfo', 'last_logged_user')\n", (14283, 14330), False, 'from south.db import db\n'), ((14401, 14470), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""date_of_last_inventory"""'], {}), "('ralph_assets_officeinfo', 'date_of_last_inventory')\n", (14417, 14470), False, 'from south.db import db\n'), ((14529, 14586), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""attachment"""'], {}), "('ralph_assets_officeinfo', 'attachment')\n", (14545, 14586), False, 'from south.db import db\n'), ((14647, 14706), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""license_type"""'], {}), "('ralph_assets_officeinfo', 'license_type')\n", (14663, 14706), False, 'from south.db import db\n'), ((16061, 16110), 'south.db.db.delete_unique', 'db.delete_unique', (['"""ralph_assets_licence"""', "['niw']"], {}), "('ralph_assets_licence', ['niw'])\n", (16077, 16110), False, 'from south.db import db\n'), ((16166, 16216), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_transitionshistory"""'], {}), "('ralph_assets_transitionshistory')\n", (16181, 16216), False, 'from south.db import db\n'), ((16296, 16353), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_transitionshistory_assets"""'], {}), "('ralph_assets_transitionshistory_assets')\n", (16311, 16353), False, 'from south.db import db\n'), ((16401, 16443), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_attachment"""'], {}), "('ralph_assets_attachment')\n", (16416, 16443), False, 'from south.db import db\n'), ((16489, 16529), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_coaoemos"""'], {}), "('ralph_assets_coaoemos')\n", (16504, 16529), False, 'from south.db import db\n'), ((16573, 16611), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_action"""'], {}), "('ralph_assets_action')\n", (16588, 16611), False, 'from south.db import db\n'), ((16664, 16711), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_reportodtsource"""'], {}), "('ralph_assets_reportodtsource')\n", (16679, 16711), False, 'from south.db import db\n'), ((16756, 16795), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_service"""'], {}), "('ralph_assets_service')\n", (16771, 16795), False, 'from south.db import db\n'), ((16843, 16885), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_transition"""'], {}), "('ralph_assets_transition')\n", (16858, 16885), False, 'from south.db import db\n'), ((16958, 17008), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_transition_actions"""'], {}), "('ralph_assets_transition_actions')\n", (16973, 17008), False, 'from south.db import db\n'), ((17066, 17118), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_licencehistorychange"""'], {}), "('ralph_assets_licencehistorychange')\n", (17081, 17118), False, 'from south.db import db\n'), ((17169, 17214), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_importproblem"""'], {}), "('ralph_assets_importproblem')\n", (17184, 17214), False, 'from south.db import db\n'), ((17720, 17776), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_licence"""', '"""invoice_date"""'], {}), "('ralph_assets_licence', 'invoice_date')\n", (17736, 17776), False, 'from south.db import db\n'), ((17830, 17882), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_licence"""', '"""provider"""'], {}), "('ralph_assets_licence', 'provider')\n", (17846, 17882), False, 'from south.db import db\n'), ((17938, 17992), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_licence"""', '"""invoice_no"""'], {}), "('ralph_assets_licence', 'invoice_no')\n", (17954, 17992), False, 'from south.db import db\n'), ((18061, 18107), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_licence_assets"""'], {}), "('ralph_assets_licence_assets')\n", (18076, 18107), False, 'from south.db import db\n'), ((18175, 18220), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_licence_users"""'], {}), "('ralph_assets_licence_users')\n", (18190, 18220), False, 'from south.db import db\n'), ((18294, 18345), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_licence_attachments"""'], {}), "('ralph_assets_licence_attachments')\n", (18309, 18345), False, 'from south.db import db\n'), ((18945, 18993), 'south.db.db.create_unique', 'db.create_unique', (['"""ralph_assets_licence"""', "['sn']"], {}), "('ralph_assets_licence', ['sn'])\n", (18961, 18993), False, 'from south.db import db\n'), ((19322, 19372), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_asset"""', '"""location"""'], {}), "('ralph_assets_asset', 'location')\n", (19338, 19372), False, 'from south.db import db\n'), ((19428, 19485), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_asset"""', '"""service_name_id"""'], {}), "('ralph_assets_asset', 'service_name_id')\n", (19444, 19485), False, 'from south.db import db\n'), ((19542, 19597), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_asset"""', '"""loan_end_date"""'], {}), "('ralph_assets_asset', 'loan_end_date')\n", (19558, 19597), False, 'from south.db import db\n'), ((19645, 19691), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_asset"""', '"""note"""'], {}), "('ralph_assets_asset', 'note')\n", (19661, 19691), False, 'from south.db import db\n'), ((19763, 19812), 'south.db.db.delete_table', 'db.delete_table', (['"""ralph_assets_asset_attachments"""'], {}), "('ralph_assets_asset_attachments')\n", (19778, 19812), False, 'from south.db import db\n'), ((22031, 22088), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""coa_number"""'], {}), "('ralph_assets_officeinfo', 'coa_number')\n", (22047, 22088), False, 'from south.db import db\n'), ((22147, 22207), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""coa_oem_os_id"""'], {}), "('ralph_assets_officeinfo', 'coa_oem_os_id')\n", (22163, 22207), False, 'from south.db import db\n'), ((22260, 22311), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""imei"""'], {}), "('ralph_assets_officeinfo', 'imei')\n", (22276, 22311), False, 'from south.db import db\n'), ((22367, 22421), 'south.db.db.delete_column', 'db.delete_column', (['"""ralph_assets_officeinfo"""', '"""purpose"""'], {}), "('ralph_assets_officeinfo', 'purpose')\n", (22383, 22421), False, 'from south.db import db\n'), ((1744, 1816), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (1760, 1816), False, 'from django.db import models\n'), ((1854, 1923), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.transitionshistory']"], {'null': '(False)'}), "(orm['ralph_assets.transitionshistory'], null=False)\n", (1871, 1923), False, 'from django.db import models\n'), ((1948, 2004), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.asset']"], {'null': '(False)'}), "(orm['ralph_assets.asset'], null=False)\n", (1965, 2004), False, 'from django.db import models\n'), ((6567, 6639), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (6583, 6639), False, 'from django.db import models\n'), ((6669, 6730), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.transition']"], {'null': '(False)'}), "(orm['ralph_assets.transition'], null=False)\n", (6686, 6730), False, 'from django.db import models\n'), ((6756, 6813), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.action']"], {'null': '(False)'}), "(orm['ralph_assets.action'], null=False)\n", (6773, 6813), False, 'from django.db import models\n'), ((9673, 9745), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (9689, 9745), False, 'from django.db import models\n'), ((9772, 9830), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.licence']"], {'null': '(False)'}), "(orm['ralph_assets.licence'], null=False)\n", (9789, 9830), False, 'from django.db import models\n'), ((9855, 9911), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.asset']"], {'null': '(False)'}), "(orm['ralph_assets.asset'], null=False)\n", (9872, 9911), False, 'from django.db import models\n'), ((10140, 10212), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (10156, 10212), False, 'from django.db import models\n'), ((10239, 10297), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.licence']"], {'null': '(False)'}), "(orm['ralph_assets.licence'], null=False)\n", (10256, 10297), False, 'from django.db import models\n'), ((10321, 10368), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['auth.user']"], {'null': '(False)'}), "(orm['auth.user'], null=False)\n", (10338, 10368), False, 'from django.db import models\n'), ((10607, 10679), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (10623, 10679), False, 'from django.db import models\n'), ((10706, 10764), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.licence']"], {'null': '(False)'}), "(orm['ralph_assets.licence'], null=False)\n", (10723, 10764), False, 'from django.db import models\n'), ((10794, 10855), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.attachment']"], {'null': '(False)'}), "(orm['ralph_assets.attachment'], null=False)\n", (10811, 10855), False, 'from django.db import models\n'), ((12873, 12945), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'primary_key': '(True)', 'auto_created': '(True)'}), "(verbose_name='ID', primary_key=True, auto_created=True)\n", (12889, 12945), False, 'from django.db import models\n'), ((12970, 13026), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.asset']"], {'null': '(False)'}), "(orm['ralph_assets.asset'], null=False)\n", (12987, 13026), False, 'from django.db import models\n'), ((13056, 13117), 'django.db.models.ForeignKey', 'models.ForeignKey', (["orm['ralph_assets.attachment']"], {'null': '(False)'}), "(orm['ralph_assets.attachment'], null=False)\n", (13073, 13117), False, 'from django.db import models\n')] |
import connexion
import six
from openapi_server import query_manager
from openapi_server.utils.vars import VARIABLE_TYPE_NAME, VARIABLE_TYPE_URI
from openapi_server.models.variable import Variable # noqa: E501
from openapi_server import util
def variables_get(username=None, label=None, page=None, per_page=None): # noqa: E501
"""List all instances of Variable
Gets a list of all instances of Variable (more information in https://w3id.org/okn/o/sd#Variable) # noqa: E501
:param username: Name of the user graph to query
:type username: str
:param label: Filter by label
:type label: str
:param page: Page number
:type page: int
:param per_page: Items per page
:type per_page: int
:rtype: List[Variable]
"""
return query_manager.get_resource(
username=username,
label=label,
page=page,
per_page=per_page,
rdf_type_uri=VARIABLE_TYPE_URI,
rdf_type_name=VARIABLE_TYPE_NAME,
kls=Variable)
def variables_id_delete(id, user=None): # noqa: E501
"""Delete an existing Variable
Delete an existing Variable (more information in https://w3id.org/okn/o/sd#Variable) # noqa: E501
:param id: The ID of the Variable to be retrieved
:type id: str
:param user: Username
:type user: str
:rtype: None
"""
return query_manager.delete_resource(id=id,
user=user,
rdf_type_uri=VARIABLE_TYPE_URI,
rdf_type_name=VARIABLE_TYPE_NAME,
kls=Variable)
def variables_id_get(id, username=None): # noqa: E501
"""Get a single Variable by its id
Gets the details of a given Variable (more information in https://w3id.org/okn/o/sd#Variable) # noqa: E501
:param id: The ID of the Variable to be retrieved
:type id: str
:param username: Name of the user graph to query
:type username: str
:rtype: Variable
"""
return query_manager.get_resource(id=id,
username=username,
rdf_type_uri=VARIABLE_TYPE_URI,
rdf_type_name=VARIABLE_TYPE_NAME,
kls=Variable)
def variables_id_put(id, user=None, variable=None): # noqa: E501
"""Update an existing Variable
Updates an existing Variable (more information in https://w3id.org/okn/o/sd#Variable) # noqa: E501
:param id: The ID of the Variable to be retrieved
:type id: str
:param user: Username
:type user: str
:param variable: An old Variableto be updated
:type variable: dict | bytes
:rtype: Variable
"""
if connexion.request.is_json:
variable = Variable.from_dict(connexion.request.get_json()) # noqa: E501
return query_manager.put_resource(id=id,
user=user,
body=variable,
rdf_type_uri=VARIABLE_TYPE_URI,
rdf_type_name=VARIABLE_TYPE_NAME,
kls=Variable)
def variables_post(user=None, variable=None): # noqa: E501
"""Create one Variable
Create a new instance of Variable (more information in https://w3id.org/okn/o/sd#Variable) # noqa: E501
:param user: Username
:type user: str
:param variable: Information about the Variableto be created
:type variable: dict | bytes
:rtype: Variable
"""
if connexion.request.is_json:
variable = Variable.from_dict(connexion.request.get_json()) # noqa: E501
return query_manager.post_resource(
user=user,
body=variable,
rdf_type_uri=VARIABLE_TYPE_URI,
rdf_type_name=VARIABLE_TYPE_NAME,
kls=Variable)
| [
"openapi_server.query_manager.delete_resource",
"openapi_server.query_manager.post_resource",
"openapi_server.query_manager.get_resource",
"connexion.request.get_json",
"openapi_server.query_manager.put_resource"
] | [((776, 953), 'openapi_server.query_manager.get_resource', 'query_manager.get_resource', ([], {'username': 'username', 'label': 'label', 'page': 'page', 'per_page': 'per_page', 'rdf_type_uri': 'VARIABLE_TYPE_URI', 'rdf_type_name': 'VARIABLE_TYPE_NAME', 'kls': 'Variable'}), '(username=username, label=label, page=page,\n per_page=per_page, rdf_type_uri=VARIABLE_TYPE_URI, rdf_type_name=\n VARIABLE_TYPE_NAME, kls=Variable)\n', (802, 953), False, 'from openapi_server import query_manager\n'), ((1354, 1486), 'openapi_server.query_manager.delete_resource', 'query_manager.delete_resource', ([], {'id': 'id', 'user': 'user', 'rdf_type_uri': 'VARIABLE_TYPE_URI', 'rdf_type_name': 'VARIABLE_TYPE_NAME', 'kls': 'Variable'}), '(id=id, user=user, rdf_type_uri=\n VARIABLE_TYPE_URI, rdf_type_name=VARIABLE_TYPE_NAME, kls=Variable)\n', (1383, 1486), False, 'from openapi_server import query_manager\n'), ((1915, 2052), 'openapi_server.query_manager.get_resource', 'query_manager.get_resource', ([], {'id': 'id', 'username': 'username', 'rdf_type_uri': 'VARIABLE_TYPE_URI', 'rdf_type_name': 'VARIABLE_TYPE_NAME', 'kls': 'Variable'}), '(id=id, username=username, rdf_type_uri=\n VARIABLE_TYPE_URI, rdf_type_name=VARIABLE_TYPE_NAME, kls=Variable)\n', (1941, 2052), False, 'from openapi_server import query_manager\n'), ((2648, 2792), 'openapi_server.query_manager.put_resource', 'query_manager.put_resource', ([], {'id': 'id', 'user': 'user', 'body': 'variable', 'rdf_type_uri': 'VARIABLE_TYPE_URI', 'rdf_type_name': 'VARIABLE_TYPE_NAME', 'kls': 'Variable'}), '(id=id, user=user, body=variable, rdf_type_uri=\n VARIABLE_TYPE_URI, rdf_type_name=VARIABLE_TYPE_NAME, kls=Variable)\n', (2674, 2792), False, 'from openapi_server import query_manager\n'), ((3330, 3468), 'openapi_server.query_manager.post_resource', 'query_manager.post_resource', ([], {'user': 'user', 'body': 'variable', 'rdf_type_uri': 'VARIABLE_TYPE_URI', 'rdf_type_name': 'VARIABLE_TYPE_NAME', 'kls': 'Variable'}), '(user=user, body=variable, rdf_type_uri=\n VARIABLE_TYPE_URI, rdf_type_name=VARIABLE_TYPE_NAME, kls=Variable)\n', (3357, 3468), False, 'from openapi_server import query_manager\n'), ((2592, 2620), 'connexion.request.get_json', 'connexion.request.get_json', ([], {}), '()\n', (2618, 2620), False, 'import connexion\n'), ((3274, 3302), 'connexion.request.get_json', 'connexion.request.get_json', ([], {}), '()\n', (3300, 3302), False, 'import connexion\n')] |
import pycxsimulator
from pylab import *
import copy as cp
nr = 500. # carrying capacity of rabbits
r_init = 100 # initial rabbit population
mr = 0.03 # magnitude of movement of rabbits
dr = 1.0 # death rate of rabbits when it faces foxes
rr = 0.1 # reproduction rate of rabbits
f_init = 30 # initial fox population
mf = 0.05 # magnitude of movement of foxes
df = 0.1 # death rate of foxes when there is no food
rf = 0.5 # reproduction rate of foxes
cd = 0.02 # radius for collision detection
cdsq = cd ** 2
class agent:
pass
def initialize():
global agents
agents = []
for i in range(r_init + f_init):
ag = agent()
ag.type = 'r' if i < r_init else 'f'
ag.x = random()
ag.y = random()
agents.append(ag)
def observe():
global agents
cla()
rabbits = [ag for ag in agents if ag.type == 'r']
if len(rabbits) > 0:
x = [ag.x for ag in rabbits]
y = [ag.y for ag in rabbits]
plot(x, y, 'b.')
foxes = [ag for ag in agents if ag.type == 'f']
if len(foxes) > 0:
x = [ag.x for ag in foxes]
y = [ag.y for ag in foxes]
plot(x, y, 'ro')
axis('image')
axis([0, 1, 0, 1])
def update_one_agent():
global agents
if agents == []:
return
ag = choice(agents)
# simulating random movement
m = mr if ag.type == 'r' else mf
ag.x += uniform(-m, m)
ag.y += uniform(-m, m)
ag.x = 1 if ag.x > 1 else 0 if ag.x < 0 else ag.x
ag.y = 1 if ag.y > 1 else 0 if ag.y < 0 else ag.y
# detecting collision and simulating death or birth
neighbors = [nb for nb in agents if nb.type != ag.type
and (ag.x - nb.x)**2 + (ag.y - nb.y)**2 < cdsq]
if ag.type == 'r':
if len(neighbors) > 0: # if there are foxes nearby
if random() < dr:
agents.remove(ag)
return
if random() < rr*(1-sum([1 for x in agents if x.type == 'r'])/nr):
agents.append(cp.copy(ag))
else:
if len(neighbors) == 0: # if there are no rabbits nearby
if random() < df:
agents.remove(ag)
return
else: # if there are rabbits nearby
if random() < rf:
agents.append(cp.copy(ag))
def update():
global agents
t = 0.
while t < 1. and len(agents) > 0:
t += 1. / len(agents)
update_one_agent()
pycxsimulator.GUI().start(func=[initialize, observe, update])
| [
"copy.copy",
"pycxsimulator.GUI"
] | [((2420, 2439), 'pycxsimulator.GUI', 'pycxsimulator.GUI', ([], {}), '()\n', (2437, 2439), False, 'import pycxsimulator\n'), ((1988, 1999), 'copy.copy', 'cp.copy', (['ag'], {}), '(ag)\n', (1995, 1999), True, 'import copy as cp\n'), ((2267, 2278), 'copy.copy', 'cp.copy', (['ag'], {}), '(ag)\n', (2274, 2278), True, 'import copy as cp\n')] |
# Copyright 2021 The ML Collections Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Tests for ml_collections.FrozenConfigDict."""
from collections import abc as collections_abc
import copy
import pickle
from absl.testing import absltest
import ml_collections
_TEST_DICT = {
'int': 2,
'list': [1, 2],
'nested_list': [[1, [2]]],
'set': {1, 2},
'tuple': (1, 2),
'frozenset': frozenset({1, 2}),
'dict': {
'float': -1.23,
'list': [1, 2],
'dict': {},
'tuple_containing_list': (1, 2, (3, [4, 5], (6, 7))),
'list_containing_tuple': [1, 2, [3, 4], (5, 6)],
},
'ref': ml_collections.FieldReference({'int': 0})
}
def _test_dict_deepcopy():
return copy.deepcopy(_TEST_DICT)
def _test_configdict():
return ml_collections.ConfigDict(_TEST_DICT)
def _test_frozenconfigdict():
return ml_collections.FrozenConfigDict(_TEST_DICT)
class FrozenConfigDictTest(absltest.TestCase):
"""Tests FrozenConfigDict in config flags library."""
def assertFrozenRaisesValueError(self, input_list):
"""Assert initialization on all elements of input_list raise ValueError."""
for initial_dictionary in input_list:
with self.assertRaises(ValueError):
_ = ml_collections.FrozenConfigDict(initial_dictionary)
def testBasicEquality(self):
"""Tests basic equality with different types of initialization."""
fcd = _test_frozenconfigdict()
fcd_cd = ml_collections.FrozenConfigDict(_test_configdict())
fcd_fcd = ml_collections.FrozenConfigDict(fcd)
self.assertEqual(fcd, fcd_cd)
self.assertEqual(fcd, fcd_fcd)
def testImmutability(self):
"""Tests immutability of frozen config."""
fcd = _test_frozenconfigdict()
self.assertEqual(fcd.list, tuple(_TEST_DICT['list']))
self.assertEqual(fcd.tuple, _TEST_DICT['tuple'])
self.assertEqual(fcd.set, frozenset(_TEST_DICT['set']))
self.assertEqual(fcd.frozenset, _TEST_DICT['frozenset'])
# Must manually check set to frozenset conversion, since Python == does not
self.assertIsInstance(fcd.set, frozenset)
self.assertEqual(fcd.dict.list, tuple(_TEST_DICT['dict']['list']))
self.assertNotEqual(fcd.dict.tuple_containing_list,
_TEST_DICT['dict']['tuple_containing_list'])
self.assertEqual(fcd.dict.tuple_containing_list[2][1],
tuple(_TEST_DICT['dict']['tuple_containing_list'][2][1]))
self.assertIsInstance(fcd.dict, ml_collections.FrozenConfigDict)
with self.assertRaises(AttributeError):
fcd.newitem = 0
with self.assertRaises(AttributeError):
fcd.dict.int = 0
with self.assertRaises(AttributeError):
fcd['newitem'] = 0
with self.assertRaises(AttributeError):
del fcd.int
with self.assertRaises(AttributeError):
del fcd['int']
def testLockAndFreeze(self):
"""Ensures .lock() and .freeze() raise errors."""
fcd = _test_frozenconfigdict()
self.assertFalse(fcd.is_locked)
self.assertFalse(fcd.as_configdict().is_locked)
with self.assertRaises(AttributeError):
fcd.lock()
with self.assertRaises(AttributeError):
fcd.unlock()
with self.assertRaises(AttributeError):
fcd.freeze()
with self.assertRaises(AttributeError):
fcd.unfreeze()
def testInitConfigDict(self):
"""Tests that ConfigDict initialization handles FrozenConfigDict.
Initializing a ConfigDict on a dictionary with FrozenConfigDict values
should unfreeze these values.
"""
dict_without_fcd_node = _test_dict_deepcopy()
dict_without_fcd_node.pop('ref')
dict_with_fcd_node = copy.deepcopy(dict_without_fcd_node)
dict_with_fcd_node['dict'] = ml_collections.FrozenConfigDict(
dict_with_fcd_node['dict'])
cd_without_fcd_node = ml_collections.ConfigDict(dict_without_fcd_node)
cd_with_fcd_node = ml_collections.ConfigDict(dict_with_fcd_node)
fcd_without_fcd_node = ml_collections.FrozenConfigDict(
dict_without_fcd_node)
fcd_with_fcd_node = ml_collections.FrozenConfigDict(dict_with_fcd_node)
self.assertEqual(cd_without_fcd_node, cd_with_fcd_node)
self.assertEqual(fcd_without_fcd_node, fcd_with_fcd_node)
def testInitCopying(self):
"""Tests that initialization copies when and only when necessary.
Ensures copying only occurs when converting mutable type to immutable type,
regardless of whether the FrozenConfigDict is initialized by a dict or a
FrozenConfigDict. Also ensures no copying occurs when converting from
FrozenConfigDict back to ConfigDict.
"""
fcd = _test_frozenconfigdict()
# These should be uncopied when creating fcd
fcd_unchanged_from_test_dict = [
(_TEST_DICT['tuple'], fcd.tuple),
(_TEST_DICT['frozenset'], fcd.frozenset),
(_TEST_DICT['dict']['tuple_containing_list'][2][2],
fcd.dict.tuple_containing_list[2][2]),
(_TEST_DICT['dict']['list_containing_tuple'][3],
fcd.dict.list_containing_tuple[3])
]
# These should be copied when creating fcd
fcd_different_from_test_dict = [
(_TEST_DICT['list'], fcd.list),
(_TEST_DICT['dict']['tuple_containing_list'][2][1],
fcd.dict.tuple_containing_list[2][1])
]
for (x, y) in fcd_unchanged_from_test_dict:
self.assertEqual(id(x), id(y))
for (x, y) in fcd_different_from_test_dict:
self.assertNotEqual(id(x), id(y))
# Also make sure that converting back to ConfigDict makes no copies
self.assertEqual(
id(_TEST_DICT['dict']['tuple_containing_list']),
id(ml_collections.ConfigDict(fcd).dict.tuple_containing_list))
def testAsConfigDict(self):
"""Tests that converting FrozenConfigDict to ConfigDict works correctly.
In particular, ensures that FrozenConfigDict does the inverse of ConfigDict
regarding type_safe, lock, and attribute mutability.
"""
# First ensure conversion to ConfigDict works on empty FrozenConfigDict
self.assertEqual(
ml_collections.ConfigDict(ml_collections.FrozenConfigDict()),
ml_collections.ConfigDict())
cd = _test_configdict()
cd_fcd_cd = ml_collections.ConfigDict(ml_collections.FrozenConfigDict(cd))
self.assertEqual(cd, cd_fcd_cd)
# Make sure locking is respected
cd.lock()
self.assertEqual(
cd, ml_collections.ConfigDict(ml_collections.FrozenConfigDict(cd)))
# Make sure type_safe is respected
cd = ml_collections.ConfigDict(_TEST_DICT, type_safe=False)
self.assertEqual(
cd, ml_collections.ConfigDict(ml_collections.FrozenConfigDict(cd)))
def testInitSelfReferencing(self):
"""Ensure initialization fails on self-referencing dicts."""
self_ref = {}
self_ref['self'] = self_ref
parent_ref = {'dict': {}}
parent_ref['dict']['parent'] = parent_ref
tuple_parent_ref = {'dict': {}}
tuple_parent_ref['dict']['tuple'] = (1, 2, tuple_parent_ref)
attribute_cycle = {'dict': copy.deepcopy(self_ref)}
self.assertFrozenRaisesValueError(
[self_ref, parent_ref, tuple_parent_ref, attribute_cycle])
def testInitCycles(self):
"""Ensure initialization fails if an attribute of input is cyclic."""
inner_cyclic_list = [1, 2]
cyclic_list = [3, inner_cyclic_list]
inner_cyclic_list.append(cyclic_list)
cyclic_tuple = tuple(cyclic_list)
test_dict_cyclic_list = _test_dict_deepcopy()
test_dict_cyclic_tuple = _test_dict_deepcopy()
test_dict_cyclic_list['cyclic_list'] = cyclic_list
test_dict_cyclic_tuple['dict']['cyclic_tuple'] = cyclic_tuple
self.assertFrozenRaisesValueError(
[test_dict_cyclic_list, test_dict_cyclic_tuple])
def testInitDictInList(self):
"""Ensure initialization fails on dict and ConfigDict in lists/tuples."""
list_containing_dict = {'list': [1, 2, 3, {'a': 4, 'b': 5}]}
tuple_containing_dict = {'tuple': (1, 2, 3, {'a': 4, 'b': 5})}
list_containing_cd = {'list': [1, 2, 3, _test_configdict()]}
tuple_containing_cd = {'tuple': (1, 2, 3, _test_configdict())}
fr_containing_list_containing_dict = {
'fr': ml_collections.FieldReference([1, {
'a': 2
}])
}
self.assertFrozenRaisesValueError([
list_containing_dict, tuple_containing_dict, list_containing_cd,
tuple_containing_cd, fr_containing_list_containing_dict
])
def testInitFieldReferenceInList(self):
"""Ensure initialization fails on FieldReferences in lists/tuples."""
list_containing_fr = {'list': [1, 2, 3, ml_collections.FieldReference(4)]}
tuple_containing_fr = {
'tuple': (1, 2, 3, ml_collections.FieldReference('a'))
}
self.assertFrozenRaisesValueError([list_containing_fr, tuple_containing_fr])
def testInitInvalidAttributeName(self):
"""Ensure initialization fails on attributes with invalid names."""
dot_name = {'dot.name': None}
immutable_name = {'__hash__': None}
with self.assertRaises(ValueError):
ml_collections.FrozenConfigDict(dot_name)
with self.assertRaises(AttributeError):
ml_collections.FrozenConfigDict(immutable_name)
def testFieldReferenceResolved(self):
"""Tests that FieldReferences are resolved."""
cfg = ml_collections.ConfigDict({'fr': ml_collections.FieldReference(1)})
frozen_cfg = ml_collections.FrozenConfigDict(cfg)
self.assertNotIsInstance(frozen_cfg._fields['fr'],
ml_collections.FieldReference)
hash(frozen_cfg) # with FieldReference resolved, frozen_cfg is hashable
def testFieldReferenceCycle(self):
"""Tests that FieldReferences may not contain reference cycles."""
frozenset_fr = {'frozenset': frozenset({1, 2})}
frozenset_fr['fr'] = ml_collections.FieldReference(
frozenset_fr['frozenset'])
list_fr = {'list': [1, 2]}
list_fr['fr'] = ml_collections.FieldReference(list_fr['list'])
cyclic_fr = {'a': 1}
cyclic_fr['fr'] = ml_collections.FieldReference(cyclic_fr)
cyclic_fr_parent = {'dict': {}}
cyclic_fr_parent['dict']['fr'] = ml_collections.FieldReference(
cyclic_fr_parent)
# FieldReference is allowed to point to non-cyclic objects:
_ = ml_collections.FrozenConfigDict(frozenset_fr)
_ = ml_collections.FrozenConfigDict(list_fr)
# But not cycles:
self.assertFrozenRaisesValueError([cyclic_fr, cyclic_fr_parent])
def testDeepCopy(self):
"""Ensure deepcopy works and does not affect equality."""
fcd = _test_frozenconfigdict()
fcd_deepcopy = copy.deepcopy(fcd)
self.assertEqual(fcd, fcd_deepcopy)
def testEquals(self):
"""Tests that __eq__() respects hidden mutability."""
fcd = _test_frozenconfigdict()
# First, ensure __eq__() returns False when comparing to other types
self.assertNotEqual(fcd, (1, 2))
self.assertNotEqual(fcd, fcd.as_configdict())
list_to_tuple = _test_dict_deepcopy()
list_to_tuple['list'] = tuple(list_to_tuple['list'])
fcd_list_to_tuple = ml_collections.FrozenConfigDict(list_to_tuple)
set_to_frozenset = _test_dict_deepcopy()
set_to_frozenset['set'] = frozenset(set_to_frozenset['set'])
fcd_set_to_frozenset = ml_collections.FrozenConfigDict(set_to_frozenset)
self.assertNotEqual(fcd, fcd_list_to_tuple)
# Because set == frozenset in Python:
self.assertEqual(fcd, fcd_set_to_frozenset)
# Items are not affected by hidden mutability
self.assertCountEqual(fcd.items(), fcd_list_to_tuple.items())
self.assertCountEqual(fcd.items(), fcd_set_to_frozenset.items())
def testEqualsAsConfigDict(self):
"""Tests that eq_as_configdict respects hidden mutability but not type."""
fcd = _test_frozenconfigdict()
# First, ensure eq_as_configdict() returns True with an equal ConfigDict but
# False for other types.
self.assertFalse(fcd.eq_as_configdict([1, 2]))
self.assertTrue(fcd.eq_as_configdict(fcd.as_configdict()))
empty_fcd = ml_collections.FrozenConfigDict()
self.assertTrue(empty_fcd.eq_as_configdict(ml_collections.ConfigDict()))
# Now, ensure it has the same immutability detection as __eq__().
list_to_tuple = _test_dict_deepcopy()
list_to_tuple['list'] = tuple(list_to_tuple['list'])
fcd_list_to_tuple = ml_collections.FrozenConfigDict(list_to_tuple)
set_to_frozenset = _test_dict_deepcopy()
set_to_frozenset['set'] = frozenset(set_to_frozenset['set'])
fcd_set_to_frozenset = ml_collections.FrozenConfigDict(set_to_frozenset)
self.assertFalse(fcd.eq_as_configdict(fcd_list_to_tuple))
# Because set == frozenset in Python:
self.assertTrue(fcd.eq_as_configdict(fcd_set_to_frozenset))
def testHash(self):
"""Ensures __hash__() respects hidden mutability."""
list_to_tuple = _test_dict_deepcopy()
list_to_tuple['list'] = tuple(list_to_tuple['list'])
self.assertEqual(
hash(_test_frozenconfigdict()),
hash(ml_collections.FrozenConfigDict(_test_dict_deepcopy())))
self.assertNotEqual(
hash(_test_frozenconfigdict()),
hash(ml_collections.FrozenConfigDict(list_to_tuple)))
# Ensure Python realizes FrozenConfigDict is hashable
self.assertIsInstance(_test_frozenconfigdict(), collections_abc.Hashable)
def testUnhashableType(self):
"""Ensures __hash__() fails if FrozenConfigDict has unhashable value."""
unhashable_fcd = ml_collections.FrozenConfigDict(
{'unhashable': bytearray()})
with self.assertRaises(TypeError):
hash(unhashable_fcd)
def testToDict(self):
"""Ensure to_dict() does not care about hidden mutability."""
list_to_tuple = _test_dict_deepcopy()
list_to_tuple['list'] = tuple(list_to_tuple['list'])
self.assertEqual(_test_frozenconfigdict().to_dict(),
ml_collections.FrozenConfigDict(list_to_tuple).to_dict())
def testPickle(self):
"""Make sure FrozenConfigDict can be dumped and loaded with pickle."""
fcd = _test_frozenconfigdict()
locked_fcd = ml_collections.FrozenConfigDict(_test_configdict().lock())
unpickled_fcd = pickle.loads(pickle.dumps(fcd))
unpickled_locked_fcd = pickle.loads(pickle.dumps(locked_fcd))
self.assertEqual(fcd, unpickled_fcd)
self.assertEqual(locked_fcd, unpickled_locked_fcd)
if __name__ == '__main__':
absltest.main()
| [
"pickle.dumps",
"ml_collections.FrozenConfigDict",
"ml_collections.ConfigDict",
"absl.testing.absltest.main",
"copy.deepcopy",
"ml_collections.FieldReference"
] | [((1167, 1208), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (["{'int': 0}"], {}), "({'int': 0})\n", (1196, 1208), False, 'import ml_collections\n'), ((1249, 1274), 'copy.deepcopy', 'copy.deepcopy', (['_TEST_DICT'], {}), '(_TEST_DICT)\n', (1262, 1274), False, 'import copy\n'), ((1310, 1347), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', (['_TEST_DICT'], {}), '(_TEST_DICT)\n', (1335, 1347), False, 'import ml_collections\n'), ((1389, 1432), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['_TEST_DICT'], {}), '(_TEST_DICT)\n', (1420, 1432), False, 'import ml_collections\n'), ((14768, 14783), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (14781, 14783), False, 'from absl.testing import absltest\n'), ((2038, 2074), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['fcd'], {}), '(fcd)\n', (2069, 2074), False, 'import ml_collections\n'), ((4145, 4181), 'copy.deepcopy', 'copy.deepcopy', (['dict_without_fcd_node'], {}), '(dict_without_fcd_node)\n', (4158, 4181), False, 'import copy\n'), ((4215, 4274), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (["dict_with_fcd_node['dict']"], {}), "(dict_with_fcd_node['dict'])\n", (4246, 4274), False, 'import ml_collections\n'), ((4310, 4358), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', (['dict_without_fcd_node'], {}), '(dict_without_fcd_node)\n', (4335, 4358), False, 'import ml_collections\n'), ((4382, 4427), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', (['dict_with_fcd_node'], {}), '(dict_with_fcd_node)\n', (4407, 4427), False, 'import ml_collections\n'), ((4455, 4509), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['dict_without_fcd_node'], {}), '(dict_without_fcd_node)\n', (4486, 4509), False, 'import ml_collections\n'), ((4543, 4594), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['dict_with_fcd_node'], {}), '(dict_with_fcd_node)\n', (4574, 4594), False, 'import ml_collections\n'), ((6965, 7019), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', (['_TEST_DICT'], {'type_safe': '(False)'}), '(_TEST_DICT, type_safe=False)\n', (6990, 7019), False, 'import ml_collections\n'), ((9816, 9852), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['cfg'], {}), '(cfg)\n', (9847, 9852), False, 'import ml_collections\n'), ((10231, 10287), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (["frozenset_fr['frozenset']"], {}), "(frozenset_fr['frozenset'])\n", (10260, 10287), False, 'import ml_collections\n'), ((10348, 10394), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (["list_fr['list']"], {}), "(list_fr['list'])\n", (10377, 10394), False, 'import ml_collections\n'), ((10443, 10483), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (['cyclic_fr'], {}), '(cyclic_fr)\n', (10472, 10483), False, 'import ml_collections\n'), ((10557, 10604), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (['cyclic_fr_parent'], {}), '(cyclic_fr_parent)\n', (10586, 10604), False, 'import ml_collections\n'), ((10687, 10732), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['frozenset_fr'], {}), '(frozenset_fr)\n', (10718, 10732), False, 'import ml_collections\n'), ((10741, 10781), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['list_fr'], {}), '(list_fr)\n', (10772, 10781), False, 'import ml_collections\n'), ((11016, 11034), 'copy.deepcopy', 'copy.deepcopy', (['fcd'], {}), '(fcd)\n', (11029, 11034), False, 'import copy\n'), ((11478, 11524), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['list_to_tuple'], {}), '(list_to_tuple)\n', (11509, 11524), False, 'import ml_collections\n'), ((11663, 11712), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['set_to_frozenset'], {}), '(set_to_frozenset)\n', (11694, 11712), False, 'import ml_collections\n'), ((12431, 12464), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', ([], {}), '()\n', (12462, 12464), False, 'import ml_collections\n'), ((12736, 12782), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['list_to_tuple'], {}), '(list_to_tuple)\n', (12767, 12782), False, 'import ml_collections\n'), ((12921, 12970), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['set_to_frozenset'], {}), '(set_to_frozenset)\n', (12952, 12970), False, 'import ml_collections\n'), ((6593, 6620), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', ([], {}), '()\n', (6618, 6620), False, 'import ml_collections\n'), ((6693, 6728), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['cd'], {}), '(cd)\n', (6724, 6728), False, 'import ml_collections\n'), ((7479, 7502), 'copy.deepcopy', 'copy.deepcopy', (['self_ref'], {}), '(self_ref)\n', (7492, 7502), False, 'import copy\n'), ((8619, 8663), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (["[1, {'a': 2}]"], {}), "([1, {'a': 2}])\n", (8648, 8663), False, 'import ml_collections\n'), ((9488, 9529), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['dot_name'], {}), '(dot_name)\n', (9519, 9529), False, 'import ml_collections\n'), ((9581, 9628), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['immutable_name'], {}), '(immutable_name)\n', (9612, 9628), False, 'import ml_collections\n'), ((14555, 14572), 'pickle.dumps', 'pickle.dumps', (['fcd'], {}), '(fcd)\n', (14567, 14572), False, 'import pickle\n'), ((14614, 14638), 'pickle.dumps', 'pickle.dumps', (['locked_fcd'], {}), '(locked_fcd)\n', (14626, 14638), False, 'import pickle\n'), ((1769, 1820), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['initial_dictionary'], {}), '(initial_dictionary)\n', (1800, 1820), False, 'import ml_collections\n'), ((6549, 6582), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', ([], {}), '()\n', (6580, 6582), False, 'import ml_collections\n'), ((6878, 6913), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['cd'], {}), '(cd)\n', (6909, 6913), False, 'import ml_collections\n'), ((7080, 7115), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['cd'], {}), '(cd)\n', (7111, 7115), False, 'import ml_collections\n'), ((9038, 9070), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (['(4)'], {}), '(4)\n', (9067, 9070), False, 'import ml_collections\n'), ((9128, 9162), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (['"""a"""'], {}), "('a')\n", (9157, 9162), False, 'import ml_collections\n'), ((9764, 9796), 'ml_collections.FieldReference', 'ml_collections.FieldReference', (['(1)'], {}), '(1)\n', (9793, 9796), False, 'import ml_collections\n'), ((12512, 12539), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', ([], {}), '()\n', (12537, 12539), False, 'import ml_collections\n'), ((13530, 13576), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['list_to_tuple'], {}), '(list_to_tuple)\n', (13561, 13576), False, 'import ml_collections\n'), ((14252, 14298), 'ml_collections.FrozenConfigDict', 'ml_collections.FrozenConfigDict', (['list_to_tuple'], {}), '(list_to_tuple)\n', (14283, 14298), False, 'import ml_collections\n'), ((6103, 6133), 'ml_collections.ConfigDict', 'ml_collections.ConfigDict', (['fcd'], {}), '(fcd)\n', (6128, 6133), False, 'import ml_collections\n')] |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
パッケージpyserialをインストールすること
pytho2.x系で動作(python3.*系も動作検証済み)
Creater：<NAME>
'''
import serial
import binascii
import signal
import sys
import platform
from serial.tools import list_ports
#platformの切り替え
if platform.system() == 'Windows': #windows用
ports = list_ports.comports()
portnumber = None
for port in ports:
if (port.vid == 1027) and (port.pid == 24597): #プロダクトIDとベンダーIDが一致したら接続
portnumber = port.device
print("connect to " + portnumber)
break
if portnumber == None:
print("not connetc to im920!")
sys.exit(1)
elif platform.system() == 'Linux': #Linux用
portnumber = '/dev/ttyUSB0'
'''
ctrl+cの命令
'''
def signal_handler(signal, frame):
print('exit')
sys.exit()
'''
serial.Serialの設定
mybaudrate:ボーレート
'''
def setSerial(mybaudrate):
com = serial.Serial(
port = portnumber,
baudrate = mybaudrate,
bytesize = serial.EIGHTBITS,
parity = serial.PARITY_NONE,
timeout = None,
xonxoff = False,
rtscts = False,
writeTimeout = None,
dsrdtr = False,
interCharTimeout = None)
#bufferクリア
com.flushInput()
com.flushOutput()
return com
'''
固有IDの読み出し
mybaudrate:ボーレート
'''
def Rdid(mybaudrate):
com = setSerial(mybaudrate)
com.flushInput()
com.write(b'RDID' + b'\r\n')
com.flushOutput()
print(com.readline().strip())
com.close()
'''
ボーレートの設定
mybaudrate:現在のボーレート
setbaudrate:セットするボーレート(文字列でもってくること)
0 1200bps
1 2400bps
2 4800bps
3 9600bps
4 19200bps
5 38400bps
'''
def Sbrt(mybaudrate, setbaudrate):
com = setSerial(mybaudrate)
com.flushInput()
com.write(b'ENWR' + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'SBRT ' + setbaudrate.encode('utf-8') + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'DSWR' + b'\r\n')
com.flushOutput()
com.readline()
com.close()
'''
ペアリング
mybaudrate:ボーレート
args:ペアリングしたいID(文字列にすること)
'''
def Srid(mybaudrate, args):
com = setSerial(mybaudrate)
com.flushInput()
com.write(b'ENWR' + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'SRID ' + args.encode('utf-8') + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'DSWR' + b'\r\n')
com.flushOutput()
com.readline()
com.close()
'''
ペアリングの削除
全て削除されるため注意!
mybaudrate:ボーレート
'''
def Erid(mybaudrate):
com = setSerial(mybaudrate)
com.flushInput()
com.write(b'ENWR' + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'ERID' + b'\r\n')
com.flushOutput()
com.readline()
com.write(b'DSWR' + b'\r\n')
com.flushOutput()
com.readline()
com.close()
'''
送信
mybaudrate:ボーレート
args:送信したい文字列 (数字の場合も文字列型にすること)
'''
def Send(mybaudrate, args):
com = setSerial(mybaudrate)
com.flushInput()
com.write(b'TXDA' + binascii.b2a_hex(args.encode('utf-8')) + b'\r\n')
com.flushOutput()
com.readline()
com.close()
'''
受信
アスキーコードから文字列に変換したものを返す
mybaudrate:ボーレート
'''
def Reception(mybaudrate):
com = setSerial(mybaudrate)
com.flushInput()
text = ""
cngtext = ""
try:
text = com.readline().decode('utf-8').strip() #受信と空白の削除
com.close()
text = text.replace("\r\n","")
text = text.split(":")[1]
text = text.split(",")
for x in text:
cngtext += chr(int(x,16))
except Exception:
print("not input data")
return cngtext
'''
中継機化
mybaudrate:ボーレート
'''
def Repeater(mybaudrate):
signal.signal(signal.SIGINT, signal_handler)
while True:
data = Reception(mybaudrate)
if len(data) != 0:
print("input data:", data)
Send(19200, data) | [
"signal.signal",
"serial.tools.list_ports.comports",
"platform.system",
"serial.Serial",
"sys.exit"
] | [((252, 269), 'platform.system', 'platform.system', ([], {}), '()\n', (267, 269), False, 'import platform\n'), ((307, 328), 'serial.tools.list_ports.comports', 'list_ports.comports', ([], {}), '()\n', (326, 328), False, 'from serial.tools import list_ports\n'), ((793, 803), 'sys.exit', 'sys.exit', ([], {}), '()\n', (801, 803), False, 'import sys\n'), ((884, 1097), 'serial.Serial', 'serial.Serial', ([], {'port': 'portnumber', 'baudrate': 'mybaudrate', 'bytesize': 'serial.EIGHTBITS', 'parity': 'serial.PARITY_NONE', 'timeout': 'None', 'xonxoff': '(False)', 'rtscts': '(False)', 'writeTimeout': 'None', 'dsrdtr': '(False)', 'interCharTimeout': 'None'}), '(port=portnumber, baudrate=mybaudrate, bytesize=serial.\n EIGHTBITS, parity=serial.PARITY_NONE, timeout=None, xonxoff=False,\n rtscts=False, writeTimeout=None, dsrdtr=False, interCharTimeout=None)\n', (897, 1097), False, 'import serial\n'), ((3608, 3652), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'signal_handler'], {}), '(signal.SIGINT, signal_handler)\n', (3621, 3652), False, 'import signal\n'), ((629, 640), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (637, 640), False, 'import sys\n'), ((647, 664), 'platform.system', 'platform.system', ([], {}), '()\n', (662, 664), False, 'import platform\n')] |
from test.webdnn_test.graph_test.operators_test.util import template_test_unary_operator
from webdnn.graph.operators.sigmoid import Sigmoid
def template():
template_test_unary_operator(Sigmoid)
def test():
template()
| [
"test.webdnn_test.graph_test.operators_test.util.template_test_unary_operator"
] | [((162, 199), 'test.webdnn_test.graph_test.operators_test.util.template_test_unary_operator', 'template_test_unary_operator', (['Sigmoid'], {}), '(Sigmoid)\n', (190, 199), False, 'from test.webdnn_test.graph_test.operators_test.util import template_test_unary_operator\n')] |
import pybullet_data
import pybullet as p
import time
import numpy as np
from src.utils_geom import *
from src.utils_depth import *
from src.panda import Panda
def full_jacob_pb(jac_t, jac_r):
return np.vstack((jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2]))
class pandaEnv():
def __init__(self,
urdfRoot=pybullet_data.getDataPath(),
mu=0.3,
sigma=0.01,
timestep=1./240.,
long_finger=False,
):
self._urdfRoot = urdfRoot
self._timeStep = timestep
self._pandaId = None
self._planeId = None
self._tableId = None
self._mu = mu
self._sigma = sigma
self.long_finger = long_finger
def reset_env(self):
p.resetSimulation()
p.setPhysicsEngineParameter(numSolverIterations=150,
enableConeFriction=1,
contactBreakingThreshold=1e-3)
p.setTimeStep(self._timeStep)
# Set gravity
p.setGravity(0, 0, -9.81)
# Load plane and table
self._planeId = p.loadURDF(self._urdfRoot+'/plane.urdf', basePosition=[0, 0, -1], useFixedBase=1)
self._tableId = p.loadURDF(self._urdfRoot+'/table/table.urdf', basePosition=[0.4000000, 0.00000, -0.63+0.005], baseOrientation=[0, 0, 0, 1.0], useFixedBase=1)
# Load arm, no need to settle (joint angle set instantly)
self._panda = Panda(self.long_finger)
self._pandaId = self._panda.load()
# Set friction coefficients of arm and table
self.change_friction_coeffs(self._mu, self._sigma)
# Create a constraint to keep the fingers centered (upper links)
fingerGear = p.createConstraint(self._pandaId,
9,
self._pandaId,
11,
jointType=p.JOINT_GEAR,
jointAxis=[1, 0, 0],
parentFramePosition=[0, 0, 0],
childFramePosition=[0, 0, 0])
p.changeConstraint(fingerGear, gearRatio=-1, erp=0.1, maxForce=2*self._panda.maxFingerForce)
# Disable damping for all links
for i in range(self._panda.numJoints):
p.changeDynamics(self._pandaId, i,
linearDamping=0,
angularDamping=0)
def change_friction_coeffs(self, mu, sigma):
p.changeDynamics(self._pandaId, self._panda.pandaLeftFingerLinkIndex, lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
p.changeDynamics(self._pandaId, self._panda.pandaRightFingerLinkIndex, lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
p.changeDynamics(self._tableId, -1,
lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
def reset_arm_joints_ik(self, pos, orn, fingerPos=0.0):
jointPoses = list(p.calculateInverseKinematics(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
pos, orn,
jointDamping=self._panda.jd,
lowerLimits=self._panda.jointLowerLimit,
upperLimits=self._panda.jointUpperLimit,
jointRanges=self._panda.jointRange,
restPoses=self._panda.jointRestPose,
residualThreshold=1e-4))
# , maxNumIterations=1e5))
jointPoses = jointPoses[:7] + [0, -np.pi/4, fingerPos, 0.00, fingerPos, 0.00]
self._panda.reset(jointPoses)
def reset_arm_joints(self, joints):
jointPoses = joints + [0, -np.pi/4, self._panda.fingerOpenPos,
0.00, self._panda.fingerOpenPos, 0.00]
self._panda.reset(jointPoses)
########################* Arm control *#######################
def move_pos(self, absolute_pos=None,
relative_pos=None,
absolute_global_euler=None, # preferred
relative_global_euler=None, # preferred
relative_local_euler=None, # not using
absolute_global_quat=None, # preferred
relative_azi=None, # for arm
# relative_quat=None, # never use relative quat
numSteps=50,
maxJointVel=0.20,
relativePos=True,
globalOrn=True,
checkContact=False,
checkPalmContact=False,
objId=None,
gripper_target_pos=None,
timeStep=0):
# Get trajectory
eePosNow, eeQuatNow = self._panda.get_ee()
# Determine target pos
if absolute_pos is not None:
targetPos = absolute_pos
elif relative_pos is not None:
targetPos = eePosNow + relative_pos
else:
targetPos = eePosNow
# Determine target orn
if absolute_global_euler is not None:
targetOrn = euler2quat(absolute_global_euler)
elif relative_global_euler is not None:
targetOrn = quatMult(euler2quat(relative_global_euler), eeQuatNow)
elif relative_local_euler is not None:
targetOrn = quatMult(eeQuatNow, euler2quat(relative_local_euler))
elif absolute_global_quat is not None:
targetOrn = absolute_global_quat
elif relative_azi is not None:
# Extrinsic yaw
targetOrn = quatMult(euler2quat([relative_azi[0],0,0]), eeQuatNow)
# Intrinsic pitch
targetOrn = quatMult(targetOrn, euler2quat([0,relative_azi[1],0]))
# elif relative_quat is not None:
# targetOrn = quatMult(eeQuatNow, relative_quat)
else:
targetOrn = array([1.0, 0., 0., 0.])
# Get trajectory
trajPos = self.traj_time_scaling(startPos=eePosNow,
endPos=targetPos,
numSteps=numSteps)
# Run steps
numSteps = len(trajPos)
for step in range(numSteps):
# Get joint velocities from error tracking control
jointDot = self.traj_tracking_vel(targetPos=trajPos[step], targetQuat=targetOrn)
# Send velocity commands to joints
for i in range(self._panda.numJointsArm):
p.setJointMotorControl2(self._pandaId,
i,
p.VELOCITY_CONTROL,
targetVelocity=jointDot[i],
force=self._panda.maxJointForce[i],
maxVelocity=maxJointVel)
if gripper_target_pos is None:
# Keep gripper current velocity
p.setJointMotorControl2(self._pandaId,
self._panda.pandaLeftFingerJointIndex,
p.VELOCITY_CONTROL,
targetVelocity=self._panda.fingerCurVel,
force=self._panda.maxJointForce[i],
maxVelocity=0.04)
p.setJointMotorControl2(self._pandaId,
self._panda.pandaRightFingerJointIndex,
p.VELOCITY_CONTROL,
targetVelocity=self._panda.fingerCurVel,
force=self._panda.maxJointForce[i],
maxVelocity=0.04)
else:
p.setJointMotorControl2(self._pandaId,
self._panda.pandaLeftFingerJointIndex,
p.POSITION_CONTROL,
targetPosition=gripper_target_pos,
maxVelocity=0.04)
p.setJointMotorControl2(self._pandaId,
self._panda.pandaRightFingerJointIndex,
p.POSITION_CONTROL,
targetPosition=gripper_target_pos,
maxVelocity=0.04)
# Quit if contact at either finger or palm
if checkContact:
contact = self.check_contact(objId, both=False)
if contact:
return timeStep, False
if checkPalmContact:
contact = self.check_palm_contact(objId)
if contact:
return timeStep, False
# Step simulation
p.stepSimulation()
timeStep += 1
return timeStep, True
def grasp(self, targetVel=0):
# Change gripper velocity direction
if targetVel > 1e-2 or targetVel < -1e-2: # Use specified velocity if available
self._panda.fingerCurVel = targetVel
else:
if self._panda.fingerCurVel > 0.0:
self._panda.fingerCurVel = -0.05
else:
self._panda.fingerCurVel = 0.05
return
def traj_time_scaling(self, startPos, endPos, numSteps):
trajPos = np.zeros((numSteps, 3))
for step in range(numSteps):
s = 3 * (1.0 * step / numSteps) ** 2 - 2 * (1.0 * step / numSteps) ** 3
trajPos[step] = (endPos-startPos)*s+startPos
return trajPos
def traj_tracking_vel(self, targetPos, targetQuat, posGain=20, velGain=5):
eePos, eeQuat = self._panda.get_ee()
eePosError = targetPos - eePos
eeOrnError = log_rot(quat2rot(targetQuat).dot((quat2rot(eeQuat).T))) # in spatial frame
jointPoses = self._panda.get_arm_joints() + [0,0,0] # add fingers
eeState = p.getLinkState(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
computeLinkVelocity=1,
computeForwardKinematics=1)
# Get the Jacobians for the CoM of the end-effector link. Note that in this example com_rot = identity, and we would need to use com_rot.T * com_trn. The localPosition is always defined in terms of the link frame coordinates.
zero_vec = [0.0] * len(jointPoses)
jac_t, jac_r = p.calculateJacobian(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
eeState[2],
jointPoses,
zero_vec,
zero_vec) # use localInertialFrameOrientation
jac_sp = full_jacob_pb(jac_t, jac_r)[:, :7] # 6x10 -> 6x7, ignore last three columns
try:
jointDot = np.linalg.pinv(jac_sp).dot((np.hstack((posGain*eePosError, velGain*eeOrnError)).reshape(6,1))) # pseudo-inverse
except np.linalg.LinAlgError:
jointDot = np.zeros((7,1))
return jointDot
############################### Contact ##################################
def get_contact(self, objId, minForceThres=1e-1):
left_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaLeftFingerLinkIndex,
linkIndexB=-1)
right_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaRightFingerLinkIndex,
linkIndexB=-1)
left_contacts = [i for i in left_contacts if i[9] > minForceThres]
right_contacts = [i for i in right_contacts if i[9] > minForceThres]
return left_contacts, right_contacts
def get_finger_force(self, objId):
left_contacts, right_contacts = self.get_contact(objId)
left_force = np.zeros((3))
right_force = np.zeros((3))
for i in left_contacts:
left_force += i[9]*np.array(i[7])+i[10]*np.array(i[11])+i[12]*np.array(i[13])
for i in right_contacts:
right_force += i[9]*np.array(i[7])+i[10]*np.array(i[11])+i[12]*np.array(i[13])
leftNormalMag = sum([i[9] for i in left_contacts])
rightNormalMag = sum([i[9] for i in right_contacts])
numLeftContact = len(left_contacts)
numRightContact = len(right_contacts)
if numLeftContact < 1 or numRightContact < 1:
return None
else:
return left_force, right_force, \
np.array(left_contacts[0][6]), np.array(right_contacts[0][6]), \
leftNormalMag, rightNormalMag
def check_hold_object(self, objId, minForceThres=10.0):
left_contacts, right_contacts = self.get_contact(objId)
leftNormalMag = sum([i[9] for i in left_contacts])
rightNormalMag = sum([i[9] for i in right_contacts])
return leftNormalMag > minForceThres and rightNormalMag > minForceThres
def check_contact(self, objId, both=False):
leftContacts, rightContacts = self.get_contact(objId)
if both:
if len(leftContacts) > 0 and len(rightContacts) > 0:
return 1
else:
if len(leftContacts) > 0 or len(rightContacts) > 0:
return 1
return 0
def check_palm_contact(self, objId, minForceThres=1e-1):
palm_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaHandLinkIndex,
linkIndexB=-1)
palm_contacts = [i for i in palm_contacts if i[9] > minForceThres]
return len(palm_contacts) > 0
############################### Info ##################################
def get_ee(self):
return self._panda.get_ee()
def get_gripper_tip_long(self):
return self._panda.get_gripper_tip_long()
def get_arm_joints(self):
return self._panda.get_arm_joints()
def get_gripper_joint(self):
return self._panda.get_gripper_joint()
def get_left_finger(self):
return self._panda.get_left_finger()
def get_right_finger(self):
return self._panda.get_right_finger()
def get_obs(self):
return self._panda.get_obs()
| [
"pybullet_data.getDataPath",
"numpy.linalg.pinv",
"numpy.hstack",
"pybullet.setTimeStep",
"pybullet.setGravity",
"numpy.array",
"pybullet.setPhysicsEngineParameter",
"src.panda.Panda",
"pybullet.calculateJacobian",
"pybullet.createConstraint",
"numpy.vstack",
"pybullet.changeConstraint",
"py... | [((207, 278), 'numpy.vstack', 'np.vstack', (['(jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2])'], {}), '((jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2]))\n', (216, 278), True, 'import numpy as np\n'), ((333, 360), 'pybullet_data.getDataPath', 'pybullet_data.getDataPath', ([], {}), '()\n', (358, 360), False, 'import pybullet_data\n'), ((675, 694), 'pybullet.resetSimulation', 'p.resetSimulation', ([], {}), '()\n', (692, 694), True, 'import pybullet as p\n'), ((697, 807), 'pybullet.setPhysicsEngineParameter', 'p.setPhysicsEngineParameter', ([], {'numSolverIterations': '(150)', 'enableConeFriction': '(1)', 'contactBreakingThreshold': '(0.001)'}), '(numSolverIterations=150, enableConeFriction=1,\n contactBreakingThreshold=0.001)\n', (724, 807), True, 'import pybullet as p\n'), ((827, 856), 'pybullet.setTimeStep', 'p.setTimeStep', (['self._timeStep'], {}), '(self._timeStep)\n', (840, 856), True, 'import pybullet as p\n'), ((876, 901), 'pybullet.setGravity', 'p.setGravity', (['(0)', '(0)', '(-9.81)'], {}), '(0, 0, -9.81)\n', (888, 901), True, 'import pybullet as p\n'), ((946, 1033), 'pybullet.loadURDF', 'p.loadURDF', (["(self._urdfRoot + '/plane.urdf')"], {'basePosition': '[0, 0, -1]', 'useFixedBase': '(1)'}), "(self._urdfRoot + '/plane.urdf', basePosition=[0, 0, -1],\n useFixedBase=1)\n", (956, 1033), True, 'import pybullet as p\n'), ((1046, 1187), 'pybullet.loadURDF', 'p.loadURDF', (["(self._urdfRoot + '/table/table.urdf')"], {'basePosition': '[0.4, 0.0, -0.63 + 0.005]', 'baseOrientation': '[0, 0, 0, 1.0]', 'useFixedBase': '(1)'}), "(self._urdfRoot + '/table/table.urdf', basePosition=[0.4, 0.0, -\n 0.63 + 0.005], baseOrientation=[0, 0, 0, 1.0], useFixedBase=1)\n", (1056, 1187), True, 'import pybullet as p\n'), ((1266, 1289), 'src.panda.Panda', 'Panda', (['self.long_finger'], {}), '(self.long_finger)\n', (1271, 1289), False, 'from src.panda import Panda\n'), ((1511, 1681), 'pybullet.createConstraint', 'p.createConstraint', (['self._pandaId', '(9)', 'self._pandaId', '(11)'], {'jointType': 'p.JOINT_GEAR', 'jointAxis': '[1, 0, 0]', 'parentFramePosition': '[0, 0, 0]', 'childFramePosition': '[0, 0, 0]'}), '(self._pandaId, 9, self._pandaId, 11, jointType=p.\n JOINT_GEAR, jointAxis=[1, 0, 0], parentFramePosition=[0, 0, 0],\n childFramePosition=[0, 0, 0])\n', (1529, 1681), True, 'import pybullet as p\n'), ((1717, 1816), 'pybullet.changeConstraint', 'p.changeConstraint', (['fingerGear'], {'gearRatio': '(-1)', 'erp': '(0.1)', 'maxForce': '(2 * self._panda.maxFingerForce)'}), '(fingerGear, gearRatio=-1, erp=0.1, maxForce=2 * self.\n _panda.maxFingerForce)\n', (1735, 1816), True, 'import pybullet as p\n'), ((2033, 2168), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'self._panda.pandaLeftFingerLinkIndex'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._pandaId, self._panda.pandaLeftFingerLinkIndex,\n lateralFriction=mu, spinningFriction=sigma, frictionAnchor=1)\n', (2049, 2168), True, 'import pybullet as p\n'), ((2178, 2314), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'self._panda.pandaRightFingerLinkIndex'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._pandaId, self._panda.pandaRightFingerLinkIndex,\n lateralFriction=mu, spinningFriction=sigma, frictionAnchor=1)\n', (2194, 2314), True, 'import pybullet as p\n'), ((2325, 2427), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._tableId', '(-1)'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._tableId, -1, lateralFriction=mu, spinningFriction=\n sigma, frictionAnchor=1)\n', (2341, 2427), True, 'import pybullet as p\n'), ((7318, 7341), 'numpy.zeros', 'np.zeros', (['(numSteps, 3)'], {}), '((numSteps, 3))\n', (7326, 7341), True, 'import numpy as np\n'), ((7837, 7960), 'pybullet.getLinkState', 'p.getLinkState', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex'], {'computeLinkVelocity': '(1)', 'computeForwardKinematics': '(1)'}), '(self._pandaId, self._panda.pandaEndEffectorLinkIndex,\n computeLinkVelocity=1, computeForwardKinematics=1)\n', (7851, 7960), True, 'import pybullet as p\n'), ((8260, 8381), 'pybullet.calculateJacobian', 'p.calculateJacobian', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex', 'eeState[2]', 'jointPoses', 'zero_vec', 'zero_vec'], {}), '(self._pandaId, self._panda.pandaEndEffectorLinkIndex,\n eeState[2], jointPoses, zero_vec, zero_vec)\n', (8279, 8381), True, 'import pybullet as p\n'), ((8933, 9042), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaLeftFingerLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaLeftFingerLinkIndex, linkIndexB=-1)\n', (8951, 9042), True, 'import pybullet as p\n'), ((9081, 9191), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaRightFingerLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaRightFingerLinkIndex, linkIndexB=-1)\n', (9099, 9191), True, 'import pybullet as p\n'), ((9503, 9514), 'numpy.zeros', 'np.zeros', (['(3)'], {}), '(3)\n', (9511, 9514), True, 'import numpy as np\n'), ((9533, 9544), 'numpy.zeros', 'np.zeros', (['(3)'], {}), '(3)\n', (9541, 9544), True, 'import numpy as np\n'), ((10813, 10916), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaHandLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaHandLinkIndex, linkIndexB=-1)\n', (10831, 10916), True, 'import pybullet as p\n'), ((1895, 1964), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'i'], {'linearDamping': '(0)', 'angularDamping': '(0)'}), '(self._pandaId, i, linearDamping=0, angularDamping=0)\n', (1911, 1964), True, 'import pybullet as p\n'), ((2517, 2838), 'pybullet.calculateInverseKinematics', 'p.calculateInverseKinematics', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex', 'pos', 'orn'], {'jointDamping': 'self._panda.jd', 'lowerLimits': 'self._panda.jointLowerLimit', 'upperLimits': 'self._panda.jointUpperLimit', 'jointRanges': 'self._panda.jointRange', 'restPoses': 'self._panda.jointRestPose', 'residualThreshold': '(0.0001)'}), '(self._pandaId, self._panda.\n pandaEndEffectorLinkIndex, pos, orn, jointDamping=self._panda.jd,\n lowerLimits=self._panda.jointLowerLimit, upperLimits=self._panda.\n jointUpperLimit, jointRanges=self._panda.jointRange, restPoses=self.\n _panda.jointRestPose, residualThreshold=0.0001)\n', (2545, 2838), True, 'import pybullet as p\n'), ((6855, 6873), 'pybullet.stepSimulation', 'p.stepSimulation', ([], {}), '()\n', (6871, 6873), True, 'import pybullet as p\n'), ((5360, 5518), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'i', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'jointDot[i]', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': 'maxJointVel'}), '(self._pandaId, i, p.VELOCITY_CONTROL,\n targetVelocity=jointDot[i], force=self._panda.maxJointForce[i],\n maxVelocity=maxJointVel)\n', (5383, 5518), True, 'import pybullet as p\n'), ((5639, 5841), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaLeftFingerJointIndex', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'self._panda.fingerCurVel', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaLeftFingerJointIndex, p.VELOCITY_CONTROL, targetVelocity=self.\n _panda.fingerCurVel, force=self._panda.maxJointForce[i], maxVelocity=0.04)\n', (5662, 5841), True, 'import pybullet as p\n'), ((5891, 6094), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaRightFingerJointIndex', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'self._panda.fingerCurVel', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaRightFingerJointIndex, p.VELOCITY_CONTROL, targetVelocity=self.\n _panda.fingerCurVel, force=self._panda.maxJointForce[i], maxVelocity=0.04)\n', (5914, 6094), True, 'import pybullet as p\n'), ((6153, 6313), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaLeftFingerJointIndex', 'p.POSITION_CONTROL'], {'targetPosition': 'gripper_target_pos', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaLeftFingerJointIndex, p.POSITION_CONTROL, targetPosition=\n gripper_target_pos, maxVelocity=0.04)\n', (6176, 6313), True, 'import pybullet as p\n'), ((6352, 6513), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaRightFingerJointIndex', 'p.POSITION_CONTROL'], {'targetPosition': 'gripper_target_pos', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaRightFingerJointIndex, p.POSITION_CONTROL, targetPosition=\n gripper_target_pos, maxVelocity=0.04)\n', (6375, 6513), True, 'import pybullet as p\n'), ((8747, 8763), 'numpy.zeros', 'np.zeros', (['(7, 1)'], {}), '((7, 1))\n', (8755, 8763), True, 'import numpy as np\n'), ((10064, 10093), 'numpy.array', 'np.array', (['left_contacts[0][6]'], {}), '(left_contacts[0][6])\n', (10072, 10093), True, 'import numpy as np\n'), ((10095, 10125), 'numpy.array', 'np.array', (['right_contacts[0][6]'], {}), '(right_contacts[0][6])\n', (10103, 10125), True, 'import numpy as np\n'), ((8588, 8610), 'numpy.linalg.pinv', 'np.linalg.pinv', (['jac_sp'], {}), '(jac_sp)\n', (8602, 8610), True, 'import numpy as np\n'), ((9639, 9654), 'numpy.array', 'np.array', (['i[13]'], {}), '(i[13])\n', (9647, 9654), True, 'import numpy as np\n'), ((9748, 9763), 'numpy.array', 'np.array', (['i[13]'], {}), '(i[13])\n', (9756, 9763), True, 'import numpy as np\n'), ((8616, 8671), 'numpy.hstack', 'np.hstack', (['(posGain * eePosError, velGain * eeOrnError)'], {}), '((posGain * eePosError, velGain * eeOrnError))\n', (8625, 8671), True, 'import numpy as np\n'), ((9596, 9610), 'numpy.array', 'np.array', (['i[7]'], {}), '(i[7])\n', (9604, 9610), True, 'import numpy as np\n'), ((9617, 9632), 'numpy.array', 'np.array', (['i[11]'], {}), '(i[11])\n', (9625, 9632), True, 'import numpy as np\n'), ((9705, 9719), 'numpy.array', 'np.array', (['i[7]'], {}), '(i[7])\n', (9713, 9719), True, 'import numpy as np\n'), ((9726, 9741), 'numpy.array', 'np.array', (['i[11]'], {}), '(i[11])\n', (9734, 9741), True, 'import numpy as np\n')] |
import datetime
import decimal
import enum
import typing as T
import uuid
import graphene
import graphene.types
import pydantic
import pytest
from pydantic import BaseModel, create_model
import graphene_pydantic.converters as converters
from graphene_pydantic.converters import ConversionError, convert_pydantic_field
from graphene_pydantic.objecttype import PydanticObjectType
from graphene_pydantic.registry import get_global_registry, Placeholder
def _get_field_from_spec(name, type_spec_or_default):
kwargs = {name: type_spec_or_default}
m = create_model("model", **kwargs)
return m.__fields__[name]
def _convert_field_from_spec(name, type_spec_or_default):
return convert_pydantic_field(
_get_field_from_spec(name, type_spec_or_default),
get_global_registry(PydanticObjectType),
)
def test_required_string():
field = _convert_field_from_spec("s", (str, ...))
assert field is not None
assert isinstance(field, graphene.Field)
# The ellipsis in the type spec means required
assert isinstance(field.type, graphene.NonNull)
assert field.type.of_type == graphene.String
def test_default_values():
field = _convert_field_from_spec("s", "hi")
assert field is not None
assert isinstance(field, graphene.Field)
# there's a default value, so it's not required
assert not isinstance(field.type, graphene.NonNull)
assert field.type == graphene.String
assert field.default_value == "hi"
@pytest.mark.parametrize(
"input, expected",
[
((bool, False), graphene.Boolean),
((float, 0.1), graphene.Float),
((int, 6), graphene.Int),
((str, "hi"), graphene.String),
((uuid.UUID, uuid.uuid4()), graphene.UUID),
((datetime.date, datetime.date(2019, 1, 1)), graphene.Date),
((datetime.time, datetime.time(15, 29)), graphene.Time),
((datetime.datetime, datetime.datetime(2019, 1, 1, 1, 37)), graphene.DateTime),
],
)
def test_builtin_scalars(input, expected):
field = _convert_field_from_spec("attr", input)
assert isinstance(field, graphene.Field)
assert field.type == expected
assert field.default_value == input[1]
def test_union():
field = _convert_field_from_spec("attr", (T.Union[int, float, str], 5.0))
assert issubclass(field.type, graphene.Union)
assert field.default_value == 5.0
assert field.type.__name__.startswith("UnionOf")
def test_mapping():
with pytest.raises(ConversionError) as exc:
_convert_field_from_spec("attr", (T.Dict[str, int], {"foo": 5}))
assert exc.value.args[0] == "Don't know how to handle mappings in Graphene."
def test_decimal(monkeypatch):
monkeypatch.setattr(converters, "DECIMAL_SUPPORTED", True)
field = _convert_field_from_spec("attr", (decimal.Decimal, decimal.Decimal(1.25)))
assert field.type.__name__ == "Decimal"
monkeypatch.setattr(converters, "DECIMAL_SUPPORTED", False)
field = _convert_field_from_spec("attr", (decimal.Decimal, decimal.Decimal(1.25)))
assert field.type.__name__ == "Float"
def test_iterables():
field = _convert_field_from_spec("attr", (T.List[int], [1, 2]))
assert isinstance(field.type, graphene.types.List)
field = _convert_field_from_spec("attr", (list, [1, 2]))
assert field.type == graphene.types.List
field = _convert_field_from_spec("attr", (T.Set[int], {1, 2}))
assert isinstance(field.type, graphene.types.List)
field = _convert_field_from_spec("attr", (set, {1, 2}))
assert field.type == graphene.types.List
field = _convert_field_from_spec("attr", (T.Tuple[int, float], (1, 2.2)))
assert isinstance(field.type, graphene.types.List)
field = _convert_field_from_spec("attr", (T.Tuple[int, ...], (1, 2.2)))
assert isinstance(field.type, graphene.types.List)
field = _convert_field_from_spec("attr", (tuple, (1, 2)))
assert field.type == graphene.types.List
field = _convert_field_from_spec("attr", (T.Union[None, int], 1))
assert field.type == graphene.types.Int
def test_enum():
class Color(enum.Enum):
RED = 1
GREEN = 2
field = _convert_field_from_spec("attr", (Color, Color.RED))
assert field.type.__name__ == "Color"
assert field.type._meta.enum == Color
def test_existing_model():
from graphene_pydantic import PydanticObjectType
class Foo(BaseModel):
name: str
class GraphFoo(PydanticObjectType):
class Meta:
model = Foo
field = _convert_field_from_spec("attr", (Foo, Foo(name="bar")))
assert field.type == GraphFoo
def test_unresolved_placeholders():
# no errors should be raised here -- instead a placeholder is created
field = _convert_field_from_spec("attr", (create_model("Model", size=int), None))
assert any(
isinstance(x, Placeholder)
for x in get_global_registry(PydanticObjectType)._registry.values()
)
# this is a runtime error waiting to happen, but what can we do about it?
assert field.type is None
def test_self_referencing():
class NodeModel(BaseModel):
id: int
name: str
# nodes: Union['NodeModel', None]
nodes: T.Optional["NodeModel"]
NodeModel.update_forward_refs()
class NodeModelSchema(PydanticObjectType):
class Meta: # noqa: too-few-public-methods
model = NodeModel
@classmethod
def is_type_of(cls, root, info):
return isinstance(root, (cls, NodeModel))
NodeModelSchema.resolve_placeholders()
assert NodeModelSchema._meta.model is NodeModel
| [
"datetime.datetime",
"datetime.time",
"uuid.uuid4",
"pytest.raises",
"datetime.date",
"pydantic.create_model",
"graphene_pydantic.registry.get_global_registry",
"decimal.Decimal"
] | [((558, 589), 'pydantic.create_model', 'create_model', (['"""model"""'], {}), "('model', **kwargs)\n", (570, 589), False, 'from pydantic import BaseModel, create_model\n'), ((781, 820), 'graphene_pydantic.registry.get_global_registry', 'get_global_registry', (['PydanticObjectType'], {}), '(PydanticObjectType)\n', (800, 820), False, 'from graphene_pydantic.registry import get_global_registry, Placeholder\n'), ((2461, 2491), 'pytest.raises', 'pytest.raises', (['ConversionError'], {}), '(ConversionError)\n', (2474, 2491), False, 'import pytest\n'), ((2813, 2834), 'decimal.Decimal', 'decimal.Decimal', (['(1.25)'], {}), '(1.25)\n', (2828, 2834), False, 'import decimal\n'), ((3009, 3030), 'decimal.Decimal', 'decimal.Decimal', (['(1.25)'], {}), '(1.25)\n', (3024, 3030), False, 'import decimal\n'), ((4752, 4783), 'pydantic.create_model', 'create_model', (['"""Model"""'], {'size': 'int'}), "('Model', size=int)\n", (4764, 4783), False, 'from pydantic import BaseModel, create_model\n'), ((1712, 1724), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1722, 1724), False, 'import uuid\n'), ((1768, 1793), 'datetime.date', 'datetime.date', (['(2019)', '(1)', '(1)'], {}), '(2019, 1, 1)\n', (1781, 1793), False, 'import datetime\n'), ((1837, 1858), 'datetime.time', 'datetime.time', (['(15)', '(29)'], {}), '(15, 29)\n', (1850, 1858), False, 'import datetime\n'), ((1906, 1942), 'datetime.datetime', 'datetime.datetime', (['(2019)', '(1)', '(1)', '(1)', '(37)'], {}), '(2019, 1, 1, 1, 37)\n', (1923, 1942), False, 'import datetime\n'), ((4860, 4899), 'graphene_pydantic.registry.get_global_registry', 'get_global_registry', (['PydanticObjectType'], {}), '(PydanticObjectType)\n', (4879, 4899), False, 'from graphene_pydantic.registry import get_global_registry, Placeholder\n')] |
import numpy as np
import pandas as pd
from pathlib import Path
import multiprocessing as mp
from functools import partial
from src.audio import read_as_melspectrogram
from src.utils import get_params_hash
from src import config
NOISE_SOUNDS = [
'Buzz',
'Car_passing_by',
'Crackle',
'Cricket',
'Hiss',
'Mechanical_fan',
'Stream',
'Traffic_noise_and_roadway_noise',
'Walk_and_footsteps',
'Waves_and_surf',
'Crowd',
'Run',
'Female_speech_and_woman_speaking',
'Male_speech_and_man_speaking',
'Raindrop',
'Sink_(filling_or_washing)',
'Gurgling',
'Frying_(food)',
]
def check_noise(labels):
noise = True
for label in labels.split(','):
if label not in NOISE_SOUNDS:
noise = False
break
return noise
def make_spectrogram_and_save(file_path: Path, save_dir: Path, audio_params):
spec = read_as_melspectrogram(file_path, audio_params)
if spec.shape[1] >= 320:
save_dir.mkdir(parents=True, exist_ok=True)
save_path = save_dir / (file_path.name + '.npy')
np.save(save_path, spec)
def prepare_freesound_data(dir_path, audio_params):
dir_path = Path(dir_path)
file_path_lst = []
train_df = pd.read_csv(config.freesound_train_curated_csv_path)
for i, row in train_df.iterrows():
if check_noise(row.labels):
file_path = config.freesound_train_curated_dir / row.fname
file_path_lst.append(file_path)
train_df = pd.read_csv(config.freesound_train_noisy_csv_path)
for i, row in train_df.iterrows():
if check_noise(row.labels):
file_path = config.freesound_train_noisy_dir / row.fname
file_path_lst.append(file_path)
func = partial(make_spectrogram_and_save,
save_dir=dir_path, audio_params=audio_params)
with mp.Pool(mp.cpu_count()) as pool:
pool.map(func, file_path_lst)
def check_prepared_freesound_data(audio_params):
params_hash = get_params_hash({**audio_params.dict(),
'noise_sounds': NOISE_SOUNDS})
prepared_train_dir = config.freesound_prepared_train_curated_dir / params_hash
if not prepared_train_dir.exists():
print(f"Start preparing freesound dataset to '{prepared_train_dir}'")
prepare_freesound_data(prepared_train_dir, audio_params)
print(f"Dataset prepared.")
else:
print(f"'{prepared_train_dir}' already exists.")
def get_freesound_folds_data(audio_params):
params_hash = get_params_hash({**audio_params.dict(),
'noise_sounds': NOISE_SOUNDS})
prepared_train_dir = config.freesound_prepared_train_curated_dir / params_hash
folds_data = []
audio_paths = sorted(prepared_train_dir.glob("*.npy"))
for i, spec_path in enumerate(audio_paths):
sample = {
'ebird_code': 'nocall',
'spec_path': spec_path,
'fold': config.n_folds
}
folds_data.append(sample)
return folds_data
if __name__ == "__main__":
check_prepared_freesound_data(audio_params=config.audio)
| [
"pandas.read_csv",
"pathlib.Path",
"src.audio.read_as_melspectrogram",
"multiprocessing.cpu_count",
"functools.partial",
"numpy.save"
] | [((906, 953), 'src.audio.read_as_melspectrogram', 'read_as_melspectrogram', (['file_path', 'audio_params'], {}), '(file_path, audio_params)\n', (928, 953), False, 'from src.audio import read_as_melspectrogram\n'), ((1194, 1208), 'pathlib.Path', 'Path', (['dir_path'], {}), '(dir_path)\n', (1198, 1208), False, 'from pathlib import Path\n'), ((1247, 1299), 'pandas.read_csv', 'pd.read_csv', (['config.freesound_train_curated_csv_path'], {}), '(config.freesound_train_curated_csv_path)\n', (1258, 1299), True, 'import pandas as pd\n'), ((1518, 1568), 'pandas.read_csv', 'pd.read_csv', (['config.freesound_train_noisy_csv_path'], {}), '(config.freesound_train_noisy_csv_path)\n', (1529, 1568), True, 'import pandas as pd\n'), ((1769, 1854), 'functools.partial', 'partial', (['make_spectrogram_and_save'], {'save_dir': 'dir_path', 'audio_params': 'audio_params'}), '(make_spectrogram_and_save, save_dir=dir_path, audio_params=audio_params\n )\n', (1776, 1854), False, 'from functools import partial\n'), ((1100, 1124), 'numpy.save', 'np.save', (['save_path', 'spec'], {}), '(save_path, spec)\n', (1107, 1124), True, 'import numpy as np\n'), ((1887, 1901), 'multiprocessing.cpu_count', 'mp.cpu_count', ([], {}), '()\n', (1899, 1901), True, 'import multiprocessing as mp\n')] |
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from __future__ import unicode_literals
import frappe, unittest
from erpnext.accounts.doctype.fiscal_year.fiscal_year import FiscalYearIncorrectDate
test_records = frappe.get_test_records('Fiscal Year')
test_ignore = ["Company"]
class TestFiscalYear(unittest.TestCase):
def test_extra_year(self):
if frappe.db.exists("Fiscal Year", "_Test Fiscal Year 2000"):
frappe.delete_doc("Fiscal Year", "_Test Fiscal Year 2000")
fy = frappe.get_doc({
"doctype": "Fiscal Year",
"year": "_Test Fiscal Year 2000",
"year_end_date": "2002-12-31",
"year_start_date": "2000-04-01"
})
self.assertRaises(FiscalYearIncorrectDate, fy.insert)
| [
"frappe.db.exists",
"frappe.delete_doc",
"frappe.get_test_records",
"frappe.get_doc"
] | [((295, 333), 'frappe.get_test_records', 'frappe.get_test_records', (['"""Fiscal Year"""'], {}), "('Fiscal Year')\n", (318, 333), False, 'import frappe, unittest\n'), ((436, 493), 'frappe.db.exists', 'frappe.db.exists', (['"""Fiscal Year"""', '"""_Test Fiscal Year 2000"""'], {}), "('Fiscal Year', '_Test Fiscal Year 2000')\n", (452, 493), False, 'import frappe, unittest\n'), ((565, 709), 'frappe.get_doc', 'frappe.get_doc', (["{'doctype': 'Fiscal Year', 'year': '_Test Fiscal Year 2000',\n 'year_end_date': '2002-12-31', 'year_start_date': '2000-04-01'}"], {}), "({'doctype': 'Fiscal Year', 'year': '_Test Fiscal Year 2000',\n 'year_end_date': '2002-12-31', 'year_start_date': '2000-04-01'})\n", (579, 709), False, 'import frappe, unittest\n'), ((498, 556), 'frappe.delete_doc', 'frappe.delete_doc', (['"""Fiscal Year"""', '"""_Test Fiscal Year 2000"""'], {}), "('Fiscal Year', '_Test Fiscal Year 2000')\n", (515, 556), False, 'import frappe, unittest\n')] |
from typing import Callable, Generator, Any
from unittest import mock
import pytest
from screenpy import AnActor, pacing, settings
from screenpy.abilities import AuthenticateWith2FA, BrowseTheWeb, MakeAPIRequests
from screenpy.narration.narrator import Narrator
@pytest.fixture(scope="function")
def Tester() -> AnActor:
"""Provide an Actor with mocked web browsing abilities."""
AuthenticateWith2FA_Mocked = mock.Mock(spec=AuthenticateWith2FA)
AuthenticateWith2FA_Mocked.otp = mock.Mock()
BrowseTheWeb_Mocked = mock.Mock(spec=BrowseTheWeb)
BrowseTheWeb_Mocked.browser = mock.Mock()
return AnActor.named("Tester").who_can(
AuthenticateWith2FA_Mocked, BrowseTheWeb_Mocked
)
@pytest.fixture(scope="function")
def APITester() -> AnActor:
"""Provide an Actor with mocked API testing abilities."""
MakeAPIRequests_Mocked = mock.Mock(spec=MakeAPIRequests)
MakeAPIRequests_Mocked.session = mock.Mock()
return AnActor.named("Tester").who_can(MakeAPIRequests_Mocked)
@pytest.fixture(scope="function")
def mocked_narrator() -> Generator[mock.MagicMock, Any, None]:
"""Mock out the Narrator for a test, replacing the old one afterwards."""
MockNarrator = mock.MagicMock(spec=Narrator)
old_narrator = pacing.the_narrator
pacing.the_narrator = MockNarrator
yield MockNarrator
pacing.the_narrator = old_narrator
def mock_settings(**new_settings) -> Callable:
"""Mock one or more settings for the duration of a test."""
def decorator(func: Callable) -> Callable:
def wrapper(*args, **kwargs) -> Callable:
old_settings = {
key: getattr(settings, key)
for key in new_settings.keys()
}
for key, value in new_settings.items():
setattr(settings, key, value)
try:
func(*args, **kwargs)
finally:
for key, value in old_settings.items():
setattr(settings, key, value)
return wrapper
return decorator
| [
"pytest.fixture",
"unittest.mock.MagicMock",
"unittest.mock.Mock",
"screenpy.AnActor.named"
] | [((267, 299), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (281, 299), False, 'import pytest\n'), ((717, 749), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (731, 749), False, 'import pytest\n'), ((1021, 1053), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1035, 1053), False, 'import pytest\n'), ((421, 456), 'unittest.mock.Mock', 'mock.Mock', ([], {'spec': 'AuthenticateWith2FA'}), '(spec=AuthenticateWith2FA)\n', (430, 456), False, 'from unittest import mock\n'), ((494, 505), 'unittest.mock.Mock', 'mock.Mock', ([], {}), '()\n', (503, 505), False, 'from unittest import mock\n'), ((532, 560), 'unittest.mock.Mock', 'mock.Mock', ([], {'spec': 'BrowseTheWeb'}), '(spec=BrowseTheWeb)\n', (541, 560), False, 'from unittest import mock\n'), ((595, 606), 'unittest.mock.Mock', 'mock.Mock', ([], {}), '()\n', (604, 606), False, 'from unittest import mock\n'), ((869, 900), 'unittest.mock.Mock', 'mock.Mock', ([], {'spec': 'MakeAPIRequests'}), '(spec=MakeAPIRequests)\n', (878, 900), False, 'from unittest import mock\n'), ((938, 949), 'unittest.mock.Mock', 'mock.Mock', ([], {}), '()\n', (947, 949), False, 'from unittest import mock\n'), ((1214, 1243), 'unittest.mock.MagicMock', 'mock.MagicMock', ([], {'spec': 'Narrator'}), '(spec=Narrator)\n', (1228, 1243), False, 'from unittest import mock\n'), ((619, 642), 'screenpy.AnActor.named', 'AnActor.named', (['"""Tester"""'], {}), "('Tester')\n", (632, 642), False, 'from screenpy import AnActor, pacing, settings\n'), ((962, 985), 'screenpy.AnActor.named', 'AnActor.named', (['"""Tester"""'], {}), "('Tester')\n", (975, 985), False, 'from screenpy import AnActor, pacing, settings\n')] |
import numpy as np
import pandas as pd
from sklearn.externals import joblib
#from sklearn.ensemble import RandomForestRegressor
#from sklearn.multioutput import MultiOutputRegressor
#from sklearn.multioutput import MultiOutputRegressor
from sklearn.model_selection import train_test_split
df = pd.read_csv('https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5',sep=',')
df_X = df.iloc[:, 2:13].copy()
df_X = pd.get_dummies(df_X)
df_y1 = df.iloc[:, 13:16].copy()
df_y1 = pd.get_dummies(df_y1)
df_y2 = df.iloc[:, 16:20].copy()
df_y2 = pd.get_dummies(df_y2)
#X_train, df_X, y_train, df_y1 = train_test_split(df_X, df_y1, test_size=0.2, random_state=0)
def accuracy(model, X_test, y_test):
predictions = model.predict(X_test)
print(model.score(X_test, y_test))
errors = np.abs(predictions - y_test)
mape = 100 * (errors / y_test)
for col in mape:
accuracy = 100 - np.mean(mape[col])
print('Accuracy:', round(accuracy, 2), '%.')
def test(model, df_X, df_y1, num):
accuracy(model, df_X, df_y1)
predictions = pd.DataFrame(model.predict(df_X))
errors = np.abs(predictions - df_y1)
print(type(predictions))
print(type(errors))
for i in range(num):
#results = df_X.iloc[:, 0:10].values
#results = np.append(results, df_y1.ix[:, i])
#results = np.append(results, predictions[:, i])
#results = np.append(results, errors.ix[:, i])
#result_df = pd.DataFrame(results)
df_X.join(df_y1.ix[:, i]).join(predictions.ix[:, i]).to_csv("ModelPredictions" + str(num) + str(i) + ".csv")
#model = RandomForestRegressor(n_estimators = 1900, max_depth = 70, random_state = 50, learning_rate = 0.1, min_samples_split = 0.1, max_features = 'sqrt', loss = 'lad', warm_start = True, min_samples_leaf = 0.0005)
#model1 = MultipleOutputRegressor(model)
#model2 = MultipleOutputRegressor(model, n_jobs = -1)
#model1.fit(X_train, y_train)
model = joblib.load("RegressorChainGradientBoostingRegressorEarningsNew.pkl")
test(model, df_X, df_y1, 3)
model = joblib.load("RegressorChainGradientBoostingRegressorRepaymentNew.pkl")
test(model, df_X, df_y2, 4)
#model2.fit(X_train, y_train)
#joblib.dump(model2, "MultiplepleOutputRandomForestRegressorEarnings.pkl")
#print("Model 2: ");
#accuracy(model2, df_X, df_y1)
#X_train, df_X, y_train, df_y1 = train_test_split(df_X, df_y2, test_size=0.2, random_state=0)
#model1.fit(X_train, y_train)
#joblib.dump(model1, "MultipleOutputRegressorRandomForestRegressorRepayment.pkl")
#print("Model 3: ");
#accuracy(model1, df_X, df_y1)
#model2.fit(X_train, y_train)
#joblib.dump(model2, "MultiplepleOutputRandomForestRegressorRepayment.pkl")
#print("Model 4: ");
#accuracy(model2, df_X, df_y1)
| [
"numpy.abs",
"numpy.mean",
"pandas.read_csv",
"sklearn.externals.joblib.load",
"pandas.get_dummies"
] | [((297, 411), 'pandas.read_csv', 'pd.read_csv', (['"""https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5"""'], {'sep': '""","""'}), "(\n 'https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5'\n , sep=',')\n", (308, 411), True, 'import pandas as pd\n'), ((440, 460), 'pandas.get_dummies', 'pd.get_dummies', (['df_X'], {}), '(df_X)\n', (454, 460), True, 'import pandas as pd\n'), ((503, 524), 'pandas.get_dummies', 'pd.get_dummies', (['df_y1'], {}), '(df_y1)\n', (517, 524), True, 'import pandas as pd\n'), ((567, 588), 'pandas.get_dummies', 'pd.get_dummies', (['df_y2'], {}), '(df_y2)\n', (581, 588), True, 'import pandas as pd\n'), ((1882, 1951), 'sklearn.externals.joblib.load', 'joblib.load', (['"""RegressorChainGradientBoostingRegressorEarningsNew.pkl"""'], {}), "('RegressorChainGradientBoostingRegressorEarningsNew.pkl')\n", (1893, 1951), False, 'from sklearn.externals import joblib\n'), ((1988, 2058), 'sklearn.externals.joblib.load', 'joblib.load', (['"""RegressorChainGradientBoostingRegressorRepaymentNew.pkl"""'], {}), "('RegressorChainGradientBoostingRegressorRepaymentNew.pkl')\n", (1999, 2058), False, 'from sklearn.externals import joblib\n'), ((804, 832), 'numpy.abs', 'np.abs', (['(predictions - y_test)'], {}), '(predictions - y_test)\n', (810, 832), True, 'import numpy as np\n'), ((1099, 1126), 'numpy.abs', 'np.abs', (['(predictions - df_y1)'], {}), '(predictions - df_y1)\n', (1105, 1126), True, 'import numpy as np\n'), ((905, 923), 'numpy.mean', 'np.mean', (['mape[col]'], {}), '(mape[col])\n', (912, 923), True, 'import numpy as np\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import argparse
import docx
from docx.shared import Cm
import pylatex
from pytablewriter import MarkdownTableWriter
def set_column_width(column, width):
column.width = width
for cell in column.cells:
cell.width = width
def generate_word_revision_sheet(filepath, result_path, lines, starting_item):
document = docx.Document()
document.add_heading('Revision sheet', 0)
table = document.add_table(rows=1, cols=3)
hdr_cells = table.rows[0].cells
hdr_cells[0].text = 'Nr.'
hdr_cells[1].text = 'Comment'
hdr_cells[2].text = 'How the comment is addressed'
for line in lines:
if not line.strip():
continue
row_cells = table.add_row().cells
row_cells[0].text = str(starting_item)
row_cells[1].text = line.replace('\\newline', '')
row_cells[2].text = ''
starting_item += 1
set_column_width(table.columns[0], Cm(1.5))
set_column_width(table.columns[1], Cm(10))
set_column_width(table.columns[2], Cm(6))
if result_path:
document.save(result_path)
else:
document.save(filepath[:-4] + '_revision_sheet.docx')
return
def generate_tex_revision_sheet(filepath, result_path,lines, starting_item):
geometry_options = {"tmargin": "2.54cm", "lmargin": "2.54cm"}
doc = pylatex.Document(geometry_options=geometry_options)
with doc.create(pylatex.Section('Revision sheet')):
with doc.create(pylatex.LongTable('|r|p{8cm}|p{8cm}|')) as table:
table.add_hline()
table.add_row(('Nr.', 'Comment', 'How the comment is addressed'))
table.add_hline()
for line in lines:
if not line.strip():
continue
table.add_row((starting_item, line.replace('\\newline', '').replace(' ',''), ''))
table.add_hline()
starting_item += 1
if result_path:
doc.generate_pdf(result_path, clean_tex=False)
else:
doc.generate_pdf(filepath[:-4] + '_revision_sheet.tex', clean_tex=False)
return
def generate_md_revision_sheet(filepath, result_path,lines, starting_item):
writer = MarkdownTableWriter()
if result_path:
result_path = result_path
else:
result_path = result_path + "revision_sheet.md"
writer.headers = ["Nr.", "Comment", "How the comment is addressed"]
comment_list = []
for line in lines:
if not line.strip():
continue
comment_list.append(line.replace('\\newline', ''))
matrix = []
for i in range(len(comment_list)):
matrix.append([starting_item, comment_list[i], ""])
starting_item += 1
print(matrix)
writer.value_matrix = matrix
writer.write_table()
with open(result_path, "w") as f:
writer.stream = f
writer.write_table()
return
def load_file(filepath):
comment_file = open(filepath, 'r')
lines = comment_file.readlines()
revised_lines = []
temp = ''
for line in lines:
if '\\newline' in line or ('Reviewer' in line and len(line.strip()) < 15):
temp += line
continue
if '' == temp:
revised_lines.append(line.rstrip())
else:
revised_lines.append(temp + line.rstrip())
temp = ''
if '' != temp:
revised_lines.append(temp.rstrip())
lines = revised_lines
return lines
if __name__ == "__main__":
parser = argparse.ArgumentParser(description = "Revision-sheet generator")
parser.add_argument("--input", default=None, help="path to the review text file")
parser.add_argument("--format", default='w', help="format of the output document , w for word (default) or t for tex or m for markdown")
parser.add_argument("--output", default=None, help="path to the file where to put the results (optional)")
parser.add_argument("--i", default=1, help="start of comment numbering (optional)")
args = parser.parse_args()
filepath = args.input
output_format = args.format
result_path = args.output
if not result_path:
result_path = 'revision_sheet'
starting_item = int(args.i)
assert output_format in ['t', 'w', 'm']
if 'w' == output_format:
if result_path:
if '.doc' != result_path[:-4] or '.docx' != result_path[:-5]:
result_path += '.doc'
if 't' == output_format:
if result_path:
if '.tex' != result_path[:-4]:
result_path += '.tex'
if 'm' == output_format:
if result_path:
if '.md' != result_path[:-4]:
result_path += '.md'
assert filepath[-4:] == '.txt'
assert isinstance(starting_item, int)
if result_path:
assert not os.path.exists(result_path)
lines = load_file(filepath)
if 'w' == output_format:
generate_word_revision_sheet(filepath, result_path, lines, starting_item)
if 't' == output_format:
generate_tex_revision_sheet(filepath, result_path, lines, starting_item)
if 'm' == output_format:
generate_md_revision_sheet(filepath, result_path, lines, starting_item)
| [
"os.path.exists",
"pylatex.Section",
"argparse.ArgumentParser",
"pylatex.LongTable",
"docx.shared.Cm",
"pytablewriter.MarkdownTableWriter",
"pylatex.Document",
"docx.Document"
] | [((389, 404), 'docx.Document', 'docx.Document', ([], {}), '()\n', (402, 404), False, 'import docx\n'), ((1377, 1428), 'pylatex.Document', 'pylatex.Document', ([], {'geometry_options': 'geometry_options'}), '(geometry_options=geometry_options)\n', (1393, 1428), False, 'import pylatex\n'), ((2242, 2263), 'pytablewriter.MarkdownTableWriter', 'MarkdownTableWriter', ([], {}), '()\n', (2261, 2263), False, 'from pytablewriter import MarkdownTableWriter\n'), ((3565, 3628), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Revision-sheet generator"""'}), "(description='Revision-sheet generator')\n", (3588, 3628), False, 'import argparse\n'), ((978, 985), 'docx.shared.Cm', 'Cm', (['(1.5)'], {}), '(1.5)\n', (980, 985), False, 'from docx.shared import Cm\n'), ((1026, 1032), 'docx.shared.Cm', 'Cm', (['(10)'], {}), '(10)\n', (1028, 1032), False, 'from docx.shared import Cm\n'), ((1073, 1078), 'docx.shared.Cm', 'Cm', (['(6)'], {}), '(6)\n', (1075, 1078), False, 'from docx.shared import Cm\n'), ((1450, 1483), 'pylatex.Section', 'pylatex.Section', (['"""Revision sheet"""'], {}), "('Revision sheet')\n", (1465, 1483), False, 'import pylatex\n'), ((4878, 4905), 'os.path.exists', 'os.path.exists', (['result_path'], {}), '(result_path)\n', (4892, 4905), False, 'import os\n'), ((1511, 1549), 'pylatex.LongTable', 'pylatex.LongTable', (['"""|r|p{8cm}|p{8cm}|"""'], {}), "('|r|p{8cm}|p{8cm}|')\n", (1528, 1549), False, 'import pylatex\n')] |
import torch
import numpy as np
import utility
from decimal import Decimal
from tqdm import tqdm
from option import args
from torchvision import transforms
from PIL import Image
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import copy
class Trainer():
def __init__(self, opt, loader, my_model, my_loss, ckp):
self.opt = opt
self.scale = opt.scale
self.ckp = ckp
self.loader_train = loader.loader_train
self.loader_test = loader.loader_test
self.model = my_model
self.loss = my_loss
self.optimizer = utility.make_optimizer(opt, self.model)
self.scheduler = utility.make_scheduler(opt, self.optimizer)
self.dual_models = self.model.dual_models
self.dual_optimizers = utility.make_dual_optimizer(opt, self.dual_models)
self.dual_scheduler = utility.make_dual_scheduler(opt, self.dual_optimizers)
self.error_last = 1e8
def train(self):
epoch = self.scheduler.last_epoch + 1
lr = self.scheduler.get_lr()[0]
self.ckp.set_epoch(epoch)
self.ckp.write_log(
'[Epoch {}]\tLearning rate: {:.2e}'.format(epoch, Decimal(lr))
)
self.loss.start_log()
self.model.train()
timer_data, timer_model = utility.timer(), utility.timer()
for batch, (lr, hr, _) in enumerate(self.loader_train):
lr, hr = self.prepare(lr, hr)
# flip train
# flip_lr = copy.deepcopy(lr)
# for i in range(0,len(flip_lr)):
# for j in range(0, len(flip_lr[i])):
# for k in range(0, len(flip_lr[i][j])):
# flip_lr[i][j][k]= torch.fliplr(flip_lr[i][j][k])
timer_data.hold()
timer_model.tic()
self.optimizer.zero_grad()
for i in range(len(self.dual_optimizers)):
self.dual_optimizers[i].zero_grad()
# forward
sr = self.model(lr[0])
# flip train
# flip_sr = self.model(flip_lr[0])
# for i in range(0, len(flip_sr)):
# for j in range(0, len(flip_sr[i])):
# for k in range(0, len(flip_sr[i][j])):
# flip_sr[i][j][k] = torch.fliplr(flip_sr[i][j][k])
# fflip_sr = flip_sr
sr2lr = []
for i in range(len(self.dual_models)):
sr2lr_i = self.dual_models[i](sr[i - len(self.dual_models)])
sr2lr.append(sr2lr_i)
# compute primary loss
loss_primary = self.loss(sr[-1], hr)
for i in range(1, len(sr)):
loss_primary += self.loss(sr[i - 1 - len(sr)], lr[i - len(sr)])
# compute dual loss
loss_dual = self.loss(sr2lr[0], lr[0])
for i in range(1, len(self.scale)):
loss_dual += self.loss(sr2lr[i], lr[i])
# compute average loss
# average_feat =(sr[-1]+fflip_sr[-1])/2
# loss_average = self.loss(average_feat, hr)
#copute flip loss
loss_flip =0
# for i in range(0, len(sr)):
# loss_flip+= self.loss(sr[i], fflip_sr[i])
# compute total loss
loss = loss_primary+ self.opt.dual_weight * loss_dual
if loss.item() < self.opt.skip_threshold * self.error_last:
loss.backward()
self.optimizer.step()
for i in range(len(self.dual_optimizers)):
self.dual_optimizers[i].step()
else:
print('Skip this batch {}! (Loss: {})'.format(
batch + 1, loss.item()
))
timer_model.hold()
if (batch + 1) % self.opt.print_every == 0:
self.ckp.write_log('[{}/{}]\t{}\t{:.1f}+{:.1f}s'.format(
(batch + 1) * self.opt.batch_size,
len(self.loader_train.dataset),
self.loss.display_loss(batch),
timer_model.release(),
timer_data.release()))
timer_data.tic()
self.loss.end_log(len(self.loader_train))
self.error_last = self.loss.log[-1, -1]
self.step()
def test(self):
epoch = self.scheduler.last_epoch
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, 1))
self.model.eval()
timer_test = utility.timer()
with torch.no_grad():
scale = max(self.scale)
for si, s in enumerate([scale]):
f= open('5060_flip o.txt', 'w')
eval_psnr = 0
eval_simm =0
tqdm_test = tqdm(self.loader_test, ncols=80)
for _, (lr, hr, filename) in enumerate(tqdm_test):
filename = filename[0]
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare(lr, hr)
else:
lr, = self.prepare(lr)
sr = self.model(lr[0])
if isinstance(sr, list): sr = sr[-1]
sr = utility.quantize(sr, self.opt.rgb_range)
if not no_eval:
psnr = utility.calc_psnr(
sr, hr, s, self.opt.rgb_range,
benchmark=self.loader_test.dataset.benchmark
)
hr_numpy = hr[0].cpu().numpy().transpose(1, 2, 0)
sr_numpy = sr[0].cpu().numpy().transpose(1, 2, 0)
simm = utility.SSIM(hr_numpy, sr_numpy)
eval_simm += simm
eval_psnr +=psnr
# save test results // SR result !
if self.opt.save_results:
self.ckp.save_results_nopostfix(filename, sr, s)
self.ckp.log[-1, si] = eval_psnr / len(self.loader_test)
eval_simm = eval_simm / len(self.loader_test)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.2f} (Best: {:.2f} @epoch {})'.format(
self.opt.data_test, s,
self.ckp.log[-1, si],
best[0][si],
best[1][si] + 1
)
)
print('SIMM:',eval_simm)
self.ckp.write_log(
'Total time: {:.2f}s\n'.format(timer_test.toc()), refresh=True
)
if not self.opt.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0] + 1 == epoch))
def step(self):
self.scheduler.step()
for i in range(len(self.dual_scheduler)):
self.dual_scheduler[i].step()
def prepare(self, *args):
device = torch.device('cpu' if self.opt.cpu else 'cuda')
if len(args) > 1:
return [a.to(device) for a in args[0]], args[-1].to(device)
return [a.to(device) for a in args[0]],
def terminate(self):
if self.opt.test_only:
self.test()
return True
else:
epoch = self.scheduler.last_epoch
return epoch >= self.opt.epochs
| [
"utility.timer",
"utility.quantize",
"utility.calc_psnr",
"matplotlib.use",
"utility.make_dual_scheduler",
"tqdm.tqdm",
"utility.SSIM",
"utility.make_optimizer",
"utility.make_dual_optimizer",
"utility.make_scheduler",
"torch.no_grad",
"torch.zeros",
"decimal.Decimal",
"torch.device"
] | [((200, 223), 'matplotlib.use', 'matplotlib.use', (['"""TkAgg"""'], {}), "('TkAgg')\n", (214, 223), False, 'import matplotlib\n'), ((601, 640), 'utility.make_optimizer', 'utility.make_optimizer', (['opt', 'self.model'], {}), '(opt, self.model)\n', (623, 640), False, 'import utility\n'), ((666, 709), 'utility.make_scheduler', 'utility.make_scheduler', (['opt', 'self.optimizer'], {}), '(opt, self.optimizer)\n', (688, 709), False, 'import utility\n'), ((791, 841), 'utility.make_dual_optimizer', 'utility.make_dual_optimizer', (['opt', 'self.dual_models'], {}), '(opt, self.dual_models)\n', (818, 841), False, 'import utility\n'), ((872, 926), 'utility.make_dual_scheduler', 'utility.make_dual_scheduler', (['opt', 'self.dual_optimizers'], {}), '(opt, self.dual_optimizers)\n', (899, 926), False, 'import utility\n'), ((4656, 4671), 'utility.timer', 'utility.timer', ([], {}), '()\n', (4669, 4671), False, 'import utility\n'), ((7138, 7185), 'torch.device', 'torch.device', (["('cpu' if self.opt.cpu else 'cuda')"], {}), "('cpu' if self.opt.cpu else 'cuda')\n", (7150, 7185), False, 'import torch\n'), ((1305, 1320), 'utility.timer', 'utility.timer', ([], {}), '()\n', (1318, 1320), False, 'import utility\n'), ((1322, 1337), 'utility.timer', 'utility.timer', ([], {}), '()\n', (1335, 1337), False, 'import utility\n'), ((4589, 4606), 'torch.zeros', 'torch.zeros', (['(1)', '(1)'], {}), '(1, 1)\n', (4600, 4606), False, 'import torch\n'), ((4685, 4700), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (4698, 4700), False, 'import torch\n'), ((1191, 1202), 'decimal.Decimal', 'Decimal', (['lr'], {}), '(lr)\n', (1198, 1202), False, 'from decimal import Decimal\n'), ((4918, 4950), 'tqdm.tqdm', 'tqdm', (['self.loader_test'], {'ncols': '(80)'}), '(self.loader_test, ncols=80)\n', (4922, 4950), False, 'from tqdm import tqdm\n'), ((5402, 5442), 'utility.quantize', 'utility.quantize', (['sr', 'self.opt.rgb_range'], {}), '(sr, self.opt.rgb_range)\n', (5418, 5442), False, 'import utility\n'), ((5512, 5611), 'utility.calc_psnr', 'utility.calc_psnr', (['sr', 'hr', 's', 'self.opt.rgb_range'], {'benchmark': 'self.loader_test.dataset.benchmark'}), '(sr, hr, s, self.opt.rgb_range, benchmark=self.loader_test\n .dataset.benchmark)\n', (5529, 5611), False, 'import utility\n'), ((5888, 5920), 'utility.SSIM', 'utility.SSIM', (['hr_numpy', 'sr_numpy'], {}), '(hr_numpy, sr_numpy)\n', (5900, 5920), False, 'import utility\n')] |
# Get the database using the method we defined in pymongo_test_insert file
from pymongo_test_insert import get_database
dbname = get_database()
# Create a new collection
collection_name = dbname["user_1_items"]
item_details = collection_name.find()
for item in item_details:
# This will give readable output, but KeyError
print(item['item_name'], item['category'])
###---------------------------------------------------###
### Comment the above 'for loop' & 'print statements' ###
### for the next lines of code to work ###
###---------------------------------------------------###
from pandas import DataFrame
# Convert the dictionary objects to dataframe
items_df = DataFrame(item_details)
# View all items
print(items_df)
###--------------------------------------------------------###
### Get items of particular category without and with index###
###--------------------------------------------------------###
item_details = collection_name.find({"category" : "food"})
for item in item_details:
print(item)
# Add more data to understand the need for indexing
import pymongo_test_insert_more_items
# Create index on category, as an example
category_index = collection_name.create_index("category")
# Execute the previous query again to see the documents scanned (refer to the article) | [
"pandas.DataFrame",
"pymongo_test_insert.get_database"
] | [((132, 146), 'pymongo_test_insert.get_database', 'get_database', ([], {}), '()\n', (144, 146), False, 'from pymongo_test_insert import get_database\n'), ((710, 733), 'pandas.DataFrame', 'DataFrame', (['item_details'], {}), '(item_details)\n', (719, 733), False, 'from pandas import DataFrame\n')] |
import json
from django.core.serializers.json import DjangoJSONEncoder
from django.http import HttpResponse
from django.template import Context
from django.template import RequestContext
from django.template.loader import render_to_string, select_template
from django.utils.encoding import force_unicode
from ..compat import context_flatten
from ..compat import get_template_name
class JsonResponseMixin(object):
status = 'ok'
json_encoder_class = DjangoJSONEncoder
def get_json(self, **kwargs):
json_data = {
'status': self.status,
}
json_data.update(kwargs)
return json_data
def render_json_response(self, json_data, **response_kwargs):
json_serialized = json.dumps(
json_data,
cls=self.json_encoder_class)
json_serialized = json_serialized.encode('utf-8')
return HttpResponse(json_serialized,
content_type='application/json; charset=utf-8',
**response_kwargs)
class DialogResponseMixin(JsonResponseMixin):
'''
Use this mixin to provide valid responses for calls from the AjaxDialog
classes in the client.
Subclasses need to have a ``get_template_names`` method that returns the
template names that should be rendered inside the
``page_wrapper_template_name``.
The mixin returns JSON if ``request.is_ajax() == True``. The return value
of the ``get_json()`` method is therefore serialized to JSON.
'''
title = None
page_wrapper_template_name = 'django_backend/page_wrapper.html'
def get_title(self):
return self.title
def get_context_data(self, **kwargs):
kwargs.setdefault('title', self.get_title())
kwargs['is_dialog'] = self.is_dialog()
return super(DialogResponseMixin, self).get_context_data(**kwargs)
def get_page_wrapper_template_names(self):
'''
Returns the wrapper template name that takes the real template names to
be rendered inside.
'''
return [self.page_wrapper_template_name]
def is_dialog(self):
return self.request.is_ajax()
def get_json(self, **kwargs):
json_data = super(DialogResponseMixin, self).get_json(**kwargs)
title = self.get_title()
if title:
json_data['title'] = force_unicode(title)
return json_data
def render_to_response(self, context, **response_kwargs):
if self.is_dialog():
context = RequestContext(self.request, context)
context.update(self.get_context_data())
json_data = self.get_json()
json_data['html'] = render_to_string(
self.get_template_names(), context)
return self.render_json_response(json_data, **response_kwargs)
else:
return self.render_html_response(context, **response_kwargs)
def render_html_response(self, context, **response_kwargs):
response_kwargs.setdefault('content_type', self.content_type)
template = select_template(self.get_template_names())
context['template_name'] = get_template_name(template)
return self.response_class(
request=self.request,
template=self.get_page_wrapper_template_names(),
context=context,
**response_kwargs)
| [
"django.http.HttpResponse",
"django.utils.encoding.force_unicode",
"json.dumps",
"django.template.RequestContext"
] | [((730, 780), 'json.dumps', 'json.dumps', (['json_data'], {'cls': 'self.json_encoder_class'}), '(json_data, cls=self.json_encoder_class)\n', (740, 780), False, 'import json\n'), ((879, 980), 'django.http.HttpResponse', 'HttpResponse', (['json_serialized'], {'content_type': '"""application/json; charset=utf-8"""'}), "(json_serialized, content_type=\n 'application/json; charset=utf-8', **response_kwargs)\n", (891, 980), False, 'from django.http import HttpResponse\n'), ((2353, 2373), 'django.utils.encoding.force_unicode', 'force_unicode', (['title'], {}), '(title)\n', (2366, 2373), False, 'from django.utils.encoding import force_unicode\n'), ((2513, 2550), 'django.template.RequestContext', 'RequestContext', (['self.request', 'context'], {}), '(self.request, context)\n', (2527, 2550), False, 'from django.template import RequestContext\n')] |
#! /usr/bin/env python
from setuptools import setup, Extension
import importlib
import os
# copied from kymatio's setup.py: https://github.com/kymatio/kymatio/blob/master/setup.py
sfm_version_spec = importlib.util.spec_from_file_location('sfm_version', 'sfm/version.py')
sfm_version_module = importlib.util.module_from_spec(sfm_version_spec)
sfm_version_spec.loader.exec_module(sfm_version_module)
VERSION = sfm_version_module.version
setup(
name='sfm',
version='0.1',
description='Spatial frequency preferences model',
license='MIT',
url='https://github.com/billbrod/spatial-frequency-model',
author='<NAME>',
author_email='<EMAIL>',
classifiers=[
'Development Status :: 3 - Alpha',
'Programming Language :: Python :: 3.7'],
keywords='Visual Information Processing',
packages=['sfm'],
install_requires=['numpy>=1.1',
'torch>=1.1',
'pandas>=0.25'
'scipy>=1.0',
'matplotlib>=3.1',
'pytest',
'seaborn>=0.9.0'],
tests='tests',
)
| [
"importlib.util.spec_from_file_location",
"setuptools.setup",
"importlib.util.module_from_spec"
] | [((201, 272), 'importlib.util.spec_from_file_location', 'importlib.util.spec_from_file_location', (['"""sfm_version"""', '"""sfm/version.py"""'], {}), "('sfm_version', 'sfm/version.py')\n", (239, 272), False, 'import importlib\n'), ((294, 343), 'importlib.util.module_from_spec', 'importlib.util.module_from_spec', (['sfm_version_spec'], {}), '(sfm_version_spec)\n', (325, 343), False, 'import importlib\n'), ((438, 953), 'setuptools.setup', 'setup', ([], {'name': '"""sfm"""', 'version': '"""0.1"""', 'description': '"""Spatial frequency preferences model"""', 'license': '"""MIT"""', 'url': '"""https://github.com/billbrod/spatial-frequency-model"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'classifiers': "['Development Status :: 3 - Alpha', 'Programming Language :: Python :: 3.7']", 'keywords': '"""Visual Information Processing"""', 'packages': "['sfm']", 'install_requires': "['numpy>=1.1', 'torch>=1.1', 'pandas>=0.25scipy>=1.0', 'matplotlib>=3.1',\n 'pytest', 'seaborn>=0.9.0']", 'tests': '"""tests"""'}), "(name='sfm', version='0.1', description=\n 'Spatial frequency preferences model', license='MIT', url=\n 'https://github.com/billbrod/spatial-frequency-model', author='<NAME>',\n author_email='<EMAIL>', classifiers=['Development Status :: 3 - Alpha',\n 'Programming Language :: Python :: 3.7'], keywords=\n 'Visual Information Processing', packages=['sfm'], install_requires=[\n 'numpy>=1.1', 'torch>=1.1', 'pandas>=0.25scipy>=1.0', 'matplotlib>=3.1',\n 'pytest', 'seaborn>=0.9.0'], tests='tests')\n", (443, 953), False, 'from setuptools import setup, Extension\n')] |
# from pipet.core.sql.query_interface import *
from pypipet.core.operations.inventory import *
import pytest
from pprint import pprint
_supplie_id = 1
def test_update_invs(session, obj_classes, shop_conn):
invs = [ {'sku':'s22456', 'supplier_id':_supplie_id, 'qty':20}]
update_inventory_bulk(obj_classes, session,
invs, ignore_new=False)
res = get_inventory_by_sku(obj_classes, session,
invs[0]['sku'], by_supplier=False)
pprint(res)
# def test_match_upc(session, obj_classes):
# invs = [ {'upc':'48743213', 'supplier_id':1, 'qty':10},
# {'upc':'9348886', 'supplier_id':1, 'qty':10}]
# res = match_variation_sku_by_upc(obj_classes.get('variation'), session, invs)
# assert res is not None
def test_update_inv(session, obj_classes, shop_conn):
inv = {'sku':'s2789', 'supplier_id':_supplie_id, 'qty':82}
update_inventory_db_by_sku(obj_classes, session, inv['sku'], inv)
res = get_inventory_by_sku(obj_classes, session,
inv['sku'], by_supplier=False)
def test_update_front_shop_bulk(obj_classes, session, shop_conn):
update_instock_front_shop(obj_classes, session, shop_conn, set_inventory_management=True)
def test_update_front_shop(obj_classes, session, shop_conn):
update_instock_front_shop_by_sku(obj_classes, session, shop_conn, 's2789')
update_instock_front_shop_by_sku(obj_classes, session, shop_conn, 's22456') | [
"pprint.pprint"
] | [((502, 513), 'pprint.pprint', 'pprint', (['res'], {}), '(res)\n', (508, 513), False, 'from pprint import pprint\n')] |
# Costs
# 2019 - Luque, Straub - Risk-based optimal inspection strategies for
# structural systems using dynamic Bayesian networks
# Table 4, case 1
import numpy as np
class InspectionMaintenance:
"""
Inspection and Maintenance
==========================
Cost calculation for inspection and maintenance reliability analysis.
Parameters:
-----------
c_c : float
individual cost of campaign
c_i : float
individual cost of inspection
c_r : float
individual cost of repair
c_f : float
individual cost of failure
r : float
discount rate
"""
def __init__(self, c_c=5.0, c_i=1.0, c_r=10.0, c_f=10000, r=0.02):
self.c_c, self.c_i, self.c_r, self.c_c, self.c_f, self.r = c_c, c_i, c_r, c_c, c_f, r
def compute_cost_breakdown(self, system_model):
"""
Compute cost breakdown
======================
From simulated model, compute all lifetime costs:
- campaign : C_C
- inspection : C_I
- repair : C_R
- failure : C_F
Results are stored in the system atributes in dictionaries:
- system_obs
- system_action
- yearly_costs_breakdown
- cost_breakdown
"""
system_insp, system_repair = dict(), dict()
t, pf = np.vstack(system_model.system_pf).T
unique_mask = np.diff(t) == 1
delta_pf = np.diff(pf)[unique_mask]
abs_t = np.unique(t).astype(int) # t[1:][unique_mask]
C_C, C_I, C_R, R_F = np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float)
for component in system_model.components_list:
action, output = np.array(component.action), np.array(component.output)
y_t = (1 - self.r)**(np.array(component.t))
if any(action):
comp_t = np.array(component.t, dtype=int)
t_insp = comp_t[action == 'PoD']
t_repair = comp_t[action == 'PR']
C_I[t_insp] += self.c_i*(1 - self.r)**t_insp
C_R[t_repair] += self.c_r*(1 - self.r)**t_repair
system_insp[component.id]= t_insp
system_repair[component.id] = t_repair
else:
system_insp[component.id]= list()
system_repair[component.id] = list()
t_temp = np.unique(np.concatenate(list(system_insp.values()))).astype(int)
C_C[t_temp] += self.c_c*(1 - self.r)**(t_temp)
R_F[abs_t[1:]] = self.c_f*delta_pf*(1 - self.r)**abs_t[1:]
C_T = C_C + C_I + C_R + R_F
system_model.yearly_costs_breakdown = {'t' : abs_t, 'C_C' : C_C, 'C_I' : C_I, 'C_R' : C_R, 'R_F' : R_F, 'C_T': C_T}
system_model.cost_breakdown = {'C_C' : C_C.sum(), 'C_I' : C_I.sum(), 'C_R' : C_R.sum(), 'R_F' : R_F.sum(), 'C_T': C_T.sum()} | [
"numpy.unique",
"numpy.diff",
"numpy.array",
"numpy.vstack",
"numpy.zeros_like"
] | [((1359, 1392), 'numpy.vstack', 'np.vstack', (['system_model.system_pf'], {}), '(system_model.system_pf)\n', (1368, 1392), True, 'import numpy as np\n'), ((1417, 1427), 'numpy.diff', 'np.diff', (['t'], {}), '(t)\n', (1424, 1427), True, 'import numpy as np\n'), ((1452, 1463), 'numpy.diff', 'np.diff', (['pf'], {}), '(pf)\n', (1459, 1463), True, 'import numpy as np\n'), ((1569, 1602), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1582, 1602), True, 'import numpy as np\n'), ((1604, 1637), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1617, 1637), True, 'import numpy as np\n'), ((1639, 1672), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1652, 1672), True, 'import numpy as np\n'), ((1674, 1707), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1687, 1707), True, 'import numpy as np\n'), ((1493, 1505), 'numpy.unique', 'np.unique', (['t'], {}), '(t)\n', (1502, 1505), True, 'import numpy as np\n'), ((1792, 1818), 'numpy.array', 'np.array', (['component.action'], {}), '(component.action)\n', (1800, 1818), True, 'import numpy as np\n'), ((1820, 1846), 'numpy.array', 'np.array', (['component.output'], {}), '(component.output)\n', (1828, 1846), True, 'import numpy as np\n'), ((1880, 1901), 'numpy.array', 'np.array', (['component.t'], {}), '(component.t)\n', (1888, 1901), True, 'import numpy as np\n'), ((1956, 1988), 'numpy.array', 'np.array', (['component.t'], {'dtype': 'int'}), '(component.t, dtype=int)\n', (1964, 1988), True, 'import numpy as np\n')] |
from __future__ import absolute_import, division, print_function
import json
import os.path as op
import six
import numpy as np
import scipy.signal as sig
import scipy.io.wavfile as sciwav
MAXINT16 = 2**15 - 1
FS = 44100
COEFF_DIR = op.join(op.dirname(op.abspath(__file__)), 'coeffs')
def normalize(data, maxamp=1):
data *= maxamp / max(abs(data))
def load_coeffs(fname):
with open(op.join(COEFF_DIR, fname)) as f:
return json.load(f)
POTS_COEFFS = load_coeffs('pots.json')
def pots(data, snr=30, seed=None):
if seed is not None:
np.random.seed(seed)
# ensure mono
if data.ndim != 1:
data = data[:,0]
# convert to float, but simulate 16-bit quantization if needed
orig_dtype = data.dtype
data = data.astype('float')
if orig_dtype != 'int16':
normalize(data, maxamp=MAXINT16)
np.around(data, out=data)
normalize(data)
# pad start and end
#leader_len = np.random.randint(0.1 * FS, 0.4 * FS)
#trailer_len = 0.5 * FS - leader_len
#data = np.concatenate([np.zeros(leader_len), data, np.zeros(trailer_len)])
# do filtering
for b, a in POTS_COEFFS['signal']:
data = sig.lfilter(b, a, data)
# add band-limited noise (filtered white noise)
#np.random.seed(0)
noise = 10**(-snr/20) * ((np.random.random(size=data.shape) * 2) - 1)
for b, a in POTS_COEFFS['noiseband']:
noise = sig.lfilter(b, a, noise)
data += noise
# renormalize and convert to 16-bit integers
normalize(data, maxamp=MAXINT16)
data = data.astype('int16')
return data
class DigitalStreamFilter(object):
mimes = {
'wav': 'audio/vnd.wave',
'txt': 'text/plain',
'json': 'application/json',
}
output_suffix = 'filtered'
def __init__(self, data=None, stream=None, filename=None, dtype=None):
if dtype is None and filename is None:
try:
# werkzeug.FileStorage has 'filename', python files have 'name'
filename = getattr(stream, 'filename', getattr(stream, 'name'))
except AttributeError:
raise ValueError("Can't determine type from stream. "
"Provide dtype or filename to infer type.")
if dtype is None:
dtype = filename.split('.')[-1]
self.dtype = dtype
self.filename = filename
self.json_extra = {}
if data is not None:
self.data = np.array(data)
elif stream is not None:
self.load(stream)
else:
with open(filename, 'rb') as stream:
self.load(stream)
def load(self, stream):
dispatcher = {
'wav': self._load_wave,
'txt': self._load_text,
'json': self._load_json,
}
try:
data = dispatcher[self.dtype](stream)
except KeyError:
raise TypeError('Unsupported input type: {} (accepts {})'.format(
self.dtype, ', '.join(dispatcher.keys())))
self.data = np.array(data)
def process(self, *args, **kwargs):
raise NotImplementedError('abstract method')
def dump(self, stream, dtype=None):
if dtype is None:
dtype = self.dtype
{'wav': self._dump_wave,
'txt': self._dump_text,
'json': self._dump_json,
}[dtype](stream)
def suggested_name(self):
parts = self.filename.split('.')[:-1]
parts.extend([self.output_suffix, self.dtype])
return '.'.join(parts)
def mimetype(self):
return self.mimes[self.dtype]
def _load_wave(self, stream):
rate, data = sciwav.read(stream)
return data
def _load_text(self, stream):
return np.loadtxt(stream, dtype='int16')
def _load_json(self, stream):
return np.array(json.load(stream))
def _dump_wave(self, stream):
sciwav.write(stream, FS, self.data)
def _dump_text(self, stream):
np.savetxt(stream, self.data, fmt='%d')
def _dump_json(self, stream):
json.dump({'data': self.data.tolist(), 'rate': FS}, stream)
class POTSFilter(DigitalStreamFilter):
output_suffix = 'pots-filtered'
def process(self, *args, **kwargs):
self.data = pots(self.data, *args, **kwargs)
| [
"numpy.random.random",
"os.path.join",
"json.load",
"numpy.array",
"scipy.signal.lfilter",
"scipy.io.wavfile.read",
"numpy.around",
"numpy.random.seed",
"scipy.io.wavfile.write",
"os.path.abspath",
"numpy.savetxt",
"numpy.loadtxt"
] | [((255, 275), 'os.path.abspath', 'op.abspath', (['__file__'], {}), '(__file__)\n', (265, 275), True, 'import os.path as op\n'), ((443, 455), 'json.load', 'json.load', (['f'], {}), '(f)\n', (452, 455), False, 'import json\n'), ((565, 585), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (579, 585), True, 'import numpy as np\n'), ((860, 885), 'numpy.around', 'np.around', (['data'], {'out': 'data'}), '(data, out=data)\n', (869, 885), True, 'import numpy as np\n'), ((1182, 1205), 'scipy.signal.lfilter', 'sig.lfilter', (['b', 'a', 'data'], {}), '(b, a, data)\n', (1193, 1205), True, 'import scipy.signal as sig\n'), ((1414, 1438), 'scipy.signal.lfilter', 'sig.lfilter', (['b', 'a', 'noise'], {}), '(b, a, noise)\n', (1425, 1438), True, 'import scipy.signal as sig\n'), ((3071, 3085), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (3079, 3085), True, 'import numpy as np\n'), ((3686, 3705), 'scipy.io.wavfile.read', 'sciwav.read', (['stream'], {}), '(stream)\n', (3697, 3705), True, 'import scipy.io.wavfile as sciwav\n'), ((3776, 3809), 'numpy.loadtxt', 'np.loadtxt', (['stream'], {'dtype': '"""int16"""'}), "(stream, dtype='int16')\n", (3786, 3809), True, 'import numpy as np\n'), ((3931, 3966), 'scipy.io.wavfile.write', 'sciwav.write', (['stream', 'FS', 'self.data'], {}), '(stream, FS, self.data)\n', (3943, 3966), True, 'import scipy.io.wavfile as sciwav\n'), ((4010, 4049), 'numpy.savetxt', 'np.savetxt', (['stream', 'self.data'], {'fmt': '"""%d"""'}), "(stream, self.data, fmt='%d')\n", (4020, 4049), True, 'import numpy as np\n'), ((395, 420), 'os.path.join', 'op.join', (['COEFF_DIR', 'fname'], {}), '(COEFF_DIR, fname)\n', (402, 420), True, 'import os.path as op\n'), ((2467, 2481), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (2475, 2481), True, 'import numpy as np\n'), ((3869, 3886), 'json.load', 'json.load', (['stream'], {}), '(stream)\n', (3878, 3886), False, 'import json\n'), ((1312, 1345), 'numpy.random.random', 'np.random.random', ([], {'size': 'data.shape'}), '(size=data.shape)\n', (1328, 1345), True, 'import numpy as np\n')] |
# Standard library
import atexit
import os
os.environ["OMP_NUM_THREADS"] = "1"
import sys
import traceback
# Third-party
from astropy.utils import iers
iers.conf.auto_download = False
import astropy.table as at
import numpy as np
# This project
from totoro.config import cache_path
from totoro.data import datasets, elem_names
from totoro.objective import TorusImagingObjective
def worker(task):
i, obj, x0, tmp_filename = task
res = None
try:
res = obj.minimize(x0=x0, method="nelder-mead",
options=dict(maxiter=250))
print(f"{i} finished optimizing: {res}")
except Exception as e:
print(f"{i} failed: {str(e)}")
traceback.print_exc()
if res is None or not res.success:
xopt = np.nan * np.array(x0)
else:
xopt = res.x
xopt = {
'zsun': [xopt[0]],
'vzsun': [xopt[1]],
'mdisk_f': [xopt[2]],
'disk_hz': [xopt[3]],
}
at.Table(xopt).write(tmp_filename, overwrite=True)
return tmp_filename
def combine_output(all_filename, this_cache_path, elem_name):
import glob
cache_glob_pattr = str(this_cache_path / f'tmp-*{elem_name}*.csv')
if os.path.exists(all_filename):
prev_table = at.Table.read(all_filename)
else:
prev_table = None
# combine the individual worker cache files
all_tables = []
remove_filenames = []
for filename in glob.glob(cache_glob_pattr):
all_tables.append(at.Table.read(filename))
remove_filenames.append(filename)
if all_tables:
all_table = at.vstack(all_tables)
else:
return
if prev_table:
all_table = at.vstack((prev_table, all_table))
all_table.write(all_filename, overwrite=True)
for filename in remove_filenames:
os.unlink(filename)
def main(pool, overwrite=False):
tree_K = 32 # MAGIC NUMBER: set heuristically in Objective-function.ipynb
bootstrap_K = 128 # MAGIC NUMBER
for data_name, d in datasets.items():
# TODO: make seed configurable?
rnd = np.random.default_rng(seed=42)
# loop over all elements
tasks = []
cache_paths = []
cache_filenames = []
for elem_name in elem_names[data_name]:
print(f"Running element: {elem_name}")
# TODO: if galah in data_name, filter on flag??
this_cache_path = cache_path / data_name
this_cache_filename = (this_cache_path /
f'optimize-results-{elem_name}.csv')
if this_cache_filename.exists() and not overwrite:
print(f"Cache file exists for {elem_name}: "
f"{this_cache_filename}")
continue
atexit.register(combine_output,
this_cache_filename,
this_cache_path,
elem_name)
cache_paths.append(this_cache_path)
cache_filenames.append(this_cache_filename)
# print("Optimizing with full sample to initialize bootstraps...")
# obj = TorusImagingObjective(d.t, d.c, elem_name, tree_K=tree_K)
# full_sample_res = obj.minimize(method="nelder-mead",
# options=dict(maxiter=1024))
# if not full_sample_res.success:
# print(f"FAILED TO CONVERGE: optimize for full sample failed "
# f"for {elem_name}")
# continue
# print(f"Finished optimizing full sample: {full_sample_res.x}")
# x0 = full_sample_res.x
x0 = np.array([20.8, 7.78, 1.1, 0.28]) # HACK: init from fiducial
for k in range(bootstrap_K):
idx = rnd.choice(len(d), len(d), replace=True)
obj = TorusImagingObjective(d[idx], elem_name,
tree_K=tree_K)
tmp_filename = (this_cache_path /
f'tmp-optimize-results-{elem_name}-{k}.csv')
tasks.append((k, obj, x0, tmp_filename))
print("Done setting up bootstrap samples - running pool.map() on "
f"{len(tasks)} tasks")
for _ in pool.map(worker, tasks):
pass
for this_cache_filename, this_cache_path, elem_name in zip(
cache_filenames,
cache_paths,
elem_names[data_name]):
combine_output(this_cache_filename, this_cache_path, elem_name)
sys.exit(0)
if __name__ == '__main__':
from argparse import ArgumentParser
# Define parser object
parser = ArgumentParser()
parser.add_argument("-o", "--overwrite", dest="overwrite",
action="store_true")
# vq_group = parser.add_mutually_exclusive_group()
# vq_group.add_argument('-v', '--verbose', action='count', default=0,
# dest='verbosity')
# vq_group.add_argument('-q', '--quiet', action='count', default=0,
# dest='quietness')
group = parser.add_mutually_exclusive_group()
group.add_argument("--procs", dest="n_procs", default=1,
type=int, help="Number of processes.")
group.add_argument("--mpi", dest="mpi", default=False,
action="store_true", help="Run with MPI.")
parsed = parser.parse_args()
# deal with multiproc:
if parsed.mpi:
from schwimmbad.mpi import MPIPool
Pool = MPIPool
kw = dict()
elif parsed.n_procs > 1:
from schwimmbad import MultiPool
Pool = MultiPool
kw = dict(processes=parsed.n_procs)
else:
from schwimmbad import SerialPool
Pool = SerialPool
kw = dict()
Pool = Pool
Pool_kwargs = kw
with Pool(**Pool_kwargs) as pool:
main(pool=pool, overwrite=parsed.overwrite)
sys.exit(0)
| [
"os.path.exists",
"numpy.random.default_rng",
"argparse.ArgumentParser",
"astropy.table.Table",
"astropy.table.vstack",
"totoro.data.datasets.items",
"numpy.array",
"os.unlink",
"sys.exit",
"totoro.objective.TorusImagingObjective",
"traceback.print_exc",
"atexit.register",
"glob.glob",
"as... | [((1200, 1228), 'os.path.exists', 'os.path.exists', (['all_filename'], {}), '(all_filename)\n', (1214, 1228), False, 'import os\n'), ((1430, 1457), 'glob.glob', 'glob.glob', (['cache_glob_pattr'], {}), '(cache_glob_pattr)\n', (1439, 1457), False, 'import glob\n'), ((2009, 2025), 'totoro.data.datasets.items', 'datasets.items', ([], {}), '()\n', (2023, 2025), False, 'from totoro.data import datasets, elem_names\n'), ((4562, 4573), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (4570, 4573), False, 'import sys\n'), ((4684, 4700), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (4698, 4700), False, 'from argparse import ArgumentParser\n'), ((5940, 5951), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (5948, 5951), False, 'import sys\n'), ((1251, 1278), 'astropy.table.Table.read', 'at.Table.read', (['all_filename'], {}), '(all_filename)\n', (1264, 1278), True, 'import astropy.table as at\n'), ((1592, 1613), 'astropy.table.vstack', 'at.vstack', (['all_tables'], {}), '(all_tables)\n', (1601, 1613), True, 'import astropy.table as at\n'), ((1679, 1713), 'astropy.table.vstack', 'at.vstack', (['(prev_table, all_table)'], {}), '((prev_table, all_table))\n', (1688, 1713), True, 'import astropy.table as at\n'), ((1812, 1831), 'os.unlink', 'os.unlink', (['filename'], {}), '(filename)\n', (1821, 1831), False, 'import os\n'), ((2081, 2111), 'numpy.random.default_rng', 'np.random.default_rng', ([], {'seed': '(42)'}), '(seed=42)\n', (2102, 2111), True, 'import numpy as np\n'), ((694, 715), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (713, 715), False, 'import traceback\n'), ((780, 792), 'numpy.array', 'np.array', (['x0'], {}), '(x0)\n', (788, 792), True, 'import numpy as np\n'), ((964, 978), 'astropy.table.Table', 'at.Table', (['xopt'], {}), '(xopt)\n', (972, 978), True, 'import astropy.table as at\n'), ((1485, 1508), 'astropy.table.Table.read', 'at.Table.read', (['filename'], {}), '(filename)\n', (1498, 1508), True, 'import astropy.table as at\n'), ((2768, 2853), 'atexit.register', 'atexit.register', (['combine_output', 'this_cache_filename', 'this_cache_path', 'elem_name'], {}), '(combine_output, this_cache_filename, this_cache_path, elem_name\n )\n', (2783, 2853), False, 'import atexit\n'), ((3664, 3697), 'numpy.array', 'np.array', (['[20.8, 7.78, 1.1, 0.28]'], {}), '([20.8, 7.78, 1.1, 0.28])\n', (3672, 3697), True, 'import numpy as np\n'), ((3853, 3908), 'totoro.objective.TorusImagingObjective', 'TorusImagingObjective', (['d[idx]', 'elem_name'], {'tree_K': 'tree_K'}), '(d[idx], elem_name, tree_K=tree_K)\n', (3874, 3908), False, 'from totoro.objective import TorusImagingObjective\n')] |
"""
Problem:
You are given a huge list of airline ticket prices between different cities around the
world on a given day. These are all direct flights. Each element in the list has the
format (source_city, destination, price).
Consider a user who is willing to take up to k connections from their origin city A to
their destination B. Find the cheapest fare possible for this journey and print the
itinerary for that journey.
For example, our traveler wants to go from JFK to LAX with up to 3 connections, and our
input flights are as follows:
[
('JFK', 'ATL', 150),
('ATL', 'SFO', 400),
('ORD', 'LAX', 200),
('LAX', 'DFW', 80),
('JFK', 'HKG', 800),
('ATL', 'ORD', 90),
('JFK', 'LAX', 500),
]
Due to some improbably low flight prices, the cheapest itinerary would be
JFK -> ATL -> ORD -> LAX, costing $440.
"""
from sys import maxsize
from typing import Dict, List, Optional, Tuple
from DataStructures.Graph import GraphDirectedWeighted
from DataStructures.PriorityQueue import MinPriorityQueue
def modified_dijkstra(
graph: GraphDirectedWeighted, start: str, k: int
) -> Tuple[Dict[str, int], Dict[str, Optional[str]]]:
dist = {node: maxsize for node in graph.connections}
parent = {node: None for node in graph.connections}
dist[start] = 0
priority_queue = MinPriorityQueue()
[priority_queue.push(node, weight) for node, weight in dist.items()]
while not priority_queue.is_empty():
node = priority_queue.extract_min()
ancestors = 0
parent_node = parent[node]
# calculating ancestors
while parent_node:
ancestors += 1
parent_node = parent[parent_node]
# limiting distance update till k moves
if ancestors <= k:
for neighbour in graph.connections[node]:
if dist[neighbour] > dist[node] + graph.connections[node][neighbour]:
dist[neighbour] = dist[node] + graph.connections[node][neighbour]
parent[neighbour] = node
priority_queue.update_key(neighbour, dist[neighbour])
return dist, parent
def generate_path(
flights: List[Tuple[str, str, int]], start: str, dest: str, k: int
) -> Tuple[int, List[str]]:
# graph generation
graph = GraphDirectedWeighted()
for src, dest, wt in flights:
graph.add_edge(src, dest, wt)
# running dijkstra's algorithm
dist, parent = modified_dijkstra(graph, start, k)
# getting the cost and path
if not parent[dest]:
return []
path, cost = [dest], dist[dest]
curr = parent[dest]
while curr:
path.append(curr)
curr = parent[curr]
return cost, path[::-1]
if __name__ == "__main__":
flights = [
("JFK", "ATL", 150),
("ATL", "SFO", 400),
("ORD", "LAX", 200),
("LAX", "DFW", 80),
("JFK", "HKG", 800),
("ATL", "ORD", 90),
("JFK", "LAX", 500),
]
print(generate_path(flights, "JFK", "LAX", 3))
"""
SPECS:
TIME COMPLEXITY: O(e x v x log(v))
SPACE COMPLEXITY: O(v ^ 2)
[even though dijkstra's algorithm runs in O(e x log(v)) to lock maximum k moves, the
compleity increases to O(e x v x log(v))]
"""
| [
"DataStructures.Graph.GraphDirectedWeighted",
"DataStructures.PriorityQueue.MinPriorityQueue"
] | [((1315, 1333), 'DataStructures.PriorityQueue.MinPriorityQueue', 'MinPriorityQueue', ([], {}), '()\n', (1331, 1333), False, 'from DataStructures.PriorityQueue import MinPriorityQueue\n'), ((2281, 2304), 'DataStructures.Graph.GraphDirectedWeighted', 'GraphDirectedWeighted', ([], {}), '()\n', (2302, 2304), False, 'from DataStructures.Graph import GraphDirectedWeighted\n')] |
"""PyTorch Distributed Data Parallel example from NVIDIA."""
# https://github.com/NVIDIA/DeepLearningExamples
import argparse
import utils
import virtual_machine
def main():
parser = argparse.ArgumentParser(description='Optional app description')
parser.add_argument('--vm-name', dest='vm_name', type=str, required=True)
parser.add_argument('--vm-number', dest='vm_num', type=int, default=2)
parser.add_argument('--gpu-per-vm', dest='gpu_per_vm', type=int, default=1)
args = parser.parse_args()
gpu_per_vm = args.gpu_per_vm
vm_num = args.vm_num
vms = []
for i in range(args.vm_num):
vm_name = '{}-{}'.format(args.vm_name, str(i))
vms.append(virtual_machine.VirtualMachine(vm_name))
# prepare
prepare_command = """
# install DALI
pip install --extra-index-url https://developer.download.nvidia.com/compute/redist nvidia-dali-cuda110
# install apex
pip install apex
# install nvidia-dllogger
pip install nvidia-pyindex
pip install nvidia-dllogger
# install pytorch-quantization
git clone https://github.com/NVIDIA/TensorRT.git
cd TensorRT/tools/pytorch-quantization || exit
python setup.py install
cd || exit
# clone main repo
git clone https://github.com/NVIDIA/DeepLearningExamples.git
"""
utils.run_threads(vms, [prepare_command] * len(vms), login_shell=True)
# run
master_ip = vms[0].internal_ip
master_port = '1234'
# pylint: disable=implicit-str-concat
run_command_template = (
'python '
'./DeepLearningExamples/PyTorch/Classification/ConvNets/multiproc.py '
'--node_rank {node_rank} '
'--master_addr {master_ip} '
'--master_port {master_port} '
'--nnodes {vm_num} '
'--nproc_per_node {gpu_per_vm} '
'./DeepLearningExamples/PyTorch/Classification/ConvNets/main.py '
'~/fake-data-path '
'--data-backend syntetic '
'--raport-file raport.json '
'-j8 -p 100 '
'--lr 4.096 '
'--optimizer-batch-size 4096 '
'--warmup 16 '
'--arch resnet50 '
'--label-smoothing 0.1 '
'--lr-schedule cosine '
'--mom 0.875 '
'--wd 3.0517578125e-05 '
'--no-checkpoints '
'-b 256 '
'--amp '
'--static-loss-scale 128 '
'--epochs 2'
)
commands = []
for i, _ in enumerate(vms):
run_command = run_command_template.format(
node_rank=i,
master_ip=master_ip,
master_port=master_port,
vm_num=vm_num,
gpu_per_vm=gpu_per_vm,
)
commands.append(run_command)
utils.run_threads(vms, commands, login_shell=True)
if __name__ == "__main__":
main()
| [
"utils.run_threads",
"virtual_machine.VirtualMachine",
"argparse.ArgumentParser"
] | [((188, 251), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Optional app description"""'}), "(description='Optional app description')\n", (211, 251), False, 'import argparse\n'), ((2429, 2479), 'utils.run_threads', 'utils.run_threads', (['vms', 'commands'], {'login_shell': '(True)'}), '(vms, commands, login_shell=True)\n', (2446, 2479), False, 'import utils\n'), ((672, 711), 'virtual_machine.VirtualMachine', 'virtual_machine.VirtualMachine', (['vm_name'], {}), '(vm_name)\n', (702, 711), False, 'import virtual_machine\n')] |
from torch.utils.data import Dataset
from skimage import io
import os
import torch
class MnistData(Dataset):
def __init__(self, root_dir):
self.root_dir = root_dir
img_list = []
label_list = os.listdir(self.root_dir)
for label in label_list:
file_names = os.listdir(os.path.join(self.root_dir, label))
for name in file_names:
img_list.append(label + "&" + name)
self.images = img_list
def __len__(self):
return len(self.images)
def __getitem__(self, index):
image_index = self.images[index]
img_label = image_index.split("&")[0]
img_name = image_index.split("&")[1]
img_path = os.path.join(self.root_dir,img_label)
img_path = os.path.join(img_path, img_name)
img = io.imread(img_path)
sample = [img, img_label]
return sample | [
"skimage.io.imread",
"os.listdir",
"os.path.join"
] | [((229, 254), 'os.listdir', 'os.listdir', (['self.root_dir'], {}), '(self.root_dir)\n', (239, 254), False, 'import os\n'), ((735, 773), 'os.path.join', 'os.path.join', (['self.root_dir', 'img_label'], {}), '(self.root_dir, img_label)\n', (747, 773), False, 'import os\n'), ((793, 825), 'os.path.join', 'os.path.join', (['img_path', 'img_name'], {}), '(img_path, img_name)\n', (805, 825), False, 'import os\n'), ((841, 860), 'skimage.io.imread', 'io.imread', (['img_path'], {}), '(img_path)\n', (850, 860), False, 'from skimage import io\n'), ((326, 360), 'os.path.join', 'os.path.join', (['self.root_dir', 'label'], {}), '(self.root_dir, label)\n', (338, 360), False, 'import os\n')] |
from qunetsim.backends.rw_lock import RWLock
from qunetsim.objects.logger import Logger
import queue
class QuantumStorage(object):
"""
An object which stores qubits.
"""
STORAGE_LIMIT_ALL = 1
STORAGE_LIMIT_PER_HOST = 2
STORAGE_LIMIT_INDIVIDUALLY_PER_HOST = 3
def __init__(self):
# _host_dict stores host_id -> array with qubits of the host.
self._host_dict = {}
# _qubit_dict stores qubit_id -> dict Host_id -> Qubit objects with this id.
self._qubit_dict = {}
# _purpose_dict stores qubit_id -> dict Host_id -> Purpose belonging to
# the Qubit with the same Host and ID.
self._purpose_dict = {}
self._storage_mode = QuantumStorage.STORAGE_LIMIT_INDIVIDUALLY_PER_HOST
self._storage_limits_per_host = {}
self._amount_qubits_stored_per_host = {}
self._default_storage_limit_per_host = -1
self._storage_limit = -1
self._amount_qubit_stored = 0
# read write lock, for threaded access
self.lock = RWLock()
self.logger = Logger.get_instance()
# for tracking pending requests
# dictionary tracks the request made by a pending request.
self._pending_request_dict = {}
# Determines a unique ID for a pending request.
self._request_id = 0
# Amount of pending requests
self._amount_pending_requests = 0
def __str__(self):
out = ""
out += "Quantum storage with the properties:\nstorage mode: %d\nstorage limit: %d\n" % (
self._storage_mode, self._storage_limit)
out += "Host dictionary is:\n"
out += "; ".join([str(key) + ":" + str([v.id for v in value])
for key, value in self._host_dict.items()])
out += "\n"
out += "Qubit dictionary is:\n"
out += "; ".join([str(key) + ":" + str(value)
for key, value in self._qubit_dict.items()])
out += "\n"
out += "Purpose dictionary is:\n"
out += "; ".join([str(key) + ":" + str(value)
for key, value in self._purpose_dict.items()])
out += "\n"
return out
@property
def storage_limit(self):
return self._storage_limit
@storage_limit.setter
def storage_limit(self, new_limit):
"""
Set a new storage limit for the storage. The implementations depends on
the storage mode.
Args:
new_limit (int): The new max amount of qubit.
"""
if self._storage_mode == QuantumStorage.STORAGE_LIMIT_ALL:
self._storage_limit = new_limit
elif self._storage_mode == QuantumStorage.STORAGE_LIMIT_PER_HOST:
self._storage_limit = new_limit
elif self._storage_mode == QuantumStorage.STORAGE_LIMIT_INDIVIDUALLY_PER_HOST:
self._default_storage_limit_per_host = new_limit
for id_ in list(self._storage_limits_per_host):
self._storage_limits_per_host[id_] = new_limit
else:
raise ValueError(
"Internal Value Error, this storage mode does not exist.")
@property
def storage_limit_mode(self):
return self._storage_mode
@storage_limit_mode.setter
def storage_limit_mode(self, new_mode):
self._storage_mode = new_mode
@property
def amount_qubits_stored(self):
return self._amount_qubit_stored
def amount_qubits_stored_with_host(self, host_id):
return self._amount_qubits_stored_per_host[host_id]
def set_storage_limit_with_host(self, new_limit, host_id):
"""
Set a new storage limit for the storage. The implementations depends on
the storage mode.
Args:
new_limit (int): The new max amount of qubit.
host_id (str): optional, if given, and the storage mode is
STORAGE_LIMIT_INDIVIDUALLY_PER_HOST, the limit is only
set for this specific host.
"""
if self._storage_mode == QuantumStorage.STORAGE_LIMIT_INDIVIDUALLY_PER_HOST:
if host_id is None:
raise ValueError(
"Host ID must be given in this storage mode")
else:
self._storage_limits_per_host[host_id] = new_limit
else:
raise ValueError(
"Internal Value Error, this storage mode does not exist.")
def reset_storage(self):
"""
Reset the quantum storage.
"""
for host in self._host_dict:
self.reset_qubits_from_host(host)
def release_storage(self):
"""
Releases all qubits in this storage. The storage is not
usable anymore after this function has been called.
"""
self.lock.acquire_write()
for q in self._qubit_dict.values():
for ele in q.values():
ele.release()
# do not release write, storage not usable anymore
def check_qubit_from_host_exists(self, from_host_id, purpose=None):
"""
Check if a qubit from a host exists in this quantum storage.
Args:
from_host_id (str): The host id of the host from which the qubit is from.
purpose (int): Optional, purpose of the qubit which should exist.
Returns:
(bool): True, if such a qubit is in the storage, false if not.
"""
self.lock.acquire_write()
if from_host_id not in self._host_dict:
self.lock.release_write()
return False
for q in self._host_dict[from_host_id]:
if self._check_qubit_in_system(q, from_host_id, purpose):
self.lock.release_write()
return True
self.lock.release_write()
return False
def get_qubit_by_id(self, q_id):
"""
Return the qubit that has the id *q_id*
Args:
q_id (str): The ID of the qubit
Returns:
(Qubit): The qubit with the id *q_id* or None if it does not exist
"""
if q_id in self._qubit_dict:
return list(self._qubit_dict[q_id].values())[0]
return None
def change_qubit_id(self, from_host_id, new_id, old_id=None):
"""
Changes the ID of a qubit. If the ID is not given, a random
qubit which is from a host is changed to the new id.
Args:
from_host_id (str): The ID of the owner
new_id (str): The ID to change to
old_id (str): The old ID
Returns:
(str): The new ID
"""
new_id = str(new_id)
self.lock.acquire_write()
if old_id is not None:
old_id = str(old_id)
qubit, purpose = self._pop_qubit_with_id_and_host_from_qubit_dict(
old_id, from_host_id)
if qubit is not None:
qubit.id = new_id
self._add_qubit_to_qubit_dict(qubit, purpose, from_host_id)
else:
if from_host_id in self._host_dict and self._host_dict[from_host_id]:
qubit = self._host_dict[from_host_id][0]
old_id = qubit.id
_, purpose = self._pop_qubit_with_id_and_host_from_qubit_dict(
old_id, from_host_id)
qubit.id = new_id
self._add_qubit_to_qubit_dict(qubit, purpose, from_host_id)
self.lock.release_write()
return old_id
def add_qubit_from_host(self, qubit, purpose, from_host_id):
"""
Adds a qubit which has been received from a host.
Args:
qubit (Qubit): qubit which should be stored.
from_host_id (str): Id of the Host from whom the qubit has
been received.
purpose (str): Purpose of the Qubit, for example EPR or data.
"""
self.lock.acquire_write()
if self._check_qubit_in_system(qubit, from_host_id, purpose=purpose):
self.logger.log("Qubit with id %s, purpose %s and from host %s"
" already in storage" % (qubit.id, purpose, from_host_id))
raise ValueError("Qubit with these parameters already in storage!")
if from_host_id not in self._host_dict:
self._add_new_host(from_host_id)
if not self._increase_qubit_counter(from_host_id):
qubit.release()
self.lock.release_write()
return
self._host_dict[from_host_id].append(qubit)
self._add_qubit_to_qubit_dict(qubit, purpose, from_host_id)
# Check if a Qubit of one of the callbacks has arrived
self._check_all_requests()
self.lock.release_write()
def get_all_qubits_from_host(self, from_host_id, purpose=None, remove=False):
"""
Get all Qubits from a specific host id.
These qubits are not removed from storage!
Args:
from_host_id (str): The host who the qubits are from
purpose (int): The purpose of the qubits
remove (bool): Also remove from storage
Returns:
(list): The list of qubits
"""
if from_host_id in self._host_dict:
out = []
self.lock.acquire_write()
flag = False
for q in self._host_dict[from_host_id]:
if self._check_qubit_in_system(q, from_host_id, purpose):
if not remove:
out.append(q)
else:
flag = True
if remove:
break
if not flag and remove:
num_qubits = len(self._host_dict[from_host_id])
for _ in range(num_qubits):
out.append(self._get_qubit_from_host(from_host_id, purpose=purpose))
self.lock.release_write()
return out
return []
def reset_qubits_from_host(self, from_host_id, purpose=None):
"""
Remove all stored qubits from the host *from_host_id*.
Args:
from_host_id (str): The host who the qubits are from
purpose (int):
"""
self.lock.acquire_write()
if from_host_id in self._host_dict:
for q in self._host_dict[from_host_id]:
if self._check_qubit_in_system(q, from_host_id, purpose):
self._get_qubit_from_host(from_host_id, purpose=purpose)
self.lock.release_write()
def _check_all_requests(self):
"""
Checks if any of the pending requests is now fulfilled.
Returns:
If a request is fulfilled, the request is handled and the function
returns the qubit of this request.
"""
for req_id, args in self._pending_request_dict.items():
ret = self._get_qubit_from_host(args[1], args[2], args[3])
if ret is not None:
args[0].put(ret)
self._remove_request(req_id)
return ret
def _add_request(self, args):
"""
Adds a new request to the quantum storage. If a new qubit arrives, it
is checked if the request for the qubit is satisfied.
Args:
args (list): [Queue, from_host_id, q_id, purpose]
"""
self._pending_request_dict[self._request_id] = args
self._request_id += 1
self._amount_pending_requests += 1
return self._request_id
def _remove_request(self, req_id):
"""
Removes a pending request from the request dict.
Args:
req_id (int): The id of the request to remove.
"""
if req_id in self._pending_request_dict:
del self._pending_request_dict[req_id]
self._amount_pending_requests -= 1
def get_qubit_from_host(self, from_host_id, q_id=None, purpose=None, wait=0):
"""
Returns next qubit which has been received from a host. If the qubit has
not been receives yet, the thread is blocked for a maxiumum of the wait time,
till the qubit arrives (The default is 0). If the id is given, the exact qubit with the id
is returned, or None if it does not exist.
The qubit is removed from the quantum storage.
Args:
from_host_id (str): Host id from who the qubit has been received.
q_id (str): Optional Id, to return the exact qubit with the Id.
purpose (str): Optional, purpose of the Qubit.
wait (int): Default is 0. The maximum blocking time. -1 if blocking forever.
Returns:
(bool): If such a qubit exists, it returns the qubit. Otherwise, None
is returned.
"""
# Block forever if wait is -1
if wait == -1:
wait = None
self.lock.acquire_write()
ret = self._get_qubit_from_host(from_host_id, q_id, purpose)
if ret is not None or wait == 0:
self.lock.release_write()
return ret
q = queue.Queue()
args = [q, from_host_id, q_id, purpose]
req_id = self._add_request(args)
self.lock.release_write()
ret = None
try:
ret = q.get(timeout=wait)
except queue.Empty:
pass
if ret is None:
self.lock.acquire_write()
self._remove_request(req_id)
self.lock.release_write()
return ret
def _get_qubit_from_host(self, from_host_id, q_id=None, purpose=None):
if q_id is not None:
qubit = self._pop_qubit_with_id_and_host_from_qubit_dict(
q_id, from_host_id, purpose=purpose)
if qubit is not None:
qubit, purp = qubit
if from_host_id not in self._host_dict or \
qubit not in self._host_dict[from_host_id]:
# Qubit with the ID exists, but does not belong to the host requested
self._add_qubit_to_qubit_dict(qubit, purp, from_host_id)
return None
self._host_dict[from_host_id].remove(qubit)
self._decrease_qubit_counter(from_host_id)
return qubit
if from_host_id not in self._host_dict:
return None
if self._host_dict[from_host_id]:
# check purposes of all qubits
for _ in range(len(self._host_dict[from_host_id])):
qubit = self._host_dict[from_host_id].pop(0)
out = self._pop_qubit_with_id_and_host_from_qubit_dict(
qubit.id, from_host_id, purpose=purpose)
if out is not None:
self._decrease_qubit_counter(from_host_id)
return out[0]
self._host_dict[from_host_id].append(qubit)
return None
def _pop_qubit_with_id_and_host_from_qubit_dict(self, q_id, from_host_id, purpose=None):
def _pop_purpose_from_purpose_dict():
nonlocal q_id, from_host_id
if q_id not in self._purpose_dict:
return None
pur = self._purpose_dict[q_id].pop(from_host_id, None)
if pur is not None:
if not self._purpose_dict[q_id]:
del self._purpose_dict[q_id]
return pur
return None
purp = _pop_purpose_from_purpose_dict()
if purp is not None:
if purpose is None or purpose == purp:
qubit = self._qubit_dict[q_id].pop(from_host_id, None)
if qubit is not None:
if not self._qubit_dict[q_id]:
del self._qubit_dict[q_id]
return qubit, purp
else:
if q_id not in self._purpose_dict:
self._purpose_dict[q_id] = {}
self._purpose_dict[q_id][from_host_id] = purp
return None
def _add_qubit_to_qubit_dict(self, qubit, purpose, from_host_id):
def _add_purpose_to_purpose_dict(q_id):
nonlocal purpose, from_host_id
if q_id not in self._purpose_dict:
self._purpose_dict[q_id] = {}
self._purpose_dict[q_id][from_host_id] = purpose
if qubit.id not in self._qubit_dict:
self._qubit_dict[qubit.id] = {}
self._qubit_dict[qubit.id][from_host_id] = qubit
_add_purpose_to_purpose_dict(qubit.id)
def _add_new_host(self, host_id):
if host_id not in self._host_dict:
self._host_dict[host_id] = []
if host_id not in self._storage_limits_per_host:
self._storage_limits_per_host[host_id] = self._default_storage_limit_per_host
self._amount_qubits_stored_per_host[host_id] = 0
def _check_qubit_in_system(self, qubit, from_host_id, purpose=None):
"""
True if qubit with same parameters already in the systems
Args:
qubit (Qubit): The qubit in question
from_host_id (str): The ID of the sending host
purpose (int): Qubit's purpose
Returns:
(bool): If the qubit is in the system.
"""
if qubit.id in self._qubit_dict and \
from_host_id in self._qubit_dict[qubit.id]:
if purpose is None or (purpose == self._purpose_dict[qubit.id][from_host_id]):
return True
return False
def _check_memory_limits(self, host_id):
"""
Checks if another qubit can be added to the storage.
Args:
host_id (str): The host_id the qubit should be added to.
Returns:
True if no storage limit has been reached, False if a memory
limit has occurred.
"""
if self._storage_mode == QuantumStorage.STORAGE_LIMIT_ALL:
if self._storage_limit == -1:
return True
if self._storage_limit <= self._amount_qubit_stored:
return False
else:
return True
elif self._storage_mode == QuantumStorage.STORAGE_LIMIT_PER_HOST:
if self._storage_limit == -1:
return True
if self._storage_limit <= self._amount_qubits_stored_per_host[host_id]:
return False
else:
return True
elif self._storage_mode == QuantumStorage.STORAGE_LIMIT_INDIVIDUALLY_PER_HOST:
if self._storage_limits_per_host[host_id] == -1:
return True
if self._storage_limits_per_host[host_id] <= self._amount_qubits_stored_per_host[host_id]:
return False
else:
return True
else:
raise ValueError(
"Internal Value Error, this storage mode does not exist.")
def _increase_qubit_counter(self, host_id):
"""
Checks if the qubit counter can be increased, because of memory limits,
and increases the counter.
Args:
host_id (str): From who the qubit comes from.
Returns:
True, if the counter could be increased, False if not.
"""
if not self._check_memory_limits(host_id):
return False
self._amount_qubits_stored_per_host[host_id] += 1
self._amount_qubit_stored += 1
return True
def _reset_qubit_counter(self, host_id):
"""
Args:
host_id (str):
Returns:
(bool): True, if the counter could be decreased, False if not.
"""
if self._amount_qubits_stored_per_host[host_id] <= 0 or \
self._amount_qubit_stored <= 0:
return False
num_qubits = self._amount_qubits_stored_per_host[host_id]
self._amount_qubits_stored_per_host[host_id] = 0
self._amount_qubit_stored -= num_qubits
def _decrease_qubit_counter(self, host_id):
"""
Checks if the qubit counter can be decreased
and decreases the counter.
Args:
host_id (str): From who the qubit comes from.
Returns:
(bool): True, if the counter could be decreased, False if not.
"""
if self._amount_qubits_stored_per_host[host_id] <= 0 or \
self._amount_qubit_stored <= 0:
return False
self._amount_qubits_stored_per_host[host_id] -= 1
self._amount_qubit_stored -= 1
| [
"qunetsim.objects.logger.Logger.get_instance",
"queue.Queue",
"qunetsim.backends.rw_lock.RWLock"
] | [((1044, 1052), 'qunetsim.backends.rw_lock.RWLock', 'RWLock', ([], {}), '()\n', (1050, 1052), False, 'from qunetsim.backends.rw_lock import RWLock\n'), ((1076, 1097), 'qunetsim.objects.logger.Logger.get_instance', 'Logger.get_instance', ([], {}), '()\n', (1095, 1097), False, 'from qunetsim.objects.logger import Logger\n'), ((13084, 13097), 'queue.Queue', 'queue.Queue', ([], {}), '()\n', (13095, 13097), False, 'import queue\n')] |
# -*- coding: utf-8 -*-
import datetime
from pagseguro.utils import (is_valid_cpf, is_valid_cnpj, is_valid_email,
parse_date)
from pagseguro.exceptions import PagSeguroValidationError
import pytest
from dateutil.tz import tzutc
def test_is_valid_email():
valid = '<EMAIL>'
valid2 = u'<EMAIL>'
not_valid = '@asd.com'
not_valid2 = 'bad'
not_valid3 = u'user@росси́я'
with pytest.raises(PagSeguroValidationError):
is_valid_email(not_valid)
with pytest.raises(PagSeguroValidationError):
is_valid_email(not_valid2)
with pytest.raises(PagSeguroValidationError):
is_valid_email(not_valid3)
assert is_valid_email(valid) == '<EMAIL>'
assert is_valid_email(valid2) == u'<EMAIL>'
def test_parse_date():
# DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
date_str = '2016-10-10T10:10:10'
assert parse_date(date_str) == datetime.datetime(2016, 10, 10, 10, 10, 10,
tzinfo=tzutc())
def test_is_valid_cpf():
valid = '041.684.826-50'
valid2 = '04168482650'
bad = 'bla///'
max_digits = '1111111111111111111111111'
invalid_cpf = '040.684.826-50'
with pytest.raises(PagSeguroValidationError):
is_valid_cpf(bad)
with pytest.raises(PagSeguroValidationError):
is_valid_cpf(max_digits)
with pytest.raises(PagSeguroValidationError):
is_valid_cpf(invalid_cpf)
assert is_valid_cpf(valid) == valid
assert is_valid_cpf(valid2) == '04168482650'
def test_is_valid_cnpj():
valid = '31331052000174'
valid2 = '72.168.117/0001-90'
invalid = '///'
digits = '1111111'
wrong_number = '31331052000175'
with pytest.raises(PagSeguroValidationError):
is_valid_cnpj(invalid)
with pytest.raises(PagSeguroValidationError):
is_valid_cnpj(digits)
with pytest.raises(PagSeguroValidationError):
is_valid_cnpj(wrong_number)
assert is_valid_cnpj(valid) == '31331052000174'
assert is_valid_cnpj(valid2) == '72168117000190'
| [
"pagseguro.utils.is_valid_cpf",
"dateutil.tz.tzutc",
"pagseguro.utils.parse_date",
"pagseguro.utils.is_valid_cnpj",
"pytest.raises",
"pagseguro.utils.is_valid_email"
] | [((427, 466), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (440, 466), False, 'import pytest\n'), ((476, 501), 'pagseguro.utils.is_valid_email', 'is_valid_email', (['not_valid'], {}), '(not_valid)\n', (490, 501), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((512, 551), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (525, 551), False, 'import pytest\n'), ((561, 587), 'pagseguro.utils.is_valid_email', 'is_valid_email', (['not_valid2'], {}), '(not_valid2)\n', (575, 587), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((598, 637), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (611, 637), False, 'import pytest\n'), ((647, 673), 'pagseguro.utils.is_valid_email', 'is_valid_email', (['not_valid3'], {}), '(not_valid3)\n', (661, 673), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((686, 707), 'pagseguro.utils.is_valid_email', 'is_valid_email', (['valid'], {}), '(valid)\n', (700, 707), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((732, 754), 'pagseguro.utils.is_valid_email', 'is_valid_email', (['valid2'], {}), '(valid2)\n', (746, 754), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((886, 906), 'pagseguro.utils.parse_date', 'parse_date', (['date_str'], {}), '(date_str)\n', (896, 906), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1215, 1254), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1228, 1254), False, 'import pytest\n'), ((1264, 1281), 'pagseguro.utils.is_valid_cpf', 'is_valid_cpf', (['bad'], {}), '(bad)\n', (1276, 1281), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1292, 1331), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1305, 1331), False, 'import pytest\n'), ((1341, 1365), 'pagseguro.utils.is_valid_cpf', 'is_valid_cpf', (['max_digits'], {}), '(max_digits)\n', (1353, 1365), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1376, 1415), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1389, 1415), False, 'import pytest\n'), ((1425, 1450), 'pagseguro.utils.is_valid_cpf', 'is_valid_cpf', (['invalid_cpf'], {}), '(invalid_cpf)\n', (1437, 1450), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1463, 1482), 'pagseguro.utils.is_valid_cpf', 'is_valid_cpf', (['valid'], {}), '(valid)\n', (1475, 1482), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1503, 1523), 'pagseguro.utils.is_valid_cpf', 'is_valid_cpf', (['valid2'], {}), '(valid2)\n', (1515, 1523), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1722, 1761), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1735, 1761), False, 'import pytest\n'), ((1771, 1793), 'pagseguro.utils.is_valid_cnpj', 'is_valid_cnpj', (['invalid'], {}), '(invalid)\n', (1784, 1793), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1804, 1843), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1817, 1843), False, 'import pytest\n'), ((1853, 1874), 'pagseguro.utils.is_valid_cnpj', 'is_valid_cnpj', (['digits'], {}), '(digits)\n', (1866, 1874), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1885, 1924), 'pytest.raises', 'pytest.raises', (['PagSeguroValidationError'], {}), '(PagSeguroValidationError)\n', (1898, 1924), False, 'import pytest\n'), ((1934, 1961), 'pagseguro.utils.is_valid_cnpj', 'is_valid_cnpj', (['wrong_number'], {}), '(wrong_number)\n', (1947, 1961), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1974, 1994), 'pagseguro.utils.is_valid_cnpj', 'is_valid_cnpj', (['valid'], {}), '(valid)\n', (1987, 1994), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((2026, 2047), 'pagseguro.utils.is_valid_cnpj', 'is_valid_cnpj', (['valid2'], {}), '(valid2)\n', (2039, 2047), False, 'from pagseguro.utils import is_valid_cpf, is_valid_cnpj, is_valid_email, parse_date\n'), ((1014, 1021), 'dateutil.tz.tzutc', 'tzutc', ([], {}), '()\n', (1019, 1021), False, 'from dateutil.tz import tzutc\n')] |
#-*- conding:utf-8 -*-
#2018-02-02 11:04:54
import time,random,requests
from lxml import etree
from fake_useragent import UserAgent
import urllib.request as ur
from pymongo import MongoClient
from multiprocessing.dummy import Pool as ThreadPool
client = MongoClient('localhost',27017)
db = client['test']
ip_list = db['ip_list']
ua = UserAgent()
headers = {'User-Agent':ua.random}
def get_ip(url):
try:
data = requests.get(url,headers=headers).text
content = etree.HTML(data)
ip = content.xpath('//*[@class="odd"]/td[2]/text()')
port = content.xpath('//*[@class="odd"]/td[3]/text()')
with open('ip_list.txt','a+') as fh:
for i in range(len(ip)):
ip_port = str(ip[i])+':'+str(port[i])
fh.write(ip_port+'\n')
print('第{num}条ip记录成功'.format(num=i+1))
except Exception as e:
print('一不意外：{error}'.format(error=e))
def verif_ip(ip_port):
proxy = {'http':'%s:%s' %(ip_port.split(':')[0],ip_port.split(':')[1][:-2])}
print('正在测试的ip是:{ip}'.format(ip=proxy))
support = ur.ProxyHandler(proxy)
opener = ur.build_opener(support,ur.HTTPHandler)
ur.install_opener(opener)
test_url = 'https://www.baidu.com/'
resp = requests.get(test_url,headers=headers)
time.sleep(random.random()*10)
try:
if resp.status_code == 200:
res = resp.text
print('字节数为:{n}'.format(n=len(res)))
db.ip_list.insert(proxy)
with open('ip_userful.txt','a+') as fh:
fh.write(ip_port+'\n')
else :
print('there is some problem!')
except Exception as e:
print('出了问题：'+str(e))
def main():
url_base = 'http://www.xicidaili.com/nn/{page}'
urls = [url_base.format(page=i+1) for i in range(12)]
pool = ThreadPool(12)
pool.map(get_ip,urls)
pool.close()
pool.join()
time.sleep(random.random()*10)
with open ('ip_list.txt','r') as fh:
try:
ip_ports = fh.readlines()
pool = ThreadPool(12)
pool.map(verif_ip,ip_ports)
pool.close()
pool.join()
#for ip_port in ip_ports:
# verif_ip(ip_port)
except Exception :
pass
if __name__ == '__main__':
main()
| [
"urllib.request.install_opener",
"urllib.request.ProxyHandler",
"requests.get",
"urllib.request.build_opener",
"lxml.etree.HTML",
"multiprocessing.dummy.Pool",
"pymongo.MongoClient",
"random.random",
"fake_useragent.UserAgent"
] | [((256, 287), 'pymongo.MongoClient', 'MongoClient', (['"""localhost"""', '(27017)'], {}), "('localhost', 27017)\n", (267, 287), False, 'from pymongo import MongoClient\n'), ((336, 347), 'fake_useragent.UserAgent', 'UserAgent', ([], {}), '()\n', (345, 347), False, 'from fake_useragent import UserAgent\n'), ((1119, 1141), 'urllib.request.ProxyHandler', 'ur.ProxyHandler', (['proxy'], {}), '(proxy)\n', (1134, 1141), True, 'import urllib.request as ur\n'), ((1156, 1196), 'urllib.request.build_opener', 'ur.build_opener', (['support', 'ur.HTTPHandler'], {}), '(support, ur.HTTPHandler)\n', (1171, 1196), True, 'import urllib.request as ur\n'), ((1201, 1226), 'urllib.request.install_opener', 'ur.install_opener', (['opener'], {}), '(opener)\n', (1218, 1226), True, 'import urllib.request as ur\n'), ((1280, 1319), 'requests.get', 'requests.get', (['test_url'], {'headers': 'headers'}), '(test_url, headers=headers)\n', (1292, 1319), False, 'import time, random, requests\n'), ((1884, 1898), 'multiprocessing.dummy.Pool', 'ThreadPool', (['(12)'], {}), '(12)\n', (1894, 1898), True, 'from multiprocessing.dummy import Pool as ThreadPool\n'), ((486, 502), 'lxml.etree.HTML', 'etree.HTML', (['data'], {}), '(data)\n', (496, 502), False, 'from lxml import etree\n'), ((427, 461), 'requests.get', 'requests.get', (['url'], {'headers': 'headers'}), '(url, headers=headers)\n', (439, 461), False, 'import time, random, requests\n'), ((1335, 1350), 'random.random', 'random.random', ([], {}), '()\n', (1348, 1350), False, 'import time, random, requests\n'), ((1977, 1992), 'random.random', 'random.random', ([], {}), '()\n', (1990, 1992), False, 'import time, random, requests\n'), ((2117, 2131), 'multiprocessing.dummy.Pool', 'ThreadPool', (['(12)'], {}), '(12)\n', (2127, 2131), True, 'from multiprocessing.dummy import Pool as ThreadPool\n')] |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
Read & write snapshot of node status data dumped to local file system.
This data is used to detect things like sytem changes that may need to be reported.
"""
import json
import time
import logging
import os
import socket
import psutil
import netifaces as ni
logging.basicConfig(level=logging.INFO)
class_logger = logging.getLogger('DataSnapshot')
#class_logger.setLevel(logging.DEBUG)
class DataSnapshot(object):
'''
Read & write snapshot of status data dumped to file system
'''
def __init__(self, local_file="/tmp/snapshot.json",):
self.local_file = local_file
self.err_msg = ''
self.data = {}
def write_data(self):
"""
Write current data snapshot to file
"""
class_logger.debug("Writing snapshot data to local file...")
try:
with open(self.local_file, 'w') as f:
json.dump(self.data, f, indent=4)
class_logger.debug("Data written OK.")
return True
except Exception as ex:
self.err_msg = "Issue writing data file: {}".format(ex)
class_logger.error(self.err_msg)
return False
def read_data(self):
"""
Read data from snapshot file
"""
class_logger.debug("Reading snapshot data from local file...")
try:
with open(self.local_file, 'r') as f:
data = json.load(f)
class_logger.debug("Data read OK.")
return data
except Exception as ex:
self.err_msg = "Issue reading data file: {}".format(ex)
class_logger.error(self.err_msg)
return False
def check_snapshot_exists(self):
"""
Check snapshot file exists on local file system, create if not
"""
if os.path.exists(self.local_file):
return True
return False
def get_hostname(self):
# get hostname
return socket.gethostname()
def get_uptime(self, format="string"):
seconds = time.time() - psutil.boot_time()
if format == "raw":
return seconds
min, sec = divmod(seconds, 60)
hour, min = divmod(min, 60)
day, hour = divmod(hour, 24)
return "%d days %d:%02d:%02d" % (day, hour, min, sec)
def get_interface_details(self):
interfaces = ni.interfaces()
AF_INET = 2
interface_data = {}
for interface in interfaces:
# ignore loopback
if interface == 'lo':
continue
# check if interface has IP address
interface_details = ni.ifaddresses(interface)
if AF_INET in interface_details.keys():
address = interface_details[AF_INET][0]['addr']
interface_data[interface] = address
return interface_data
def init_snapshot(self):
"""
Create snapshot file from scratch
"""
interface_data = self.get_interface_details()
hostname = self.get_hostname()
self.data = {
'interfaces': interface_data,
'hostname': hostname,
}
return self.data
def node_status(self):
unit_status = ''
# check if snapshot exists, create if not
class_logger.debug("Checking if we already have a status snapshot...")
if self.check_snapshot_exists():
class_logger.debug("Snapshot exists, create new one and compare to original (any diff)?")
# snapshot exists - compare existing snapshot with new snapshot
if self.read_data() == self.init_snapshot():
class_logger.debug("Snapshots match, no changes detected.")
# nothing has changed, nothing to report
return False
else:
# something has changed with the config, set status
class_logger.debug("Snapshots do not match...config change detected")
self.write_data()
unit_status = "Config change"
else:
# unit must have freshly booted, create snapshot &
# set status to rebooted
class_logger.debug("Boot detected...create snapshot")
self.init_snapshot()
self.write_data()
unit_status = "Rebooted"
if self.get_uptime(format="raw") > 120:
unit_status = "Running"
class_logger.debug("Create status data...")
# get hostname
hostname = self.data['hostname']
# get uptime
uptime = self.get_uptime()
# Figure out the interface addresses:
interfaces = self.data['interfaces']
ip_addresses = []
for name, ip in interfaces.items():
# ignore loopback interface
if name == 'lo':
continue
ip_addresses.append(f" {name}: {ip}")
# Construct message to send
now = time.ctime()
messages = [
f"Time: {now}",
f"Hostname: {hostname}",
f"Uptime: {uptime}",
f"Unit status: {unit_status}",
'\nInterfaces: '] + ip_addresses
return messages
| [
"logging.basicConfig",
"os.path.exists",
"logging.getLogger",
"time.ctime",
"netifaces.ifaddresses",
"psutil.boot_time",
"time.time",
"json.load",
"netifaces.interfaces",
"socket.gethostname",
"json.dump"
] | [((310, 349), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (329, 349), False, 'import logging\n'), ((365, 398), 'logging.getLogger', 'logging.getLogger', (['"""DataSnapshot"""'], {}), "('DataSnapshot')\n", (382, 398), False, 'import logging\n'), ((1889, 1920), 'os.path.exists', 'os.path.exists', (['self.local_file'], {}), '(self.local_file)\n', (1903, 1920), False, 'import os\n'), ((2048, 2068), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (2066, 2068), False, 'import socket\n'), ((2472, 2487), 'netifaces.interfaces', 'ni.interfaces', ([], {}), '()\n', (2485, 2487), True, 'import netifaces as ni\n'), ((5104, 5116), 'time.ctime', 'time.ctime', ([], {}), '()\n', (5114, 5116), False, 'import time\n'), ((2135, 2146), 'time.time', 'time.time', ([], {}), '()\n', (2144, 2146), False, 'import time\n'), ((2149, 2167), 'psutil.boot_time', 'psutil.boot_time', ([], {}), '()\n', (2165, 2167), False, 'import psutil\n'), ((2745, 2770), 'netifaces.ifaddresses', 'ni.ifaddresses', (['interface'], {}), '(interface)\n', (2759, 2770), True, 'import netifaces as ni\n'), ((957, 990), 'json.dump', 'json.dump', (['self.data', 'f'], {'indent': '(4)'}), '(self.data, f, indent=4)\n', (966, 990), False, 'import json\n'), ((1488, 1500), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1497, 1500), False, 'import json\n')] |
"""
開発初期段階では、サイトレポートをVIEWに直書きしていた
パフォーマンス改善のため、バッチ処理に変更
このVIEWは今は使われていないが、一応残しておく
"""
from django.conf import settings
from django.db.models import Q, Count
from django.utils import html
from .models import Post, Category, Tag
from datetime import datetime
from janome.tokenizer import Tokenizer
from janome.analyzer import Analyzer
from janome.charfilter import *
from janome.tokenfilter import *
import itertools
""" データ可視化 """
def statistics(request):
label = 'データ可視化'
"""
基本のクエリセット
"""
""" queryset | 公開されている記事一覧 """
published_post = Post.objects.select_related('category').prefetch_related('tag').filter(is_public=True).order_by('published_at', 'created_at', 'updated_at')
""" queryset | （紐づく記事が）公開されているカテゴリ一覧 """
published_category = Category.objects.filter(post__is_public=True).order_by('index')
""" queryset | （紐づく記事が）公開されているタグ一覧 """
published_tag = Tag.objects.filter(post__is_public=True).order_by('name')
"""
カテゴリを基準とした集計
"""
""" list | カテゴリ一覧からカテゴリ名のリストを作る """
category_list = list(published_category.distinct().values_list('name', flat=True))
""" list | カテゴリ一覧からカテゴリ別記事数のリストを作る """
category_post_list = list(published_category.annotate(count=Count('post')).values_list('count', flat=True))
""" list | カテゴリ一覧からカテゴリ別タグ数のリストを作る """
category_tag_list = list(published_category.annotate(count=Count('tag', filter=Q(tag__post__is_public=True), distinct=True)).values_list('count', flat=True))
""" dict | カテゴリ別記事数の辞書を作る """
category_post_dict = dict(zip(category_list, category_post_list))
""" dict | カテゴリ別タグ数の辞書を作る """
category_tag_dict = dict(zip(category_list, category_tag_list))
"""
タグを基準とした集計
"""
""" list | タグ一覧からタグ名のリストを作る """
tag_list = list(published_tag.distinct().values_list('name', flat=True))
""" list | タグ一覧からタグ別記事数のリストを作る """
tag_post_list = list(published_tag.annotate(count=Count('post')).values_list('count', flat=True))
""" dict | タグ別記事数の辞書を作る 順番は記事数降順にする """
tag_post_dict = dict(zip(tag_list, tag_post_list))
tag_post_dict = sorted(tag_post_dict.items(), reverse=True, key=lambda x:x[1])
tag_post_dict = dict(tag_post_dict)
""" タグが多すぎる場合の「その他」化 """
tag_post_dict_length = len(tag_post_dict)
display_length = 20
enable_length = display_length - 1
if enable_length < 0:
enable_length = 0
if tag_post_dict_length > enable_length:
dif_length = tag_post_dict_length - enable_length
if dif_length != 1:
key_list = list(tag_post_dict.keys())[:enable_length]
value_list = list(tag_post_dict.values())[:enable_length]
others_value = sum(list(tag_post_dict.values())[-dif_length:])
tag_post_dict = dict(zip(key_list, value_list))
tag_post_dict['その他'] = others_value
"""
投稿年月を基準とした集計
"""
""" list | 投稿年月リストを作る """
month_list = sorted(list(set(map(lambda date: date.strftime('%Y-%m'), list(published_post.values_list('published_at', flat=True))))))
""" list | 年月リスト、カテゴリリスト、記事数リストを各々作る """
""" warn | ループでSQLが多重発行されるため、より良い方法の模索が必要 """
list1, list2, list3 = [], [], []
for date, category in itertools.product(month_list, category_list):
yyyy, mm = date.split('-')
month_post_count = published_post.filter(published_at__year=yyyy, published_at__month=mm).filter(category__name=category).annotate(count=Count('pk')).count()
list1.append(date)
list2.append(category)
list3.append(month_post_count)
""" list | 年月リスト、カテゴリリスト、記事数リストを一つのリストにまとめる """
month_post_list = list(set(zip(list1, list2, list3)))
"""
ワードクラウドのための形態素解析 前処理
"""
""" 直近のタイトルと説明とテキスト本文を抽出しクレンジング """
post_count = 30
post_titles = list(published_post.values_list('title', flat=True))[:post_count]
post_titles = ' '.join(post_titles).split()
post_descriptions = list(published_post.values_list('description', flat=True))[:post_count]
post_descriptions = ' '.join(post_descriptions).split()
post_texts = list(map(lambda lfc: lfc.replace('\r\n', '\n').replace('\r', '\n').replace('\n', ' '), list(published_post.values_list('text', flat=True))))[:post_count]
post_texts = html.strip_tags(''.join(post_texts)).split()
tokens = ' '.join(post_descriptions + post_titles + post_texts)
"""
janome 形態素解析でワードクラウド生成用の辞書を作る
"""
""" 形態素解析のためのアナライザを定義 """
udic_path = settings.JANOME_DICTIONARY_PATH
char_filters = [UnicodeNormalizeCharFilter(), RegexReplaceCharFilter('\,', '')]
tokenizer = Tokenizer(udic=udic_path, udic_type='simpledic', udic_enc='utf8')
token_filters = [CompoundNounFilter(), POSKeepFilter(['名詞']), LowerCaseFilter(), TokenCountFilter()]
analyzer = Analyzer(char_filters, tokenizer, token_filters)
""" dict | 単語リストから辞書を作る """
word_dict = dict(analyzer.analyze(tokens))
""" レンダリング """
return render(request, 'blog/blog_single_report.html', {
'label': label,
'category_list': category_list,
'category_post_dict': category_post_dict,
'category_tag_dict': category_tag_dict,
'tag_post_dict': tag_post_dict,
'month_list': month_list,
'month_post_list': month_post_list,
'word_dict': word_dict,
}) | [
"janome.analyzer.Analyzer",
"django.db.models.Count",
"itertools.product",
"janome.tokenizer.Tokenizer",
"django.db.models.Q"
] | [((3315, 3359), 'itertools.product', 'itertools.product', (['month_list', 'category_list'], {}), '(month_list, category_list)\n', (3332, 3359), False, 'import itertools\n'), ((4727, 4792), 'janome.tokenizer.Tokenizer', 'Tokenizer', ([], {'udic': 'udic_path', 'udic_type': '"""simpledic"""', 'udic_enc': '"""utf8"""'}), "(udic=udic_path, udic_type='simpledic', udic_enc='utf8')\n", (4736, 4792), False, 'from janome.tokenizer import Tokenizer\n'), ((4915, 4963), 'janome.analyzer.Analyzer', 'Analyzer', (['char_filters', 'tokenizer', 'token_filters'], {}), '(char_filters, tokenizer, token_filters)\n', (4923, 4963), False, 'from janome.analyzer import Analyzer\n'), ((1275, 1288), 'django.db.models.Count', 'Count', (['"""post"""'], {}), "('post')\n", (1280, 1288), False, 'from django.db.models import Q, Count\n'), ((2004, 2017), 'django.db.models.Count', 'Count', (['"""post"""'], {}), "('post')\n", (2009, 2017), False, 'from django.db.models import Q, Count\n'), ((3543, 3554), 'django.db.models.Count', 'Count', (['"""pk"""'], {}), "('pk')\n", (3548, 3554), False, 'from django.db.models import Q, Count\n'), ((1453, 1481), 'django.db.models.Q', 'Q', ([], {'tag__post__is_public': '(True)'}), '(tag__post__is_public=True)\n', (1454, 1481), False, 'from django.db.models import Q, Count\n')] |
import os
def check(cmd, mf):
m = mf.findNode('matplotlib')
if m is None or m.filename is None:
return None
if cmd.matplotlib_backends:
backends = {}
for backend in cmd.matplotlib_backends:
if backend == '-':
pass
elif backend == '*':
mf.import_hook('matplotlib.backends', m, ['*'])
else:
mf.import_hook('matplotlib.backends.backend_%s' % (
backend,), m)
else:
backends = {'packages': ['matplotlib']}
return dict(
prescripts=['py2app.recipes.matplotlib_prescript'],
resources=[os.path.join(os.path.dirname(m.filename), 'mpl-data')],
**backends
)
| [
"os.path.dirname"
] | [((669, 696), 'os.path.dirname', 'os.path.dirname', (['m.filename'], {}), '(m.filename)\n', (684, 696), False, 'import os\n')] |
# Generated by Django 3.1.6 on 2021-02-14 18:13
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0008_auto_20210214_2039'),
]
operations = [
migrations.AlterField(
model_name='device',
name='ip_address',
field=models.GenericIPAddressField(blank=True, help_text='e.g. 192.168.0.17', null=True, verbose_name='IP address'),
),
migrations.AlterField(
model_name='device',
name='mac_address',
field=models.CharField(blank=True, help_text='e.g. A1:B2:C3:D4:5E:6F', max_length=100, null=True, verbose_name='MAC address'),
),
]
| [
"django.db.models.GenericIPAddressField",
"django.db.models.CharField"
] | [((337, 450), 'django.db.models.GenericIPAddressField', 'models.GenericIPAddressField', ([], {'blank': '(True)', 'help_text': '"""e.g. 192.168.0.17"""', 'null': '(True)', 'verbose_name': '"""IP address"""'}), "(blank=True, help_text='e.g. 192.168.0.17',\n null=True, verbose_name='IP address')\n", (365, 450), False, 'from django.db import migrations, models\n'), ((573, 697), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'help_text': '"""e.g. A1:B2:C3:D4:5E:6F"""', 'max_length': '(100)', 'null': '(True)', 'verbose_name': '"""MAC address"""'}), "(blank=True, help_text='e.g. A1:B2:C3:D4:5E:6F', max_length\n =100, null=True, verbose_name='MAC address')\n", (589, 697), False, 'from django.db import migrations, models\n')] |
import requests
import re
pattern_hashes = "^[a-f0-9]{64}$"
pattern_url = "https?:\/\/.*"
pattern_ip = "(?:(?:\d|[01]?\d\d|2[0-4]\d|25[0-5])\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d|\d)(?:\/\d{1,2})?"
pattern_domain = "^[a-zA-Z0-9][a-zA-Z0-9-_]{0,61}[a-zA-Z0-9]{0,1}\.([a-zA-Z]{1,6}|[a-zA-Z0-9-]{1,30}\.[a-zA-Z]{2,3})$"
headers = {
'Accept': 'application/json'
}
r = requests.get('https://labs.inquest.net/api/iocdb/list', headers = headers)
j = r.json()
def ioc_grabber(fileHandle, pattern, data, notUseRegular=False):
if notUseRegular:
writerHandle(fileHandle, data)
return
sections = re.findall(pattern, data, re.DOTALL)
if any(isinstance(e, str) and len(e) > 0 for e in sections):
writerHandle(fileHandle, "\n".join(sections))
def writerHandle(fileHandle, data):
fileHandle.write(data)
fileHandle.write('\n')
with open("links.txt", "a") as links:
with open("hashes.txt", "a") as ioc_hash:
with open("urls.txt", "a") as ioc_url:
with open("ip.txt", "a") as ioc_ip:
with open("domains.txt", "a") as ioc_domain:
for each in (j['data']):
ioc_grabber(links, None, each['reference_link'], True)
ioc_grabber(ioc_hash, pattern_hashes, each['artifact'])
ioc_grabber(ioc_url, pattern_url, each['artifact'])
ioc_grabber(ioc_ip, pattern_ip, each['artifact'])
ioc_grabber(ioc_domain, pattern_domain, each['artifact'])
ioc_domain.close()
ioc_ip.close()
ioc_url.close()
ioc_hash.close()
links.close()
| [
"re.findall",
"requests.get"
] | [((366, 438), 'requests.get', 'requests.get', (['"""https://labs.inquest.net/api/iocdb/list"""'], {'headers': 'headers'}), "('https://labs.inquest.net/api/iocdb/list', headers=headers)\n", (378, 438), False, 'import requests\n'), ((604, 640), 're.findall', 're.findall', (['pattern', 'data', 're.DOTALL'], {}), '(pattern, data, re.DOTALL)\n', (614, 640), False, 'import re\n')] |
# coding: utf-8
import wx
import wx.lib.sized_controls as sc
from dataclasses import dataclass
from functools import partial
from wx.adv import CommandLinkButton
from bookworm import app
from bookworm import config
from bookworm import typehints as t
from bookworm.i18n import LocaleInfo
from bookworm.concurrency import threaded_worker
from bookworm.gui.settings import SettingsPanel, ReconciliationStrategies
from bookworm.gui.components import (
make_sized_static_box,
SimpleDialog,
RobustProgressDialog,
SnakDialog,
AsyncSnakDialog,
ImmutableObjectListView,
ColumnDefn,
)
from bookworm.utils import restart_application
from bookworm.logger import logger
from bookworm.platform_services._win32 import tesseract_download
from bookworm.ocr_engines.tesseract_ocr_engine import TesseractOcrEngine
from bookworm.ocr_engines.image_processing_pipelines import (
ImageProcessingPipeline,
DebugProcessingPipeline,
DPIProcessingPipeline,
ThresholdProcessingPipeline,
BlurProcessingPipeline,
TwoInOneScanProcessingPipeline,
DeskewProcessingPipeline,
InvertColourProcessingPipeline,
ErosionProcessingPipeline,
DilationProcessingPipeline,
ConcatImagesProcessingPipeline,
SharpenColourProcessingPipeline,
)
log = logger.getChild(__name__)
@dataclass
class OcrOptions:
language: LocaleInfo
zoom_factor: float
_ipp_enabled: int
image_processing_pipelines: t.Tuple[ImageProcessingPipeline]
store_options: bool
class OcrPanel(SettingsPanel):
config_section = "ocr"
def addControls(self):
self._service = wx.GetApp().service_handler.get_service("ocr")
self._engines = self._service._available_ocr_engines
_engines_display = [_(e.display_name) for e in self._engines]
# Translators: the label of a group of controls in the reading page
generalOcrBox = self.make_static_box(_("OCR Options"))
self.ocrEngine = wx.RadioBox(
generalOcrBox,
-1,
# Translators: the title of a group of radio buttons in the OCR page
# in the application settings.
_("Default OCR Engine"),
majorDimension=1,
style=wx.RA_SPECIFY_COLS,
choices=_engines_display,
)
# Translators: the label of a group of controls in the OCR page
# of the settings related to Tesseract OCR engine
tessBox = self.make_static_box(_("Tesseract OCR Engine"))
if not tesseract_download.is_tesseract_available():
tessEngineDlBtn = CommandLinkButton(
tessBox,
-1,
_("Download Tesseract OCR Engine"),
_(
"Get a free, high-quality OCR engine that supports over 100 languages."
),
)
self.Bind(wx.EVT_BUTTON, self.onDownloadTesseractEngine, tessEngineDlBtn)
else:
tessLangDlBtn = CommandLinkButton(
tessBox,
-1,
_("Manage Tesseract OCR Languages"),
_("Add support for new languages, and /or remove installed languages."),
)
self.Bind(wx.EVT_BUTTON, self.onDownloadTesseractLanguages, tessLangDlBtn)
# Translators: the label of a group of controls in the reading page
# of the settings related to image enhancement
miscBox = self.make_static_box(_("Image processing"))
wx.CheckBox(
miscBox,
-1,
# Translators: the label of a checkbox
_("Enable default image enhancement filters"),
name="ocr.enhance_images",
)
def reconcile(self, strategy=ReconciliationStrategies.load):
if strategy is ReconciliationStrategies.load:
self.ocrEngine.SetSelection(
self._engines.index(self._service.get_first_available_ocr_engine())
)
elif strategy is ReconciliationStrategies.save:
selected_engine = self._engines[self.ocrEngine.GetSelection()]
if self.config["engine"] != selected_engine.name:
self.config["engine"] = selected_engine.name
self._service._init_ocr_engine()
super().reconcile(strategy=strategy)
if strategy is ReconciliationStrategies.save:
self._service._init_ocr_engine()
def onDownloadTesseractEngine(self, event):
AsyncSnakDialog(
task=tesseract_download.get_tesseract_download_info,
done_callback=self._on_tesseract_download_info,
message=_("Retrieving download info, please wait..."),
parent=self,
)
def onDownloadTesseractLanguages(self, event):
TesseractLanguageManager(
title=_("Manage Tesseract OCR Engine Languages"), parent=self
).ShowModal()
def _on_tesseract_download_info(self, future):
if (
info := tesseract_download.get_tesseract_download_info_from_future(
future, self
)
) is None:
return
dl_url = info.get_engine_download_url()
progress_dlg = RobustProgressDialog(
self,
# Translators: title of a progress dialog
_("Downloading Tesseract OCR Engine"),
# Translators: message of a progress dialog
_("Getting download information..."),
maxvalue=100,
can_abort=True,
)
threaded_worker.submit(
tesseract_download.download_tesseract_engine, dl_url, progress_dlg
).add_done_callback(partial(self._after_tesseract_install, progress_dlg))
def _after_tesseract_install(self, progress_dlg, future):
progress_dlg.Dismiss()
if future.result() is True:
wx.GetApp().mainFrame.notify_user(
_("Restart Required"),
_(
"Bookworm will now restart to complete the installation of the Tesseract OCR Engine."
),
)
wx.CallAfter(restart_application)
class OCROptionsDialog(SimpleDialog):
"""OCR options."""
def __init__(
self, *args, stored_options=None, languages=(), force_save=False, **kwargs
):
self.stored_options = stored_options
self.languages = languages
self.force_save = force_save
self._return_value = None
self.image_processing_pipelines = []
self.stored_ipp = (
()
if self.stored_options is None
else self.stored_options.image_processing_pipelines
)
super().__init__(*args, **kwargs)
def addControls(self, parent):
# Translators: the label of a combobox
label = wx.StaticText(parent, -1, _("Recognition Language:"))
self.langChoice = wx.Choice(
parent, -1, choices=[l.description for l in self.languages]
)
self.langChoice.SetSizerProps(expand=True)
wx.StaticText(parent, -1, _("Supplied Image resolution::"))
self.zoomFactorSlider = wx.Slider(parent, -1, minValue=0, maxValue=10)
# Translators: the label of a checkbox
self.should_enhance_images = wx.CheckBox(
parent, -1, _("Enable image enhancements")
)
ippPanel = sc.SizedPanel(parent)
# Translators: the label of a checkbox
imgProcBox = make_sized_static_box(
ippPanel, _("Available image pre-processing filters:")
)
for (ipp_cls, lbl, should_enable) in self.get_image_processing_pipelines_info():
chbx = wx.CheckBox(imgProcBox, -1, lbl)
if self.stored_options is not None:
chbx.SetValue(ipp_cls in self.stored_ipp)
else:
chbx.SetValue(should_enable)
self.image_processing_pipelines.append((chbx, ipp_cls))
wx.StaticLine(parent)
if not self.force_save:
self.storeOptionsCheckbox = wx.CheckBox(
parent,
-1,
# Translators: the label of a checkbox
_("&Save these options until I close the current book"),
)
self.Bind(wx.EVT_BUTTON, self.onOK, id=wx.ID_OK)
if self.stored_options is None:
self.langChoice.SetSelection(0)
self.zoomFactorSlider.SetValue(2)
self.should_enhance_images.SetValue(config.conf["ocr"]["enhance_images"])
else:
self.langChoice.SetSelection(
self.languages.index(self.stored_options.language)
)
self.zoomFactorSlider.SetValue(self.stored_options.zoom_factor)
self.should_enhance_images.SetValue(self.stored_options._ipp_enabled)
if not self.force_save:
self.storeOptionsCheckbox.SetValue(self.stored_options.store_options)
enable_or_disable_image_pipelines = lambda: ippPanel.Enable(
self.should_enhance_images.IsChecked()
)
self.Bind(
wx.EVT_CHECKBOX,
lambda e: enable_or_disable_image_pipelines(),
self.should_enhance_images,
)
enable_or_disable_image_pipelines()
def onOK(self, event):
if not self.should_enhance_images.IsChecked():
selected_image_pp = []
else:
selected_image_pp = [
ipp_cls
for c, ipp_cls in self.image_processing_pipelines
if c.IsChecked()
]
self._return_value = OcrOptions(
language=self.languages[self.langChoice.GetSelection()],
zoom_factor=self.zoomFactorSlider.GetValue() or 1,
_ipp_enabled=self.should_enhance_images.IsChecked(),
image_processing_pipelines=selected_image_pp,
store_options=self.force_save or self.storeOptionsCheckbox.IsChecked(),
)
self.Close()
def ShowModal(self):
super().ShowModal()
return self._return_value
def get_image_processing_pipelines_info(self):
ipp = [
(DPIProcessingPipeline, _("Increase image resolution"), True),
(ThresholdProcessingPipeline, _("Binarization"), True),
(
TwoInOneScanProcessingPipeline,
_("Split two-in-one scans to individual pages"),
False,
),
(ConcatImagesProcessingPipeline, _("Combine images"), False),
(BlurProcessingPipeline, _("Blurring"), False),
(DeskewProcessingPipeline, _("Deskewing"), False),
(ErosionProcessingPipeline, _("Erosion"), False),
(DilationProcessingPipeline, _("Dilation"), False),
(SharpenColourProcessingPipeline, _("Sharpen image"), False),
(InvertColourProcessingPipeline, _("Invert colors"), False),
]
if app.debug:
ipp.append((DebugProcessingPipeline, _("Debug"), False))
return ipp
class TesseractLanguageManager(SimpleDialog):
"""
A dialog to manage the languages for the managed
version of Tesseract OCR Engine on Windows.
"""
def __init__(self, *args, **kwargs):
self.online_languages = ()
super().__init__(*args, **kwargs)
self.SetSize((600, -1))
self.CenterOnScreen()
def addControls(self, parent):
# Translators: label of a list control containing bookmarks
wx.StaticText(parent, -1, _("Tesseract Languages"))
listPanel = sc.SizedPanel(parent)
listPanel.SetSizerType("horizontal")
listPanel.SetSizerProps(expand=True, align="center")
self.tesseractLanguageList = ImmutableObjectListView(
listPanel, wx.ID_ANY, style=wx.LC_REPORT | wx.SUNKEN_BORDER, size=(500, -1)
)
self.btnPanel = btnPanel = sc.SizedPanel(parent, -1)
btnPanel.SetSizerType("horizontal")
btnPanel.SetSizerProps(expand=True)
# Translators: text of a button to add a language to Tesseract OCR Engine (best quality model)
self.addBestButton = wx.Button(btnPanel, wx.ID_ANY, _("Download &Best Model"))
# Translators: text of a button to add a language to Tesseract OCR Engine (fastest model)
self.addFastButton = wx.Button(btnPanel, wx.ID_ANY, _("Download &Fast Model"))
# Translators: text of a button to remove a language from Tesseract OCR Engine
self.removeButton = wx.Button(btnPanel, wx.ID_REMOVE, _("&Remove"))
self.Bind(wx.EVT_BUTTON, self.onAdd, self.addFastButton)
self.Bind(wx.EVT_BUTTON, self.onAdd, self.addBestButton)
self.Bind(wx.EVT_BUTTON, self.onRemove, id=wx.ID_REMOVE)
self.Bind(
wx.EVT_LIST_ITEM_FOCUSED,
self.onListFocusChanged,
self.tesseractLanguageList,
)
AsyncSnakDialog(
task=tesseract_download.get_tesseract_download_info,
done_callback=self._on_tesseract_dl_info,
message=_("Getting download information, please wait..."),
parent=self,
)
def getButtons(self, parent):
btnsizer = wx.StdDialogButtonSizer()
# Translators: the label of a button to close a dialog
btnsizer.AddButton(wx.Button(self, wx.ID_CANCEL, _("&Close")))
btnsizer.Realize()
return btnsizer
def _on_tesseract_dl_info(self, future):
if (
info := tesseract_download.get_tesseract_download_info_from_future(
future, self
)
) is None:
return
self.online_languages = info.languages
self.populate_list()
def populate_list(self):
language_identifiers = set(
(True, lang.given_locale_name)
for lang in TesseractOcrEngine.get_recognition_languages()
)
_installed_langs = {lang[1].lower() for lang in language_identifiers}
language_identifiers.update(
(False, lang)
for lang in self.online_languages
if lang.lower() not in _installed_langs
)
languages = [
(
lang[0],
LocaleInfo.from_three_letter_code(lang[1]),
)
for lang in sorted(language_identifiers, key=lambda l: l, reverse=True)
]
column_defn = [
ColumnDefn(
# Translators: the title of a column in the Tesseract language list
_("Language"),
"left",
450,
lambda lang: lang[1].description,
),
ColumnDefn(
# Translators: the title of a column in the Tesseract language list
_("Installed"),
"center",
100,
lambda lang: _("Yes") if lang[0] else _("No"),
),
]
self.tesseractLanguageList.set_columns(column_defn)
self.tesseractLanguageList.set_objects(languages, focus_item=0)
# Maintain the state of the list
if not any(languages):
self.addBestButton.Enable(False)
self.addFastButton.Enable(False)
self.removeButton.Enable(False)
self.btnPanel.Enable(False)
def onAdd(self, event):
if (selected := self.tesseractLanguageList.get_selected()) is None:
return
lang = selected[1]
variant = "best" if event.GetEventObject() == self.addBestButton else "fast"
AsyncSnakDialog(
task=tesseract_download.get_tesseract_download_info,
done_callback=partial(
self._on_download_language, lang.given_locale_name, variant
),
message=_("Getting download information, please wait..."),
parent=self,
)
def onRemove(self, event):
if (selected := self.tesseractLanguageList.get_selected()) is None:
return
lang = selected[1]
msg = wx.MessageBox(
# Translators: content of a messagebox
_("Are you sure you want to remove language:\n{lang}?").format(
lang=lang.description
),
# Translators: title of a messagebox
_("Confirm"),
style=wx.YES_NO | wx.ICON_WARNING,
)
if msg == wx.NO:
return
try:
tesseract_download.get_language_path(lang.given_locale_name).unlink()
self.populate_list()
except:
log.exception(f"Could not remove language {lang}", exc_info=True)
def onListFocusChanged(self, event):
if (selected := self.tesseractLanguageList.get_selected()) is not None:
is_installed = selected[0]
self.addBestButton.Enable(not is_installed)
self.addFastButton.Enable(not is_installed)
self.removeButton.Enable(is_installed)
def _on_download_language(self, lang_name, variant, future):
if (
info := tesseract_download.get_tesseract_download_info_from_future(
future, self
)
) is None:
return
if lang_name not in info.languages:
log.debug(f"Could not find download info for language {lang_name}")
return
target_file = tesseract_download.get_language_path(lang_name)
if target_file.exists():
msg = wx.MessageBox(
# Translators: content of a messagebox
_(
"A version of the selected language model already exists.\n"
"Are you sure you want to replace it."
),
# Translators: title of a messagebox
_("Confirm"),
style=wx.YES_NO | wx.ICON_WARNING,
parent=self,
)
if msg == wx.NO:
return
try:
target_file.unlink(missing_ok=True)
except:
return
progress_dlg = RobustProgressDialog(
wx.GetApp().mainFrame,
# Translators: title of a progress dialog
_("Downloading Language"),
# Translators: content of a progress dialog
_("Getting download information..."),
maxvalue=100,
can_hide=True,
can_abort=True,
)
url = info.get_language_download_url(lang_name, variant=variant)
threaded_worker.submit(
tesseract_download.download_language, url, target_file, progress_dlg
).add_done_callback(
lambda future: wx.CallAfter(
self._after_download_language, progress_dlg, future
)
)
def _after_download_language(self, progress_dlg, future):
progress_dlg.Dismiss()
try:
if future.result():
wx.GetApp().mainFrame.notify_user(
# Translators: title of a messagebox
_("Language Added"),
_("The Language Model was downloaded successfully."),
parent=self,
)
self.populate_list()
except ConnectionError:
log.exception("Failed to download language data from {url}", exc_info=True)
wx.GetApp().mainFrame.notify_user(
# Translators: title of a messagebox
_("Connection Error"),
# Translators: content of a messagebox
_(
"Failed to download language data.\nPlease check your internet connection."
),
icon=wx.ICON_ERROR,
)
except:
log.exception("Failed to install language data from {url}", exc_info=True)
wx.GetApp().mainFrame.notify_user(
# Translators: title of a messagebox
_("Error"),
# Translators: content of a messagebox
_("Failed to install language data.\nPlease try again later."),
icon=wx.ICON_ERROR,
parent=self,
)
| [
"bookworm.gui.components.ImmutableObjectListView",
"bookworm.ocr_engines.tesseract_ocr_engine.TesseractOcrEngine.get_recognition_languages",
"bookworm.i18n.LocaleInfo.from_three_letter_code",
"wx.StdDialogButtonSizer",
"wx.GetApp",
"bookworm.logger.logger.getChild",
"bookworm.platform_services._win32.te... | [((1281, 1306), 'bookworm.logger.logger.getChild', 'logger.getChild', (['__name__'], {}), '(__name__)\n', (1296, 1306), False, 'from bookworm.logger import logger\n'), ((6838, 6908), 'wx.Choice', 'wx.Choice', (['parent', '(-1)'], {'choices': '[l.description for l in self.languages]'}), '(parent, -1, choices=[l.description for l in self.languages])\n', (6847, 6908), False, 'import wx\n'), ((7082, 7128), 'wx.Slider', 'wx.Slider', (['parent', '(-1)'], {'minValue': '(0)', 'maxValue': '(10)'}), '(parent, -1, minValue=0, maxValue=10)\n', (7091, 7128), False, 'import wx\n'), ((7310, 7331), 'wx.lib.sized_controls.SizedPanel', 'sc.SizedPanel', (['parent'], {}), '(parent)\n', (7323, 7331), True, 'import wx.lib.sized_controls as sc\n'), ((7886, 7907), 'wx.StaticLine', 'wx.StaticLine', (['parent'], {}), '(parent)\n', (7899, 7907), False, 'import wx\n'), ((11498, 11519), 'wx.lib.sized_controls.SizedPanel', 'sc.SizedPanel', (['parent'], {}), '(parent)\n', (11511, 11519), True, 'import wx.lib.sized_controls as sc\n'), ((11663, 11768), 'bookworm.gui.components.ImmutableObjectListView', 'ImmutableObjectListView', (['listPanel', 'wx.ID_ANY'], {'style': '(wx.LC_REPORT | wx.SUNKEN_BORDER)', 'size': '(500, -1)'}), '(listPanel, wx.ID_ANY, style=wx.LC_REPORT | wx.\n SUNKEN_BORDER, size=(500, -1))\n', (11686, 11768), False, 'from bookworm.gui.components import make_sized_static_box, SimpleDialog, RobustProgressDialog, SnakDialog, AsyncSnakDialog, ImmutableObjectListView, ColumnDefn\n'), ((11821, 11846), 'wx.lib.sized_controls.SizedPanel', 'sc.SizedPanel', (['parent', '(-1)'], {}), '(parent, -1)\n', (11834, 11846), True, 'import wx.lib.sized_controls as sc\n'), ((13116, 13141), 'wx.StdDialogButtonSizer', 'wx.StdDialogButtonSizer', ([], {}), '()\n', (13139, 13141), False, 'import wx\n'), ((17265, 17312), 'bookworm.platform_services._win32.tesseract_download.get_language_path', 'tesseract_download.get_language_path', (['lang_name'], {}), '(lang_name)\n', (17301, 17312), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((2495, 2538), 'bookworm.platform_services._win32.tesseract_download.is_tesseract_available', 'tesseract_download.is_tesseract_available', ([], {}), '()\n', (2536, 2538), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((5615, 5667), 'functools.partial', 'partial', (['self._after_tesseract_install', 'progress_dlg'], {}), '(self._after_tesseract_install, progress_dlg)\n', (5622, 5667), False, 'from functools import partial\n'), ((6055, 6088), 'wx.CallAfter', 'wx.CallAfter', (['restart_application'], {}), '(restart_application)\n', (6067, 6088), False, 'import wx\n'), ((7608, 7640), 'wx.CheckBox', 'wx.CheckBox', (['imgProcBox', '(-1)', 'lbl'], {}), '(imgProcBox, -1, lbl)\n', (7619, 7640), False, 'import wx\n'), ((4949, 5021), 'bookworm.platform_services._win32.tesseract_download.get_tesseract_download_info_from_future', 'tesseract_download.get_tesseract_download_info_from_future', (['future', 'self'], {}), '(future, self)\n', (5007, 5021), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((5484, 5578), 'bookworm.concurrency.threaded_worker.submit', 'threaded_worker.submit', (['tesseract_download.download_tesseract_engine', 'dl_url', 'progress_dlg'], {}), '(tesseract_download.download_tesseract_engine, dl_url,\n progress_dlg)\n', (5506, 5578), False, 'from bookworm.concurrency import threaded_worker\n'), ((13406, 13478), 'bookworm.platform_services._win32.tesseract_download.get_tesseract_download_info_from_future', 'tesseract_download.get_tesseract_download_info_from_future', (['future', 'self'], {}), '(future, self)\n', (13464, 13478), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((14139, 14181), 'bookworm.i18n.LocaleInfo.from_three_letter_code', 'LocaleInfo.from_three_letter_code', (['lang[1]'], {}), '(lang[1])\n', (14172, 14181), False, 'from bookworm.i18n import LocaleInfo\n'), ((15569, 15637), 'functools.partial', 'partial', (['self._on_download_language', 'lang.given_locale_name', 'variant'], {}), '(self._on_download_language, lang.given_locale_name, variant)\n', (15576, 15637), False, 'from functools import partial\n'), ((16959, 17031), 'bookworm.platform_services._win32.tesseract_download.get_tesseract_download_info_from_future', 'tesseract_download.get_tesseract_download_info_from_future', (['future', 'self'], {}), '(future, self)\n', (17017, 17031), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((17994, 18005), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (18003, 18005), False, 'import wx\n'), ((18388, 18484), 'bookworm.concurrency.threaded_worker.submit', 'threaded_worker.submit', (['tesseract_download.download_language', 'url', 'target_file', 'progress_dlg'], {}), '(tesseract_download.download_language, url,\n target_file, progress_dlg)\n', (18410, 18484), False, 'from bookworm.concurrency import threaded_worker\n'), ((18549, 18614), 'wx.CallAfter', 'wx.CallAfter', (['self._after_download_language', 'progress_dlg', 'future'], {}), '(self._after_download_language, progress_dlg, future)\n', (18561, 18614), False, 'import wx\n'), ((1609, 1620), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (1618, 1620), False, 'import wx\n'), ((13756, 13802), 'bookworm.ocr_engines.tesseract_ocr_engine.TesseractOcrEngine.get_recognition_languages', 'TesseractOcrEngine.get_recognition_languages', ([], {}), '()\n', (13800, 13802), False, 'from bookworm.ocr_engines.tesseract_ocr_engine import TesseractOcrEngine\n'), ((16339, 16399), 'bookworm.platform_services._win32.tesseract_download.get_language_path', 'tesseract_download.get_language_path', (['lang.given_locale_name'], {}), '(lang.given_locale_name)\n', (16375, 16399), False, 'from bookworm.platform_services._win32 import tesseract_download\n'), ((5811, 5822), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (5820, 5822), False, 'import wx\n'), ((18810, 18821), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (18819, 18821), False, 'import wx\n'), ((19237, 19248), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (19246, 19248), False, 'import wx\n'), ((19718, 19729), 'wx.GetApp', 'wx.GetApp', ([], {}), '()\n', (19727, 19729), False, 'import wx\n')] |
# Copyright (c) 2012 <NAME> <<EMAIL>>
#
# This is free software released under the MIT license.
# See COPYING file for details, or visit:
# http://www.opensource.org/licenses/mit-license.php
#
# The file is part of FSMonitor, a file-system monitoring library.
# https://github.com/shaurz/fsmonitor
import sys, os, time, threading, errno
from .common import FSEvent, FSMonitorError
def get_dir_contents(path):
return [(filename, os.stat(os.path.join(path, filename)))
for filename in os.listdir(path)]
class FSMonitorDirWatch(object):
def __init__(self, path, flags, user):
self.path = path
self.flags = flags
self.user = user
self.enabled = True
self._timestamp = time.time()
try:
self._contents = get_dir_contents(path)
self._deleted = False
except OSError as e:
self._contents = []
self._deleted = (e.errno == errno.ENOENT)
def __repr__(self):
return "<FSMonitorDirWatch %r>" % self.path
@classmethod
def new_state(cls, path):
return [(filename, os.stat(os.path.join(path, filename)))
for filename in os.listdir(path)]
def getstate(self):
return self._contents
def delstate(self):
self._contents = []
self._deleted = True
def setstate(self, state):
self._contents = state
self._deleted = False
state = property(getstate, setstate, delstate)
class FSMonitorFileWatch(object):
def __init__(self, path, flags, user):
self.path = path
self.flags = flags
self.user = user
self.enabled = True
self._timestamp = time.time()
try:
self._stat = os.stat(path)
self._deleted = False
except OSError as e:
self._stat = None
self._deleted = (e.errno == errno.ENOENT)
def __repr__(self):
return "<FSMonitorFileWatch %r>" % self.path
@classmethod
def new_state(cls, path):
return os.stat(path)
def getstate(self):
return self._stat
def delstate(self):
self._stat = None
self._deleted = True
def setstate(self, state):
self._stat = state
self._deleted = False
state = property(getstate, setstate, delstate)
class FSMonitorWatch(object):
def __init__(self, path, flags, user):
self.path = path
self.flags = flags
self.user = user
self.enabled = True
self._timestamp = time.time()
try:
self._contents = get_dir_contents(path)
self._deleted = False
except OSError as e:
self._contents = []
self._deleted = (e.errno == errno.ENOENT)
def __repr__(self):
return "<FSMonitorWatch %r>" % self.path
def _compare_contents(watch, new_contents, events_out, before):
name_to_new_stat = dict(new_contents)
for name, old_stat in watch._contents:
new_stat = name_to_new_stat.get(name)
if new_stat:
_compare_stat(watch, new_stat, events_out, before, old_stat, name)
else:
events_out.append(FSEvent(watch, FSEvent.Delete, name))
old_names = frozenset(x[0] for x in watch._contents)
for name, new_stat in new_contents:
if name not in old_names:
events_out.append(FSEvent(watch, FSEvent.Create, name))
def _compare_stat(watch, new_stat, events_out, before, old_stat, filename):
if new_stat.st_atime != old_stat.st_atime and new_stat.st_atime < before:
events_out.append(FSEvent(watch, FSEvent.Access, filename))
if new_stat.st_mtime != old_stat.st_mtime:
events_out.append(FSEvent(watch, FSEvent.Modify, filename))
def round_fs_resolution(t):
if sys.platform == "win32":
return t // 2 * 2
else:
return t // 1
class FSMonitor(object):
def __init__(self):
self.__lock = threading.Lock()
self.__dir_watches = set()
self.__file_watches = set()
self.polling_interval = 0.5
@property
def watches(self):
with self.__lock:
return list(self.__dir_watches) + list(self.__file_watches)
def add_dir_watch(self, path, flags=FSEvent.All, user=None):
watch = FSMonitorDirWatch(path, flags, user)
with self.__lock:
self.__dir_watches.add(watch)
return watch
def add_file_watch(self, path, flags=FSEvent.All, user=None):
watch = FSMonitorFileWatch(path, flags, user)
with self.__lock:
self.__file_watches.add(watch)
return watch
def remove_watch(self, watch):
with self.__lock:
if watch in self.__dir_watches:
self.__dir_watches.discard(watch)
elif watch in self.__file_watches:
self.__file_watches.discard(watch)
def remove_all_watches(self):
with self.__lock:
self.__dir_watches.clear()
self.__file_watches.clear()
def enable_watch(self, watch, enable=True):
watch.enabled = enable
def disable_watch(self, watch):
watch.enabled = False
def read_events(self, timeout=None):
now = start_time = time.time()
watches = self.watches
watches.sort(key=lambda watch: abs(now - watch._timestamp), reverse=True)
events = []
for watch in watches:
now = time.time()
if watch._timestamp < now:
tdiff = now - watch._timestamp
if tdiff < self.polling_interval:
time.sleep(self.polling_interval - tdiff)
watch._timestamp = now
if not watch.enabled:
continue
before = round_fs_resolution(time.time())
try:
new_state = watch.new_state(watch.path)
except OSError as e:
if e.errno == errno.ENOENT:
if not watch._deleted:
del watch.state
events.append(FSEvent(watch, FSEvent.DeleteSelf))
else:
if isinstance(watch, FSMonitorDirWatch):
_compare_contents(watch, new_state, events, before)
elif isinstance(watch, FSMonitorFileWatch):
_compare_stat(watch, new_state, events, before,
watch.state, watch.path)
watch.state = new_state
return events
| [
"os.listdir",
"threading.Lock",
"os.path.join",
"time.sleep",
"os.stat",
"time.time"
] | [((730, 741), 'time.time', 'time.time', ([], {}), '()\n', (739, 741), False, 'import sys, os, time, threading, errno\n'), ((1690, 1701), 'time.time', 'time.time', ([], {}), '()\n', (1699, 1701), False, 'import sys, os, time, threading, errno\n'), ((2042, 2055), 'os.stat', 'os.stat', (['path'], {}), '(path)\n', (2049, 2055), False, 'import sys, os, time, threading, errno\n'), ((2534, 2545), 'time.time', 'time.time', ([], {}), '()\n', (2543, 2545), False, 'import sys, os, time, threading, errno\n'), ((3948, 3964), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (3962, 3964), False, 'import sys, os, time, threading, errno\n'), ((5237, 5248), 'time.time', 'time.time', ([], {}), '()\n', (5246, 5248), False, 'import sys, os, time, threading, errno\n'), ((502, 518), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (512, 518), False, 'import sys, os, time, threading, errno\n'), ((1740, 1753), 'os.stat', 'os.stat', (['path'], {}), '(path)\n', (1747, 1753), False, 'import sys, os, time, threading, errno\n'), ((5431, 5442), 'time.time', 'time.time', ([], {}), '()\n', (5440, 5442), False, 'import sys, os, time, threading, errno\n'), ((443, 471), 'os.path.join', 'os.path.join', (['path', 'filename'], {}), '(path, filename)\n', (455, 471), False, 'import sys, os, time, threading, errno\n'), ((1179, 1195), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (1189, 1195), False, 'import sys, os, time, threading, errno\n'), ((5778, 5789), 'time.time', 'time.time', ([], {}), '()\n', (5787, 5789), False, 'import sys, os, time, threading, errno\n'), ((1116, 1144), 'os.path.join', 'os.path.join', (['path', 'filename'], {}), '(path, filename)\n', (1128, 1144), False, 'import sys, os, time, threading, errno\n'), ((5599, 5640), 'time.sleep', 'time.sleep', (['(self.polling_interval - tdiff)'], {}), '(self.polling_interval - tdiff)\n', (5609, 5640), False, 'import sys, os, time, threading, errno\n')] |
import math
import random
import string
from datetime import datetime, timedelta
from textwrap import dedent
import config
import discord
from discord.ext import commands
import asyncio
class etc(commands.Cog):
def __init__(self, bot):
self.bot = bot
@commands.command(name="clear")
async def _messages_clear(self, ctx):
def me(m):
return m.author == self.bot.user
await ctx.channel.purge(check=me)
await ctx.message.add_reaction("👌")
@commands.command(name="recent")
async def _recent_cases(self, ctx):
async with self.bot.pool.acquire() as conn:
cases = await conn.fetch("SELECT * FROM infractions WHERE guild = $1",ctx.guild.id)
case_list = ""
for x in cases:
case_list += f"**{x['real_id']}** | Serial: {x['id']} | {x['moderator']} | {x['target']} | {x['guild']} | {x['time_punished']} | {x['reason']}\n"
await ctx.send(case_list)
@commands.command(name="reason")
async def _update_reason(self,ctx,case,*,new_reason):
if case.lower() in ['|','^','%','&','/','?','recent','r','~','-']:
case = self.bot.cases[ctx.guild.id]
async with self.bot.pool.acquire() as conn:
fetch_case = await conn.fetchrow("SELECT * FROM infractions WHERE real_id = $1 AND guild = $2",int(case),ctx.guild.id)
if not fetch_case:
return await ctx.send(":wood: not a case.")
try:
await conn.execute("UPDATE infractions SET reason = $1 WHERE real_id = $2 AND guild = $3",new_reason,int(case),ctx.guild.id)
except Exception as err:
return await ctx.send(f"There was an error.\n```{err}```")
await ctx.send(":ok_hand:")
@commands.command(name="reset")
async def _reset_cases(self,ctx):
async with self.bot.pool.acquire() as conn:
try:
await conn.execute("DELETE FROM infractions WHERE guild = $1",ctx.guild.id)
del self.bot.cases[ctx.guild.id]
except Exception as err:
return await ctx.send(f"There was an error.\n```{err}```")
await ctx.send(":ok_hand:")
def setup(bot):
bot.add_cog(etc(bot))
| [
"discord.ext.commands.command"
] | [((273, 303), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""clear"""'}), "(name='clear')\n", (289, 303), False, 'from discord.ext import commands\n'), ((503, 534), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""recent"""'}), "(name='recent')\n", (519, 534), False, 'from discord.ext import commands\n'), ((1009, 1040), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""reason"""'}), "(name='reason')\n", (1025, 1040), False, 'from discord.ext import commands\n'), ((1828, 1858), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""reset"""'}), "(name='reset')\n", (1844, 1858), False, 'from discord.ext import commands\n')] |
# Copyright 2019 Xilinx Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import scipy.misc
import scipy.io
from matplotlib.patches import Rectangle
import datetime
import cv2
import sys
def nms(dets, thresh):
"""Pure Python NMS baseline."""
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
return keep
class Detect(object):
def __init__(self):
self.expand_scale_=0.0
self.force_gray_=False
self.input_mean_value_=128.0
self.input_scale_=1.0
self.pixel_blob_name_='pixel-loss'
self.bb_blob_name_='bb-output-tiled'
self.res_stride_=4
self.det_threshold_=0.7
self.nms_threshold_=0.3
self.caffe_path_=""
self.input_channels_=3
def model_init(self,caffe_python_path,model_path,def_path):
sys.path.insert(0,caffe_python_path)
import caffe
self.caffe_path_=caffe_python_path
self.net_=caffe.Net(def_path,model_path,caffe.TEST)
def detect(self,image):
#sys.path.insert(0,self.caffe_path_)
import caffe
#caffe.set_mode_cpu()
#caffe.set_device(0)
self.transformer_=caffe.io.Transformer({'data': (1,self.input_channels_,image.shape[0],image.shape[1])})
if self.force_gray_:
image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
self.input_channels_=1
else:
self.transformer_.set_transpose('data', (2,0,1))
transformed_image=self.transformer_.preprocess('data',image)
transformed_image=(transformed_image-self.input_mean_value_)*self.input_scale_
sz=image.shape
self.net_.blobs['data'].reshape(1, self.input_channels_, sz[0], sz[1])
self.net_.blobs['data'].data[0, ...] = transformed_image
output = self.net_.forward()
prob = output[self.pixel_blob_name_][0, 1, ...]
bb = output[self.bb_blob_name_][0, ...]
gy = np.arange(0, sz[0], self.res_stride_)
gx = np.arange(0, sz[1], self.res_stride_)
gy = gy[0 : bb.shape[1]]
gx = gx[0 : bb.shape[2]]
[x, y] = np.meshgrid(gx, gy)
#print bb.shape[1],len(gy),sz[0],sz[1]
bb[0, :, :] += x
bb[2, :, :] += x
bb[1, :, :] += y
bb[3, :, :] += y
bb = np.reshape(bb, (4, -1)).T
prob = np.reshape(prob, (-1, 1))
bb = bb[prob.ravel() > self.det_threshold_, :]
prob = prob[prob.ravel() > self.det_threshold_, :]
rects = np.hstack((bb, prob))
keep = nms(rects, self.nms_threshold_)
rects = rects[keep, :]
rects_expand=[]
for rect in rects:
rect_expand=[]
rect_w=rect[2]-rect[0]
rect_h=rect[3]-rect[1]
rect_expand.append(int(max(0,rect[0]-rect_w*self.expand_scale_)))
rect_expand.append(int(max(0,rect[1]-rect_h*self.expand_scale_)))
rect_expand.append(int(min(sz[1],rect[2]+rect_w*self.expand_scale_)))
rect_expand.append(int(min(sz[0],rect[3]+rect_h*self.expand_scale_)))
rects_expand.append(rect_expand)
return rects_expand
| [
"sys.path.insert",
"numpy.reshape",
"numpy.minimum",
"numpy.hstack",
"caffe.io.Transformer",
"numpy.where",
"cv2.cvtColor",
"caffe.Net",
"numpy.meshgrid",
"numpy.maximum",
"numpy.arange"
] | [((1052, 1084), 'numpy.maximum', 'np.maximum', (['x1[i]', 'x1[order[1:]]'], {}), '(x1[i], x1[order[1:]])\n', (1062, 1084), True, 'import numpy as np\n'), ((1099, 1131), 'numpy.maximum', 'np.maximum', (['y1[i]', 'y1[order[1:]]'], {}), '(y1[i], y1[order[1:]])\n', (1109, 1131), True, 'import numpy as np\n'), ((1146, 1178), 'numpy.minimum', 'np.minimum', (['x2[i]', 'x2[order[1:]]'], {}), '(x2[i], x2[order[1:]])\n', (1156, 1178), True, 'import numpy as np\n'), ((1193, 1225), 'numpy.minimum', 'np.minimum', (['y2[i]', 'y2[order[1:]]'], {}), '(y2[i], y2[order[1:]])\n', (1203, 1225), True, 'import numpy as np\n'), ((1239, 1269), 'numpy.maximum', 'np.maximum', (['(0.0)', '(xx2 - xx1 + 1)'], {}), '(0.0, xx2 - xx1 + 1)\n', (1249, 1269), True, 'import numpy as np\n'), ((1282, 1312), 'numpy.maximum', 'np.maximum', (['(0.0)', '(yy2 - yy1 + 1)'], {}), '(0.0, yy2 - yy1 + 1)\n', (1292, 1312), True, 'import numpy as np\n'), ((1926, 1963), 'sys.path.insert', 'sys.path.insert', (['(0)', 'caffe_python_path'], {}), '(0, caffe_python_path)\n', (1941, 1963), False, 'import sys\n'), ((2033, 2076), 'caffe.Net', 'caffe.Net', (['def_path', 'model_path', 'caffe.TEST'], {}), '(def_path, model_path, caffe.TEST)\n', (2042, 2076), False, 'import caffe\n'), ((2234, 2327), 'caffe.io.Transformer', 'caffe.io.Transformer', (["{'data': (1, self.input_channels_, image.shape[0], image.shape[1])}"], {}), "({'data': (1, self.input_channels_, image.shape[0],\n image.shape[1])})\n", (2254, 2327), False, 'import caffe\n'), ((2932, 2969), 'numpy.arange', 'np.arange', (['(0)', 'sz[0]', 'self.res_stride_'], {}), '(0, sz[0], self.res_stride_)\n', (2941, 2969), True, 'import numpy as np\n'), ((2979, 3016), 'numpy.arange', 'np.arange', (['(0)', 'sz[1]', 'self.res_stride_'], {}), '(0, sz[1], self.res_stride_)\n', (2988, 3016), True, 'import numpy as np\n'), ((3088, 3107), 'numpy.meshgrid', 'np.meshgrid', (['gx', 'gy'], {}), '(gx, gy)\n', (3099, 3107), True, 'import numpy as np\n'), ((3286, 3311), 'numpy.reshape', 'np.reshape', (['prob', '(-1, 1)'], {}), '(prob, (-1, 1))\n', (3296, 3311), True, 'import numpy as np\n'), ((3430, 3451), 'numpy.hstack', 'np.hstack', (['(bb, prob)'], {}), '((bb, prob))\n', (3439, 3451), True, 'import numpy as np\n'), ((1411, 1434), 'numpy.where', 'np.where', (['(ovr <= thresh)'], {}), '(ovr <= thresh)\n', (1419, 1434), True, 'import numpy as np\n'), ((2358, 2397), 'cv2.cvtColor', 'cv2.cvtColor', (['image', 'cv2.COLOR_BGR2GRAY'], {}), '(image, cv2.COLOR_BGR2GRAY)\n', (2370, 2397), False, 'import cv2\n'), ((3249, 3272), 'numpy.reshape', 'np.reshape', (['bb', '(4, -1)'], {}), '(bb, (4, -1))\n', (3259, 3272), True, 'import numpy as np\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'cnheider'
import csv
import matplotlib.pyplot as plt
import utilities as U
# print(plt.style.available)
plot_style = 'fivethirtyeight'
# plot_style='bmh'
# plot_style='ggplot'
plt.style.use('seaborn-poster')
plt.style.use(plot_style)
plt.rcParams['axes.edgecolor'] = '#ffffff'
plt.rcParams['axes.facecolor'] = '#ffffff'
plt.rcParams['figure.facecolor'] = '#ffffff'
plt.rcParams['patch.edgecolor'] = '#ffffff'
plt.rcParams['patch.facecolor'] = '#ffffff'
plt.rcParams['savefig.edgecolor'] = '#ffffff'
plt.rcParams['savefig.facecolor'] = '#ffffff'
plt.rcParams['xtick.labelsize'] = 16
plt.rcParams['ytick.labelsize'] = 16
# set up matplotlib
is_ipython = 'inline' in plt.get_backend()
if is_ipython:
pass
plt.ion()
def simple_plot(file_path, name='Statistic Name'):
with open(file_path, 'r') as f:
agg = U.StatisticAggregator()
reader = csv.reader(f, delimiter=' ', quotechar='|')
for line in reader:
agg.append(float(line[0]))
plt.plot(agg.values)
plt.title(name)
plt.show()
if __name__ == '__main__':
# import configs.base_config as C
# _list_of_files = list(C.LOG_DIRECTORY.glob('*.csv'))
# _latest_model = max(_list_of_files, key=os.path.getctime)
from tkinter import Tk
from tkinter.filedialog import askopenfilename
# import easygui
# print easygui.fileopenbox()
Tk().withdraw() # we don't want a full GUI, so keep the root window from appearing
file_path = askopenfilename() # show an "Open" dialog box and return the path to the selected file
file_name = file_path.split('/')[-1]
simple_plot(file_path, file_name)
| [
"matplotlib.pyplot.get_backend",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.style.use",
"utilities.StatisticAggregator",
"tkinter.Tk",
"matplotlib.pyplot.ion",
"matplotlib.pyplot.title",
"csv.reader",
"tkinter.filedialog.askopenfilename",
"matplotlib.pyplot.show"
] | [((242, 273), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""seaborn-poster"""'], {}), "('seaborn-poster')\n", (255, 273), True, 'import matplotlib.pyplot as plt\n'), ((274, 299), 'matplotlib.pyplot.style.use', 'plt.style.use', (['plot_style'], {}), '(plot_style)\n', (287, 299), True, 'import matplotlib.pyplot as plt\n'), ((772, 781), 'matplotlib.pyplot.ion', 'plt.ion', ([], {}), '()\n', (779, 781), True, 'import matplotlib.pyplot as plt\n'), ((731, 748), 'matplotlib.pyplot.get_backend', 'plt.get_backend', ([], {}), '()\n', (746, 748), True, 'import matplotlib.pyplot as plt\n'), ((1494, 1511), 'tkinter.filedialog.askopenfilename', 'askopenfilename', ([], {}), '()\n', (1509, 1511), False, 'from tkinter.filedialog import askopenfilename\n'), ((879, 902), 'utilities.StatisticAggregator', 'U.StatisticAggregator', ([], {}), '()\n', (900, 902), True, 'import utilities as U\n'), ((917, 960), 'csv.reader', 'csv.reader', (['f'], {'delimiter': '""" """', 'quotechar': '"""|"""'}), "(f, delimiter=' ', quotechar='|')\n", (927, 960), False, 'import csv\n'), ((1023, 1043), 'matplotlib.pyplot.plot', 'plt.plot', (['agg.values'], {}), '(agg.values)\n', (1031, 1043), True, 'import matplotlib.pyplot as plt\n'), ((1048, 1063), 'matplotlib.pyplot.title', 'plt.title', (['name'], {}), '(name)\n', (1057, 1063), True, 'import matplotlib.pyplot as plt\n'), ((1069, 1079), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (1077, 1079), True, 'import matplotlib.pyplot as plt\n'), ((1396, 1400), 'tkinter.Tk', 'Tk', ([], {}), '()\n', (1398, 1400), False, 'from tkinter import Tk\n')] |
# =============================================================================
# Copyright 2020 NVIDIA. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
import numpy as np
from nemo import logging
def analyze_confusion_matrix(cm, dict, max_pairs=10):
"""
Sort all confusions in the confusion matrix by value and display results.
Print results in a format: (name -> name, value)
Args:
cm: Confusion matrix
dict: Dictionary with key as a name and index as a value (Intents or Slots)
max_pairs: Max number of confusions to print
"""
threshold = 5 # just arbitrary value to take confusion with at least this number
confused_pairs = {}
size = cm.shape[0]
for i in range(size):
res = cm[i].argsort()
for j in range(size):
pos = res[size - j - 1]
# no confusion - same row and column
if pos == i:
continue
elif cm[i][pos] >= threshold:
str = f'{dict[i]} -> {dict[pos]}'
confused_pairs[str] = cm[i][pos]
else:
break
# sort by max confusions and print first max_pairs
sorted_confused_pairs = sorted(confused_pairs.items(), key=lambda x: x[1], reverse=True)
for i, pair_str in enumerate(sorted_confused_pairs):
if i >= max_pairs:
break
logging.info(pair_str)
def errors_per_class(cm, dict):
"""
Summarize confusions per each class in the confusion matrix.
It can be useful both for Intents and Slots.
It counts each confusion twice in both directions.
Args:
cm: Confusion matrix
dict: Dictionary with key as a name and index as a value (Intents or Slots)
"""
size = cm.shape[0]
confused_per_class = {}
total_errors = 0
for class_num in range(size):
sum = 0
for i in range(size):
if i != class_num:
sum += cm[class_num][i]
sum += cm[i][class_num]
confused_per_class[dict[class_num]] = sum
total_errors += sum
# logging.info(f'{dict[class_num]} - {sum}')
logging.info(f'Total errors (multiplied by 2): {total_errors}')
sorted_confused_per_class = sorted(confused_per_class.items(), key=lambda x: x[1], reverse=True)
for conf_str in sorted_confused_per_class:
logging.info(conf_str)
def log_misclassified_queries(intent_labels, intent_preds, queries, intent_dict, limit=50):
"""
Display examples of Intent mistakes.
In a format: Query, predicted and labeled intent names.
"""
logging.info(f'*** Misclassified intent queries (limit {limit}) ***')
cnt = 0
for i in range(len(intent_preds)):
if intent_labels[i] != intent_preds[i]:
query = queries[i].split('\t')[0]
logging.info(
f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'
)
cnt = cnt + 1
if cnt >= limit:
break
def log_misclassified_slots(
intent_labels, intent_preds, slot_labels, slot_preds, subtokens_mask, queries, intent_dict, slot_dict, limit=50
):
"""
Display examples of Slot mistakes.
In a format: Query, predicted and labeled intent names and list of predicted and labeled slot numbers.
also prints dictionary of the slots at the start for easier reading.
"""
logging.info('')
logging.info(f'*** Misclassified slots queries (limit {limit}) ***')
# print slot dictionary
logging.info(f'Slot dictionary:')
str = ''
for i, slot in enumerate(slot_dict):
str += f'{i} - {slot}, '
if i % 5 == 4 or i == len(slot_dict) - 1:
logging.info(str)
str = ''
logging.info('----------------')
cnt = 0
for i in range(len(intent_preds)):
cur_slot_pred = slot_preds[i][subtokens_mask[i]]
cur_slot_label = slot_labels[i][subtokens_mask[i]]
if not np.all(cur_slot_pred == cur_slot_label):
query = queries[i].split('\t')[0]
logging.info(
f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'
)
logging.info(f'p: {cur_slot_pred}')
logging.info(f'l: {cur_slot_label}')
cnt = cnt + 1
if cnt >= limit:
break
def check_problematic_slots(slot_preds_list, slot_dict):
""" Check non compliance of B- and I- slots for datasets that use such slot encoding. """
cnt = 0
# for sentence in slot_preds:
# slots = sentence.split(" ")
sentence = slot_preds_list
for i in range(len(sentence)):
slot_name = slot_dict[int(sentence[i])]
if slot_name.startswith("I-"):
prev_slot_name = slot_dict[int(sentence[i - 1])]
if slot_name[2:] != prev_slot_name[2:]:
print("Problem: " + slot_name + " - " + prev_slot_name)
cnt += 1
print("Total problematic slots: " + str(cnt))
| [
"nemo.logging.info",
"numpy.all"
] | [((2735, 2798), 'nemo.logging.info', 'logging.info', (['f"""Total errors (multiplied by 2): {total_errors}"""'], {}), "(f'Total errors (multiplied by 2): {total_errors}')\n", (2747, 2798), False, 'from nemo import logging\n'), ((3193, 3262), 'nemo.logging.info', 'logging.info', (['f"""*** Misclassified intent queries (limit {limit}) ***"""'], {}), "(f'*** Misclassified intent queries (limit {limit}) ***')\n", (3205, 3262), False, 'from nemo import logging\n'), ((4028, 4044), 'nemo.logging.info', 'logging.info', (['""""""'], {}), "('')\n", (4040, 4044), False, 'from nemo import logging\n'), ((4049, 4117), 'nemo.logging.info', 'logging.info', (['f"""*** Misclassified slots queries (limit {limit}) ***"""'], {}), "(f'*** Misclassified slots queries (limit {limit}) ***')\n", (4061, 4117), False, 'from nemo import logging\n'), ((4150, 4183), 'nemo.logging.info', 'logging.info', (['f"""Slot dictionary:"""'], {}), "(f'Slot dictionary:')\n", (4162, 4183), False, 'from nemo import logging\n'), ((4377, 4409), 'nemo.logging.info', 'logging.info', (['"""----------------"""'], {}), "('----------------')\n", (4389, 4409), False, 'from nemo import logging\n'), ((1971, 1993), 'nemo.logging.info', 'logging.info', (['pair_str'], {}), '(pair_str)\n', (1983, 1993), False, 'from nemo import logging\n'), ((2955, 2977), 'nemo.logging.info', 'logging.info', (['conf_str'], {}), '(conf_str)\n', (2967, 2977), False, 'from nemo import logging\n'), ((3420, 3541), 'nemo.logging.info', 'logging.info', (['f"""{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})"""'], {}), "(\n f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'\n )\n", (3432, 3541), False, 'from nemo import logging\n'), ((4333, 4350), 'nemo.logging.info', 'logging.info', (['str'], {}), '(str)\n', (4345, 4350), False, 'from nemo import logging\n'), ((4592, 4631), 'numpy.all', 'np.all', (['(cur_slot_pred == cur_slot_label)'], {}), '(cur_slot_pred == cur_slot_label)\n', (4598, 4631), True, 'import numpy as np\n'), ((4691, 4812), 'nemo.logging.info', 'logging.info', (['f"""{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})"""'], {}), "(\n f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'\n )\n", (4703, 4812), False, 'from nemo import logging\n'), ((4845, 4880), 'nemo.logging.info', 'logging.info', (['f"""p: {cur_slot_pred}"""'], {}), "(f'p: {cur_slot_pred}')\n", (4857, 4880), False, 'from nemo import logging\n'), ((4893, 4929), 'nemo.logging.info', 'logging.info', (['f"""l: {cur_slot_label}"""'], {}), "(f'l: {cur_slot_label}')\n", (4905, 4929), False, 'from nemo import logging\n')] |
from datetime import datetime
import pytz
from .constants import TIMEZONE
timezone = pytz.timezone(TIMEZONE)
def get_ist_now():
"""Returns Indian Standard Time datetime object.
Returns:
object -- Datetime object
"""
return datetime.now(timezone)
| [
"pytz.timezone",
"datetime.datetime.now"
] | [((88, 111), 'pytz.timezone', 'pytz.timezone', (['TIMEZONE'], {}), '(TIMEZONE)\n', (101, 111), False, 'import pytz\n'), ((253, 275), 'datetime.datetime.now', 'datetime.now', (['timezone'], {}), '(timezone)\n', (265, 275), False, 'from datetime import datetime\n')] |
"""
LibriParty Dataset creation by using official metadata.
Author
------
<NAME>, 2020
<NAME>, 2020
"""
import os
import sys
import speechbrain as sb
from hyperpyyaml import load_hyperpyyaml
from speechbrain.utils.data_utils import download_file
from local.create_mixtures_from_metadata import create_mixture
import json
from tqdm import tqdm
URL_METADATA = (
"https://www.dropbox.com/s/0u6x6ndyedb4rl7/LibriParty_metadata.zip?dl=1"
)
# Load hyperparameters file with command-line overrides
params_file, run_opts, overrides = sb.core.parse_arguments(sys.argv[1:])
with open(params_file) as fin:
params = load_hyperpyyaml(fin, overrides)
metadata_folder = params["metadata_folder"]
if not os.path.exists(metadata_folder):
os.makedirs(metadata_folder)
# Download meta data from the web
download_file(
URL_METADATA,
metadata_folder + "/meta.zip",
unpack=True,
dest_unpack=metadata_folder,
)
for data_split in ["train", "dev", "eval"]:
with open(os.path.join(metadata_folder, data_split + ".json"), "r") as f:
metadata = json.load(f)
print("Creating data for {} set".format(data_split))
c_folder = os.path.join(params["out_folder"], data_split)
os.makedirs(c_folder, exist_ok=True)
for sess in tqdm(metadata.keys()):
create_mixture(sess, c_folder, params, metadata[sess])
| [
"os.path.exists",
"os.makedirs",
"speechbrain.core.parse_arguments",
"os.path.join",
"local.create_mixtures_from_metadata.create_mixture",
"json.load",
"speechbrain.utils.data_utils.download_file",
"hyperpyyaml.load_hyperpyyaml"
] | [((534, 571), 'speechbrain.core.parse_arguments', 'sb.core.parse_arguments', (['sys.argv[1:]'], {}), '(sys.argv[1:])\n', (557, 571), True, 'import speechbrain as sb\n'), ((802, 906), 'speechbrain.utils.data_utils.download_file', 'download_file', (['URL_METADATA', "(metadata_folder + '/meta.zip')"], {'unpack': '(True)', 'dest_unpack': 'metadata_folder'}), "(URL_METADATA, metadata_folder + '/meta.zip', unpack=True,\n dest_unpack=metadata_folder)\n", (815, 906), False, 'from speechbrain.utils.data_utils import download_file\n'), ((616, 648), 'hyperpyyaml.load_hyperpyyaml', 'load_hyperpyyaml', (['fin', 'overrides'], {}), '(fin, overrides)\n', (632, 648), False, 'from hyperpyyaml import load_hyperpyyaml\n'), ((701, 732), 'os.path.exists', 'os.path.exists', (['metadata_folder'], {}), '(metadata_folder)\n', (715, 732), False, 'import os\n'), ((738, 766), 'os.makedirs', 'os.makedirs', (['metadata_folder'], {}), '(metadata_folder)\n', (749, 766), False, 'import os\n'), ((1149, 1195), 'os.path.join', 'os.path.join', (["params['out_folder']", 'data_split'], {}), "(params['out_folder'], data_split)\n", (1161, 1195), False, 'import os\n'), ((1200, 1236), 'os.makedirs', 'os.makedirs', (['c_folder'], {'exist_ok': '(True)'}), '(c_folder, exist_ok=True)\n', (1211, 1236), False, 'import os\n'), ((1064, 1076), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1073, 1076), False, 'import json\n'), ((1284, 1338), 'local.create_mixtures_from_metadata.create_mixture', 'create_mixture', (['sess', 'c_folder', 'params', 'metadata[sess]'], {}), '(sess, c_folder, params, metadata[sess])\n', (1298, 1338), False, 'from local.create_mixtures_from_metadata import create_mixture\n'), ((981, 1032), 'os.path.join', 'os.path.join', (['metadata_folder', "(data_split + '.json')"], {}), "(metadata_folder, data_split + '.json')\n", (993, 1032), False, 'import os\n')] |
import subprocess
from pathlib import Path
import pytest
# from py4gh import __version__
from py4gh.utility import decrypt_files, encrypt_files, get_files
# def test_version():
# assert __version__ == "0.1.0"
@pytest.fixture(scope="session")
def keys(tmpdir_factory):
test_pub1 = tmpdir_factory.mktemp("data").join("test1.pub")
test_sec1 = tmpdir_factory.mktemp("data").join("test1.sec")
test_pub2 = tmpdir_factory.mktemp("data").join("test2.pub")
test_sec2 = tmpdir_factory.mktemp("data").join("test2.sec")
# with open(stdout, "w") as sdf:
# subprocess.run(["echo", "blablaalbla"], stdout=sdf)
p1 = subprocess.Popen(
["crypt4gh-keygen", "--sk", test_sec1, "--pk", test_pub1, "--nocrypt"],
stdin=subprocess.PIPE,
)
p1.stdin.write(b"")
p1.communicate()[0]
p1.stdin.close()
subprocess.run(
["crypt4gh-keygen", "--sk", test_sec2, "--pk", test_pub2, "--nocrypt"],
# stdin=subprocess.PIPE,
text=True,
input="",
# encoding="ascii",
)
return [(test_pub1, test_sec1), (test_pub2, test_sec2)]
@pytest.fixture(scope="session")
def files(tmp_path):
d = tmp_path / "sub"
p = d / "hello.txt"
p.write_text("This is a secret message")
return p
# def test_file(files):
# with open(files, "r") as f:
# print(f.read())
# assert 1 == 3
def test_encryption(keys, tmpdir):
d = tmpdir.mkdir("sub")
f = d / "hello.txt"
f.write("This is a secret message")
files = get_files(d)
err, res = encrypt_files(keys[0][1], [keys[0][0]], files)
proc = subprocess.run(["ls", d], capture_output=True, text=True)
output_list = proc.stdout.split("\n")
assert output_list[1] == "hello.txt.c4gh"
encrypted_file = Path(d / output_list[1])
assert encrypted_file.stat().st_size != 0
print(err)
print(res)
def test_multiple_encryption(keys, tmpdir):
d = tmpdir.mkdir("sub")
f = d / "hello.txt"
message = "This is a secret message"
f.write(message)
files = get_files(d)
encrypt_files(keys[0][1], [keys[0][0], keys[1][0]], files)
proc = subprocess.run(["ls", d], capture_output=True, text=True)
print(proc.stdout)
output_list = proc.stdout.split("\n")
assert output_list[1] == "hello.txt.c4gh"
encrypted_file = Path(d / output_list[1])
# print(encrypted_file.read_bytes()[0])
# assert encrypted_file.read_text() != message
assert encrypted_file.stat().st_size != 0
def test_muliple_encryption_decryption(keys, tmpdir):
d = tmpdir.mkdir("sub")
f = d / "hello.txt"
message = "This is a secret message"
f.write(message)
files = get_files(d)
encrypt_files(keys[0][1], [keys[0][0], keys[1][0]], files)
subprocess.run(["ls", d], capture_output=True, text=True)
subprocess.run(["rm", f])
proc2 = subprocess.run(["ls", d], capture_output=True, text=True)
proc2_out = proc2.stdout.split("\n")
assert len(proc2_out) == 2
assert proc2_out[0] == "hello.txt.c4gh"
assert proc2_out[1] == ""
files2 = get_files(d)
decrypt_files(keys[1][1], files2)
proc = subprocess.run(["ls", d], capture_output=True, text=True)
output_list = proc.stdout.split("\n")
print(output_list)
assert output_list[0] == "hello.txt"
decrypted_file = Path(d / output_list[0])
assert decrypted_file.read_text() == message
assert decrypted_file.stat().st_size != 0
| [
"py4gh.utility.encrypt_files",
"py4gh.utility.get_files",
"pathlib.Path",
"subprocess.Popen",
"subprocess.run",
"py4gh.utility.decrypt_files",
"pytest.fixture"
] | [((219, 250), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (233, 250), False, 'import pytest\n'), ((1113, 1144), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (1127, 1144), False, 'import pytest\n'), ((641, 756), 'subprocess.Popen', 'subprocess.Popen', (["['crypt4gh-keygen', '--sk', test_sec1, '--pk', test_pub1, '--nocrypt']"], {'stdin': 'subprocess.PIPE'}), "(['crypt4gh-keygen', '--sk', test_sec1, '--pk', test_pub1,\n '--nocrypt'], stdin=subprocess.PIPE)\n", (657, 756), False, 'import subprocess\n'), ((850, 961), 'subprocess.run', 'subprocess.run', (["['crypt4gh-keygen', '--sk', test_sec2, '--pk', test_pub2, '--nocrypt']"], {'text': '(True)', 'input': '""""""'}), "(['crypt4gh-keygen', '--sk', test_sec2, '--pk', test_pub2,\n '--nocrypt'], text=True, input='')\n", (864, 961), False, 'import subprocess\n'), ((1524, 1536), 'py4gh.utility.get_files', 'get_files', (['d'], {}), '(d)\n', (1533, 1536), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((1552, 1598), 'py4gh.utility.encrypt_files', 'encrypt_files', (['keys[0][1]', '[keys[0][0]]', 'files'], {}), '(keys[0][1], [keys[0][0]], files)\n', (1565, 1598), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((1610, 1667), 'subprocess.run', 'subprocess.run', (["['ls', d]"], {'capture_output': '(True)', 'text': '(True)'}), "(['ls', d], capture_output=True, text=True)\n", (1624, 1667), False, 'import subprocess\n'), ((1778, 1802), 'pathlib.Path', 'Path', (['(d / output_list[1])'], {}), '(d / output_list[1])\n', (1782, 1802), False, 'from pathlib import Path\n'), ((2051, 2063), 'py4gh.utility.get_files', 'get_files', (['d'], {}), '(d)\n', (2060, 2063), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((2068, 2126), 'py4gh.utility.encrypt_files', 'encrypt_files', (['keys[0][1]', '[keys[0][0], keys[1][0]]', 'files'], {}), '(keys[0][1], [keys[0][0], keys[1][0]], files)\n', (2081, 2126), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((2138, 2195), 'subprocess.run', 'subprocess.run', (["['ls', d]"], {'capture_output': '(True)', 'text': '(True)'}), "(['ls', d], capture_output=True, text=True)\n", (2152, 2195), False, 'import subprocess\n'), ((2328, 2352), 'pathlib.Path', 'Path', (['(d / output_list[1])'], {}), '(d / output_list[1])\n', (2332, 2352), False, 'from pathlib import Path\n'), ((2676, 2688), 'py4gh.utility.get_files', 'get_files', (['d'], {}), '(d)\n', (2685, 2688), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((2693, 2751), 'py4gh.utility.encrypt_files', 'encrypt_files', (['keys[0][1]', '[keys[0][0], keys[1][0]]', 'files'], {}), '(keys[0][1], [keys[0][0], keys[1][0]], files)\n', (2706, 2751), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((2756, 2813), 'subprocess.run', 'subprocess.run', (["['ls', d]"], {'capture_output': '(True)', 'text': '(True)'}), "(['ls', d], capture_output=True, text=True)\n", (2770, 2813), False, 'import subprocess\n'), ((2818, 2843), 'subprocess.run', 'subprocess.run', (["['rm', f]"], {}), "(['rm', f])\n", (2832, 2843), False, 'import subprocess\n'), ((2856, 2913), 'subprocess.run', 'subprocess.run', (["['ls', d]"], {'capture_output': '(True)', 'text': '(True)'}), "(['ls', d], capture_output=True, text=True)\n", (2870, 2913), False, 'import subprocess\n'), ((3073, 3085), 'py4gh.utility.get_files', 'get_files', (['d'], {}), '(d)\n', (3082, 3085), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((3090, 3123), 'py4gh.utility.decrypt_files', 'decrypt_files', (['keys[1][1]', 'files2'], {}), '(keys[1][1], files2)\n', (3103, 3123), False, 'from py4gh.utility import decrypt_files, encrypt_files, get_files\n'), ((3135, 3192), 'subprocess.run', 'subprocess.run', (["['ls', d]"], {'capture_output': '(True)', 'text': '(True)'}), "(['ls', d], capture_output=True, text=True)\n", (3149, 3192), False, 'import subprocess\n'), ((3320, 3344), 'pathlib.Path', 'Path', (['(d / output_list[0])'], {}), '(d / output_list[0])\n', (3324, 3344), False, 'from pathlib import Path\n')] |
from unittest import TestCase
from parameterized import parameterized
from pyecsca.ec.context import local
from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, \
DifferentialLadderMultiplier
from pyecsca.ec.params import get_params
from pyecsca.sca.re.rpa import MultipleContext
class MultipleContextTests(TestCase):
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.add = self.coords.formulas["add-1998-cmo"]
self.dbl = self.coords.formulas["dbl-1998-cmo"]
self.neg = self.coords.formulas["neg"]
self.scale = self.coords.formulas["z"]
@parameterized.expand([
("10", 10),
("2355498743", 2355498743),
("325385790209017329644351321912443757746", 325385790209017329644351321912443757746),
("13613624287328732", 13613624287328732)
])
def test_basic(self, name, scalar):
mult = LTRMultiplier(self.add, self.dbl, self.scale, always=False, complete=False, short_circuit=True)
with local(MultipleContext()) as ctx:
mult.init(self.secp128r1, self.base)
mult.multiply(scalar)
muls = list(ctx.points.values())
self.assertEqual(muls[-1], scalar)
def test_precomp(self):
bnaf = BinaryNAFMultiplier(self.add, self.dbl, self.neg, self.scale)
with local(MultipleContext()) as ctx:
bnaf.init(self.secp128r1, self.base)
muls = list(ctx.points.values())
self.assertListEqual(muls, [1, -1])
wnaf = WindowNAFMultiplier(self.add, self.dbl, self.neg, 3, self.scale)
with local(MultipleContext()) as ctx:
wnaf.init(self.secp128r1, self.base)
muls = list(ctx.points.values())
self.assertListEqual(muls, [1, 2, 3, 5])
def test_ladder(self):
curve25519 = get_params("other", "Curve25519", "xz")
base = curve25519.generator
coords = curve25519.curve.coordinate_model
ladd = coords.formulas["ladd-1987-m"]
dadd = coords.formulas["dadd-1987-m"]
dbl = coords.formulas["dbl-1987-m"]
scale = coords.formulas["scale"]
ladd_mult = LadderMultiplier(ladd, dbl, scale)
with local(MultipleContext()) as ctx:
ladd_mult.init(curve25519, base)
ladd_mult.multiply(1339278426732672313)
muls = list(ctx.points.values())
self.assertEqual(muls[-2], 1339278426732672313)
dadd_mult = DifferentialLadderMultiplier(dadd, dbl, scale)
with local(MultipleContext()) as ctx:
dadd_mult.init(curve25519, base)
dadd_mult.multiply(1339278426732672313)
muls = list(ctx.points.values())
self.assertEqual(muls[-2], 1339278426732672313)
| [
"parameterized.parameterized.expand",
"pyecsca.ec.mult.LadderMultiplier",
"pyecsca.ec.params.get_params",
"pyecsca.ec.mult.DifferentialLadderMultiplier",
"pyecsca.ec.mult.BinaryNAFMultiplier",
"pyecsca.sca.re.rpa.MultipleContext",
"pyecsca.ec.mult.LTRMultiplier",
"pyecsca.ec.mult.WindowNAFMultiplier"
... | [((785, 990), 'parameterized.parameterized.expand', 'parameterized.expand', (["[('10', 10), ('2355498743', 2355498743), (\n '325385790209017329644351321912443757746', \n 325385790209017329644351321912443757746), ('13613624287328732', \n 13613624287328732)]"], {}), "([('10', 10), ('2355498743', 2355498743), (\n '325385790209017329644351321912443757746', \n 325385790209017329644351321912443757746), ('13613624287328732', \n 13613624287328732)])\n", (805, 990), False, 'from parameterized import parameterized\n'), ((422, 467), 'pyecsca.ec.params.get_params', 'get_params', (['"""secg"""', '"""secp128r1"""', '"""projective"""'], {}), "('secg', 'secp128r1', 'projective')\n", (432, 467), False, 'from pyecsca.ec.params import get_params\n'), ((1069, 1168), 'pyecsca.ec.mult.LTRMultiplier', 'LTRMultiplier', (['self.add', 'self.dbl', 'self.scale'], {'always': '(False)', 'complete': '(False)', 'short_circuit': '(True)'}), '(self.add, self.dbl, self.scale, always=False, complete=False,\n short_circuit=True)\n', (1082, 1168), False, 'from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, DifferentialLadderMultiplier\n'), ((1422, 1483), 'pyecsca.ec.mult.BinaryNAFMultiplier', 'BinaryNAFMultiplier', (['self.add', 'self.dbl', 'self.neg', 'self.scale'], {}), '(self.add, self.dbl, self.neg, self.scale)\n', (1441, 1483), False, 'from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, DifferentialLadderMultiplier\n'), ((1680, 1744), 'pyecsca.ec.mult.WindowNAFMultiplier', 'WindowNAFMultiplier', (['self.add', 'self.dbl', 'self.neg', '(3)', 'self.scale'], {}), '(self.add, self.dbl, self.neg, 3, self.scale)\n', (1699, 1744), False, 'from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, DifferentialLadderMultiplier\n'), ((1979, 2018), 'pyecsca.ec.params.get_params', 'get_params', (['"""other"""', '"""Curve25519"""', '"""xz"""'], {}), "('other', 'Curve25519', 'xz')\n", (1989, 2018), False, 'from pyecsca.ec.params import get_params\n'), ((2303, 2337), 'pyecsca.ec.mult.LadderMultiplier', 'LadderMultiplier', (['ladd', 'dbl', 'scale'], {}), '(ladd, dbl, scale)\n', (2319, 2337), False, 'from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, DifferentialLadderMultiplier\n'), ((2598, 2644), 'pyecsca.ec.mult.DifferentialLadderMultiplier', 'DifferentialLadderMultiplier', (['dadd', 'dbl', 'scale'], {}), '(dadd, dbl, scale)\n', (2626, 2644), False, 'from pyecsca.ec.mult import LTRMultiplier, BinaryNAFMultiplier, WindowNAFMultiplier, LadderMultiplier, DifferentialLadderMultiplier\n'), ((1184, 1201), 'pyecsca.sca.re.rpa.MultipleContext', 'MultipleContext', ([], {}), '()\n', (1199, 1201), False, 'from pyecsca.sca.re.rpa import MultipleContext\n'), ((1503, 1520), 'pyecsca.sca.re.rpa.MultipleContext', 'MultipleContext', ([], {}), '()\n', (1518, 1520), False, 'from pyecsca.sca.re.rpa import MultipleContext\n'), ((1764, 1781), 'pyecsca.sca.re.rpa.MultipleContext', 'MultipleContext', ([], {}), '()\n', (1779, 1781), False, 'from pyecsca.sca.re.rpa import MultipleContext\n'), ((2357, 2374), 'pyecsca.sca.re.rpa.MultipleContext', 'MultipleContext', ([], {}), '()\n', (2372, 2374), False, 'from pyecsca.sca.re.rpa import MultipleContext\n'), ((2664, 2681), 'pyecsca.sca.re.rpa.MultipleContext', 'MultipleContext', ([], {}), '()\n', (2679, 2681), False, 'from pyecsca.sca.re.rpa import MultipleContext\n')] |