Fly With Python at the Speed of Thought – Real Python

Subscribe to GitHub Copilot

To allow GitHub Copilot, go to the billing settings in your GitHub profile and scroll down till you see the related part. Sadly, the service doesn’t come freed from cost for most individuals on the market. On the time of writing, the service prices ten {dollars} monthly or 100 {dollars} per yr when paid upfront. You possibly can take pleasure in a sixty-day trial interval with out paying something, however solely after offering your billing data.

College students and open-source maintainers might get a free GitHub Copilot subscription. When you’re a fortunate one, then you definitely’ll see the next data after enabling the service:

GitHub will confirm your standing annually primarily based on proof of educational enrollment, corresponding to an image of your faculty ID or an e mail handle within the .edu area, or your exercise in one of many fashionable open-source repositories.

For detailed directions on organising and managing your GitHub subscription, comply with the steps within the official documentation. Subsequent up, you’ll discover ways to set up the GitHub Copilot extension for Visible Studio Code. When you’d desire to make use of GitHub Copilot with PyCharm as an alternative, then skip forward to learn how.

Set up a Visible Studio Code Extension

As a result of Microsoft owns GitHub, it’s no shock that their Visible Studio Code editor was the primary device to obtain GitHub Copilot assist. There are a couple of methods to put in extensions in Visible Studio Code, however the quickest one might be by mentioning the Fast Open panel utilizing Ctrl+P or Cmd+P after which typing the next command:

ext set up GitHub.copilot

Once you affirm it by urgent Enter, it’ll set up the extension and immediate you to reload the editor afterward.

Alternatively, you’ll find the Extensions icon within the Exercise Bar situated on the left-hand aspect of the window and take a look at trying to find the GitHub Copilot extension on the Visual Studio Marketplace:

You may also present the Extensions view in Visible Studio Code immediately through the use of a corresponding keyboard shortcut.

After the set up is full, Visible Studio Code will ask you to register to GitHub to present it entry to your GitHub profile, which your new extension requires:

Visible Studio Code must know who you might be to confirm your GitHub Copilot subscription standing. Nevertheless, granting entry to your GitHub profile will even permit the editor to learn your personal repositories. When you change your thoughts, then you may revoke this authorization at any time by going to your GitHub profile settings and discovering GitHub for VS Code within the Authorized OAuth Apps.

To make working with GitHub Copilot in Visible Studio Code much more productive, listed here are the commonest keyboard shortcuts price remembering:

If you run into issues getting the default shortcuts to work, then try defining your own key bindings in Visual Studio Code. This might be especially helpful if you’re working with a non-US keyboard layout.

Sometimes GitHub Copilot suggestions may get in your way. If that’s the case, then you can disable them globally or for a particular programming language by clicking on the extension’s icon in the bottom right corner of the editor’s window:

That’s it! You’re all set to start using the GitHub Copilot extension in Visual Studio Code. But if you’d prefer to use GitHub Copilot with PyCharm, read on to find out how.

Install a PyCharm Plugin

PyCharm is one of many popular integrated development environments provided by JetBrains and sharing a common GitHub Copilot plugin. You can install that plugin by opening the Settings in your IDE, and choosing Plugins from the list of options. Then, on the Marketplace tab, search for the GitHub Copilot plugin and click the Install button next to it:

After installing the plugin, you’ll be prompted to restart your IDE. When you do, you’ll have to log in to GitHub by choosing Tools from the PyCharm menu, then GitHub Copilot, and Login to GitHub:

That’ll generate a pseudo-random device code that you must copy and paste into the Device Activation page in your web browser, which you’ll be taken to after logging in to GitHub:

As with Visual Studio Code, you’ll need to authorize PyCharm’s plugin to verify your identity and the corresponding GitHub Copilot subscription status. However, PyCharm uses the GitHub API instead of an OAuth token, so the authorization process looks a little different:

Note that granting access to your GitHub profile will allow the plugin to retrieve your profile information, such as your email address, and to read your private repositories. If you change your mind, then you can revoke this authorization at any time by going to your GitHub profile settings and finding GitHub Copilot Plugin in the Authorized GitHub Apps.

To make working with GitHub Copilot in PyCharm even more productive, here are the most common keyboard shortcuts worth remembering:

Sometimes GitHub Copilot automatic completions may get in your way. If that’s the case, then you can disable them globally or for a particular programming language by clicking on the plugin’s icon in the bottom right corner of the editor’s window:

That’s it! You’re all set to start using the GitHub Copilot plugin in PyCharm.

Hand Over the Reins to GitHub Copilot

Now it’s time to make sure GitHub Copilot is working as expected in either Visual Studio Code or PyCharm. To check if GitHub Copilot is working as expected in your Visual Studio Code editor, create a new text file, select Python as the underlying programming language, and start writing a sample function signature, such as hello():

