def __init__(self):
# config
app_title = "Oscbar"
interval = 2 # seconds per calibration step
# initial oscillator settings
self.wave_type = "sine_wave"
self.amplitude = 0.5
self.frequency = 440
self.store_wave = None
self.store_freq = None
# object instances
self.app = rumps.App(app_title, icon=APP_ICON)
self.oct_timer = rumps.Timer(
lambda sender, factor=2, max_freq=880, title='Octave Walk': self.
advance_frequency(sender, factor, max_freq, title),
interval)
self.oct_thirds_timer = rumps.Timer(
lambda sender, factor=(2**(1 / 3)), max_freq=880, title
='Octave Walk â…“': self.advance_frequency(
sender, factor, max_freq, title),
interval)
self.osc = Oscillator(self.wave_type, self.amplitude, self.frequency)
# set up menu
self.build_menu()
self.osc_ready_menu()
def __init__(self, dockerShell):
# rumps.debug_mode(True)
super().__init__("DockerMenu", icon="./assets/icon.png")
self.__dockerShell = dockerShell
self.__containers = dict()
self.__menuUpdater = rumps.Timer(self.refresh, 10).start()
self.__containerUpdater = rumps.Timer(self.updateContainers, 5).start()
def __init__(self):
super().__init__(name="AutoClicker", icon="mouselogo.icns")
default_value = 0.0
self.cps_value = AutoClicker.map_slider_to_cps(default_value)
self.click_timer = rumps.Timer(
lambda _: self.mouse.click(mouse.Button.left), 1 / self.cps_value)
def timer_start(_):
#print(rumps.timers())
self.click_timer.start()
self.menu = [
rumps.MenuItem("Start", timer_start), None, "Stop key: esc",
"Start key: \\", None, "cps_value",
rumps.SliderMenuItem(dimensions=(180, 15),
callback=self.change_cps,
min_value=-1,
max_value=5,
value=default_value), None
]
self.menu["cps_value"].title = f"CPS: {self.cps_value}"
self.mouse = mouse.Controller()
self.check_keys()
def __init__(self, ml, interval=30, ic="u3.png"):
super(MailNotifier, self).__init__("MailNotifier", icon=ic)
self.MailHelper = MailHelper()
self.timer = rumps.Timer(self.timerb, 5)
self.maillist = ml
self.defaulticon = ic
self.timer.start()
def __init__(self):
self.config = {
"app_name": "Pomodoro",
"start": "Bắt Đầu 🏁",
"pause": "Tạm Dừng ⏸",
"continue": "Tiếp Tục ▶️",
"stop": "Dừng Lại 🛑",
"break_message": "25 phút đã trôi qua! +1 🍅",
"interval": 1500,
"reset_round": "Đặt Lại Số Lượt 🍅",
"work_mode": "Tập Trung 💪",
"rest_mode": "Giải Lao 💤"
}
self.round = 0
self.app = rumps.App(self.config["app_name"])
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.count = 0
self.interval = self.config["interval"]
self.start_pause_button = rumps.MenuItem(title=self.config["start"],
callback=self.start_timer)
self.stop_button = rumps.MenuItem(title=self.config["stop"],
callback=None)
self.set_up_menu()
self.is_in_mode = self.config["work_mode"]
self.reset_round_button = rumps.MenuItem(
title=self.config["reset_round"], callback=self.reset_round)
self.mode_button = rumps.MenuItem(title=self.config["rest_mode"],
callback=self.rest)
self.app.menu = [
self.start_pause_button, self.stop_button, self.reset_round_button,
self.mode_button
]
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App("Raindrop", "🍅")
self.start_pause_button = rumps.MenuItem(
title='Start Timer',
callback=lambda _: self.start_timer(_, self.interval))
self.stop_button = rumps.MenuItem(title='Stop Timer', callback=None)
self.buttons = {}
self.buttons_callback = {}
for i in [5, 10, 15, 20, 25]:
title = str(i) + ' Minutes'
callback = lambda _, j=i: self.set_mins(_, j)
self.buttons["btn_" + str(i)] = rumps.MenuItem(title=title,
callback=callback)
self.buttons_callback[title] = callback
self.interval = 5 * SEC_TO_MIN # current 5 min by default
self.buttons['btn_5'].state = True
self.app.menu = [
self.start_pause_button,
None,
# self.button_things,
# None,
*self.buttons.values(),
None,
self.stop_button
]
def __init__(self):
self.config = {"app_name": "QRD", "interval": 1}
self.app = rumps.App(self.config["app_name"], quit_button=None)
self.timer = rumps.Timer(self.set_title, 1)
self.interval = self.config["interval"]
self.set_up_menu()
self.app.menu = []
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App("Timebox", "🥊")
self.start_pause_button = rumps.MenuItem(title='Start Timer',
callback=lambda _: self.start_timer(_, self.interval))
self.stop_button = rumps.MenuItem(title='Stop Timer',
callback=None)
self.buttons = {}
self.buttons_callback = {}
for i in [5, 10, 15, 20, 25]:
title = str(i) + ' Minutes'
callback = lambda _, j=i: self.set_mins(_, j)
self.buttons["btn_" + str(i)] = rumps.MenuItem(title=title, callback=callback)
self.buttons_callback[title] = callback
self.interval = get_things_min()*SEC_TO_MIN
self.button_things = rumps.MenuItem(title="Things Interval ("+str(round(self.interval/SEC_TO_MIN))+"min)", callback=lambda _: self.set_things_mins(_))
self.button_things.state = True
self.app.menu = [
self.start_pause_button,
None,
self.button_things,
None,
*self.buttons.values(),
None,
self.stop_button]
def __init__(self):
self.app = rumps.App("twenny")
self.timer = rumps.Timer(self.ticker, 1)
self.interval = 1200
self.bau_menu()
self.start_knopf = rumps.MenuItem(title="Start Timer", callback=self.start_timer)
self.stopuhr = rumps.MenuItem(title="20:00")
self.app.menu = [self.stopuhr, self.start_knopf]
def scheduler(self, sender):
self.set_up_menu()
self.timer = rumps.Timer(self.check_schedule, 1)
self.timer.start()
self.auto_button.set_callback(self.auto_zoom)
self.hide_button.set_callback(self.hide_camera)
self.show_button.set_callback(self.show_camera)
self.schedule_button.set_callback(None)
def create_country_listing(self, country):
data = self.get_country_data(country.title)
for k, v in data.items():
self.app.menu.add(rumps.MenuItem(self.string_mapper(k, v)))
current_time = datetime.datetime.now().strftime("%H:%M")
self.app.menu.add(rumps.MenuItem(title=f"Updated at {current_time}"))
self.timer = rumps.Timer(self.on_update, self.update_interval)
self.timer.start()
def auto_zoom(self, sender):
self.set_up_menu()
self.timer = rumps.Timer(self.check_zoom, 1)
self.last_on_zoom = float("-inf") # Resetting this if needed
self.timer.start()
self.auto_button.set_callback(None)
self.hide_button.set_callback(self.hide_camera)
self.show_button.set_callback(self.show_camera)
self.schedule_button.set_callback(self.scheduler)
def __init__(self, *args, **kwargs):
super(IdiotApp, self).__init__(*args, **kwargs)
self.title = emoji.emojize(random.choice(list(config.ok_titles)),
use_aliases=True)
self.cm = CheckManager()
self.quit_button = None
self.update_menu()
self.timer = rumps.Timer(self.cm.run_checks, config.check_interval)
self.timer.start()
def create_province_listing(self, province):
# print("Creating")
data = self.get_province_data(province.title)
for k, v in data.items():
self.app.menu.add(rumps.MenuItem(self.string_mapper(k, v)))
current_time = datetime.datetime.now().strftime("%H:%M")
self.app.menu.add(rumps.MenuItem(title=f"Updated at {current_time}"))
# print("Created")
self.timer = rumps.Timer(self.on_update, self.update_interval)
self.timer.start()
def __init__(self, work_interval=3600, nag_interval=60, debug=False):
"""
Constructor.
work_interval - integer, seconds. Time that will elapse before telling
the user to take a break.
nag_interval - integer, seconds. After an initial notification, notifications
will increase in frequency - this setting controls how long
to wait between each subsequent notice.
debug - boolean. Proxy for the rumps.debug function, turns on detailed
logging within rumps (log entries end up in the MacOS Console)
"""
self.work_interval = work_interval
self.nag_interval = nag_interval
self.work_delta = datetime.timedelta(seconds=work_interval)
self.nag_delta = datetime.timedelta(seconds=nag_interval)
self.delta = self.work_delta
self.checkin = datetime.datetime.now()
self.app = rumps.App(
"Break Timer",
icon=NORMAL_ICON)
self.app.menu = [
rumps.MenuItem('Stop', self.stop),
rumps.MenuItem('Take Break', self.break_popup),
rumps.MenuItem("Time Left", None)
]
self.work_timer = rumps.Timer(self.take_break, 10)
self.front_timer = rumps.Timer(self.bring_to_front, 10)
self.time_left_timer = rumps.Timer(self.update_time_left, 45)
self.nag = False
self.paused = False
rumps.debug_mode(debug)
def __init__(self):
self.is_coding = False
self.timer = rumps.Timer(self.make_record, Coding.INTERVAL)
home = expanduser("~")
self.folder = os.path.join(home, "Development", "Memcode", "data")
self.make_dir(self.folder)
self.session_id = None
db_path = os.path.join(self.folder, 'database.db')
self.conn = sqlite3.connect(db_path)
self.setup_db()
def __init__(self, autostart=True, debug=False):
# Set default values
self.debug_mode = debug
rumps.debug_mode(self.debug_mode)
self.setting_file = SETTING_FILE
self.plist_file = PLIST_FILE
self.karabiner_json = KARABINER_JSON
self.icon_set = ICON_SET
self.icon_set_gray = ICON_SET_GRAY
self.icons = self.icon_set
# Read settings
self.settings = {}
self.read_settings()
# Application setup
super(VEM, self).__init__(type(self).__name__,
title=None,
icon=self.icons['insert'])
self.menu = [
'About',
None,
'Gray icon',
None,
'Set check interval',
'Start at login',
None,
'Uninstall',
None,
]
# Other class variables
if 'gray_icon' in self.settings and self.settings['gray_icon'] == '1':
self.icons = self.icon_set_gray
self.menu['Gray icon'].state = True
else:
self.icons = self.icon_set
self.menu['Gray icon'].state = False
if 'start_at_login' in self.settings\
and self.settings['start_at_login'] == '1':
self.menu['Start at login'].state = True
else:
self.menu['Start at login'].state = False
# Set and start get_messages
self.timer = rumps.Timer(
self.check_karabiner,
int(self.settings['interval'])
if 'interval' in self.settings else CHECK_INTERVAL)
if autostart:
self.start()
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App('Pymodoro')
self.start_pause_button = rumps.MenuItem(title='Start timer',
callback=self.start_timer)
self.stop_button = rumps.MenuItem(title='Stop timer',
callback=self.stop_timer)
self.app.menu = [self.start_pause_button,
self.stop_button]
self.app.icon = 'icons/tomato.png'
def __init__(self):
self.config = {
"app_name": "Nightscout menu bar",
"interval": 180,
"ns_url": "https://endafarrell-nightscout.herokuapp.com",
}
self.app = rumps.App(self.config["app_name"])
self.timer = rumps.Timer(self.on_update, self.config["interval"])
self.timer.start()
self.url_button = rumps.MenuItem(title=self.config["ns_url"],
callback=self.url_callback)
self.app.menu = [self.url_button]
def interval_menu_callback(self, item):
item.state = not item.state
for title, value in filter(lambda x: x[0] != item.title, self.intervals.items()):
value[0].state = False
if self.timer and self.timer.is_alive():
self.timer.stop()
if item.state:
self.timer = rumps.Timer(self.timer_callback, self.intervals[item.title][1])
self.timer.start()
def __init__(self, timer_interval=1):
self.timer = rumps.Timer(self.on_tick, 1)
self.timer.stop() # timer running when initialized
self.timer.count = 0
self.app = rumps.App("Timebox", "🥊")
self.desk_handler = SSHDeskHandler()
self.interval = SEC_TO_MIN
self.current_things_task_url = None
self.start_pause_button = rumps.MenuItem(
title="Start Timer",
callback=lambda _: self.start_timer(_, self.interval),
key="s",
)
self.toggle_sit_stand_button = rumps.MenuItem(
title="Toggle Sit/Stand",
callback=lambda sender: self.toggle_button(sender),
key="t",
)
self.toggle_sit_stand_button.state = True
self.stop_button = rumps.MenuItem(title="Stop Timer", callback=None)
self.buttons = {}
self.buttons_callback = {}
for i in [5, 10, 15, 20, 25]:
title = str(i) + " Minutes"
callback = lambda _, j=i: self.set_mins(_, j, None)
self.buttons["btn_" + str(i)] = rumps.MenuItem(
title=title, callback=callback
)
self.buttons_callback[title] = callback
self.sync_button = rumps.MenuItem(
title="Sync", callback=lambda _: self.sync_data(), key="r"
)
self.sum_menu_item = rumps.MenuItem(
title="sum_total_time", callback=None
)
self.app.menu = [
self.start_pause_button,
self.sync_button,
self.toggle_sit_stand_button,
None,
self.sum_menu_item,
# *self.things_buttons.values(),
None,
*self.buttons.values(),
None,
self.stop_button,
]
self.sync_data()
def __init__(self):
self.config = {
"app_name": "SpeedTest",
"start": "Check Speed",
"interval": 1500
}
self.app = rumps.App(self.config["app_name"])
self.timer = rumps.Timer(self.on_tick, 60)
self.interval = self.config["interval"]
self.set_up_menu()
self.update_button = rumps.MenuItem(title=self.config["start"],
callback=self.check_speed)
self.app.menu = [self.update_button]
def __init__(self):
super(App, self).__init__("HipStatus")
self.icon = _menu_bar_icon(0)
self.preferences = Preferences()
self._validate_preferences()
self.keychain = Keychain(self.preferences.email())
self._validate_keychain()
self.hipchat = HipChat(self.keychain.read_token())
self.office365 = Office365(self.preferences.email(),
self.keychain.read_o365())
self.menu_pause_button = rumps.MenuItem("Pause HipStatus",
self.timer_pause)
self.menu_preferences = rumps.MenuItem('Preferences...')
self.menu = [
self.menu_pause_button, rumps.separator, self.menu_preferences,
rumps.separator
]
self.menu_preferences_message = rumps.MenuItem(
"", self.preferences_message)
if self.preferences.default_message():
self.menu_preferences_message.title = self.preferences.default_message(
)
else:
self.menu_preferences_message.title = "None..."
self.menu_preferences_email = rumps.MenuItem(
"Change email address", self.preferences_update_email)
self.menu_preferences_o365 = rumps.MenuItem(
"Update saved Office 365 password", self.preferences_update_o365)
self.menu_preferences_token = rumps.MenuItem(
"Update saved HipChat token", self.preferences_update_token)
self.menu_preferences_get_token = rumps.MenuItem(
"Get your HipChat token", open_browser)
self.menu_preferences.add(rumps.MenuItem('Status message...'))
self.menu_preferences.add(self.menu_preferences_message)
self.menu_preferences.add(rumps.separator)
self.menu_preferences.add(rumps.MenuItem('Preferences...'))
self.menu_preferences.add(self.menu_preferences_email)
self.menu_preferences.add(self.menu_preferences_o365)
self.menu_preferences.add(self.menu_preferences_token)
self.menu_preferences.add(rumps.separator)
self.menu_preferences.add(self.menu_preferences_get_token)
self.main_timer = rumps.Timer(self.timer_trigger, 300)
self.main_timer.start()
def refresh_interval_thread(self, force_refresh=False, stop=False):
""" Our interval Timer (thread) which will request our tickets
after a specified time """
if self.refresh_interval_timer is not None:
if stop:
self.refresh_interval_timer.stop()
return
elif force_refresh:
self.refresh_interval_timer.stop()
# new Timer with callback and time
self.refresh_interval_timer = rumps.Timer(self.get_tickets, self.refresh_interval_minutes)
self.refresh_interval_timer.start()
def __init__(self):
# Create subclass of rumps.App
super(CrawlPaper, self).__init__(
type(self).__name__,
icon="/Users/jonathanolson/GitHub/crawlpaper/menuicon.png",
template=True)
self.currentWallpaper = None
self.timer = rumps.Timer(self.updateWallpaper, 60)
self.timer.start()
self.menu = [
"Update Wallpaper", "Download New Wallpapers",
"Delete Current Wallpaper", "Delete All Wallpapers",
"Enable Wallpaper Auto Update", "Disable Wallpaper Auto Update"
]
def __init__(self, work_interval=3600, nag_interval=60):
self.work_interval = work_interval
self.nag_interval = nag_interval
self.work_delta = datetime.timedelta(seconds=work_interval)
self.nag_delta = datetime.timedelta(seconds=nag_interval)
self.delta = self.work_delta
self.checkin = datetime.datetime.now()
self.app = rumps.App(
"Break Timer",
icon="wind.png")
self.app.menu = [
rumps.MenuItem('Stop', self.stop),
rumps.MenuItem('Take Break', self.break_popup)
]
self.work_timer = rumps.Timer(self.take_break, 10)
self.front_timer = rumps.Timer(self.bring_to_front, 10)
self.nag = False
self.paused = False
def __init__(self, initial_seconds):
super(TimerApp, self).__init__("")
self.mode = "hourglass"
self.timekeeper = timekeeper.Timer(initial_seconds)
self.template = True
self.im = icon_manager.Icon_manager(initial_seconds)
self.change_icon()
self.remaining_sec = rumps.MenuItem(self.timekeeper.get_remaining_string())
self.menu = [self.remaining_sec]
self.next_icon_change = self.im.icon_interval
self.rumps_timer = rumps.Timer(self.tick,0.5)
self.rumps_timer.callback(self.tick)
self.invert_counter = 0
self.notified = False
self.sound = True
def init_menu(self):
check_in_menu = rumps.MenuItem('自动签到')
check_in_menu.state = 1 if self.setting_config.get(
'check', False) else 0
self.menu.add(check_in_menu)
msg_menu = rumps.MenuItem("消息提醒")
msg_menu.state = 1 if self.setting_config.get("msg", False) else 0
self.menu.add(msg_menu)
molecules_menu = rumps.MenuItem("分子提醒")
molecules_menu.state = 1 if self.setting_config.get(
"molecule", False) else 0
self.menu.add(molecules_menu)
if self.setting_config.get("molecule", False) or self.setting_config.get("msg", False):
self.msg_timer = rumps.Timer(self.get_msg, 10 * 60)
self.msg_timer.start()
def run(self):
if self.config.welcome:
self.welcome()
else:
self.check_accessibility()
osa_api.set_require_password_wake()
threading.Thread(target=self.thread_monitor).start()
def t_refresh():
try:
ts = []
count = 0
while True:
if not self.need_restart:
t = time.time()
self.callback_refresh()
t = time.time() - t
if count > 5:
tl = len(ts)
ta = t if tl == 0 else sum(ts) / tl
if tl < 10 or t < ta * 2:
ts.append(t)
if tl >= 10:
ts.pop(0)
if ta >= Const.restart_deadline:
self.need_restart = True
Log.append(
t_refresh, 'Warning',
'Refresh timeout (%s), Need restart.' % ta)
if count % 30 == 0 and not self.lid_stat:
Log.append(t_refresh, 'Info',
'Refresh average time (%s).' % ta)
else:
self.callback_refresh()
time.sleep(1)
count += 1
except:
self.callback_exception()
threading.Thread(target=t_refresh).start()
rumps.Timer(self.callback_refresh_view, 1).start()
super().run()
def __init__(self):
super().__init__(
"Codefresh Status",
icon=green_icon,
menu=[
rumps.separator,
ErroredBuildsMenu(),
rumps.separator,
TimePeriodMenu(self),
SettingsMenu(self),
rumps.separator,
],
)
self.event_loop = rumps.Timer(self._get_cf_builds,
float(settings.status_check_interval))
self.event_loop.start()
