DEV Community: Eli Ostreicher

Tune VS Code like a BOSS

Eli Ostreicher — Sat, 12 Mar 2022 10:11:53 +0000

14 Kick-Ass Extensions You Don’t Wanna Miss!

They say that with Visual Studio Code, Microsoft redeemed themselves amongst the developer community.

Many old time programmers carried a grudge against the Redmond tech giant given their outspoken anti open source stance.

Former Microsoft CEO Steve Ballmer even infamously called the open source operating system Linux “a cancer.”

Today, 14 million developers call VS Code ‘home’. Given that the number of devs worldwide - according to Statista - is around 24 million, thats an insane number!

While VS Code is 100% free, it is also a totally brilliant marketing strategy into Microsoft’s Azure.

As an ex Google Cloud and AWS user, I'd say it's highly doubtful whether without VS Code, Azure would have gotten to be part of ‘the big 3’. Now however, with GitHub and VS Code combined, they pretty much own us all.

Microsoft invests more than $10 Billion In data centers annually and is on pace to build between 50 and 100 new data centers each year for the foreseeable future.

Enough with the politics. Let’s dive into the juicy parts. The following VS Code extensions are a ‘must’:

Bear in mind, given how lightweight VS Code is, there is really never a worry about having ‘too many’ extensions. So just knock yourself out!

Sourcery

Sourcery runs in the background and suggests real-time refactoring improvements. It's actually really fun seeing Sourcery in action #solid

Sourcery Real time Python refactoring

Bookmarks

Bookmarks helps you to navigate your code, and moves between important positions easily and quickly. It also supports a set of selection commands, which allows you to easily select bookmarked lines and regions.

Bookmarks: Mark and Jump

Thunder Client

Thunder Client is a lightweight Rest API Client with a simple and clean design; you’ll never need Postman again. Super fast too!

Thunder Client: an API client done right

Docs View

Automatically displays documentation for the function at the cursor position.
The “Documentation” view shows in the panel by default, move it any panel by just dragging.
Supports syntax highlighting and markdown rendering in the docs view.

For imported functions that have lots of args, this is a lifesaver.

Docs View: Display documentation in the sidebar

Sourcegraph

Sourcegraph allows you to search millions of open source repositories right from VS Code. Super fast too!

Sourcegraph: Search millions of repositories

AI Doc Writer

Writing documentation is no fun, this AI takes care of it. Just highlight the code and hit ⌘ + . The makers of this one are actually on top of their game and constantly keep perfecting. Kudos!

Mintlify: AI Doc Writer

file-size

Shows the current file size in the status bar. I know this sounds 'basic' but it really is super helpful.

file-size: a simple/great extension

Krinql

Based on OpenAI’s powerful GPT-3, Krinql explains the highlighted code in plain English, plus some other Codex features.

Krinql: Code explainer

GistPad

Bonus: Comes with a really useful scratchpad (for note taking etc.) One of my favs.

GistPad: Browse & edit Gists without leaving VS Code

CodeSnap

Just right click a code selection and click CodeSnap, basically a built-in 'Carbon'.

CodeSnap: 📷 Take beautiful screenshots of your code.

IntelliCode Completions

From our friends at Microsoft, this experimental extension predicts up to a whole line of code based on your current context. Predictions appear as grey-text to the right of your cursor.

I’ve head a really great experience using it so far (couple months now)! Mostly I love how conservative it is vs making silly guesses. If it doesn't know, it says nothing.

IntelliCode Completions: AI-driven code auto-completion

AREPL

AREPL: automatically evaluates python code in real-time as you type

Similar to AREPL, Wolf uncovers variables and objects inline:

Wolf: outputs variables inline

While the above are both too cluttering for everyday, they do have their perfect use cases (i.e. a complex code block etc.).

Gather

Again from the awesome peeps at Microsoft, when called from within a notebook cell, Gather magically figures out its dependencies. A game changer for Dataframers & Plotters.

Gather: Jupyter notebook dependencies

Make sure to hit that unicorn please if you enjoyed this post 🦄

Hello Codex: an OpenAI Telegram Bot

Eli Ostreicher — Sun, 06 Mar 2022 18:49:37 +0000

Tired of waiting for a Github Copilot invite, I decided to take matters into my own hands 🙈

OpenAI’s Codex is a a GPT-3 powerhouse that converts plain english into runnable code. It can also do many other tasks related to Code, like translate code from one language to another, generate docstrings and explain already written code in plain english.