As soon as you type the colon (:) at the end of the first line to introduce a new code block, GitHub Copilot fills in the suggested function body for you. Until you either accept it by hitting Tab or reject it with Esc, it’ll show up in gray font. The suggested code calls the print() function to display the Hello World text on the screen in this case. While that wasn’t spectacular, it confirms that GitHub Copilot is indeed working correctly.

Working with GitHub Copilot in PyCharm is virtually the same as in other code editors. To verify if the plugin installation succeeded, try a different example. Start writing a function signature whose name may indicate that you wish to add two numbers together, such as add(a, b):

Sure enough, GitHub Copilot gives a very sensible suggestion, which returns the sum of a and b. Notice the difference between returning a value from the function and printing the result on the screen. Your clever virtual assistant can infer the intent from the function’s name and arguments.

In the rest of this tutorial, you’ll explore several hands-on use cases for GitHub Copilot in daily software engineering tasks. You’ll learn how to take your productivity to a whole new level by getting instant code suggestions tailored to your programming needs.

Solve a Programming Contest Puzzle

To test the true power of GitHub Copilot, you can copy and paste a fragment of the textual description of a coding challenge and see how it’ll cope. For example, why don’t you grab the first part of the Sonar Sweep puzzle from the first day of the 2021 Advent of Code calendar:

# For example, suppose you had the following report:
#
# 199
# 200
# 208
# 210
# 200
# 207
# 240
# 269
# 260
# 263
#
# (...)
#
# In this example, there are 7 measurements that are larger 
# than the previous measurement.
#
# How many measurements are larger than the previous measurement?

def solve(measurements):

The complete description of the problem is slightly longer and was abbreviated in the code block above to save space. In short, your goal is to determine the number of times a depth measurement increases with respect to the previous measurement. GitHub Copilot works out the solution to this specific problem particularly well, considering how many people have tackled exactly the same task and shared their solutions on GitHub:

def solve(measurements):
    count = 0
    for i in range(1, len(measurements)):
        if measurements[i] > measurements[i - 1]:
            rely += 1
    return rely

It’s a brief loop that begins on the second merchandise on the measurements record and compares the present studying to the earlier one. If the present studying is larger, then it will increase the counter, which the operate returns on the finish. This answer works accurately and within reason environment friendly and readable, however don’t really feel obliged to make use of GitHub Copilot’s solutions in literal kind. It’s not all or nothing!

You possibly can edit the code generated by GitHub Copilot identical to your personal code. Typically, you could not like its formatting, the naming conventions that it utilized, or a particular fragment of the logic that you simply’d moderately rewrite. On different events, seeing a suggestion might encourage you to give you a extra intelligent different. On this case, you could possibly use this one-liner answer, for example:

def clear up(measurements):
    return sum(1 for x, y in zip(measurements, measurements[1:]) if y - x > 0)

You’re taking the sum of the sequence of ones produced with a generator expression for each pair of adjoining measurements if their distinction is constructive. Relying in your Python data degree, you could like this or the advised code snippet higher.

Now you understand how to generate code from pure language utilizing a number of Python feedback. Nevertheless, as a software program engineer, you’ll in all probability recognize contextual code solutions much more.

Let GitHub Copilot Learn Your Thoughts

Say that you simply wish to find the roots of the second-degree polynomial, also called the quadratic function, with three coefficients: 𝑎, 𝑏, and 𝑐. You possibly can specific such a operate utilizing the next algebraic kind:

For instance, the concrete operate 𝑥² + 2𝑥 – 3 has these coefficient values: 𝑎 = 1, 𝑏 = 2, 𝑐 = -3, which you should utilize to calculate the so-called discriminant, typically denoted with the Greek letter delta:

On this case, the discriminant of the operate is the same as sixteen (Δ = 16) while you substitute the letters 𝑎, 𝑏, and 𝑐 with the corresponding values within the system above. Relying on the signal of the discriminant, your quadratic operate can have two, one, or no roots in any respect:

For the reason that discriminant calculated earlier than is a constructive quantity, sixteen, you understand that your quadratic operate has exactly two roots, which consider to 𝑥₁ = -3 and 𝑥₂ = 1 while you apply the formulation above. Plugging both of them into your quadratic operate as the worth of the 𝑥 variable makes the operate return zero. The roots of the operate are the factors the place the corresponding parabola crosses the horizontal axis when plotted.

Now you can implement a Python operate to search out the roots of such a polynomial primarily based on its three coefficients, 𝑎, 𝑏, and 𝑐. You’ll wish to comply with the identical algorithm by calculating the discriminant and evaluating the proper variety of roots. Begin by writing a descriptive operate signature, which can counsel what your intent is:

