async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Wifi status",
detailed_description="Wifi status bar components",
knobs=[],
exemplar="wifi | ▁▂▄ | ",
update_cadence=5,
identifier="take.wifi")
@iterm2.StatusBarRPC
async def wifi_status(knobs):
signal = ""
output = subprocess.check_output(args=[airport_path, "-I"]).decode()
info = re.findall(
"[\s]*(agrCtlRSSI|agrCtlNoise|state|lastTxRate|SSID):[\s]([!-~\ ]*)",
output)
rssi = int(info[0][1])
noise = int(info[1][1])
rate = info[3][1]
ssid = info[5][1]
snr = rssi - noise
if int(rate) == 0:
signal = "🙅♂️"
status = "{0}".format(signal)
else:
# 25dB SNR -> 5 bars
power = min(snr // 5, 5)
signal = "".join(signals[:power])
status = "{0} | {1} |".format(ssid, signal)
# print(f"rssi: {rssi}, noise: {noise}, snr: {snr}, ssid: {ssid}")
return status
await component.async_register(connection, wifi_status)
async def main(connection):
await iterm2.async_get_app(connection)
icon2x = iterm2.StatusBarComponent.Icon(
2,
"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"
)
icon1x = iterm2.StatusBarComponent.Icon(
1,
"iVBORw0KGgoAAAANSUhEUgAAABAAAAARCAYAAADUryzEAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAAlmVYSWZNTQAqAAAACAAFARIAAwAAAAEAAQAAARoABQAAAAEAAABKARsABQAAAAEAAABSATEAAgAAABEAAABah2kABAAAAAEAAABsAAAAAAAAAGAAAAABAAAAYAAAAAF3d3cuaW5rc2NhcGUub3JnAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAEKADAAQAAAABAAAAEQAAAAAWaVyHAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAComlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnRpZmY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvIgogICAgICAgICAgICB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+d3d3Lmlua3NjYXBlLm9yZzwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8dGlmZjpPcmllbnRhdGlvbj4xPC90aWZmOk9yaWVudGF0aW9uPgogICAgICAgICA8ZXhpZjpDb2xvclNwYWNlPjE8L2V4aWY6Q29sb3JTcGFjZT4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjE3PC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjE2PC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CvGU6sAAAAEcSURBVDgRrZK7agJBFIZX10saRRC0sAmkTZXa1sYiraWCD+Fj5FFSWfoAEru8gY0QQtDCEJKgfr87J2x2ZsDCA9+enXP5Z87spkncSqTK8fSVMmlARzvLHmAEG/iEBvzCEf4sJKBkCyYwhyH04BbeQGK2iTejJboUreEVtGsHZN6deIGsLjngTUxH/nEo/s9iAiqqu8oqXnUV5104czEBHXsKLzCAD9Du3gmkGrJvgnfQhBXs4CIBza2Z287jkhvQJSpXg6jZpWnmZ5CQffdZrsvqcqHs1f6JPss95AXeWUvYaw5dopq/QCYR2Rb0KW2tWNBM8Imsio2xq/ZOUAxobbs88n4PC1jCxVYUVWModhaMJsjaODbGuaH4OAEUkzSDoz1zAAAAAABJRU5ErkJggg=="
)
component = iterm2.StatusBarComponent(
short_description="Temp CPU",
detailed_description="Shows the temperature of the CPU",
knobs=[],
exemplar=GetTemp(),
update_cadence=10,
identifier="com.iterm2.example.cpu-temp",
icons=[icon1x, icon2x])
# This function gets called once per second.
@iterm2.StatusBarRPC
async def coro(knobs, cputemp=iterm2.Reference("iterm2.user.cputemp?")):
return GetTemp() + " ☢ " + GetFan()
# Register the component.
await component.async_register(connection, coro)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Vagrant Counter",
detailed_description="Show Number of Vagrant VM",
knobs=[],
exemplar="[Vagrant Counter]",
update_cadence=30,
identifier="koh-sh.vagrant-counter")
@iterm2.StatusBarRPC
async def vagrant_counter(knobs):
# TODO: find better emojis
up = "🔵 "
down = "âš« "
try:
fpath = os.environ["HOME"] + "/.vagrant.d/data/machine-index/index"
with open(fpath, "r") as f:
d = json.loads(f.read())
vms = d["machines"]
up_vms = [x for x in vms if vms[x]["state"] == "running"]
all_machines = len(vms)
up_machines = len(up_vms)
return (up * up_machines) + (down * (all_machines - up_machines))
except Exception:
return "Cannot find Vagrant info"
await component.async_register(connection, vagrant_counter)
async def main(connection):
app = await iterm2.async_get_app(connection)
asyncio.create_task(poll(app))
icon1x = iterm2.StatusBarComponent.Icon(1, ICON1X)
icon2x = iterm2.StatusBarComponent.Icon(2, ICON2X)
# Register the status bar component.
component = iterm2.StatusBarComponent(
short_description="Disk IO",
detailed_description="Shows your overall disk read/write speed",
knobs=[],
exemplar="🆁1.2MB/s 🆆️10.5MB/",
update_cadence=None,
identifier="catj.moe.disk_io",
icons=[icon1x, icon2x])
@iterm2.StatusBarRPC
async def disk_io_coroutine(knobs, value=iterm2.Reference("iterm2.user." + DISK_IO_VARIABLE + "?")):
"""This function returns the value to show in a status bar."""
if value:
return value
return "Loading…"
# Register the component.
await component.async_register(connection, disk_io_coroutine)
async def main(connection):
fmt = 'fmt'
default_fmt = '%m/%d %a %H:%M:%S'
knobs = [
iterm2.StringKnob(name='format',
placeholder=default_fmt,
default_value=default_fmt,
key=fmt)
]
component = iterm2.StatusBarComponent(
short_description='Clock',
detailed_description='A customized clock.',
knobs=knobs,
exemplar=' 08/03 Sat 01:56:48',
update_cadence=1,
identifier='peinan.clock')
@iterm2.StatusBarRPC
async def clock(knobs):
n = datetime.now()
clock_char = ''
if fmt in knobs and knobs[fmt]:
clock_face = f'{clock_char} {n.strftime(knobs[fmt])}'
else:
clock_face = f'{clock_char} {n.strftime(default_fmt)}'
return clock_face
await component.async_register(connection, clock)
async def main(connection):
# Define the configuration knobs:
ds = "docker_status"
knobs = []
component = iterm2.StatusBarComponent(
short_description="Docker Status",
detailed_description=
"Show docker status and number or running containers",
knobs=knobs,
exemplar=" Docker status",
update_cadence=60,
identifier="fr.gabrielpichot.iterm2.statusbarcomponent.docker_status")
@iterm2.StatusBarRPC
async def coro(knobs):
try:
running = get_docker_info('ContainersRunning')
paused = get_docker_info('ContainersPaused')
stopped = get_docker_info('ContainersStopped')
except DockerNotRunning as e:
print(e)
return " Stopped"
except Exception as e:
print(e)
return " Errored"
return " {} {} {} ".format(running, stopped, paused)
# Register the component.
await component.async_register(connection, coro)
async def main(connection):
icon1x = iterm2.StatusBarComponent.Icon(1, ICON1X)
icon2x = iterm2.StatusBarComponent.Icon(2, ICON2X)
component = iterm2.StatusBarComponent(
short_description="Enhanced Time",
detailed_description="Display current tme with extra information",
knobs=[],
exemplar=local_time(),
update_cadence=1,
identifier="catj.moe.localtime",
icons=[icon1x, icon2x])
@iterm2.StatusBarRPC
async def localtime(knobs):
return local_time()
@iterm2.RPC
async def onclick(session_id):
word_time = "Loading"
try:
word_time = get_world_time()
except:
word_time = "Loading"
if word_time is not None:
await component.async_open_popover(session_id, word_time,
iterm2.util.Size(256, 340))
# Register the component.
await component.async_register(connection, localtime, onclick=onclick)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='pyenv',
detailed_description='The currently active Python',
exemplar='🐍 3.7.2',
update_cadence=2,
identifier='engineering.dane.iterm-components.pyenv',
knobs=[],
)
@iterm2.StatusBarRPC
async def pyenv_coroutine(knobs):
proc = await asyncio.create_subprocess_shell(
'pyenv local',
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await proc.communicate()
if stderr:
return stderr.decode().strip()
env = stdout.decode().strip()
return f'🐍 {env}'
await component.async_register(connection, pyenv_coroutine)
async def main(connection):
api_key = "atlas_api_key"
knobs = [iterm2.StringKnob("API key", "API KEY", "", api_key)]
component = iterm2.StatusBarComponent(
short_description="RIPE Atlas Credits",
detailed_description="Shows credits balance at atlas.ripe.net",
knobs=knobs,
exemplar="0.0 / 34,000.0 / 4,000,000.0",
update_cadence=300,
identifier="com.iterm2.example.status-bar")
@iterm2.StatusBarRPC
async def coro(knobs):
URL = 'https://atlas.ripe.net/api/v2/credits/'
PARAMS = {'key': knobs[api_key]}
try:
r = requests.get(url=URL, params=PARAMS)
data = r.json()
daily = data['estimated_daily_income']
total = data['current_balance']
expenditure = data['estimated_daily_expenditure']
except:
raise
else:
return f'{float(expenditure):,.1f} / {float(daily):,.1f} / {float(total):,.1f}'
await component.async_register(connection, coro)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='GitHub stars',
detailed_description='How many stars a GitHub repository has',
exemplar='some-user/project ★ 103',
update_cadence=300,
identifier='engineering.dane.iterm-components.github-stars',
knobs=[
iterm2.StringKnob('Repository', 'some-user/project', 'some-user/project', REPO_KNOB_NAME),
iterm2.StringKnob('Personal access token', 'token value (optional, for rate limiting or private repos)', '', TOKEN_KNOB_NAME)
],
)
@iterm2.StatusBarRPC
async def github_stars_coroutine(knobs):
github_repo = knobs[REPO_KNOB_NAME]
token = knobs[TOKEN_KNOB_NAME]
info_url = f'https://api.github.com/repos/{github_repo}'
try:
request = urllib.request.Request(
info_url,
headers={'Authorization': f'token {token}'} if token else {},
)
stars = json.loads(
urllib.request.urlopen(request).read().decode()
)['stargazers_count']
stars = human_number(stars)
except:
raise
else:
return f'{github_repo} ★ {stars}'
await component.async_register(connection, github_stars_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='rvm gemset',
detailed_description='The currently active rvm gemset',
exemplar='♦ gemset',
update_cadence=2,
identifier='engineering.dane.iterm-components.rvm-gemset',
knobs=[],
)
@iterm2.StatusBarRPC
async def rvm_gemset_coroutine(knobs):
proc = await asyncio.create_subprocess_shell(
'${HOME}/.rvm/bin/rvm-prompt g',
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await proc.communicate()
if stderr:
return '♦ rvm not installed!'
gemset = stdout.decode().strip().replace('@', '') or 'default'
return f'♦ {gemset}'
await component.async_register(connection, rvm_gemset_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Execute a user defined command',
detailed_description='A component that displays the output of an arbitrary command with an optional prefix',
exemplar='> hello world',
update_cadence=7,
identifier='engineering.dane.iterm-components.generic-command',
knobs=[
iterm2.StringKnob('Script', 'echo "hello world"', '', SCRIPT),
iterm2.StringKnob('Prefix', '>', '', PREFIX)
],
)
@iterm2.StatusBarRPC
async def generic_command_coroutine(knobs):
proc = await asyncio.create_subprocess_shell(
knobs[SCRIPT],
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await proc.communicate()
prefix = knobs[PREFIX]
prefix = f'{prefix} ' if prefix else ''
return f'{prefix}{stdout.decode().strip()}' if not stderr else 'Command failed!'
await component.async_register(connection, generic_command_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Bitcoin Mempool Stats',
detailed_description=
'Displays BTC mempool size and unconfirmed transactions count',
exemplar='BTC Mempool 4,239 txs @ 1.03 MB',
update_cadence=60,
identifier='schnogz.iterm-crypto-components.btc-mempool',
knobs=[],
)
@iterm2.StatusBarRPC
async def btc_mempool_coroutine(knobs):
stats_url = 'https://api.blockchair.com/bitcoin/stats'
try:
context = ssl._create_unverified_context()
request = urllib.request.Request(
stats_url,
headers={},
)
stats = json.loads(
urllib.request.urlopen(request,
context=context).read().decode())
unconfirmed_tx_count = format(
stats['data']['mempool_transactions'], ',')
mempool_size = round(stats['data']['mempool_size'] / 1000000, 2)
except:
raise
else:
return f'BTC Mempool {unconfirmed_tx_count} txs @ {mempool_size} MB'
await component.async_register(connection, btc_mempool_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Weather',
detailed_description='Display weather by using darksky-weather',
exemplar='🌧️8°C',
update_cadence=900,
identifier='vxider.iterm-components.weather',
knobs=[],
)
@iterm2.StatusBarRPC
async def weather_coroutine(knobs):
try:
output = check_output(["/usr/local/bin/weather", "-json"],
stderr=STDOUT,
timeout=10)
data = json.loads(output.decode().strip())
weather = data['currently']['temperature']
icon_text = data['currently']['icon']
unit = data['flags']['units']
return f'{get_weather_icon(icon_text)}{int(weather)}{get_temperature(unit)}'
except Exception as e:
print(e)
return '☁️ N/A'
await component.async_register(connection, weather_coroutine, timeout=15)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Ethereum Price',
detailed_description='Displays current price of Ethereum',
exemplar='ETH $321.50',
update_cadence=30,
identifier='schnogz.iterm-crypto-components.eth-price',
knobs=[],
)
@iterm2.StatusBarRPC
async def ethereum_price_coroutine(knobs):
price_url = 'https://api.blockchair.com/ethereum/stats'
try:
context = ssl._create_unverified_context()
request = urllib.request.Request(
price_url,
headers={},
)
price = format(
round(
json.loads(
urllib.request.urlopen(
request, context=context).read().decode())['data']
['market_price_usd'], 2), ',')
except:
raise
else:
return f'ETH ${price}'
await component.async_register(connection, ethereum_price_coroutine)
async def main(connection):
app = await iterm2.async_get_app(connection)
# Start fetching the URL
asyncio.create_task(updater(app, type='current'))
asyncio.create_task(updater(app, type='forecast'))
location_knob = "weather_location"
update_interval_knob = "weather_update_interval"
knobs = [
iterm2.StringKnob("Location", "Hangzhou", "Hangzhou", location_knob),
iterm2.StringKnob("Update Interval", "60", "60", update_interval_knob)
]
# icon1x = iterm2.StatusBarComponent.Icon(1, ICON1X)
# icon2x = iterm2.StatusBarComponent.Icon(2, ICON2X)
# Register the status bar component.
component = iterm2.StatusBarComponent(
short_description="Weather",
detailed_description="Shows your local weather",
knobs=knobs,
exemplar="☁️Weather",
update_cadence=None,
identifier="catj.moe.weather")
@iterm2.StatusBarRPC
async def weather(knobs,
value=iterm2.Reference("iterm2.user." +
CURRENT_VARIABLE + "?")):
"""This function returns the value to show in a status bar."""
global city
global update_interval
if location_knob in knobs and knobs[location_knob]:
city = knobs[location_knob]
if update_interval_knob in knobs and knobs[update_interval_knob]:
update_interval = int(knobs[update_interval_knob])
if value:
return value
return "Loading…"
@iterm2.RPC
async def onclick(session_id):
session = app.get_session_by_id(session_id)
forecast_weather = "Loading"
try:
forecast_weather = await format_weather(app)
except:
forecast_weather = "Loading"
if forecast_weather is not None:
await component.async_open_popover(session_id, forecast_weather,
iterm2.util.Size(480, 520))
# Register the component.
await component.async_register(connection, weather, onclick=onclick)
async def main(connection):
knob_icons = KnobOption('icons', '')
knob_free = KnobOption('free', True)
knob_usedtotal = KnobOption('usedtotal', True)
knob_usedpercent = KnobOption('usedpercent', True)
knobs = [
iterm2.StringKnob(name='Icons',
default_value=knob_icons.v,
placeholder=knob_icons.v,
key=knob_icons.name),
iterm2.CheckboxKnob(name='Show Free Space',
default_value=knob_free.v,
key=knob_free.name),
iterm2.CheckboxKnob(name='Show Used/Total Space',
default_value=knob_usedtotal.v,
key=knob_usedtotal.name),
iterm2.CheckboxKnob(name='Show Used Space (%)',
default_value=knob_usedpercent.v,
key=knob_usedpercent.name),
]
component = iterm2.StatusBarComponent(
short_description='Disk Usage',
detailed_description='Display the usage of disk.',
knobs=knobs,
exemplar=' 44.1 GB 179.7/233.5 GB (81.0%)',
update_cadence=2,
identifier='peinan.diskusage')
def is_true_knob(knobs, knob_option: KnobOption):
return knob_option.name in knobs and knobs[knob_option.name]
@iterm2.StatusBarRPC
async def diskusage(knobs):
true_icons = is_true_knob(knobs, knob_icons)
true_free = is_true_knob(knobs, knob_free)
true_usedtotal = is_true_knob(knobs, knob_usedtotal)
true_usedpercent = is_true_knob(knobs, knob_usedpercent)
char_header = knobs[knob_icons.name][0] if true_icons else ''
char_usedtotal = f' {knobs[knob_icons.name][-1]}' if true_icons and true_free and true_usedtotal else ''
disk = shutil.disk_usage('/')
unit = sizeof_fmt(disk.total)[1]
v_free = f' {" ".join(sizeof_fmt(disk.free))}' if true_free else ''
v_usedtotal = f' {sizeof_fmt(disk.used)[0]}/{sizeof_fmt(disk.total)[0]} {unit}' if true_usedtotal else ''
v_usedp = f' ({100 * disk.used / disk.total:.1f}%)' if (true_free or true_usedtotal) and true_usedpercent\
else f' {100 * disk.used / disk.total:.1f}%' if true_usedpercent else ''
usage = f'{char_header}{v_free}{char_usedtotal}{v_usedtotal}{v_usedp}'
return usage
await component.async_register(connection, diskusage)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="spotify",
detailed_description="This Component shows the current spotfiy song",
knobs=[],
exemplar="spotify",
update_cadence=1,
identifier="com.iterm2.spotify")
@iterm2.StatusBarRPC
async def coro(knobs,
rows=iterm2.Reference("rows"),
cols=iterm2.Reference("columns")):
status_delimiter = '-~`/='
ascript = '''
tell application "System Events"
set process_list to (name of every process)
end tell
if process_list contains "Spotify" then
tell application "Spotify"
if player state is playing or player state is paused then
set track_name to name of current track
set artist_name to artist of current track
set album_name to album of current track
set track_length to duration of current track
set now_playing to "" & player state & "{0}" & album_name & "{0}" & artist_name & "{0}" & track_name & "{0}" & track_length & "{0}" & player position
return now_playing
else
return player state
end if
end tell
end if
'''.format(status_delimiter)
spotify = asrun(ascript)
if not spotify:
return ""
spotify_status = spotify.split(status_delimiter)
state = _convert_state(spotify_status[0])
if state == 'stop':
return None
artist = spotify_status[2]
title = spotify_status[3]
total = _convert_seconds(
int(spotify_status[4].replace(',', '.')) / 1000)
elapsed = _convert_seconds(spotify_status[5].replace(',', '.'))
return "{} {} - {} {}/{}".format(state, artist, title, elapsed, total)
# Register the component.
await component.async_register(connection, coro)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Hello, world!',
detailed_description='Says hello in a random language periodically',
exemplar='¡Hola, mundo!',
update_cadence=5,
identifier='engineering.dane.iterm-components.sentinel',
knobs=[],
)
@iterm2.StatusBarRPC
async def hello_world_coroutine(knobs):
return random.choice(GREETINGS)
await component.async_register(connection, hello_world_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Sprint',
detailed_description='show Sprint days',
exemplar='Sprint',
update_cadence=5,
identifier='engineering.paulomcnally.iterm-components.sprint',
knobs=[],
)
@iterm2.StatusBarRPC
async def sprint_coroutine(knobs):
return '🗓️ Sprint %d: %s' % (SPRINT_NUMBER, message(days))
await component.async_register(connection, sprint_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Unix Time",
detailed_description="Show Unix Time",
knobs=[],
exemplar="[Unix Time]",
update_cadence=1,
identifier="koh-sh.iterm2-statusbar-scripts.unixtime"
)
@iterm2.StatusBarRPC
async def showunixtime(knobs):
return "UnixTime: " + str(int(time.time()))
await component.async_register(connection, showunixtime)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Load Average",
detailed_description="Show Load Average",
knobs=[],
exemplar="[Load Average]",
update_cadence=1,
identifier="koh-sh.iterm2-statusbar-scripts.loadaverage")
@iterm2.StatusBarRPC
async def showloadaverage(knobs):
la = os.getloadavg()
return ("LoadAvg: " + " ".join([str(round(x, 2)) for x in la]))
await component.async_register(connection, showloadaverage)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Current song playing",
detailed_description=
"Show the current song playing in iTunes or Spotify",
exemplar="Spotify: ▶️ Danzig - Mother",
update_cadence=1,
identifier="dev.djordje.iterm-components.current-song",
knobs=[])
@iterm2.StatusBarRPC
async def current_song_coroutine(knobs):
current_song = get_current_song()
return current_song
await component.async_register(connection, current_song_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Days until Christmas',
detailed_description='Display the number of days until christmas.',
knobs=[],
exemplar='🎄 93',
update_cadence=1,
identifier='xmas.counter')
@iterm2.StatusBarRPC
async def christmas_counter(knobs):
christmas = datetime.datetime.now()
christmas = christmas.replace(month=12, day=25)
return "🎄 {}".format((christmas - datetime.datetime.now()).days)
await component.async_register(connection, christmas_counter)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='NodeJS Version',
detailed_description='show nodejs version',
exemplar='NodeJS Version',
update_cadence=5,
identifier='engineering.paulomcnally.iterm-components.node',
knobs=[],
)
@iterm2.StatusBarRPC
async def node_coroutine(knobs):
output = subprocess.check_output(['bash', '-c', bashCommand]).strip()
return 'Node: %s' % output[1:]
await component.async_register(connection, node_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='Days employed',
detailed_description='Display the number of days at Kubra.',
knobs=[],
exemplar='💼 93',
update_cadence=1,
identifier='employment.counter'
)
@iterm2.StatusBarRPC
async def days_employed_counter(knobs):
employed_at = datetime.datetime(month=6, day=24, year=2019)
return "💼 {}".format((datetime.datetime.now() - employed_at).days)
await component.async_register(connection, days_employed_counter)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description='pyenv',
detailed_description='The currently active Python',
exemplar='🐍 3.7.2',
update_cadence=2,
identifier='engineering.dane.iterm-components.pyenv',
knobs=[],
)
@iterm2.StatusBarRPC
async def pyenv_coroutine(knobs, python=iterm2.Reference('user.python_version?')):
python = python or '☠️'
return f'🐍 {python}'
await component.async_register(connection, pyenv_coroutine)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="iTunes",
detailed_description="This Component shows the current itunes song",
knobs=[],
exemplar="iTunes",
update_cadence=1,
identifier="com.iterm2.iTunes")
@iterm2.StatusBarRPC
async def coro(
knobs,
rows=iterm2.Reference("rows"),
cols=iterm2.Reference("columns")):
status_delimiter = '-~`/='
ascript = '''
tell application "System Events"
set process_list to (name of every process)
end tell
if process_list contains "Music" then
tell application "Music"
set t_title to name of current track
set t_artist to artist of current track
set t_album to album of current track
set t_duration to duration of current track
set t_elapsed to player position
set t_state to player state
return t_title & "{0}" & t_artist & "{0}" & t_album & "{0}" & t_elapsed & "{0}" & t_duration & "{0}" & t_state
end tell
end if
'''.format(status_delimiter)
now_playing = asrun(ascript)
if not now_playing:
return ""
now_playing = now_playing.split(status_delimiter)
if len(now_playing) != 6:
return
title, artist, album = now_playing[0], now_playing[1], now_playing[2]
state = _convert_state(now_playing[5])
total = _convert_seconds(now_playing[4].replace(',', '.'))
elapsed = _convert_seconds(now_playing[3].replace(',', '.'))
return "{} {} - {} {}/{}".format(state, artist, title, elapsed, total)
# Register the component.
await component.async_register(connection, coro)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="Kubernetes Configuration",
detailed_description=
"This tells you what your current kubernetes context and namespace are",
exemplar="⎈ context:staging namespace:my-cluster",
update_cadence=5,
identifier="com.iterm2.jebentier.iterm2-kubernetes-context",
knobs=[])
@iterm2.StatusBarRPC
async def coro(knobs):
current_config = config.list_kube_config_contexts()[1]
return "⎈ context:{} namespace:{}".format(
current_config['name'], current_config['context']['namespace'])
await component.async_register(connection, coro)
async def main(connection):
component = iterm2.StatusBarComponent(
short_description="GMT Clock",
detailed_description="Shows the time in jolly old England",
knobs=[],
exemplar="[12:00 GMT]",
update_cadence=1,
identifier="com.iterm2.example.gmt-clock")
# This function gets called once per second.
@iterm2.StatusBarRPC
async def coro(knobs):
return datetime.datetime.now(
datetime.timezone.utc).strftime("%H:%M:%S GMT")
# Register the component.
await component.async_register(connection, coro)
