def OnInit(self):
wx.InitAllImageHandlers()
mainFrame = MainFrame(None, "")
self.SetTopWindow(mainFrame)
mainFrame.Maximize(True)
mainFrame.Show()
return 1
def __init__(self):
super().__init__()
self.winfo_toplevel().title("Calculadora")
self.resizable(0, 0)
self.mainFrame = MainFrame(self)
self.mainFrame.grid(row=0, column=0, padx=10, pady=10, sticky='NSEW')
def OnInit(self):
self.SetAppName(self._application_name)
self.SetVendorName(self._vendor_name)
if hasattr(sys, "frozen"):
directory = os.path.dirname(medipy.__file__)
os.environ["MEDIPY_PLUGINS_PATH"] = "{0}{1}{2}".format(
directory, os.pathsep, os.environ.get("MEDIPY_PLUGINS_PATH",
""))
if self.options.ensure_value("menu_file", None) is not None:
menu = menu_builder.from_file.build_menu(self.options.menu_file)
else:
menu = []
for directory in medipy.__path__[1:]:
menu.extend(
menu_builder.from_api.build_menu(directory, directory))
self.frame = MainFrame(menu,
None,
title=self._application_name,
size=(1000, 800))
self.frame.Show()
self.frame.Bind(wx.EVT_CLOSE, self.OnMainFrameClose)
self.SetTopWindow(self.frame)
return True
class PomodoroApp(wx.App):
def __init__(self, *args, **kwargs):
"""Initialize the application"""
wx.App.__init__(self, *args, **kwargs)
# Create a hidden frame to act as the applications main frame
self.frame = MainFrame(25, None, wx.ID_ANY, "Test Frame")
self.frame.Show(False)
self.frame.Bind(wx.EVT_CLOSE, self.on_close)
# Create the timer in charge of the ticks
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.on_timer, self.timer)
self.timer.Start(1000)
self.MainLoop()
def on_close(self, event):
"""Handle closing event"""
# destroy the timer
self.timer.Destroy()
event.Skip()
def on_timer(self, event):
"""Handle timer event"""
self.frame.update_tomato()
def update(self, res=None, *args):
if res is "landing":
LandingFrame(self, LANDING_SIZE)
if res is "settings":
setting_frame = SettingFrame(self, SETTING_SIZE)
if self.settings is not None:
setting_frame.load(self.settings)
elif res is "configs":
main_frame = MainFrame(self, MAIN_SIZE)
if self.configs is not None:
main_frame.load(self.configs)
elif res is "proceed":
CreateFrame(self, CREATE_SIZE, self.settings, self.configs)
else:
self.root.quit()
def __init__(self):
super().__init__()
self.winfo_toplevel().title("Registro")
self.resizable(0, 0)
self.dataFrame = DataFrame(self, lambda: self.showFrame('register'))
self.dataFrame.grid(row=0, column=0, sticky='NSEW')
self.mainFrame = MainFrame(self, lambda: self.showFrame('data'))
self.mainFrame.grid(row=0, column=0, sticky='NSEW')
self.frames = dict()
self.frames['register'] = self.mainFrame
self.frames['data'] = self.dataFrame
class HRMonitorGui(wx.App):
def OnInit(self):
wx.InitAllImageHandlers()
self.mainFrame = MainFrame(None, -1, "")
self.SetTopWindow(self.mainFrame)
self.mainFrame.Show()
return 1
def main():
request = Request()
client = Client()
app = MainFrame(client, request)
while True:
try:
app.update()
header = client.receive_message(HEADER_LENGTH)
if not len(header):
print('Connection closed by the server')
sys.exit()
msg_length = int(header.decode('utf-8').strip())
msg = client.receive_message(msg_length).decode('utf-8')
print(" RESPONSE: " + msg)
app.make_update(msg)
except IOError as e:
if e.errno != errno.EAGAIN and e.errno != errno.EWOULDBLOCK:
print('Reading error: {}'.format(str(e)))
sys.exit()
continue
except tk.TclError as e:
print("Bye!")
sys.exit()
except Exception as e:
print('Reading error: '.format(str(e)))
sys.exit()
def __init__(self, *args, **kwargs):
"""Initialize the application"""
wx.App.__init__(self, *args, **kwargs)
# Create a hidden frame to act as the applications main frame
self.frame = MainFrame(25, None, wx.ID_ANY, "Test Frame")
self.frame.Show(False)
self.frame.Bind(wx.EVT_CLOSE, self.on_close)
# Create the timer in charge of the ticks
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.on_timer, self.timer)
self.timer.Start(1000)
self.MainLoop()
#!/usr/bin/env python3
import wx
from main_frame import MainFrame
if __name__ == "__main__":
app = wx.App(False)
frame = MainFrame()
app.MainLoop()
from wx import App
from main_frame import MainFrame
import keyboard
# Options
hash_lang = 'RU' # Available choices: 'EN', 'RU'
# App initialization
app = App()
main_frame = MainFrame(hash_lang)
# Listener
keyboard.add_hotkey('F1', lambda: main_frame.prev_item())
keyboard.add_hotkey('F2', lambda: main_frame.next_item())
keyboard.add_hotkey('F3', lambda: main_frame.search_first_no_hash_item())
keyboard.add_hotkey('F4', lambda: main_frame.search_last_no_hash_item())
keyboard.add_hotkey('F5', lambda: keyboard.write(main_frame.item_name()))
keyboard.add_hotkey('F6', lambda: main_frame.set_hash_to_item())
keyboard.add_hotkey('F7', lambda: main_frame.set_no_hash_to_item())
keyboard.add_hotkey('F8', lambda: main_frame.save())
app.MainLoop()
def exit_fullscreen(self, event=None):
self.fullscreen_state = False
self.attributes("-fullscreen", self.fullscreen_state)
root = Root()
padx = pady = 10
MANIM_DIR = get_manim_directory()
main_frame = MainFrame(
root,
text="Manim Rendering GUI",
add_kwargs=dict(
padx=padx,
pady=pady,
fill=tk.BOTH,
expand=1,
),
)
edit_default_frame = EditDefaultFrame(
root,
main_frame,
text="Manim GUI default configurations",
add_kwargs=dict(
padx=padx,
pady=pady,
fill=tk.BOTH,
expand=1,
),
)
def __init__(self, parent):
MainFrame.__init__(self, parent)
def OnInit(self):
wx.InitAllImageHandlers()
self.mainFrame = MainFrame(None, -1, "")
self.SetTopWindow(self.mainFrame)
self.mainFrame.Show()
return 1
time = 0
cur_puzzle = []
if app.bRecordLastPuzzle and app.lastPuzzle:
_id = app.lastPuzzle['id']
time = app.lastPuzzle['time']
puzzle = util.str2puzzle(app.lastPuzzle['puzzleDefault'])
cur_puzzle = util.str2puzzle(app.lastPuzzle['puzzleCurrent'])
logger.info('RecordLastPuzzle! id=%d, time=%s', _id, util.time_format(time))
logger.info('puzzle=%s', app.lastPuzzle['puzzleDefault'])
logger.info('cur puzzle=%s', app.lastPuzzle['puzzleCurrent'])
else:
#puzzle loader
_id, puzzle = get_puzzle_loader().pick(mode)
#anim
anim.InitAnimManager()
#frame
frame = MainFrame(None, 'Sudoku Boxer')
frame.setDefault(_id, puzzle, cur_puzzle)
if user:
frame._setUser(user)
if time:
frame.setSpendTime(time)
mainApp.MainLoop()
app.SetConfig()
util.write_config()
# Startup settings
config = configparser.ConfigParser()
config.read('settings.ini')
LANG = config['App settings']['lang']
FPS = int(config['App settings']['fps'])
TRAY_POSITION = config['App settings']['tray_position']
HOTKEY_HELP = config['Hotkey settings']['hotkey_help']
HOTKEY_SCAN = config['Hotkey settings']['hotkey_scan']
HOTKEY_EXIT = config['Hotkey settings']['hotkey_exit']
# Init app
app = App()
main_frame = MainFrame(LANG, FPS)
tray_frame = TrayFrame(TRAY_POSITION, HOTKEY_HELP, HOTKEY_SCAN, HOTKEY_EXIT)
# Turn scan
add_hotkey(HOTKEY_SCAN, lambda: main_frame.turn_thread())
add_hotkey(HOTKEY_SCAN, lambda: tray_frame.turn_active())
# Turn help
add_hotkey(HOTKEY_HELP, lambda: tray_frame.turn_help())
# Debug hotkey for view hash
add_hotkey('F3', lambda: main_frame.note_item())
# Close app
add_hotkey(HOTKEY_EXIT, lambda: main_frame.Close())
add_hotkey(HOTKEY_EXIT, lambda: tray_frame.Close())
#!/usr/bin/python3
import tkinter
import traceback, sys
from main_frame import MainFrame
from utility import Logger
#from data_store import DataStore
#from configuration import Configuration
if __name__ == "__main__":
try:
logger = Logger(__name__, Logger.DEBUG)
logger.debug(sys._getframe().f_code.co_name)
top = tkinter.Tk()
app = MainFrame(top)
top.wm_title("Shop Timer")
logger.debug("start main loop")
top.mainloop()
logger.debug("end main loop")
except Exception as e:
traceback.print_exception(*sys.exc_info())
class MediPyApp(medipy.gui.base.Application):
_application_name = "MediPy"
_vendor_name = "Université de Strasbourg"
def __init__(self, *args, **kwargs):
# Public interface
self.frame = None
self.viewer_3ds = medipy.base.ObservableList()
self._full_screen = False
super(MediPyApp, self).__init__(*args, **kwargs)
####################
# Public interface #
####################
def insert_viewer_3d(self, index, viewer_3d):
self.viewer_3ds.insert(index, viewer_3d)
viewer_3d.add_observer("close", self._on_viewer_3d_close)
def append_viewer_3d(self, viewer_3d):
return self.insert_viewer_3d(len(self.viewer_3ds), viewer_3d)
def toggle_full_screen(self):
self._full_screen = not self._full_screen
if self._full_screen:
self._frame.full_screen(self.active_image)
else:
self._frame.full_screen(None)
def execute_script(self, filename):
# Pretend we execute the script in its local dir
old_path = copy.copy(sys.path)
sys.path.insert(0, os.path.dirname(filename))
execfile(filename, globals(), locals())
sys.path = old_path
def load_object_3d(self, path, viewer_3d):
generic_reader = vtkDataReader()
generic_reader.SetFileName(path)
if generic_reader.OpenVTKFile() and generic_reader.ReadHeader():
if generic_reader.IsFileStructuredPoints():
raise Exception("Cannot read VTK structured points")
elif generic_reader.IsFilePolyData():
reader = vtkPolyDataReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileStructuredGrid():
reader = vtkStructuredGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileUnstructuredGrid():
reader = vtkUnstructuredGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
elif generic_reader.IsFileRectilinearGrid():
reader = vtkRectilinearGridReader()
reader.SetFileName(path)
object_3d = Object3D(reader.GetOutput(), path)
else:
raise Exception("Cannot read VTK file containing type %i" %
generic_reader.GetFileType())
viewer_3d.objects_3d.append(object_3d)
else:
importer = vtkVRMLImporter()
importer.SetFileName(path)
importer.Update()
actors = importer.GetRenderer().GetActors()
number_of_actors = actors.GetNumberOfItems()
actors.InitTraversal()
for i in range(number_of_actors):
actor = actors.GetNextItem()
object_3d = Object3D(path + ", %i" % i)
object_3d.actor.SetProperty(actor.GetProperty())
object_3d.actor.SetMapper(actor.GetMapper())
viewer_3d.objects_3d.append(object_3d)
# else :
# raise Exception("Cannot load file %s of unknown type"%path)
def save_object_3d(self, object_3d, path):
writer = vtkPolyDataWriter()
writer.SetFileName(path)
writer.SetFileTypeToBinary()
writer.SetHeader(object_3d.name)
writer.SetInput(object_3d.dataset)
writer.Update()
##############
# Properties #
##############
def _get_images(self):
return self.frame.images
images = property(_get_images)
##################
# Event handlers #
##################
def OnInit(self):
self.SetAppName(self._application_name)
self.SetVendorName(self._vendor_name)
if hasattr(sys, "frozen"):
directory = os.path.dirname(medipy.__file__)
os.environ["MEDIPY_PLUGINS_PATH"] = "{0}{1}{2}".format(
directory, os.pathsep, os.environ.get("MEDIPY_PLUGINS_PATH",
""))
if self.options.ensure_value("menu_file", None) is not None:
menu = menu_builder.from_file.build_menu(self.options.menu_file)
else:
menu = []
for directory in medipy.__path__[1:]:
menu.extend(
menu_builder.from_api.build_menu(directory, directory))
self.frame = MainFrame(menu,
None,
title=self._application_name,
size=(1000, 800))
self.frame.Show()
self.frame.Bind(wx.EVT_CLOSE, self.OnMainFrameClose)
self.SetTopWindow(self.frame)
return True
def OnMainFrameClose(self, event):
for viewer in self.viewer_3ds:
viewer.Close()
event.Skip()
def _on_viewer_3d_close(self, event):
viewer = event.object
index = self.viewer_3ds.index(viewer)
del self.viewer_3ds[index]
try:
import win32gui
import logging
import sys
from utils import tk_utils
from main_frame import MainFrame
if win32gui.FindWindow(None, 'MF run counter'):
resp = tk_utils.mbox(
msg=
'It seems like you already have an instance of MF Run Counter open.\n'
'Opening another instance will make the app unstable (If this is a false positive, just ignore it)\n\n'
'Do you wish to continue anyway?',
title='WARNING')
if not resp:
sys.exit(0)
MainFrame()
except Exception as e:
logging.exception(e)
raise e
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # @Date : 2018-01-29 13:57:25 # @Author : Your Name ([email protected]) # @Link : http://example.org # @Version : $Id$ ''' 公司电费估算器 ''' import wx from main_frame import MainFrame app = wx.App() frame = MainFrame() app.SetTopWindow(frame) frame.Show() app.MainLoop()
def main():
mycompany = company.Company()
mycompany.set_company_name('Татнефть')
mycompany.set_ticker('TATN')
mycompany.set_financials_excel('tatneft.XLSX')
mycompany.load_financials_from_file()
mycompany.save_company_to_file('tatneft.json')
mycompany.load_company_from_file('tatneft.json')
modelgen = model_generator.ModelGenerator()
modelgen.set_financials(mycompany.get_financials())
model = modelgen.build_linear_regression_model('Price')
years = [i for i in range(2021, 2026)]
fin = mycompany.get_financials()
fin = fin.drop(["Price"], axis=1)
modelgen.predict(model, fin, years)
# root = Tk()
# app = MainFrame(root)
# root.mainloop()
if __name__ == "__main__":
# execute only if run as a script
app = MainFrame()
app.mainloop()