After a short time, GitHub Copilot will begin supplying you with solutions. When you’re fortunate, then one in every of them can be astonishingly correct:

def find_roots(a, b, c):
    d = b**2 - 4 * a * c
    if d < 0:
        return None
    elif d == 0:
        return -b / (2 * a)
    else:
        return (-b + d**0.5) / (2 * a), (-b - d**0.5) / (2 * a)

The operate calculates the discriminant utilizing the proper system and shops the lead to a helper variable. Relying on the discriminant’s signal, it returns None, a single root worth, or a tuple comprising the 2 root values, all calculated accurately. Word that the advised answer makes use of the exponentiation operator (**) to compute the sq. root of the discriminant. That avoids importing the sqrt() operate from Python’s math module.

Okay, however the generated operate can solely discover real number roots in the event that they exist. What for those who wished to disclose all roots within the area of the complex numbers as an alternative? Within the subsequent part, you’ll uncover how you can give such hints to GitHub Copilot.

Present Context to Get Higher Strategies

The fundamental theorem of algebra states {that a} diploma 𝑛 polynomial with advanced coefficients has precisely 𝑛 advanced roots. In different phrases, a quadratic operate, which is a second-degree polynomial, at all times has precisely two advanced roots even when there are none in the actual area.

Contemplate the operate 𝑥² + 1, whose determinant is destructive, indicating no roots. You possibly can affirm the dearth of roots graphically by plotting the operate’s parabola, which doesn’t cross the horizontal axis wherever. Nevertheless, the identical operate has two advanced roots, 𝑥₁ = -𝑖 and 𝑥₂ = 𝑖, the place 𝑖 is the imaginary unit that evaluates to -1 when squared: 𝑖² = -1.

How will you request that GitHub Copilot change the implementation so that you simply’ll get the advanced roots as an alternative of the actual ones?

That you must add constraints to the issue by giving GitHub Copilot some context to attract from. For instance, you could import a module that you simply want to be used or write a Python docstring that describes the anticipated lead to pure language:

import cmath

def find_roots(a, b, c):
    """Return a tuple of advanced numbers."""

Right here, you import the cmath module, which is the math module’s advanced counterpart. It comprises the cmath.sqrt() operate, which may compute the sq. root of a destructive quantity, whereas math.sqrt() raises an error in such a case:

>>> import cmath
>>> cmath.sqrt(-1)
1j

>>> import math
>>> math.sqrt(-1)
Traceback (most up-to-date name final):
  File "<stdin>", line 1, in <module>
ValueError: math area error

The sq. root of -1 within the advanced area yields the imaginary unit, which Python refers to as 1j. You possibly can learn extra about using complex numbers in Python to be taught why it makes use of the letter j as an alternative of i to indicate the imaginary unit.

Your docstring signifies the anticipated knowledge sort that the operate ought to return. In some circumstances, you could must make clear your expectations by together with extra particular phrases. As an illustration, writing “a tuple of each advanced numbers” will indicate a tuple consisting of precisely two parts. Alternatively, the phrase pair as an alternative of tuple can be much less express.

With the addition of those two small clues, GitHub Copilot will now generate a unique implementation for the exact same operate signature:

import cmath

def find_roots(a, b, c):
    """Return a tuple of advanced numbers."""
    d = (b**2) - (4 * a * c)
    x1 = (-b + cmath.sqrt(d)) / (2 * a)
    x2 = (-b - cmath.sqrt(d)) / (2 * a)
    return x1, x2

It calculates the discriminant as earlier than however now not checks its signal. As an alternative, the operate calculates the 2 advanced roots by leveraging the cmath.sqrt() operate, simply as you wished. You possibly can take a look at your new operate within the Python REPL to verify if the operate calculates each advanced roots accurately:

>>> import cmath

>>> def find_roots(a, b, c):
...     """Return a tuple of advanced numbers."""
...     d = (b**2) - (4 * a * c)
...     x1 = (-b + cmath.sqrt(d)) / (2 * a)
...     x2 = (-b - cmath.sqrt(d)) / (2 * a)
...     return x1, x2
...
>>> find_roots(1, 0, 1)  # Operate f(x) = x² + 1
(1j, -1j)

>>> 1j**2 + 1
0j

>>> (-1j)**2 + 1
0j

This code works brilliantly! The operate x² + 1 returns 0 for the 2 advanced roots, 1j and -1j.

Even when that doesn’t strike you as significantly thrilling, you’ll in all probability be impressed by the creativity of GitHub Copilot, which may prevent plenty of time. Subsequent up, you’ll use GitHub Copilot to generate the physique of a category.

Profit From GitHub Copilot’s Creativity