Here are the steps to creating your very own personal Codex Telegram bot.

Prerequisite: For Codex API access you need to get an invite from OpenAI. This is free and I got approved after around one week. Join the waitlist here.

If you haven’t already done so, download Telegram, they also offer a great desktop app.

Request a Bot
For this, you talk to BotFather. He is your go-to for all things bot, from creation to settings etc.

Type /newbot to begin.

The BotFather will ask you to pick a bot name (which must be universally unique) and a username, it then generates an authentication token for your new bot.

Codex Key
Next, go ahead and grab your API key from OpenAI.

Take note of the 2 keys you just got, we’re going to need them soon.

💡 Dealing with secrets across environments can be a hassle. The folks at Doppler offer a great (and free) product to handle it all.

Python Code
Fire up your favorite editor (VS Code in my case) and lets have some fun!

To start, we pip install the following two libraries:

pip install openai
pip install pyTelegramBotAPI

Begin like so:

import logging
from os import environ as env
from dotenv import load_dotenv # if you dont have dotenv yet: pip install python-dotenv

import telebot
import openai

logger = telebot.logger
telebot.logger.setLevel(logging.DEBUG)

load_dotenv()
bot = telebot.TeleBot(env["BOT_API_KEY"])
openai.api_key = env["OPENAI_API_KEY"]

Enabling logging is always a great idea when working with API’s. Eventually we’ll want to host this somewhere and so the more we log, the less in the dark we are.

Notice how I’m importing environ from os. Using env[‘BOT_API_KEY’] is just prettier/neater than os.environ 🤷‍♂️

Now, let’s establish the communiqué between our shiny new bot and Codex.

@bot.message_handler(func=lambda message: True)
def get_codex(message):
    response = openai.Completion.create(
        engine="code-davinci-001",
        prompt='"""\n{}\n"""'.format(message.text),
        temperature=0,
        max_tokens=1200,
        top_p=1,
        frequency_penalty=0,
        presence_penalty=0,
        stop=['"""'])

    bot.send_message(message.chat.id,
    f'```python\n{response["choices"][0]["text"]}\n```',
    parse_mode="Markdown")

bot.infinity_polling()

Above, we first establish the bot’s decorator to pass on our message to the function below it.

We set max_tokens to 1200 this is because while Codex allows for a max of 4,096 tokens (including your prompt) per call, Telegram bots are capped at 4,096 UTF-8 characters per message. One token is equivalent to roughly 4 characters.

Learn more about the various openai.Completion.create parameters here, their docs are awesome.

In bot.send_message we take advantage of the fact that Telegram offers great Markdown support so the code displays nicely and also allows for tap-to-copy.

Finally, bot.infinity_polling() keeps a constant open ear for incoming messages.

There are lots of other cool things a Telegram bot can do and pyTelegramBotAPI breaks it all down in much detail.

Before running the script, create a .env file in your current directory like so:

BOT_API_KEY = bot-key-here
OPENAI_API_KEY = openai-key-here

Here is what your full script should look like:

    import logging
    from os import environ as env
    from dotenv import load_dotenv # if you dont have dotenv yet: pip install python-dotenv

    import telebot
    import openai


    logger = telebot.logger
    telebot.logger.setLevel(logging.DEBUG)

    load_dotenv()
    bot = telebot.TeleBot(env["BOT_API_KEY"])
    openai.api_key = env["OPENAI_API_KEY"]

    @bot.message_handler(func=lambda message: True)
    def get_codex(message):
    response = openai.Completion.create(
        engine="code-davinci-001",
        prompt='"""\n{}\n"""'.format(message.text),
        temperature=0,
        max_tokens=1200,
        top_p=1,
        frequency_penalty=0,
        presence_penalty=0,
        stop=['"""'])

    bot.send_message(message.chat.id,
    f'```python\n{response["choices"][0]["text"]}\n```',
    parse_mode="Markdown")

    bot.infinity_polling()

Congrats! You now have your very own Codex always at your fingertips.

For your bot to be always accessible you’ll want to host it in the cloud. Whether AWS or Heroku, go with your favorite; bear in mind though that bot.infinity_polling() will need a server setup (i.e. Flask) to run correctly.

To avoid constant compute minutes we can set a webhook instead of polling. In the next article I’ll show you how I did this as an Azure Function app.