What number of instances have you ever been designing a brand new knowledge sort, solely to get caught on determining the appropriate attributes or their implementation? With GitHub Copilot, you may sit again and chill out whereas it invents new attributes, methods, and properties out of skinny air for you on the push of a Tab.

Suppose you wished to outline a Individual class utilizing Python’s data classes. You begin by giving your new knowledge sort a significant identify and introducing the primary attribute, referred to as .first_name:

GitHub Copilot instantly picks up from there by suggesting the following most certainly attribute, .last_name, after which .age. Nevertheless, you understand that an individual’s age adjustments over time, so you retain a document of their delivery date as an alternative. The following logical suggestion from GitHub Copilot is a technique that calculates an individual’s age primarily based on the present date. Once you outline a brand new property, it neatly completes its physique by concatenating the primary and final names.

In the long run, that is the outcome that you simply get with only some keystrokes in your code editor:

from dataclasses import dataclass
from datetime import date

@dataclass
class Individual:
    first_name: str
    last_name: str
    birth_date: date

    def age(self):
        return (date.in the present day() - self.birth_date).days // 365

    @property
    def full_name(self):
        return f"self.first_name self.last_name"

It’s an enormous time saver and a productiveness enhance like no different. Even when you understand what to sort, GitHub Copilot allows you to code with the pace of thought, guessing what you is perhaps fascinated about after which offering an appropriate suggestion, which you’ll be able to settle for with a single click on of a button or a keystroke.

Develop into a Programming Polyglot With a Private Translator

It’s not unusual to combine a number of languages, corresponding to HTML, CSS, JavaScript, Django templating language, and Python, in a single file. Thankfully, GitHub Copilot is aware of over a dozen programming languages, much more frameworks, and several other human languages. It has no hassle switching between them on the go relying on the context, all with out breaking your circulate.

For instance, you could wish to outline a Python variable to retailer a SQL question that retrieves customers by an identical identify. So long as you utilize the appropriate phrases in your variable identify, it’s best to get a wise suggestion, corresponding to this one:

Discover the way you get the person strains individually in phases since you outlined a multiline string literal utilizing the triple-quote ("""). The outcome depicted within the video above is the next:

query_users_by_first_or_last_name = """
SELECT * FROM customers
WHERE first_name LIKE %s OR last_name LIKE %s
"""

The question seems to be okay at first look, though GitHub Copilot made some assumptions about your desk identify and the 2 columns to look via. Nonetheless, it’s comforting to see that it produced a prepared statement moderately than a plain string with a SQL question, thus serving to to prevent a SQL injection attack.

All proper, you’re getting fairly comfy with GitHub Copilot at this level. However sit tight as a result of there’s nonetheless plenty of floor to cowl!

Generate Pattern Knowledge Fixtures for Testing

Throughout your day by day growth, you typically want to think about pattern knowledge to your assessments, documentation, or default settings. When you’re drawing a clean, then GitHub Copilot involves the rescue. For instance, recall the Individual class that you simply outlined earlier:

from dataclasses import dataclass
from datetime import date

@dataclass
class Individual:
    first_name: str
    last_name: str
    birth_date: date

    def age(self):
        return (date.in the present day() - self.birth_date).days // 365

    @property
    def full_name(self):
        return f"self.first_name self.last_name"

Now, suppose you have to create a couple of cases of this class to symbolize workers of an organization. When you’re nonetheless enhancing the identical file or have imported the Individual class from one other module, you could use GitHub Copilot to populate an inventory of workers. Declare an empty Python record utilizing an expressive variable identify, and hit Enter simply after the opening sq. bracket ([) to trigger the suggestions:

As you keep hitting Tab after each suggested line, you might end up with the following list of employees:

employees = [
    Person("John", "Smith", date(1970, 1, 1)),
    Person("Jane", "Doe", date(1980, 1, 1)),
    Person("Joe", "Doe", date(1990, 1, 1)),
    Person("Jack", "Doe", date(2000, 1, 1)),
    Person("Jill", "Doe", date(2010, 1, 1)),
    Person("Jana", "Doe", date(2020, 1, 1)),
]

GitHub Copilot efficiently found out to make use of your Individual class for the worker record parts. Later, you should utilize that record as a typical test fixture for a gaggle of test cases that require it. For instance, you could wrap the record in a operate that your take a look at framework will name. GitHub Copilot will be a wonderful assist in the testing course of itself by suggesting each assessments and the code below take a look at.

Want for a Take a look at Case to Magically Seem

It’s a very good follow to present your take a look at features lengthy and descriptive names as a result of they get to be proven within the take a look at run report. When one in every of them fails, a well-named take a look at operate will instantly draw your consideration to what’s not working. Advocates of behavior-driven development suggest utilizing entire sentences beginning with the phrase ought to to concentrate on the conduct below take a look at, which makes the take a look at appear like a enterprise requirement specification.

The additional advantage of such generally ridiculously lengthy operate names is that GitHub Copilot can use them to help you in producing the take a look at case implementation. For instance, outline the next operate signature in a take a look at module of your Individual class:

def test_should_not_be_able_to_set_full_name():

Most take a look at frameworks will mechanically uncover take a look at circumstances in the event that they comply with commonplace naming conventions, corresponding to while you prefix take a look at operate names with test_. With GitHub Copilot, the suggestion triggered for the operate above might appear like the next:

def test_should_not_be_able_to_set_full_name():
    particular person = Individual("John", "Doe", date(1980, 1, 1))
    with pytest.raises(AttributeError):
        particular person.full_name = "Jane Doe"

Curiously sufficient, GitHub Copilot prefers an exterior pytest library, which you should set up and import manually, over the built-in unittest module accessible in the usual library.

Whereas automating the implementation of a take a look at case for present code might generally be useful, it’s in all probability much more fascinating to flip the steps and develop software program in a top-down style utilizing test-driven growth. On this strategy, you write your take a look at case first as a high-level specification of code, which doesn’t exist but. Upon getting an automatic take a look at case, then you definitely write some code to make it move.

Train Take a look at-Pushed Growth (TDD)

When you haven’t practiced TDD earlier than, then take a look at the Build a Hash Table in Python With TDD tutorial for a hands-on, step-by-step crash course on test-driven growth.

Briefly, you may summarize the method in three steps:

1. Write a failing take a look at case that you simply’re about to fulfill
2. Implement the smallest quantity of code to make your take a look at case move
3. Optionally, refactor the code whereas all of your take a look at circumstances are nonetheless passing

Then, rinse and repeat! So long as you’re disciplined sufficient to remain on this perpetual cycle, you’ll write testable code that has excessive test coverage and paperwork itself. On the identical time, you’ll keep away from writing code that you simply’ll by no means want, lowering the general upkeep price. That stated, test-driven growth isn’t a silver bullet, so it will not be sensible in analysis and growth initiatives, for instance.

Okay, how about replicating the HashTable implementation from the tutorial talked about above, utilizing GitHub Copilot as your digital pair programmer? Create two empty Python recordsdata subsequent to one another in the identical folder:

src/
├── hashtable.py
└── test_hashtable.py

The primary one, depicted on the left within the video under, will include the code below take a look at. The opposite one, depicted on the appropriate, can be residence to your take a look at circumstances driving the implementation. Subsequent, write your first take a look at case to confirm the instantiation of a brand new HashTable class:

Word that to comply with test-driven growth, it’s best to run every take a look at case earlier than and after implementing the corresponding little bit of code to make certain that you’re testing the appropriate factor. Other than that, it’s best to solely implement the naked minimal to fulfill your assessments. However GitHub Copilot went one step forward by attempting to foretell the code that you simply may want sooner or later. That’s not a strictly real test-driven growth methodology.

To recap, these are the 2 take a look at circumstances that you simply simply wrote to verify for those who can create a hash desk with or with out an preliminary capability:

# test_hashtable.py

from hashtable import HashTable

def test_should_create_hashtable():
    assert HashTable() is not None

def test_should_create_hashtable_with_capacity():
    assert HashTable(capability=10) is not None

Based mostly on them, GitHub Copilot has generated the next hash desk implementation to this point:

# hashtable.py

class HashTable:
    def __init__(self, capability=10):
        self.capability = capability
        self.buckets = [None] * capability
        self.measurement = 0

The initializer technique units a default capability of ten in case somebody creates a hash desk with out offering any arguments, a call which is pushed by your first take a look at case. The capability is then saved in an occasion attribute. Discover that GitHub Copilot accurately acknowledged the distinction between a hash desk’s measurement and its capability. It additionally assumed the traditional hash desk implementation primarily based on separate chaining by creating empty buckets.

Whereas GitHub Copilot will not be nearly as good as a human pair programmer at watching your again, it does a very implausible job as a digital assistant offering solutions to your questions. It’s like somebody looking Google or Stack Overflow for an answer to your distinctive downside, constructed into the code editor proper the place you want it!

By no means Assume About Boilerplate Code Once more

Python has a comparatively expressive syntax, which lets you write concise and readable code. Nonetheless, occasional boilerplate code is unavoidable, even in your favourite programming language. Typically, there’s no manner round writing a bit of code that appears lengthy and verbose but seemingly doesn’t do plenty of helpful work.

For instance, fetching data from a URL handle, serializing it to JSON, and saving the outcome to a file includes plenty of boring particulars, which don’t contribute a lot worth. Wouldn’t it’s cool for those who might concentrate on what issues to you probably the most—that’s, checking out an answer to a higher-level downside whereas letting GitHub Copilot map the person steps to fragments of code?

Nicely, it seems you can! As earlier than, begin by writing a descriptive operate signature, and go away the remainder to GitHub Copilot:

def save_json(url, filename):

The advised operate physique in response to the above signature is perhaps the next:

def save_json(url, filename):
    import json
    import requests
    import os

    if not os.path.exists(filename):
        with open(filename, "w") as f:
            f.write(json.dumps(requests.get(url).json()))
    else:
        print("File already exists")

It depends on the exterior requests library, which you may want to put in, because it’s the de facto standard for making HTTP requests in Python. The operate takes benefit of the context manager to close the file after dumping JSON into it. It’s already ok, however you could wish to add a couple of beauty tweaks:

import json
import os
import requests

def save_json(url, filename):
    if not os.path.exists(filename):
        with open(filename, mode="w", encoding="utf-8") as file:
            file.write(json.dumps(requests.get(url).json()))
    else:
        print("File already exists")

Per the PEP 8 type information, it’s best to typically outline your import statements outdoors of features, and the exterior library modules ought to come after the usual library ones. Additionally, it’s recommended that you simply explicitly state the character encoding, corresponding to UTF-8, when working with recordsdata in Python to keep away from discrepancies between totally different working methods that may assume incompatible defaults.

Utilizing GitHub Copilot is perhaps barely safer than Stack Overflow. With Stack Overflow, you may end up mindlessly copying and pasting another person’s code in verbatim kind with out totally understanding it or fascinated about whether or not it is sensible in your state of affairs. Accepting a GitHub Copilot suggestion will be equally reckless, if no more, however not less than it provides you a fine-tuned, context-specific piece of the puzzle that’s extra prone to work than not.

One other space the place GitHub Copilot shines is in sparing you from diving into the documentation of a library or an API you wish to use.

All the time Have the API Documentation at Your Fingertips

Say you wished to put in writing a small Python operate to get an inventory of the general public repositories of a GitHub consumer. Within the conventional strategy, you’d begin by making an internet seek for github api, and also you’d land on the GitHub REST API documentation web page. Then, you’d in all probability get overwhelmed by the variety of different REST APIs to select from, in addition to all their guides, fast begins, and reference documentation.

Thankfully, you could have GitHub Copilot, which has been educated to make use of well-known APIs, so that you may give it a minimal trace about which API to name. Create a brand new Python module referred to as github_api_client, and sort the next code in it:

# github_api_client.py

import os

GITHUB_API_TOKEN = os.getenv("GITHUB_API_TOKEN")

def get_repository_names(username):

Later, you’ll run this script in a terminal session together with your token saved in an environment variable. It’s customary to learn secret keys and configuration knowledge via setting variables, so that you benefit from Python’s os module to learn your private GitHub API token, which you’ll want to be able to entry the API.

One of many advised outcomes finally ends up working proper out of the field:

# github_api_client.py

import os

GITHUB_API_TOKEN = os.getenv("GITHUB_API_TOKEN")

def get_repository_names(username):
    import requests

    url = f"https://api.github.com/customers/username/repos"
    headers = "Authorization": f"token GITHUB_API_TOKEN"
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return [repo["name"] for repo in response.json()]

Earlier than testing this operate, keep in mind to generate a brand new personal access token in your GitHub profile and set the corresponding setting variable in your terminal:

PS> $env:GITHUB_API_TOKEN=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

$ export GITHUB_API_TOKEN=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

Then, whilst you’re nonetheless in the identical terminal session the place you outlined the setting variable, run the supply file together with your code in an interactive mode in order that Python reads the generated operate you can name:

$ python -i github_api_client.py
>>> for identify in get_repository_names("gvanrossum"):
...     print(identify)
...
500lines
asyncio
ballot-box
cpython
ctok
exceptiongroup
guidos_time_machine
gvanrossum.github.io
http-get-perf
minithesis
mirror-cwi-stdwin
mypy
mypy-dummy
path-pep
patma
pep550
peps
Pyjion
pythonlabs
pythonlabs-com-azure
pytype
pyxl3

On this case, you’re getting a moderately quick record of the general public repositories made by Guido van Rossum, the creator of Python.

All proper, utilizing a well known API wasn’t significantly troublesome, however what about leveraging a customized API that GitHub Copilot hasn’t seen earlier than? Nicely, you’ll discover out subsequent.

Train GitHub Copilot to Converse Your Personal Dialect

Suppose you could have the next Python module, which defines a customized API for speech synthesis by wrapping a text-to-speech (TTS) command on one of many three main platforms:

# custom_api.py

import platform
import subprocess

class TextToSpeechAPIClient:
    def __init__(self, command=None):
        self.command = command or get_default_command()

    def say(self, textual content):
        subprocess.name(self.command(textual content))

def get_default_command():
    match platform.system():
        case "Darwin":
            return lambda textual content: ["say", text]
        case "Linux":
            return lambda textual content: ["spd-say", text]
        case "Home windows":
            return lambda textual content: 
            "PowerShell -Command "Add-Kind –AssemblyName System.Speech; " 
            "(New-Object System.Speech.Synthesis.SpeechSynthesizer)." 
            f"Converse('textual content');""

The TextToSpeechAPIClient class takes an optionally available argument with the speech synthesis command related to your working system. The helper operate outlined under takes benefit of the match statement launched in Python 3.10 to find out the appropriate command.

Now, create one other Python module and inform GitHub Copilot to discover ways to use your new API by making a want in a remark:

# foremost.py

# Say "Hi there, World!" utilizing the customized text-to-speech API shopper.

if __name__ == "__main__":

The execution condition on the finish of your file provides GitHub Copilot the required context by speaking that you simply wish to write a Python script. In any other case, you is perhaps getting much less helpful solutions. Nevertheless, with this very important verify in place, one of many solutions will appear like this:

# foremost.py

# Say "Hi there, World!" utilizing the customized text-to-speech API shopper.

if __name__ == "__main__":
    import custom_api

    shopper = custom_api.TextToSpeechAPIClient()
    shopper.say("Hi there, World!")

Wonderful! GitHub Copilot discovered your customized API in one other Python module, imported it the place wanted, and used the TextToSpeechAPIClient class precisely because it ought to. Whereas it did so properly with an area module, it would as nicely counsel snippets of code for third-party modules.

Navigate an Unfamiliar Framework or Library

Exploring new libraries in Python with GitHub Copilot is an gratifying expertise. Maybe you’re revisiting a framework for which your data has change into slightly rusty, and also you’re struggling to recollect the place to start. However even while you’re fairly aware of a given device, GitHub Copilot can generally shock you by suggesting extra environment friendly options or elements of its API that you simply had no concept about.

Say you wish to expose a REST API endpoint utilizing the Flask framework to serve a JSON-serialized record of books queried from a file-based SQLite database. Now, create a brand new Python supply file, import the required modules, and adapt the earlier sentence from this paragraph right into a Python remark:

import sqlite3
import flask

# Expose a REST API endpoint utilizing the Flask framework 
# to serve a JSON-serialized record of books queried from 
# a file-based SQLite database.

Look ahead to the solutions to reach, after which decide the one that appears the very best. Typically, you’ll get higher outcomes while you begin typing the anticipated code and incrementally request line-by-line solutions by hitting Tab on every line. Ultimately, you could find yourself with one thing like this:

import sqlite3
import flask

# Expose a REST API endpoint utilizing the Flask framework 
# to serve a JSON-serialized record of books queried from 
# a file-based SQLite database.

app = flask.Flask(__name__)

@app.route("/books")
def get_books():
    conn = sqlite3.join("books.db")
    c = conn.cursor()
    c.execute("SELECT * FROM books")
    books = c.fetchall()
    conn.shut()
    return flask.jsonify(books)

if __name__ == "__main__":
    app.run(debug=True)

On this case, GitHub Copilot scaffolded the standard construction of a Flask software, which you might need forgotten about, and it outlined the endpoint you requested. To check if it really works, open your terminal in the identical folder as your Flask software, and create a brand new file-based database referred to as books.db with a couple of pattern books.

To enter SQL queries, you may run the sqlite3 command in batch mode and terminate it with the end-of-file (EOF) character:

$ sqlite3 books.db -batch
CREATE TABLE books(
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   isbn TEXT,
   creator TEXT,
   title TEXT
);
INSERT INTO books(isbn, creator, title) VALUES
   ('978-0132350884', 'Robert C. Martin', 'Clear Code'),
   ('978-1449340377', 'David Beazley', 'Python Cookbook'),
   ('978-0131872486', 'Bruce Eckel', 'Pondering in Java'),
   ('978-1775093329', 'David Amos', 'Python Fundamentals');

On Home windows, you may usually ship the EOF character to the standard input stream utilizing Ctrl+Z, whereas on Linux and macOS, you’ll use the Ctrl+D key mixture.

Subsequent, begin your Flask software on the default community interface and port quantity by operating your script, after which navigate your net browser to the /books endpoint. Alternatively, you should utilize a command like cURL immediately in your terminal to fetch the books for those who’re on macOS or Linux:

$ curl http://127.0.0.1:5000/books
[
  [
    1,
    "978-0132350884",
    "Robert C. Martin",
    "Clean Code"
  ],
  [
    2,
    "978-1449340377",
    "David Beazley",
    "Python Cookbook"
  ],
  [
    3,
    "978-0131872486",
    "Bruce Eckel",
    "Thinking in Java"
  ],
  [
    4,
    "978-1775093329",
    "David Amos",
    "Python Basics"
  ]
]

Fairly remarkably, the code generated by GitHub Copilot is alive! Simply give it some thought. You merely offered the pure language description of your required program and imported two modules to present context on which libraries to make use of. In the meantime, synthetic intelligence turned your description right into a working net software.

That being stated, GitHub Copilot has its darkish sides, which you’ll study within the subsequent part.

Is Positively Not Autopilot!

The identify copilot was a intelligent alternative by GitHub to explain this product. It avoids deceptive folks into pondering it might take management and substitute you because the programmer. Identical to the first officer in aviation, who’s generally known as the copilot, GitHub Copilot assists you however doesn’t do the job for you. This wording contrasts with advanced driver-assistance systems, which some automotive producers baldly name autopilot in the present day.

You need to do not forget that the code produced by GitHub Copilot isn’t at all times preferrred. In reality, it might probably generally be suboptimal or insecure, and it would comply with dangerous programming practices.

It’s much less of an issue when the code comprises syntactical errors or if it’s utterly nonsensical, as a result of that’s straightforward to identify. Nevertheless, the code that appears believable at first look can nonetheless be incorrect and include logical errors. Subsequently, it’s best to by no means belief GitHub Copilot with out fastidiously reviewing and testing the code it generates!

In different phrases, GitHub Copilot is a precious device to have below your belt, however you undoubtedly shouldn’t depend on its solutions alone when constructing mission-critical software program for a nuclear energy plant, for example.

Poses a Potential Safety Threat

As a result of the machine studying mannequin behind GitHub Copilot was educated on public repositories, it’s susceptible to data poisoning. A nasty actor might’ve deliberately contaminated the coaching dataset with malicious code which will trick the mannequin into suggesting comparable patterns in your code editor. This might additionally occur accidentally as a result of huge quantity of code within the coaching knowledge.

Once more, use GitHub Copilot at your personal threat!

Raises Mental Property Rights Considerations

GitHub Copilot could possibly be violating intellectual property rights, which is by far probably the most severe concern for the time being. As a result of it synthesizes code primarily based on what it has seen earlier than, it could possibly be leaking proprietary algorithms from personal repositories, copyrighted public repositories, and even open-source repositories with a non-permissive license.

The creator of Flask, Armin Ronacher, has lately demonstrated in a tweet how GitHub Copilot quotes Quake’s implementation of the fast inverse square root algorithm to the letter. Whereas the generated code is attributed to John Carmack, GitHub Copilot advised a very random license on high of it:

The produced code within the instance above even contains the unique remark with a curse phrase. GitHub claims to have filters in place that ought to theoretically block such phrases. They need to additionally take away delicate data like API keys or e mail addresses that may’ve been by chance dedicated to GitHub. But, you may by no means know for positive.

Encourages Dishonest

GitHub Copilot could be a implausible studying device for those who’re trying to grasp a brand new programming language, framework, library, or API. On the identical time, it’s not terribly troublesome to think about some college students abusing GitHub Copilot to cheat by copying and pasting a activity’s description in plain English and having their project solved inside seconds. Recall the Advent of Code puzzle that you simply did originally of this tutorial.

Additionally, college students with no intention of dishonest might desire to keep away from GitHub Copilot, as it could make them lazy and discourage them from pondering independently. Like with each highly effective device, you should utilize GitHub Copilot for the appropriate or unsuitable functions.

Requires a Subscription Plan

One of the vital frequent complaints about GitHub Copilot is the truth that it requires a paid subscription, which limits the variety of potential customers. Lots of people appear to be upset about being charged cash for a device that was supposedly educated on principally open-source code.

To make issues worse, the flat charge is mounted no matter the place you might be on this planet. It doesn’t take purchasing power parity into consideration, making the subscription an even bigger burden for purchasers in some international locations than in others. The pricing in all probability appears affordable for those who’re on an engineering wage in a rustic with excessive buying energy or if your organization buys the subscription in bulk. In any other case, the worth is perhaps very steep.

Alternatively, it’s truthful that GitHub not less than provides the trial interval and makes the service accessible at no cost to verified college students and open-source maintainers. In the end, although the pricing could also be prohibitive to some, it’s typically a very good worth for what you get, particularly contemplating the upkeep price of the infrastructure for such an enormous neural community. In spite of everything, it requires a distributed cluster to run and to realize low latency.

When you’d prefer to take a deeper dive and be taught extra concerning the underlying machine studying mannequin, then learn the unique paper on OpenAI Codex.