Instruction:
Here you have a function in Python 3, explain what it does
def parse_query(self, query, index, stop_current, shuffle):

        if index is not None and len(self.queue) > 0:
            if index < 0 or index >= len(self.queue):
                if len(self.queue) == 1:
                    self.statuslog.error("Play index must be 1 (1 song in queue)")
                    return
                else:
                    self.statuslog.error("Play index must be between 1 and {}".format(len(self.queue)))
                    return

        try:
            yt_videos = api_music.parse_query(query, self.statuslog)
            if shuffle:
                random.shuffle(yt_videos)

            if len(yt_videos) == 0:
                self.statuslog.error("No results for: {}".format(query))
                return

            if index is None:
                self.queue = self.queue + yt_videos
            else:
                if len(self.queue) > 0:
                    self.queue = self.queue[:index] + yt_videos + self.queue[index:]
                else:
                    self.queue = yt_videos

            self.update_queue()

            if stop_current:
                if self.streamer:
                    self.streamer.stop()
        except Exception as e:
            logger.exception(e)

Response: Parses a query and adds it to the queue


Instruction:
Can you tell what is the following Python 3 function doing
def update_queue(self):

        self.logger.debug("Updating queue display")

        queue_display = []
        for i in range(self.queue_display):
            try:
                if len(self.queue[i][1]) > 40:
                    songname = self.queue[i][1][:37] + "..."
                else:
                    songname = self.queue[i][1]
            except IndexError:
                songname = "---"
            queue_display.append("{}. {}\n".format(str(i + 1), songname))

        self.queuelog.debug(''.join(queue_display))
        self.queuelenlog.debug(str(len(self.queue)))

Response: Updates the queue in the music player


Instruction:
Create a Python 3 function to
set the topic for the topic channel

Response:
async def set_topic(self, topic):
        """Sets the topic for the topic channel"""
        self.topic = topic
        try:
            if self.topicchannel:
                await client.edit_channel(self.topicchannel, topic=topic)
        except Exception as e:
            logger.exception(e)


Instruction:
How would you explain what the following Python 3 function does
def clear_cache(self):
        self.logger.debug("Clearing cache")
        if os.path.isdir(self.songcache_dir):
            for filename in os.listdir(self.songcache_dir):
                file_path = os.path.join(self.songcache_dir, filename)
                try:
                    if os.path.isfile(file_path):
                        os.unlink(file_path)
                except PermissionError:
                    pass
                except Exception as e:
                    logger.exception(e)
        self.logger.debug("Cache cleared")

Response: Removes all files from the songcache dir


Instruction:
Can you write a function in Python 3 where it
moves files in the next cache dir to the root

Response:
def move_next_cache(self):
        """Moves files in the 'next' cache dir to the root"""
        if not os.path.isdir(self.songcache_next_dir):
            return

        logger.debug("Moving next cache")
        files = os.listdir(self.songcache_next_dir)
        for f in files:
            try:
                os.rename("{}/{}".format(self.songcache_next_dir, f), "{}/{}".format(self.songcache_dir, f))
            except PermissionError:
                pass
            except Exception as e:
                logger.exception(e)
        logger.debug("Next cache moved")


Instruction:
Can you tell what is the following Python 3 function doing
def ytdl_progress_hook(self, d):
        if d['status'] == 'downloading':
            self.play_empty()

            if "elapsed" in d:
                if d["elapsed"] > self.current_download_elapsed + 4:
                    self.current_download_elapsed = d["elapsed"]

                    current_download = 0
                    current_download_total = 0
                    current_download_eta = 0
                    if "total_bytes" in d and d["total_bytes"] > 0:
                        current_download_total = d["total_bytes"]
                    elif "total_bytes_estimate" in d and d["total_bytes_estimate"] > 0:
                        current_download_total = d["total_bytes_estimate"]
                    if "downloaded_bytes" in d and d["downloaded_bytes"] > 0:
                        current_download = d["downloaded_bytes"]
                    if "eta" in d and d["eta"] > 0:
                        current_download_eta = d["eta"]

                    if current_download_total > 0:
                        percent = round(100 * (current_download / current_download_total))
                        if percent > 100:
                            percent = 100
                        elif percent < 0:
                            percent = 0

                        seconds = str(round(current_download_eta)) if current_download_eta > 0 else ""
                        eta = " ({} {} remaining)".format(seconds, "seconds" if seconds != 1 else "second")

                        downloading = "Downloading song: {}%{}".format(percent, eta)
                        if self.prev_time != downloading:
                            self.timelog.debug(downloading)
                            self.prev_time = downloading
        if d['status'] == 'error':
            self.statuslog.error("Error downloading song")
        elif d['status'] == 'finished':
            self.statuslog.info("Downloaded song")
            downloading = "Downloading song: {}%".format(100)
            if self.prev_time != downloading:
                self.timelog.debug(downloading)
                self.prev_time = downloading

            if "elapsed" in d:
                download_time = "{} {}".format(d["elapsed"] if d["elapsed"] > 0 else "<1",
                                               "seconds" if d["elapsed"] != 1 else "second")
                self.logger.debug("Downloaded song in {}".format(download_time))

            # Create an FFmpeg player
            future = asyncio.run_coroutine_threadsafe(self.create_ffmpeg_player(d['filename']), client.loop)
            try:
                future.result()
            except Exception as e:
                logger.exception(e)
                return

Response: Called when youtube - dl updates progress


Instruction:
Can you generate a brief explanation for the following Python 3 code
def play_empty(self):
        if self.vclient:
            if self.streamer:
                self.streamer.volume = 0
            self.vclient.play_audio("\n".encode(), encode=False)

Response: Play blank audio to let Discord know we re still here


Instruction:
Write a Python 3 script for
downloading the next song and starts playing it

Response:
def download_next_song(self, song):
        """Downloads the next song and starts playing it"""

        dl_ydl_opts = dict(ydl_opts)
        dl_ydl_opts["progress_hooks"] = [self.ytdl_progress_hook]
        dl_ydl_opts["outtmpl"] = self.output_format

        # Move the songs from the next cache to the current cache
        self.move_next_cache()

        self.state = 'ready'
        self.play_empty()
        # Download the file and create the stream
        with youtube_dl.YoutubeDL(dl_ydl_opts) as ydl:
            try:
                ydl.download([song])
            except DownloadStreamException:
                # This is a livestream, use the appropriate player
                future = asyncio.run_coroutine_threadsafe(self.create_stream_player(song, dl_ydl_opts), client.loop)
                try:
                    future.result()
                except Exception as e:
                    logger.exception(e)
                    self.vafter_ts()
                    return
            except PermissionError:
                # File is still in use, it'll get cleared next time
                pass
            except youtube_dl.utils.DownloadError as e:
                self.logger.exception(e)
                self.statuslog.error(e)
                self.vafter_ts()
                return
            except Exception as e:
                self.logger.exception(e)
                self.vafter_ts()
                return


Instruction:
Create a Python 3 function for
downloading the next song in the queue to the cache

Response:
def download_next_song_cache(self):
        """Downloads the next song in the queue to the cache"""
        if len(self.queue) == 0:
            return

        cache_ydl_opts = dict(ydl_opts)
        cache_ydl_opts["outtmpl"] = self.output_format_next

        with youtube_dl.YoutubeDL(cache_ydl_opts) as ydl:
            try:
                url = self.queue[0][0]
                ydl.download([url])
            except:
                pass


Instruction:
How would you code a function in Python 3 to
create a streamer that plays from a file

Response:
async def create_ffmpeg_player(self, filepath):
        """Creates a streamer that plays from a file"""
        self.current_download_elapsed = 0

        self.streamer = self.vclient.create_ffmpeg_player(filepath, after=self.vafter_ts)
        self.state = "ready"
        await self.setup_streamer()

        try:
            # Read from the info json
            info_filename = "{}.info.json".format(filepath)
            with open(info_filename, 'r') as file:
                info = json.load(file)

                self.nowplayinglog.debug(info["title"])
                self.is_live = False

                if "duration" in info and info["duration"] is not None:
                    self.current_duration = info["duration"]
                else:
                    self.current_duration = 0

                if "uploader" in info:
                    self.nowplayingauthorlog.info(info["uploader"])
                else:
                    self.nowplayingauthorlog.info("Unknown")

                self.nowplayingsourcelog.info(api_music.parse_source(info))

                play_state = "Streaming" if self.is_live else "Playing"
                await self.set_topic("{} {}".format(play_state, info["title"]))
                self.statuslog.debug(play_state)
        except Exception as e:
            logger.exception(e)


Instruction:
Write a Python 3 function that can
create a streamer that plays from a URL

Response:
async def create_stream_player(self, url, opts=ydl_opts):
        """Creates a streamer that plays from a URL"""
        self.current_download_elapsed = 0

        self.streamer = await self.vclient.create_ytdl_player(url, ytdl_options=opts, after=self.vafter_ts)
        self.state = "ready"

        await self.setup_streamer()

        self.nowplayinglog.debug(self.streamer.title)
        self.nowplayingauthorlog.debug(self.streamer.uploader if self.streamer.uploader is not None else "Unknown")
        self.current_duration = 0
        self.is_live = True

        info = self.streamer.yt.extract_info(url, download=False)
        self.nowplayingsourcelog.info(api_music.parse_source(info))

        play_state = "Streaming" if self.is_live else "Playing"
        await self.set_topic("{} {}".format(play_state, self.streamer.title))
        self.statuslog.debug(play_state)


Instruction:
Given the following Python 3 function, write the documentation
async def setup_streamer(self):
        self.streamer.volume = self.volume / 100
        self.streamer.start()

        self.pause_time = None
        self.vclient_starttime = self.vclient.loop.time()

        # Cache next song
        self.logger.debug("Caching next song")
        dl_thread = threading.Thread(target=self.download_next_song_cache)
        dl_thread.start()

Response: Sets up basic defaults for the streamer


Instruction:
Can you generate a brief explanation for the following Python 3 code
def vafter_ts(self):
        logger.debug("Song finishing")
        future = asyncio.run_coroutine_threadsafe(self.vafter(), client.loop)
        try:
            future.result()
        except Exception as e:
            logger.exception(e)

Response: Function that is called after a song finishes playing


Instruction:
How would you code a function in Python 3 to
function that is called after a song finishes playing

Response:
async def vafter(self):
        """Function that is called after a song finishes playing"""
        self.logger.debug("Finished playing a song")
        if self.state != 'ready':
            self.logger.debug("Returning because player is in state {}".format(self.state))
            return

        self.pause_time = None

        if self.vclient_task:
            loop = asyncio.get_event_loop()
            loop.call_soon(self.vclient_task.cancel)
            self.vclient_task = None

        try:
            if self.streamer is None:
                await self.stop()
                return

            if self.streamer.error is None:
                await self.vplay()
            else:
                self.statuslog.error(self.streamer.error)
                await self.destroy()
        except Exception as e:
            logger.exception(e)
            try:
                await self.destroy()
            except Exception as e:
                logger.exception(e)


Instruction:
How would you code a function in Python 3 to
build the YouTube API for future use

Response:
def build_yt_api():
    """Build the YouTube API for future use"""
    data = datatools.get_data()
    if "google_api_key" not in data["discord"]["keys"]:
        logger.warning("No API key found with name 'google_api_key'")
        logger.info("Please add your Google API key with name 'google_api_key' "
                    "in data.json to use YouTube features of the music module")
        return False

    logger.debug("Building YouTube discovery API")
    ytdevkey = data["discord"]["keys"]["google_api_key"]

    try:
        global ytdiscoveryapi
        ytdiscoveryapi = googleapiclient.discovery.build("youtube", "v3", developerKey=ytdevkey)
        logger.debug("YouTube API build successful")
        return True
    except Exception as e:
        logger.exception(e)
        logger.warning("HTTP error connecting to YouTube API, YouTube won't be available")
        return False


Instruction:
Explain what the following Python 3 code does
def build_sc_api():
    data = datatools.get_data()
    if "soundcloud_client_id" not in data["discord"]["keys"]:
        logger.warning("No API key found with name 'soundcloud_client_id'")
        logger.info("Please add your SoundCloud client id with name 'soundcloud_client_id' "
                    "in data.json to use Soundcloud features of the music module")
        return False

    try:
        global scclient
        scclient = soundcloud.Client(client_id=data["discord"]["keys"]["soundcloud_client_id"])
        logger.debug("SoundCloud build successful")
        return True
    except Exception as e:
        logger.exception(e)
        return False

Response: Build the SoundCloud API for future use


Instruction:
Can you write a function in Python 3 where it
builds the Spotify API for future use

Response:
def build_spotify_api():
    """Build the Spotify API for future use"""
    data = datatools.get_data()
    if "spotify_client_id" not in data["discord"]["keys"]:
        logger.warning("No API key found with name 'spotify_client_id'")
        logger.info("Please add your Spotify client id with name 'spotify_client_id' "
                    "in data.json to use Spotify features of the music module")
        return False
    if "spotify_client_secret" not in data["discord"]["keys"]:
        logger.warning("No API key found with name 'spotify_client_secret'")
        logger.info("Please add your Spotify client secret with name 'spotify_client_secret' "
                    "in data.json to use Spotify features of the music module")
        return False

    try:
        global spclient
        client_credentials_manager = SpotifyClientCredentials(
                data["discord"]["keys"]["spotify_client_id"],
                data["discord"]["keys"]["spotify_client_secret"])
        spclient = spotipy.Spotify(client_credentials_manager=client_credentials_manager)
        logger.debug("Spotify build successful")
        return True
    except Exception as e:
        logger.exception(e)
        return False


Instruction:
Write a Python 3 function that can
parse a YouTube search query and returns a list of items from the YouTube search queue.

Response:
def parse_query(query, ilogger):
    """
    Gets either a list of videos from a query, parsing links and search queries
    and playlists

    Args:
        query (str): The YouTube search query
        ilogger (logging.logger): The logger to log API calls to

    Returns:
        queue (list): The items obtained from the YouTube search
    """

    # Try parsing this as a link
    p = urlparse(query)
    if p and p.scheme and p.netloc:
        if "youtube" in p.netloc and p.query and ytdiscoveryapi is not None:
            query_parts = p.query.split('&')
            yturl_parts = {}
            for q in query_parts:
                s = q.split('=')
                if len(s) < 2:
                    continue

                q_name = s[0]
                q_val = '='.join(s[1:])
                # Add to the query
                if q_name not in yturl_parts:
                    yturl_parts[q_name] = q_val

            if "list" in yturl_parts:
                ilogger.info("Queued YouTube playlist from link")
                return get_queue_from_playlist(yturl_parts["list"])
            elif "v" in yturl_parts:
                ilogger.info("Queued YouTube video from link")
                return [["https://www.youtube.com/watch?v={}".format(yturl_parts["v"]), query]]
        elif "soundcloud" in p.netloc:
            if scclient is None:
                ilogger.error("Could not queue from SoundCloud API, using link")
                return [[query, query]]
            try:
                result = scclient.get('/resolve', url=query)

                track_list = []
                if isinstance(result, ResourceList):
                    for r in result.data:
                        tracks = get_sc_tracks(r)
                        if tracks is not None:
                            for t in tracks:
                                track_list.append(t)
                elif isinstance(result, Resource):
                    tracks = get_sc_tracks(result)
                    if tracks is not None:
                        for t in tracks:
                            track_list.append(t)

                if track_list is not None and len(track_list) > 0:
                    ilogger.info("Queued SoundCloud songs from link")
                    return track_list
                else:
                    ilogger.error("Could not queue from SoundCloud API")
                    return [[query, query]]
            except Exception as e:
                logger.exception(e)
                ilogger.error("Could not queue from SoundCloud API, using link")
                return [[query, query]]
        else:
            ilogger.debug("Using url: {}".format(query))
            return [[query, query]]

    args = query.split(' ')
    if len(args) == 0:
        ilogger.error("No query given")
        return []

    if args[0].lower() in ["sp", "spotify"] and spclient is not None:
        if spclient is None:
            ilogger.error("Host does not support Spotify")
            return []

        try:
            if len(args) > 2 and args[1] in ['album', 'artist', 'song', 'track', 'playlist']:
                query_type = args[1].lower()
                query_search = ' '.join(args[2:])
            else:
                query_type = 'track'
                query_search = ' '.join(args[1:])
            query_type = query_type.replace('song', 'track')
            ilogger.info("Queueing Spotify {}: {}".format(query_type, query_search))
            spotify_tracks = search_sp_tracks(query_type, query_search)
            if spotify_tracks is None or len(spotify_tracks) == 0:
                ilogger.error("Could not queue Spotify {}: {}".format(query_type, query_search))
                return []
            ilogger.info("Queued Spotify {}: {}".format(query_type, query_search))
            return spotify_tracks
        except Exception as e:
            logger.exception(e)
            ilogger.error("Error queueing from Spotify")
            return []
    elif args[0].lower() in ["sc", "soundcloud"]:
        if scclient is None:
            ilogger.error("Host does not support SoundCloud")
            return []

        try:
            requests = ['song', 'songs', 'track', 'tracks', 'user', 'playlist', 'tagged', 'genre']
            if len(args) > 2 and args[1] in requests:
                query_type = args[1].lower()
                query_search = ' '.join(args[2:])
            else:
                query_type = 'track'
                query_search = ' '.join(args[1:])
            query_type = query_type.replace('song', 'track')
            ilogger.info("Queueing SoundCloud {}: {}".format(query_type, query_search))
            soundcloud_tracks = search_sc_tracks(query_type, query_search)
            ilogger.info("Queued SoundCloud {}: {}".format(query_type, query_search))
            return soundcloud_tracks
        except Exception as e:
            logger.exception(e)
            ilogger.error("Could not queue from SoundCloud")
            return []
    elif args[0].lower() in ["yt", "youtube"] and ytdiscoveryapi is not None:
        if ytdiscoveryapi is None:
            ilogger.error("Host does not support YouTube")
            return []

        try:
            query_search = ' '.join(args[1:])
            ilogger.info("Queued Youtube search: {}".format(query_search))
            return get_ytvideos(query_search, ilogger)
        except Exception as e:
            logger.exception(e)
            ilogger.error("Could not queue YouTube search")
            return []

    if ytdiscoveryapi is not None:
        ilogger.info("Queued YouTube search: {}".format(query))
        return get_ytvideos(query, ilogger)
    else:
        ilogger.error("Host does not support YouTube".format(query))
        return []


Instruction:
Can you tell what is the following Python 3 function doing
def get_ytvideos(query, ilogger):

    queue = []

    # Search YouTube
    search_result = ytdiscoveryapi.search().list(
            q=query,
            part="id,snippet",
            maxResults=1,
            type="video,playlist"
    ).execute()

    if not search_result["items"]:
        return []

    # Get video/playlist title
    title = search_result["items"][0]["snippet"]["title"]
    ilogger.info("Queueing {}".format(title))

    # Queue video if video
    if search_result["items"][0]["id"]["kind"] == "youtube#video":
        # Get ID of video
        videoid = search_result["items"][0]["id"]["videoId"]

        # Append video to queue
        queue.append(["https://www.youtube.com/watch?v={}".format(videoid), title])

    # Queue playlist if playlist
    elif search_result["items"][0]["id"]["kind"] == "youtube#playlist":
        queue = get_queue_from_playlist(search_result["items"][0]["id"]["playlistId"])

    return queue

Response: Gets either a list of videos from a playlist or a single video


Instruction:
Write a Python 3 script for
converting a duration in seconds to a string

Response:
def duration_to_string(duration):
    """
    Converts a duration to a string

    Args:
        duration (int): The duration in seconds to convert

    Returns s (str): The duration as a string
    """

    m, s = divmod(duration, 60)
    h, m = divmod(m, 60)
    return "%d:%02d:%02d" % (h, m, s)


Instruction:
Write a Python 3 script for
parsing the source info from a dictionary generated by youtube - dl

Response:
def parse_source(info):
    """
    Parses the source info from an info dict generated by youtube-dl

    Args:
        info (dict): The info dict to parse

    Returns:
        source (str): The source of this song
    """

    if "extractor_key" in info:
        source = info["extractor_key"]
        lower_source = source.lower()

        for key in SOURCE_TO_NAME:
            lower_key = key.lower()
            if lower_source == lower_key:
                source = SOURCE_TO_NAME[lower_key]

        if source != "Generic":
            return source

    if "url" in info and info["url"] is not None:
        p = urlparse(info["url"])
        if p and p.netloc:
            return p.netloc

    return "Unknown"


Instruction:
Explain what the following Python 3 code does
def flipcheck(content):

    # Prevent tampering with flip
    punct = """!"#$%&'*+,-./:;<=>?@[\]^_`{|}~ ━─"""
    tamperdict = str.maketrans('', '', punct)
    tamperproof = content.translate(tamperdict)

    # Unflip
    if "(╯°□°）╯︵" in tamperproof:
        # For tables
        if "┻┻" in tamperproof:
            # Calculate table length
            length = 0
            for letter in content:
                if letter == "━":
                    length += 1.36
                elif letter == "─":
                    length += 1
                elif letter == "-":
                    length += 0.50

            # Construct table
            putitback = "┬"

            for i in range(int(length)):
                putitback += "─"

            putitback += "┬ ノ( ゜-゜ノ)"

            return putitback

        # For text
        else:
            # Create dictionary for flipping text
            flipdict = str.maketrans(
                'abcdefghijklmnopqrstuvwxyzɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎz😅🙃😞😟😠😡☹🙁😱😨😰😦😧😢😓😥😭',
                'ɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎzabcdefghijklmnopqrstuvwxyz😄🙂🙂🙂🙂🙂🙂😀😀🙂😄🙂🙂😄😄😄😁'
            )

            # Construct flipped text
            flipstart = content.index('︵')
            flipped = content[flipstart+1:]
            flipped = str.lower(flipped).translate(flipdict)

            putitback = ''.join(list(reversed(list(flipped))))

            putitback += "ノ( ゜-゜ノ)"

            return putitback
    else:
        return False

Response: Flips a string for an anger and soothes.


Instruction:
Write a Python 3 function that can
get a botcust2 identifier used to identify a speaker with Mitsuku

Response:
def get_botcust2():
    """Gets a botcust2, used to identify a speaker with Mitsuku

    Returns:
        botcust2 (str): The botcust2 identifier
    """
    logger.debug("Getting new botcust2")

    # Set up http request packages
    params = {
        'botid': 'f6a012073e345a08',
        'amp;skin': 'chat'
    }
    headers = {
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Accept-Encoding': 'gzip, deflate, sdch, br',
        'Accept-Language': 'en-US,en;q=0.8',
        'Connection': 'keep-alive',
        'DNT': '1',
        'Host': 'kakko.pandorabots.com',
        'Upgrade-Insecure-Requests': '1',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                      'AppleWebKit/537.36 (KHTML, like Gecko) '
                      'Chrome/58.0.3029.110 Safari/537.36'
    }

    # Get response from http POST request to url
    logger.debug("Sending POST request")
    response = requests.post(
        url,
        params=params,
        headers=headers
    )
    logger.debug("POST response {}".format(response))

    # Try to extract Mitsuku response from POST response
    try:
        result = response.headers['set-cookie'][9:25]
        logger.debug("Getting botcust2 successful")
    except IndexError:
        result = False
        logger.critical("Getting botcust2 from html failed")

    return result


Instruction:
Create a Python 3 function for
sending a message to Mitsuku and retrieves the reply

Response:
def query(botcust2, message):
    """Sends a message to Mitsuku and retrieves the reply

    Args:
        botcust2 (str): The botcust2 identifier
        message (str): The message to send to Mitsuku

    Returns:
        reply (str): The message Mitsuku sent back
    """
    logger.debug("Getting Mitsuku reply")

    # Set up http request packages
    params = {
        'botid': 'f6a012073e345a08',
        'amp;skin': 'chat'
    }
    headers = {
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'en-US,en;q=0.8',
        'Cache-Control': 'max-age=0',
        'Connection': 'keep-alive',
        'Content-Length': str(len(message) + 34),
        'Content-Type': 'application/x-www-form-urlencoded',
        'Cookie': 'botcust2=' + botcust2,
        'DNT': '1',
        'Host': 'kakko.pandorabots.com',
        'Origin': 'https://kakko.pandorabots.com',
        'Referer': 'https://kakko.pandorabots.com/pandora/talk?botid=f6a012073e345a08&skin=chat',
        'Upgrade-Insecure-Requests': '1',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
                      'AppleWebKit/537.36 (KHTML, like Gecko) '
                      'Chrome/58.0.3029.110 Safari/537.36'
    }
    data = {
        'botcust2': botcust2,
        'message': message
    }

    # Get response from http POST request to url
    logger.debug("Sending POST request")
    response = requests.post(
        url,
        params=params,
        headers=headers,
        data=data
    )
    logger.debug("POST response {}".format(response))

    # Parse response
    parsed = lxml.html.parse(io.StringIO(response.text)).getroot()
    try:
        result = parsed[1][2][0][2].tail[1:]
        logger.debug("Getting botcust2 successful")
    except IndexError:
        result = False
        logger.critical("Getting botcust2 from html failed")

    return result


Instruction:
Explain what the following Python 3 code does
async def on_message(message):

    # Simplify message info
    server = message.server
    author = message.author
    channel = message.channel
    content = message.content

    data = datatools.get_data()

    if not data["discord"]["servers"][server.id][_data.modulename]["activated"]:
        return

    # Only reply to server messages and don't reply to myself
    if server is not None and author != channel.server.me:
        # Commands section
        prefix = data["discord"]["servers"][server.id]["prefix"]
        if content.startswith(prefix):
            # Parse message
            package = content.split(" ")
            command = package[0][len(prefix):]
            args = package[1:]
            arg = ' '.join(args)

            # Lock on to server if not yet locked
            if server.id not in _data.cache or _data.cache[server.id].state == 'destroyed':
                _data.cache[server.id] = _musicplayer.MusicPlayer(server.id)

            # Remove message
            if command in ['play', 'playnext', 'playnow', 'playshuffle', 'insert',
                           'pause', 'resume', 'skip', 'remove',
                           'rewind', 'restart', 'shuffle', 'volume',
                           'stop', 'destroy', 'front', 'movehere',
                           'settopic', 'cleartopic', 'notopic', 'loop']:
                try:
                    await client.delete_message(message)
                except discord.errors.NotFound:
                    logger.warning("Could not delete music player command message - NotFound")
                except discord.errors.Forbidden:
                    logger.warning("Could not delete music player command message - Forbidden")

            # Commands
            if command == 'play':
                await _data.cache[server.id].play(author, channel, arg)

            if command == 'playnext':
                await _data.cache[server.id].play(author, channel, arg, index=1)

            if command == 'playnow':
                await _data.cache[server.id].play(author, channel, arg, index=1, stop_current=True)

            if command == 'playshuffle':
                await _data.cache[server.id].play(author, channel, arg, shuffle=True)

            if command == 'insert':
                if len(args) >= 2:
                    index = args[0]
                    query = ' '.join(args[1:])
                    await _data.cache[server.id].play(author, channel, query, index=index)
                else:
                    await _data.cache[server.id].play(author, channel, arg)

            elif command == 'pause':
                await _data.cache[server.id].pause()

            elif command == 'resume':
                await _data.cache[server.id].resume()

            elif command == 'skip':
                await _data.cache[server.id].skip(query=arg)

            elif command == 'remove':
                await _data.cache[server.id].remove(index=arg)

            elif command == 'rewind':
                await _data.cache[server.id].rewind(query=arg)

            elif command == 'restart':
                await _data.cache[server.id].rewind(query="0")

            elif command == 'shuffle':
                await _data.cache[server.id].shuffle()

            elif command == 'loop':
                await _data.cache[server.id].set_loop(arg)

            elif command == 'stop':
                await _data.cache[server.id].stop(log_stop=True)

            elif command == 'volume':
                await _data.cache[server.id].setvolume(arg)

            elif command == 'settopic':
                await _data.cache[server.id].set_topic_channel(channel)

            elif command == 'cleartopic' or command == 'notopic':
                await _data.cache[server.id].clear_topic_channel(channel)

            elif command == 'nowplaying':
                await _data.cache[server.id].nowplaying_info(channel)

            elif command == 'destroy':
                await _data.cache[server.id].destroy()

            elif command == 'front' or command == 'movehere':
                await _data.cache[server.id].movehere(channel)

Response: The on_message event handler for this module.


Instruction:
Here you have a function in Python 3, explain what it does
def start(token, client_id, loop, on_ready_handler=None):
    import discord
    import asyncio

    # Create client
    logger.debug("Creating Discord client")
    asyncio.set_event_loop(loop)
    client = discord.Client()
    from . import _client
    _client.client = client

    from .. import datatools
    if datatools.has_data():
        data = datatools.get_data()
    else:
        # Create a blank data file
        data = {"discord": {}}

    # Save default server info to data
    if "servers" not in data["discord"]:
        data["discord"]["servers"] = {}

    # Save default key info to data
    if "keys" not in data["discord"]:
        data["discord"]["keys"] = {}

    # Save logger info to data
    if "log_level" not in data:
        data["log_level"] = "DEBUG"

    data["discord"]["token"] = token
    data["discord"]["client_id"] = client_id
    datatools.write_data(data)

    # Import event handlers
    logger.debug("Importing event handlers")
    event_handlers = _get_event_handlers()

    # Create event handler combiner
    logger.debug("Compiling event handlers")

    def create_event_handler(event_handler_type):
        async def func(*args, **kwargs):
            for module_event_handler in event_handlers[event_handler_type]:
                # Check for errors in the module event
                try:
                    module_event_handler_func = getattr(module_event_handler,
                                                        event_handler_type)
                    await module_event_handler_func(*args, **kwargs)
                except Exception as module_exception:
                    logger.error("An error occured in '{}'".format(module_event_handler))
                    logger.exception(module_exception)

            if on_ready_handler is not None and event_handler_type == "on_ready":
                await on_ready_handler()

        func.__name__ = event_handler_type
        return func

    # Register event handlers
    logger.debug("Registering event handlers into client")
    for event_handler in event_handlers.keys():
        client.event(create_event_handler(event_handler))

    # Run the client loop
    logger.info("Connecting to Discord")
    try:
        client.loop.run_until_complete(client.login(token))
    except Exception as e:
        logger.exception(e)
        logger.critical("Could not connect to Discord")
    else:
        logger.debug("Running the bot")
        try:
            client.loop.run_until_complete(client.connect())
        except KeyboardInterrupt:
            client.loop.run_until_complete(client.logout())
            pending = asyncio.Task.all_tasks(loop=client.loop)
            gathered = asyncio.gather(*pending, loop=client.loop)
            try:
                gathered.cancel()
                client.loop.run_until_complete(gathered)

                # we want to retrieve any exceptions to make sure that
                # they don't nag us about it being un-retrieved.
                gathered.exception()
            except Exception as e:
                logger.exception(e)
        except Exception as e:
            logger.exception(e)
            pending = asyncio.Task.all_tasks(loop=client.loop)
            gathered = asyncio.gather(*pending, loop=client.loop)
            gathered.exception()
        finally:
            try:
                client.loop.run_until_complete(client.logout())
            except Exception as e:
                logger.exception(e)

            logger.critical("Bot stopped\n")
            client.loop.close()

Response: Start the Discord client and log Modis into Discord.


Instruction:
Given the following Python 3 function, write the documentation
def _get_event_handlers():

    import os
    import importlib

    event_handlers = {
        "on_ready": [],
        "on_resume": [],
        "on_error": [],
        "on_message": [],
        "on_socket_raw_receive": [],
        "on_socket_raw_send": [],
        "on_message_delete": [],
        "on_message_edit": [],
        "on_reaction_add": [],
        "on_reaction_remove": [],
        "on_reaction_clear": [],
        "on_channel_delete": [],
        "on_channel_create": [],
        "on_channel_update": [],
        "on_member_join": [],
        "on_member_remove": [],
        "on_member_update": [],
        "on_server_join": [],
        "on_server_remove": [],
        "on_server_update": [],
        "on_server_role_create": [],
        "on_server_role_delete": [],
        "on_server_role_update": [],
        "on_server_emojis_update": [],
        "on_server_available": [],
        "on_server_unavailable": [],
        "on_voice_state_update": [],
        "on_member_ban": [],
        "on_member_unban": [],
        "on_typing": [],
        "on_group_join": [],
        "on_group_remove": []
    }

    # Iterate through module folders
    database_dir = "{}/modules".format(
        os.path.dirname(os.path.realpath(__file__)))
    for module_name in os.listdir(database_dir):
        module_dir = "{}/{}".format(database_dir, module_name)

        # Iterate through files in module
        if os.path.isdir(module_dir) and not module_name.startswith("_"):
            # Add all defined event handlers in module files
            module_event_handlers = os.listdir(module_dir)

            for event_handler in event_handlers.keys():
                if "{}.py".format(event_handler) in module_event_handlers:
                    import_name = ".discord_modis.modules.{}.{}".format(
                        module_name, event_handler)
                    logger.debug("Found event handler {}".format(import_name[23:]))

                    try:
                        event_handlers[event_handler].append(
                            importlib.import_module(import_name, "modis"))
                    except Exception as e:
                        # Log errors in modules
                        logger.exception(e)

    return event_handlers

Response: Returns a dictionary of event handlers and modules that define them


Instruction:
Make a summary of the following Python 3 code
def add_api_key(key, value):

    if key is None or key == "":
        logger.error("Key cannot be empty")

    if value is None or value == "":
        logger.error("Value cannot be empty")

    from .. import datatools
    data = datatools.get_data()

    if "keys" not in data["discord"]:
        data["discord"]["keys"] = {}

    is_key_new = False
    if key not in data["discord"]["keys"]:
        is_key_new = True
    elif data["discord"]["keys"][key] == value:
        logger.info("API key '{}' already has value '{}'".format(key, value))
        return

    data["discord"]["keys"][key] = value
    datatools.write_data(data)

    key_text = "added" if is_key_new else "updated"
    logger.info("API key '{}' {} with value '{}'".format(key, key_text, value))

Response: Adds a key to the bot s data structures.


Instruction:
Can you create a Python 3 function that
creates an embed UI containing the help message

Response:
def success(channel, title, datapacks):
    """
    Creates an embed UI containing the help message

    Args:
        channel (discord.Channel): The Discord channel to bind the embed to
        title (str): The title of the embed
        datapacks (list): The hex value

    Returns:
        ui (ui_embed.UI): The embed UI object
    """

    # Create embed UI object
    gui = ui_embed.UI(
        channel,
        title,
        "",
        modulename=modulename,
        datapacks=datapacks
    )

    return gui


Instruction:
Write a Python 3 function that can
create an embed UI containing the too long error message

Response:
def http_exception(channel, title):
    """
    Creates an embed UI containing the 'too long' error message

    Args:
        channel (discord.Channel): The Discord channel to bind the embed to
        title (str): The title of the embed

    Returns:
        ui (ui_embed.UI): The embed UI object
    """

    # Create embed UI object
    gui = ui_embed.UI(
        channel,
        "Too much help",
        "{} is too helpful! Try trimming some of the help messages.".format(title),
        modulename=modulename
    )

    return gui


Instruction:
Write a Python 3 script for
getting or create a Tarbell configuration file.

Response:
def _get_or_create_config(path, prompt=True):
    """
    Get or create a Tarbell configuration directory.
    """
    dirname = os.path.dirname(path)
    filename = os.path.basename(path)

    try:
        os.makedirs(dirname)
    except OSError:
        pass

    try:
        with open(path, 'r+') as f:
            if os.path.isfile(path):
                puts("{0} already exists, backing up".format(colored.green(path)))
                _backup(dirname, filename)
            return yaml.load(f)
    except IOError:
        return {}


Instruction:
Implement a function in Python 3 to
set up a Google spreadsheet.

Response:
def _setup_google_spreadsheets(settings, path, prompt=True):
    """
    Set up a Google spreadsheet.
    """
    ret = {}
    if prompt:
        use = raw_input("\nWould you like to use Google spreadsheets [Y/n]? ")
        if use.lower() != "y" and use != "":
            return settings

    dirname = os.path.dirname(path)
    path = os.path.join(dirname, "client_secrets.json")

    write_secrets = True
    if os.path.isfile(path):
        write_secrets_input = raw_input("client_secrets.json already exists. Would you like to overwrite it? [y/N] ")
        if not write_secrets_input.lower().startswith('y'):
            write_secrets = False

    if write_secrets:
        puts(("\nLogin in to Google and go to {0} to create an app and generate a "
              "\nclient_secrets authentication file. You should create credentials for an `installed app`. See "
              "\n{1} for more information."
              .format(colored.red("https://console.developers.google.com/project"),
                      colored.red("http://tarbell.readthedocs.org/en/{0}/install.html#configure-google-spreadsheet-access-optional".format(LONG_VERSION))
                     )
            ))

        secrets_path = raw_input(("\nWhere is your client secrets file? "
                                  "[~/Downloads/client_secrets.json] "
                                ))

        if secrets_path == "":
            secrets_path = os.path.join("~", "Downloads/client_secrets.json")

        secrets_path = os.path.expanduser(secrets_path)

        puts("\nCopying {0} to {1}\n"
             .format(colored.green(secrets_path),
                     colored.green(dirname))
        )

        _backup(dirname, "client_secrets.json")
        try:
            shutil.copy(secrets_path, os.path.join(dirname, 'client_secrets.json'))
        except shutil.Error as e:
            show_error(str(e))

    # Now, try and obtain the API for the first time
    get_api = raw_input("Would you like to authenticate your client_secrets.json? [Y/n] ")
    if get_api == '' or get_api.lower().startswith('y'):
        get_drive_api_from_client_secrets(path, reset_creds=True)

    default_account = settings.get("google_account", "")
    account = raw_input(("What Google account(s) should have access to new spreadsheets? "
                         "(e.g. somebody@gmail.com, leave blank to specify for each new "
                         "project, separate multiple addresses with commas) [{0}] "
                            .format(default_account)
                        ))
    if default_account != "" and account == "":
        account = default_account
    if account != "":
        ret = { "google_account" : account }

    puts("\n- Done configuring Google spreadsheets.")
    return ret


Instruction:
Write a Python 3 script for
prompting user to set up Amazon S3.

Response:
def _setup_s3(settings, path, prompt=True):
    """
    Prompt user to set up Amazon S3.
    """
    ret = {'default_s3_buckets': {}, 's3_credentials': settings.get('s3_credentials', {})}

    if prompt:
        use = raw_input("\nWould you like to set up Amazon S3? [Y/n] ")
        if use.lower() != "y" and use != "":
            puts("\n- Not configuring Amazon S3.")
            return ret

    existing_access_key = settings.get('default_s3_access_key_id', None) or \
                          os.environ.get('AWS_ACCESS_KEY_ID', None)
    existing_secret_key = settings.get('default_s3_secret_access_key', None) or \
                          os.environ.get('AWS_SECRET_ACCESS_KEY', None)

    access_key_prompt = "\nPlease enter your default Amazon Access Key ID:"
    if existing_access_key:
        access_key_prompt += ' [%s] ' % existing_access_key
    else:
        access_key_prompt += ' (leave blank to skip) '
    default_aws_access_key_id = raw_input(access_key_prompt)

    if default_aws_access_key_id == '' and existing_access_key:
        default_aws_access_key_id = existing_access_key

    if default_aws_access_key_id:
        secret_key_prompt = "\nPlease enter your default Amazon Secret Access Key:"
        if existing_secret_key:
            secret_key_prompt += ' [%s] ' % existing_secret_key
        else:
            secret_key_prompt += ' (leave blank to skip) '
        default_aws_secret_access_key = raw_input(secret_key_prompt)

        if default_aws_secret_access_key == '' and existing_secret_key:
            default_aws_secret_access_key = existing_secret_key

        ret.update({
            'default_s3_access_key_id': default_aws_access_key_id,
            'default_s3_secret_access_key': default_aws_secret_access_key,
        })

    # If we're all set with AWS creds, we can setup our default
    # staging and production buckets
    if default_aws_access_key_id and default_aws_secret_access_key:
        existing_staging_bucket = None
        existing_production_bucket = None
        if settings.get('default_s3_buckets'):
            existing_staging_bucket = settings['default_s3_buckets'].get('staging', None)
            existing_production_bucket = settings['default_s3_buckets'].get('production', None)

        staging_prompt = "\nWhat is your default staging bucket?"
        if existing_staging_bucket:
            staging_prompt += ' [%s] ' % existing_staging_bucket
        else:
            staging_prompt += ' (e.g. apps.beta.myorg.com, leave blank to skip) '
        staging = raw_input(staging_prompt)

        if staging == '' and existing_staging_bucket:
            staging = existing_staging_bucket
        if staging != "":
            ret['default_s3_buckets'].update({
                'staging': staging,
            })

        production_prompt = "\nWhat is your default production bucket?"
        if existing_production_bucket:
            production_prompt += ' [%s] ' % existing_production_bucket
        else:
            production_prompt += ' (e.g. apps.myorg.com, leave blank to skip) '
        production = raw_input(production_prompt)

        if production == '' and existing_production_bucket:
            production = existing_production_bucket
        if production != "":
            ret['default_s3_buckets'].update({
                'production': production,
            })

    more_prompt = "\nWould you like to add additional buckets and credentials? [y/N] "
    while raw_input(more_prompt).lower() == 'y':
        ## Ask for a uri
        additional_s3_bucket = raw_input(
            "\nPlease specify an additional bucket (e.g. "
            "additional.bucket.myorg.com/, leave blank to skip adding bucket) ")
        if additional_s3_bucket == "":
            continue

        ## Ask for an access key, if it differs from the default
        additional_access_key_prompt = "\nPlease specify an AWS Access Key ID for this bucket:"

        if default_aws_access_key_id:
            additional_access_key_prompt += ' [%s] ' % default_aws_access_key_id
        else:
            additional_access_key_prompt += ' (leave blank to skip adding bucket) '

        additional_aws_access_key_id = raw_input(additional_access_key_prompt)

        if additional_aws_access_key_id == "" and default_aws_access_key_id:
            additional_aws_access_key_id = default_aws_access_key_id
        elif additional_aws_access_key_id == "":
            continue

        # Ask for a secret key, if it differs from default
        additional_secret_key_prompt = "\nPlease specify an AWS Secret Access Key for this bucket:"

        if default_aws_secret_access_key:
            additional_secret_key_prompt += ' [%s] ' % default_aws_secret_access_key
        else:
            additional_secret_key_prompt += ' (leave blank to skip adding bucket) '

        additional_aws_secret_access_key = raw_input(
            additional_secret_key_prompt)

        if additional_aws_secret_access_key == "" and default_aws_secret_access_key:
            additional_aws_secret_access_key = default_aws_secret_access_key
        elif additional_aws_secret_access_key == "":
            continue

        ret['s3_credentials'][additional_s3_bucket] = {
            'access_key_id': additional_aws_access_key_id,
            'secret_access_key': additional_aws_secret_access_key,
        }

    puts("\n- Done configuring Amazon S3.")
    return ret


Instruction:
Can you tell what is the following Python 3 function doing
def _setup_tarbell_project_path(settings, path, prompt=True):
    default_path = os.path.expanduser(os.path.join("~", "tarbell"))
    projects_path = raw_input("\nWhat is your Tarbell projects path? [Default: {0}, 'none' to skip] ".format(default_path))
    if projects_path == "":
        projects_path = default_path
    if projects_path.lower() == 'none':
        puts("\n- Not creating projects directory.")
        return {}

    if os.path.isdir(projects_path):
        puts("\nDirectory exists!")
    else:
        puts("\nDirectory does not exist.")
        make = raw_input("\nWould you like to create it? [Y/n] ")
        if make.lower() == "y" or not make:
            os.makedirs(projects_path)
    puts("\nProjects path is {0}".format(projects_path))
    puts("\n- Done setting up projects path.")
    return {"projects_path": projects_path}

Response: Setup Tarbell project path.


Instruction:
Given the following Python 3 function, write the documentation
def _setup_default_templates(settings, path, prompt=True):
    project_templates = [{
        "name": "Basic Bootstrap 3 template",
        "url": "https://github.com/tarbell-project/tarbell-template",
    }, {
        "name": "Searchable map template",
        "url": "https://github.com/tarbell-project/tarbell-map-template",
    }, {
        "name": "Tarbell template walkthrough",
        "url": "https://github.com/tarbell-project/tarbell-tutorial-template",
    }]
    for project in project_templates:
        puts("+ Adding {0} ({1})".format(project["name"], project["url"]))

    puts("\n- Done configuring project templates.")
    return {"project_templates": project_templates}

Response: Add some (hardcoded) default templates.


Instruction:
Can you generate the documentation for the following Python 3 function
def puts(s='', newline=True, stream=STDOUT):
    if not is_werkzeug_process():
        try:
            return _puts(s, newline, stream)
        except UnicodeEncodeError:
            return _puts(s.encode(sys.stdout.encoding), newline, stream)

Response: Wrap puts to avoid getting called twice by Werkzeug reloader.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def list_get(l, idx, default=None):
    try:
        if l[idx]:
            return l[idx]
        else:
            return default
    except IndexError:
        return default

Response: Get from a list with an optional default value.


Instruction:
Can you tell what is the following Python 3 function doing
def split_sentences(s, pad=0):
    sentences = []
    for index, sentence in enumerate(s.split('. ')):
        padding = ''
        if index > 0:
            padding = ' ' * (pad + 1)
        if sentence.endswith('.'):
            sentence = sentence[:-1]
        sentences.append('%s %s.' % (padding, sentence.strip()))
    return "\n".join(sentences)

Response: Split a string into a list of sentences.


Instruction:
Can you implement a function in Python 3 that
ensures that the directory exists for a given file path.

Response:
def ensure_directory(path):
    """
    Ensure directory exists for a given file path.
    """
    dirname = os.path.dirname(path)
    if not os.path.exists(dirname):
        os.makedirs(dirname)


Instruction:
Can you generate the documentation for the following Python 3 function
def add_stream(self, policy):
        _srtp_assert(lib.srtp_add_stream(self._srtp[0], policy._policy))

Response: Add a stream to the SRTP session applying the given policy to the stream.


Instruction:
How would you code a function in Python 3 to
remove the stream with the given ssrc from the SRTP session.

Response:
def remove_stream(self, ssrc):
        """
        Remove the stream with the given `ssrc` from the SRTP session.

        :param ssrc: :class:`int`
        """
        _srtp_assert(lib.srtp_remove_stream(self._srtp[0], htonl(ssrc)))


Instruction:
Can you generate a brief explanation for the following Python 3 code
def process_xlsx(content):
    data = {}
    workbook = xlrd.open_workbook(file_contents=content)
    worksheets = [w for w in workbook.sheet_names() if not w.startswith('_')]
    for worksheet_name in worksheets:
        if worksheet_name.startswith('_'):
            continue

        worksheet = workbook.sheet_by_name(worksheet_name)

        merged_cells = worksheet.merged_cells
        if len(merged_cells):
            raise MergedCellError(worksheet.name, merged_cells)

        worksheet.name = slughifi(worksheet.name)
        headers = make_headers(worksheet)
        worksheet_data = make_worksheet_data(headers, worksheet)
        data[worksheet.name] = worksheet_data
    return data

Response: Converts Excel file contents into Tarbell worksheet data


Instruction:
Given the following Python 3 function, write the documentation
def copy_global_values(data):
    for k, v in data['values'].items():
        if not data.get(k):
            data[k] = v
        else:
            puts("There is both a worksheet and a "
                 "value named '{0}'. The worksheet data "
                 "will be preserved.".format(k))
    data.pop("values", None)
    return data

Response: Copy values from the global namespace into the data.


Instruction:
Given the following Python 3 function, write the documentation
def make_headers(worksheet):
    headers = {}
    cell_idx = 0
    while cell_idx < worksheet.ncols:
        cell_type = worksheet.cell_type(0, cell_idx)
        if cell_type == 1:
            header = slughifi(worksheet.cell_value(0, cell_idx))
            if not header.startswith("_"):
                headers[cell_idx] = header
        cell_idx += 1
    return headers

Response: Make headers from worksheet


Instruction:
Here you have a function in Python 3, explain what it does
def make_worksheet_data(headers, worksheet):
    data = []
    row_idx = 1
    while row_idx < worksheet.nrows:
        cell_idx = 0
        row_dict = {}
        while cell_idx < worksheet.ncols:
            cell_type = worksheet.cell_type(row_idx, cell_idx)
            if cell_type in VALID_CELL_TYPES:
                cell_value = worksheet.cell_value(row_idx, cell_idx)
                try:
                    if cell_type == 2 and cell_value.is_integer():
                        cell_value = int(cell_value)
                    row_dict[headers[cell_idx]] = cell_value
                except KeyError:
                    try:
                        column = ascii_uppercase[cell_idx]
                    except IndexError:
                        column = cell_idx
                        puts("There is no header for cell with value '{0}' in column '{1}' of '{2}'" .format(
                            cell_value, column, worksheet.name
                        ))
            cell_idx += 1
        data.append(row_dict)
        row_idx += 1

    # Magic key handling
    if 'key' in headers.values():
        keyed_data = {}
        for row in data:
            if 'key' in row.keys():
                key = slughifi(row['key'])
                if keyed_data.get(key):
                    puts("There is already a key named '{0}' with value "
                           "'{1}' in '{2}'. It is being overwritten with "
                           "value '{3}'.".format(key,
                                   keyed_data.get(key),
                                   worksheet.name,
                                   row))

                # Magic values worksheet
                if worksheet.name == "values":
                    value = row.get('value')
                    if value not in ("", None):
                        keyed_data[key] = value
                else:
                    keyed_data[key] = row

        data = keyed_data

    return data

Response: Make data from a worksheet.


Instruction:
Can you write a function in Python 3 where it
ensures preview is never cached

Response:
def never_cache_preview(self, response):
        """
        Ensure preview is never cached
        """
        response.cache_control.max_age = 0
        response.cache_control.no_cache = True
        response.cache_control.must_revalidate = True
        response.cache_control.no_store = True
        return response


Instruction:
Can you write a function in Python 3 where it
calls each registered hook

Response:
def call_hook(self, hook, *args, **kwargs):
        """
        Calls each registered hook
        """
        for function in self.hooks[hook]:
            function.__call__(*args, **kwargs)


Instruction:
Given the following Python 3 function, write the documentation
def _get_base(self, path):
        base = None

        # Slightly ugly DRY violation for backwards compatibility with old
        # "_base" convention
        if os.path.isdir(os.path.join(path, "_blueprint")):
            base_dir = os.path.join(path, "_blueprint/")
            # Get the blueprint template and register it as a blueprint
            if os.path.exists(os.path.join(base_dir, "blueprint.py")):
                filename, pathname, description = imp.find_module('blueprint', [base_dir])
                base = imp.load_module('blueprint', filename, pathname, description)
                self.blueprint_name = "_blueprint"
            else:
                puts("No _blueprint/blueprint.py file found")
        elif os.path.isdir(os.path.join(path, "_base")):
            puts("Using old '_base' convention")
            base_dir = os.path.join(path, "_base/")
            if os.path.exists(os.path.join(base_dir, "base.py")):
                filename, pathname, description = imp.find_module('base', [base_dir])
                base = imp.load_module('base', filename, pathname, description)
                self.blueprint_name = "_base"
            else:
                puts("No _base/base.py file found")

        if base:
            base.base_dir = base_dir

        if hasattr(base, 'blueprint') and isinstance(base.blueprint, Blueprint):
            self.app.register_blueprint(base.blueprint, site=self)

        return base

Response: Get the base module for the current project.


Instruction:
Can you write a function in Python 3 where it
loads a Tarbell project and return a dictionary of the project s attributes.

Response:
def load_project(self, path):
        """
        Load a Tarbell project
        """
        base = self._get_base(path)

        filename, pathname, description = imp.find_module('tarbell_config', [path])
        project = imp.load_module('project', filename, pathname, description)

        try:
            self.key = project.SPREADSHEET_KEY
            self.client = get_drive_api()
        except AttributeError:
            self.key = None
            self.client = None

        try:
            project.CREATE_JSON
        except AttributeError:
            project.CREATE_JSON = False

        try:
            project.S3_BUCKETS
        except AttributeError:
            project.S3_BUCKETS = {}

        project.EXCLUDES = list(set(EXCLUDES + getattr(project, 'EXCLUDES', []) + getattr(base, 'EXCLUDES', [])))

        # merge project template types with defaults
        project.TEMPLATE_TYPES = set(getattr(project, 'TEMPLATE_TYPES', [])) | set(TEMPLATE_TYPES)

        try:
            project.DEFAULT_CONTEXT
        except AttributeError:
            project.DEFAULT_CONTEXT = {}

        project.DEFAULT_CONTEXT.update({
            "PROJECT_PATH": self.path,
            "ROOT_URL": "127.0.0.1:5000",
            "SPREADSHEET_KEY": self.key,
            "BUCKETS": project.S3_BUCKETS,
            "SITE": self,
        })

        # Set up template loaders
        template_dirs = [path]
        if base:
            template_dirs.append(base.base_dir)
        error_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'error_templates')
        template_dirs.append(error_path)

        self.app.jinja_loader = TarbellFileSystemLoader(template_dirs)

        # load the project blueprint, if it exists
        if hasattr(project, 'blueprint') and isinstance(project.blueprint, Blueprint):
            self.app.register_blueprint(project.blueprint, site=self)

        return project, base


Instruction:
Implement a function in Python 3 to
resolve static file paths

Response:
def _resolve_path(self, path):
        """
        Resolve static file paths
        """
        filepath = None
        mimetype = None

        for root, dirs, files in self.filter_files(self.path):
            # Does it exist in error path?
            error_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'error_templates', path)
            try:
                with open(error_path):
                    mimetype, encoding = mimetypes.guess_type(error_path)
                    filepath = error_path
            except IOError:
                pass

            # Does it exist in Tarbell blueprint?
            if self.base:
                basepath = os.path.join(root, self.blueprint_name, path)
                try:
                    with open(basepath):
                        mimetype, encoding = mimetypes.guess_type(basepath)
                        filepath = basepath
                except IOError:
                    pass

            # Does it exist under regular path?
            fullpath = os.path.join(root, path)
            try:
                with open(fullpath):
                    mimetype, encoding = mimetypes.guess_type(fullpath)
                    filepath = fullpath
            except IOError:
                pass

        return filepath, mimetype


Instruction:
Given the following Python 3 function, write the documentation
def data_json(self, extra_context=None, publish=False):
        if not self.project.CREATE_JSON:
            # nothing to see here, but the right mimetype
            return jsonify()

        if not self.data:
            # this sets site.data by spreadsheet or gdoc
            self.get_context(publish)

        return jsonify(self.data)

Response: Serve site context as JSON. Useful for debugging.


Instruction:
Can you write a function in Python 3 where it
serves up a project path and return a response.

Response:
def preview(self, path=None, extra_context=None, publish=False):
        """
        Serve up a project path
        """
        try:
            self.call_hook("preview", self)

            if path is None:
                path = 'index.html'

            # Detect files
            filepath, mimetype = self._resolve_path(path)

            # Serve dynamic
            if filepath and mimetype and mimetype in self.project.TEMPLATE_TYPES:
                context = self.get_context(publish)
                context.update({
                    "PATH": path,
                    "PREVIEW_SERVER": not publish,
                    "TIMESTAMP": int(time.time()),
                })
                if extra_context:
                    context.update(extra_context)

                rendered = render_template(path, **context)
                return Response(rendered, mimetype=mimetype)

            # Serve static
            if filepath:
                dir, filename = os.path.split(filepath)
                return send_from_directory(dir, filename)

        except Exception as e:
            ex_type, ex, tb = sys.exc_info()
            try:
                # Find template with name of error
                cls = e.__class__
                ex_type, ex, tb = sys.exc_info()

                context = self.project.DEFAULT_CONTEXT
                context.update({
                    'PATH': path,
                    'traceback': traceback.format_exception(ex_type, ex, tb),
                    'e': e,
                })
                if extra_context:
                    context.update(extra_context)

                try:
                    error_path = '_{0}.{1}.html'.format(cls.__module__, cls.__name__)
                    rendered = render_template(error_path, **context)
                except TemplateNotFound:
                    # Find template without underscore prefix, @TODO remove in v1.1
                    error_path = '{0}.{1}.html'.format(cls.__module__, cls.__name__)
                    rendered = render_template(error_path, **context)

                return Response(rendered, mimetype="text/html")
            except TemplateNotFound:
                # Otherwise raise old error
                reraise(ex_type, ex, tb)

        # Last ditch effort -- see if path has "index.html" underneath it
        if not path.endswith("index.html"):
            if not path.endswith("/"):
                path = "{0}/".format(path)
            path = "{0}{1}".format(path, "index.html")
            return self.preview(path)

        # It's a 404
        if path.endswith('/index.html'):
            path = path[:-11]
        rendered = render_template("404.html", PATH=path)
        return Response(rendered, status=404)


Instruction:
Write a Python 3 script to
return the parsed data.

Response:
def get_context(self, publish=False):
        """
        Use optional CONTEXT_SOURCE_FILE setting to determine data source.
        Return the parsed data.

        Can be an http|https url or local file. Supports csv and excel files.
        """
        context = self.project.DEFAULT_CONTEXT
        try:
            file = self.project.CONTEXT_SOURCE_FILE
            # CSV
            if re.search(r'(csv|CSV)$', file):
                context.update(self.get_context_from_csv())
            # Excel
            if re.search(r'(xlsx|XLSX|xls|XLS)$', file):
                context.update(self.get_context_from_xlsx())
        except AttributeError:
            context.update(self.get_context_from_gdoc())

        return context


Instruction:
Write a Python 3 script for
getting context from an Excel file

Response:
def get_context_from_xlsx(self):
        """
        Get context from an Excel file
        """
        if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE):
            resp = requests.get(self.project.CONTEXT_SOURCE_FILE)
            content = resp.content
        else:
            try:
                with open(self.project.CONTEXT_SOURCE_FILE) as xlsxfile:
                    content = xlsxfile.read()
            except IOError:
                filepath = "%s/%s" % (
                    os.path.abspath(self.path),
                    self.project.CONTEXT_SOURCE_FILE)
                with open(filepath) as xlsxfile:
                    content = xlsxfile.read()

        data = process_xlsx(content)
        if 'values' in data:
            data = copy_global_values(data)

        return data


Instruction:
Write a Python 3 script for
parsing and return a context from the CONTEXT_SOURCE_FILE

Response:
def get_context_from_csv(self):
        """
        Open CONTEXT_SOURCE_FILE, parse and return a context
        """
        if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE):
            data = requests.get(self.project.CONTEXT_SOURCE_FILE)
            reader = csv.reader(
                data.iter_lines(), delimiter=',', quotechar='"')
            ret = {rows[0]: rows[1] for rows in reader}
        else:
            try:
                with open(self.project.CONTEXT_SOURCE_FILE) as csvfile:
                    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
                    ret = {rows[0]: rows[1] for rows in reader}
            except IOError:
                file = "%s/%s" % (
                    os.path.abspath(self.path),
                    self.project.CONTEXT_SOURCE_FILE)
                with open(file) as csvfile:
                    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
                    ret = {rows[0]: rows[1] for rows in reader}
        ret.update({
            "CONTEXT_SOURCE_FILE": self.project.CONTEXT_SOURCE_FILE,
        })
        return ret


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_context_from_gdoc(self):
        try:
            start = int(time.time())
            if not self.data or start > self.expires:
                self.data = self._get_context_from_gdoc(self.project.SPREADSHEET_KEY)
                end = int(time.time())
                ttl = getattr(self.project, 'SPREADSHEET_CACHE_TTL',
                              SPREADSHEET_CACHE_TTL)
                self.expires = end + ttl
            return self.data
        except AttributeError:
            return {}

Response: Wrap getting context from Google sheets in a simple caching mechanism.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def _get_context_from_gdoc(self, key):
        try:
            content = self.export_xlsx(key)
            data = process_xlsx(content)
            if 'values' in data:
                data = copy_global_values(data)
            return data
        except BadStatusLine:
            # Stale connection, reset API and data
            puts("Connection reset, reloading drive API")
            self.client = get_drive_api()
            return self._get_context_from_gdoc(key)

Response: Create a Jinja2 context from a Google spreadsheet.


Instruction:
How would you implement a function in Python 3 that
downloads xlsx version of spreadsheet.

Response:
def export_xlsx(self, key):
        """
        Download xlsx version of spreadsheet.
        """
        spreadsheet_file = self.client.files().get(fileId=key).execute()
        links = spreadsheet_file.get('exportLinks')
        downloadurl = links.get('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
        resp, content = self.client._http.request(downloadurl)
        return content


Instruction:
Write a Python 3 function that can
generate a static site for the current application.

Response:
def generate_static_site(self, output_root=None, extra_context=None):
        """
        Bake out static site
        """
        self.app.config['BUILD_PATH'] = output_root

        # use this hook for registering URLs to freeze
        self.call_hook("generate", self, output_root, extra_context)

        if output_root is not None:
            # realpath or this gets generated relative to the tarbell package
            self.app.config['FREEZER_DESTINATION'] = os.path.realpath(output_root)

        self.freezer.freeze()


Instruction:
Write a Python 3 script to
filter files based on blueprint and project configuration as well as hidden files.

Response:
def filter_files(self, path):
        """
        Exclude files based on blueprint and project configuration as well as hidden files.
        """
        excludes = r'|'.join([fnmatch.translate(x) for x in self.project.EXCLUDES]) or r'$.'
        for root, dirs, files in os.walk(path, topdown=True):
            dirs[:] = [d for d in dirs if not re.match(excludes, d)]
            dirs[:] = [os.path.join(root, d) for d in dirs]
            rel_path = os.path.relpath(root, path)

            paths = []
            for f in files:
                if rel_path == '.':
                    file_path = f
                else:
                    file_path = os.path.join(rel_path, f)
                if not re.match(excludes, file_path):
                    paths.append(f)

            files[:] = paths
            yield root, dirs, files


Instruction:
Write a Python 3 function that can
find all files for publishing yield urlname kwargs

Response:
def find_files(self):
        """
        Find all file paths for publishing, yield (urlname, kwargs)
        """
        # yield blueprint paths first
        if getattr(self, 'blueprint_name', None):
            for path in walk_directory(os.path.join(self.path, self.blueprint_name), ignore=self.project.EXCLUDES):
                yield 'preview', {'path': path}

        # then yield project paths
        for path in walk_directory(self.path, ignore=self.project.EXCLUDES):
            yield 'preview', {'path': path}


Instruction:
Write a Python 3 function for
deploying a directory to an s3 bucket.

Response:
def deploy_to_s3(self):
        """
        Deploy a directory to an s3 bucket.
        """
        self.tempdir = tempfile.mkdtemp('s3deploy')

        for keyname, absolute_path in self.find_file_paths():
            self.s3_upload(keyname, absolute_path)

        shutil.rmtree(self.tempdir, True)
        return True


Instruction:
Make a summary of the following Python 3 code
def s3_upload(self, keyname, absolute_path):
        mimetype = mimetypes.guess_type(absolute_path)
        options = {'Content-Type': mimetype[0]}

        if mimetype[0] is not None and mimetype[0].startswith('text/'):
            upload = open(absolute_path, 'rb')
            options['Content-Encoding'] = 'gzip'
            key_parts = keyname.split('/')
            filename = key_parts.pop()
            temp_path = os.path.join(self.tempdir, filename)
            gzfile = gzip.GzipFile(temp_path, 'wb', 9, None, GZIP_TIMESTAMP)
            gzfile.write(upload.read())
            gzfile.close()
            absolute_path = temp_path

        hash = '"{0}"'.format(hashlib.md5(open(absolute_path, 'rb').read()).hexdigest())
        key = "{0}/{1}".format(self.bucket.path, keyname)
        existing = self.connection.get_key(key)

        if self.force or not existing or (existing.etag != hash):
            k = Key(self.connection)
            k.key = key
            puts("+ Uploading {0}/{1}".format(self.bucket, keyname))
            k.set_contents_from_filename(absolute_path, options, policy='public-read')
        else:
            puts("- Skipping  {0}/{1}, files match".format(self.bucket, keyname))

Response: Upload a file to s3


Instruction:
Make a summary of the following Python 3 code
def find_file_paths(self):
        paths = []
        for root, dirs, files in os.walk(self.directory, topdown=True):
            rel_path = os.path.relpath(root, self.directory)
            for f in files:
                if rel_path == '.':
                    path = (f, os.path.join(root, f))
                else:
                    path = (os.path.join(rel_path, f), os.path.join(root, f))
                paths.append(path)
        return paths

Response: A generator function that recursively finds all files in the upload directory.


Instruction:
How would you explain what the following Python 3 function does
def get_drive_api():
    settings = Settings()

    if settings.credentials:
        return get_drive_api_from_file(settings.credentials_path)

    if settings.client_secrets:
        return get_drive_api_from_client_secrets(settings.client_secrets_path)

Response: Get drive API client based on settings.


Instruction:
Write a Python 3 function that can
read the client secrets file if available and authorizes them.

Response:
def get_drive_api_from_client_secrets(path, reset_creds=False):
    """
    Reads the local client secrets file if available (otherwise, opens a
    browser tab to walk through the OAuth 2.0 process, and stores the client
    secrets for future use) and then authorizes those credentials. Returns a
    Google Drive API service object.
    """
    storage = keyring_storage.Storage('tarbell', getpass.getuser())
    credentials = None
    if not reset_creds:
        credentials = storage.get()
    if path and not credentials:
        flow = client.flow_from_clientsecrets(path, scope=OAUTH_SCOPE)
        credentials = tools.run_flow(flow, storage, flags)
        storage.put(credentials)

    return _get_drive_api(credentials)


Instruction:
Explain what the following Python 3 code does
def get_drive_api_from_file(path):
    f = open(path)
    credentials = client.OAuth2Credentials.from_json(f.read())
    return _get_drive_api(credentials)

Response: Get drive API from file.


Instruction:
Write a Python 3 function for
returning a drive API object for a given set of credentials.

Response:
def _get_drive_api(credentials):
    """
    For a given set of credentials, return a drive API object.
    """
    http = httplib2.Http()
    http = credentials.authorize(http)
    service = discovery.build('drive', 'v2', http=http)
    service.credentials = credentials  # duck punch service obj. with credentials
    return service


Instruction:
Here you have a function in Python 3, explain what it does
def tarbell_install_blueprint(command, args):
    with ensure_settings(command, args) as settings:
        name = None
        error = None
        template_url = args.get(0)
        matches = [template for template in settings.config["project_templates"] if template.get("url") == template_url]
        tempdir = tempfile.mkdtemp()

        if matches:
            puts("\n{0} already exists. Nothing more to do.\n".format(
                colored.yellow(template_url)
            ))
            sys.exit()

        try:
            puts("\nInstalling {0}".format(colored.cyan(template_url)))
            puts("\n- Cloning repo")
            git = sh.git.bake(_cwd=tempdir, _tty_in=True, _tty_out=False, _err_to_out=True)
            puts(git.clone(template_url, '.'))

            _install_requirements(tempdir)

            filename, pathname, description = imp.find_module('blueprint', [tempdir])
            blueprint = imp.load_module('blueprint', filename, pathname, description)
            puts("\n- Found _blueprint/blueprint.py")
            name = blueprint.NAME
            puts("\n- Name specified in blueprint.py: {0}".format(colored.yellow(name)))
            settings.config["project_templates"].append({"name": name, "url": template_url})
            settings.save()

        except AttributeError:
            name = template_url.split("/")[-1]
            error = "\n- No name specified in blueprint.py, using '{0}'".format(colored.yellow(name))

        except ImportError:
            error = 'No blueprint.py found'

        except sh.ErrorReturnCode_128 as e:
            if e.stdout.strip('\n').endswith('Device not configured'):
                error = 'Git tried to prompt for a username or password.\n\nTarbell doesn\'t support interactive sessions. Please configure ssh key access to your Git repository. (See https://help.github.com/articles/generating-ssh-keys/)'
            else:
                error = 'Not a valid repository or Tarbell project'
        finally:
            _delete_dir(tempdir)
            if error:
                show_error(error)
            else:
                puts("\n+ Added new project template: {0}".format(colored.yellow(name)))

Response: Install a project template.


Instruction:
Write a Python 3 function for
listing available Tarbell templates.

Response:
def tarbell_list_templates(command, args):
    """
    List available Tarbell blueprints.
    """
    with ensure_settings(command, args) as settings:
        puts("\nAvailable project templates\n")
        _list_templates(settings)
        puts("")


Instruction:
Here you have a function in Python 3, explain what it does
def tarbell_newproject(command, args):
    with ensure_settings(command, args) as settings:
        # Set it up and make the directory
        name = _get_project_name(args)
        puts("Creating {0}".format(colored.cyan(name)))
        path = _get_path(name, settings)
        _mkdir(path)

        try:
            _newproject(command, path, name, settings)
        except KeyboardInterrupt:
            _delete_dir(path)
            show_error("ctrl-c pressed, not creating new project.")
        except:
            _delete_dir(path)
            show_error("Unexpected error: {0}".format(sys.exc_info()[0]))
            raise

Response: Create a new Tarbell project.


Instruction:
Write a Python 3 function that can
serve the current Tarbell project.

Response:
def tarbell_serve(command, args):
    """
    Serve the current Tarbell project.
    """
    with ensure_project(command, args) as site:
        with ensure_settings(command, args) as settings:
            address = list_get(args, 0, "").split(":")
            ip = list_get(address, 0, settings.config['default_server_ip'])
            port = int(list_get(address, 1, settings.config['default_server_port']))

        puts("\n * Running local server. Press {0} to stop the server".format(colored.red("ctrl-c")))
        puts(" * Edit this project's templates at {0}".format(colored.yellow(site.path)))
        try:
            if not is_werkzeug_process():
                site.call_hook("server_start", site)

            site.app.run(ip, port=port)

            if not is_werkzeug_process():
                site.call_hook("server_stop", site)

        except socket.error:
            show_error("Address {0} is already in use, please try another port or address."
                 .format(colored.yellow("{0}:{1}".format(ip, port))))


Instruction:
Can you generate a brief explanation for the following Python 3 code
def tarbell_switch(command, args):
    with ensure_settings(command, args) as settings:
        projects_path = settings.config.get("projects_path")
        if not projects_path:
            show_error("{0} does not exist".format(projects_path))
            sys.exit()
        project = args.get(0)
        args.remove(project)
        project_path = os.path.join(projects_path, project)
        if os.path.isdir(project_path):
            os.chdir(project_path)
            puts("\nSwitching to {0}".format(colored.red(project)))
            tarbell_serve(command, args)
        else:
            show_error("{0} isn't a tarbell project".format(project_path))

Response: Switch to a project.


Instruction:
Write a Python 3 function for
updating the current tarbell project.

Response:
def tarbell_update(command, args):
    """
    Update the current tarbell project.
    """
    with ensure_settings(command, args) as settings, ensure_project(command, args) as site:
        puts("Updating to latest blueprint\n")

        git = sh.git.bake(_cwd=site.base.base_dir)

        # stash then pull
        puts(colored.yellow("Stashing local changes"))
        puts(git.stash())

        puts(colored.yellow("Pull latest changes"))
        puts(git.pull())

        # need to pop any local changes back to get back on the original branch
        # this may behave oddly if you have old changes stashed
        if git.stash.list():
            puts(git.stash.pop())


Instruction:
How would you implement a function in Python 3 that
opens a context spreadsheet with the specified settings and project.

Response:
def tarbell_spreadsheet(command, args):
    """
    Open context spreadsheet
    """
    with ensure_settings(command, args) as settings, ensure_project(command, args) as site:
        try:
            # First, try to get the Google Spreadsheet URL
            spreadsheet_url = _google_spreadsheet_url(site.project.SPREADSHEET_KEY)
        except AttributeError:
            # The project doesn't seem to be using a Google Spreadsheet.
            # Try the URL or path specified in the CONTEXT_SOURCE_FILE setting
            try:
                spreadsheet_url = _context_source_file_url(
                    site.project.CONTEXT_SOURCE_FILE)
                print(spreadsheet_url)
            except AttributeError:
                puts(colored.red("No Google spreadsheet or context source file "
                                 "has been configured.\n"))
                return

        # Use the webbrowser package to try to open the file whether it's a
        # remote URL on the web, or a local file.  On some platforms it will
        # successfully open local files in the default application.
        # This seems preferable to trying to do os detection and calling
        # the system-specific command for opening files in default
        # applications.
        # See
        # http://stackoverflow.com/questions/434597/open-document-with-default-application-in-python
        webbrowser.open(spreadsheet_url)


Instruction:
Can you create a Python 3 function that
returns a URL for a remote or local context CSV file

Response:
def _context_source_file_url(path_or_url):
    """
    Returns a URL for a remote or local context CSV file
    """
    if path_or_url.startswith('http'):
        # Remote CSV. Just return the URL
        return path_or_url

    if path_or_url.startswith('/'):
        # Absolute path
        return "file://" + path_or_url

    return "file://" + os.path.join(os.path.realpath(os.getcwd()), path_or_url)


Instruction:
Here you have a function in Python 3, explain what it does
def _newproject(command, path, name, settings):
    key = None
    title = _get_project_title()
    template = _get_template(settings)

    # Init repo
    git = sh.git.bake(_cwd=path)
    puts(git.init())

    if template.get("url"):
        # Create submodule
        puts(git.submodule.add(template['url'], '_blueprint'))
        puts(git.submodule.update(*['--init']))

        # Create spreadsheet
        key = _create_spreadsheet(name, title, path, settings)

        # Copy html files
        puts(colored.green("\nCopying html files..."))
        files = glob.iglob(os.path.join(path, "_blueprint", "*.html"))
        for file in files:
            if os.path.isfile(file):
                dir, filename = os.path.split(file)
                if not filename.startswith("_") and not filename.startswith("."):
                    puts("Copying {0} to {1}".format(filename, path))
                    shutil.copy2(file, path)
        ignore = os.path.join(path, "_blueprint", ".gitignore")
        if os.path.isfile(ignore):
            shutil.copy2(ignore, path)
    else:
        empty_index_path = os.path.join(path, "index.html")
        open(empty_index_path, "w")

    # Create config file
    _copy_config_template(name, title, template, path, key, settings)

    # Commit
    puts(colored.green("\nInitial commit"))
    puts(git.add('.'))
    puts(git.commit(m='Created {0} from {1}'.format(name, template['name'])))

    _install_requirements(path)

    # Get site, run hook
    with ensure_project(command, args, path) as site:
        site.call_hook("newproject", site, git)

    # Messages
    puts("\nAll done! To preview your new project, type:\n")
    puts("{0} {1}".format(colored.green("tarbell switch"), colored.green(name)))
    puts("\nor\n")
    puts("{0}".format(colored.green("cd %s" % path)))
    puts("{0}".format(colored.green("tarbell serve\n")))

    puts("\nYou got this!\n")

Response: Helper to create a new project.


Instruction:
How would you implement a function in Python 3 that
installs a blueprint s requirements. txt

Response:
def _install_requirements(path):
    """
    Install a blueprint's requirements.txt
    """
    locations = [os.path.join(path, "_blueprint"), os.path.join(path, "_base"), path]
    success = True

    for location in locations:
        try:
            with open(os.path.join(location, "requirements.txt")):
                puts("\nRequirements file found at {0}".format(os.path.join(location, "requirements.txt")))
                install_reqs = raw_input("Install requirements now with pip install -r requirements.txt? [Y/n] ")
                if not install_reqs or install_reqs.lower() == 'y':
                    pip = sh.pip.bake(_cwd=location)
                    puts("\nInstalling requirements...")
                    puts(pip("install", "-r", "requirements.txt"))
                else:
                    success = False
                    puts("Not installing requirements. This may break everything! Vaya con dios.")
        except IOError:
            pass

    return success


Instruction:
Write a Python 3 function that can
remove the suffix from the string and returns the string.

Response:
def _clean_suffix(string, suffix):
    """
    If string endswith the suffix, remove it. Else leave it alone.
    """
    suffix_len = len(suffix)

    if len(string) < suffix_len:
        # the string param was shorter than the suffix
        raise ValueError("A suffix can not be bigger than string argument.")
    if string.endswith(suffix):
        # return from the beginning up to
        # but not including the first letter
        # in the suffix
        return string[0:-suffix_len]
    else:
        # leave unharmed
        return string


Instruction:
Make a summary of the following Python 3 code
def _get_path(name, settings, mkdir=True):
    default_projects_path = settings.config.get("projects_path")
    path = None

    if default_projects_path:
        path = raw_input("\nWhere would you like to create this project? [{0}/{1}] ".format(default_projects_path, name))
        if not path:
            path = os.path.join(default_projects_path, name)
    else:
        while not path:
            path = raw_input("\nWhere would you like to create this project? (e.g. ~/tarbell/) ")

    return os.path.expanduser(path)

Response: Generate a project path.


Instruction:
Can you generate the documentation for the following Python 3 function
def _mkdir(path):
    try:
        os.mkdir(path)
    except OSError as e:
        if e.errno == 17:
            show_error("ABORTING: Directory {0} already exists.".format(path))
        else:
            show_error("ABORTING: OSError {0}".format(e))
        sys.exit()

Response: Make a directory or bail.


Instruction:
Given the following Python 3 function, write the documentation
def _get_template(settings):
    puts("\nPick a template\n")
    template = None
    while not template:
        _list_templates(settings)
        index = raw_input("\nWhich template would you like to use? [1] ")
        if not index:
            index = "1"
        try:
            index = int(index) - 1
            return settings.config["project_templates"][index]
        except:
            puts("\"{0}\" isn't a valid option!".format(colored.red("{0}".format(index))))
            pass

Response: Prompt user to pick a template from a list.


Instruction:
Write a Python 3 script for
listing templates from settings.

Response:
def _list_templates(settings):
    """
    List templates from settings.
    """
    for idx, option in enumerate(settings.config.get("project_templates"), start=1):
        puts("  {0!s:5} {1!s:36}".format(
            colored.yellow("[{0}]".format(idx)),
            colored.cyan(option.get("name"))
        ))
        if option.get("url"):
            puts("      {0}\n".format(option.get("url")))


Instruction:
Create a Python 3 function to
create a Google spreadsheet.

Response:
def _create_spreadsheet(name, title, path, settings):
    """
    Create Google spreadsheet.
    """
    if not settings.client_secrets:
        return None

    create = raw_input("Would you like to create a Google spreadsheet? [Y/n] ")

    if create and not create.lower() == "y":
        return puts("Not creating spreadsheet.")

    email_message = (
        "What Google account(s) should have access to this "
        "this spreadsheet? (Use a full email address, such as "
        "your.name@gmail.com. Separate multiple addresses with commas.)")

    if settings.config.get("google_account"):
        emails = raw_input("\n{0}(Default: {1}) ".format(email_message,
                                             settings.config.get("google_account")
                                            ))
        if not emails:
            emails = settings.config.get("google_account")
    else:
        emails = None
        while not emails:
            emails = raw_input(email_message)

    try:
        media_body = _MediaFileUpload(os.path.join(path, '_blueprint/_spreadsheet.xlsx'),
                                      mimetype='application/vnd.ms-excel')
    except IOError:
        show_error("_blueprint/_spreadsheet.xlsx doesn't exist!")
        return None

    service = get_drive_api()
    body = {
        'title': '{0} (Tarbell)'.format(title),
        'description': '{0} ({1})'.format(title, name),
        'mimeType': 'application/vnd.ms-excel',
    }
    try:
        newfile = service.files()\
            .insert(body=body, media_body=media_body, convert=True).execute()
        for email in emails.split(","):
            _add_user_to_file(newfile['id'], service, user_email=email.strip())
        puts("\n{0!s}! View the spreadsheet at {1!s}".format(
            colored.green("Success"),
            colored.yellow("https://docs.google.com/spreadsheet/ccc?key={0}"
                           .format(newfile['id']))
            ))
        return newfile['id']
    except errors.HttpError as error:
        show_error('An error occurred creating spreadsheet: {0}'.format(error))
        return None


Instruction:
How would you implement a function in Python 3 that
adds a user to a file in the spreadsheet.

Response:
def _add_user_to_file(file_id, service, user_email,
                      perm_type='user', role='writer'):
    """
    Grants the given set of permissions for a given file_id. service is an
    already-credentialed Google Drive service instance.
    """
    new_permission = {
        'value': user_email,
        'type': perm_type,
        'role': role
    }
    try:
        service.permissions()\
            .insert(fileId=file_id, body=new_permission)\
            .execute()
    except errors.HttpError as error:
        show_error('An error adding users to spreadsheet: {0}'.format(error))


Instruction:
Given the following Python 3 function, write the documentation
def _copy_config_template(name, title, template, path, key, settings):
        puts("\nCopying configuration file")
        context = settings.config
        context.update({
            "default_context": {
                "name": name,
                "title": title,
            },
            "name": name,
            "title": title,
            "template_repo_url": template.get('url'),
            "key": key,
        })

        # @TODO refactor this a bit
        if not key:
            spreadsheet_path = os.path.join(path, '_blueprint/', '_spreadsheet.xlsx')
            try:
                with open(spreadsheet_path, "rb") as f:
                    puts("Copying _blueprint/_spreadsheet.xlsx to tarbell_config.py's DEFAULT_CONTEXT")
                    data = process_xlsx(f.read())
                    if 'values' in data:
                        data = copy_global_values(data)
                    context["default_context"].update(data)
            except IOError:
                pass

        s3_buckets = settings.config.get("s3_buckets")
        if s3_buckets:
            puts("")
            for bucket, bucket_conf in s3_buckets.items():
                puts("Configuring {0!s} bucket at {1!s}\n".format(
                    colored.green(bucket),
                    colored.yellow("{0}/{1}".format(bucket_conf['uri'], name))
                ))

        puts("\n- Creating {0!s} project configuration file".format(
            colored.cyan("tarbell_config.py")
        ))
        template_dir = os.path.dirname(pkg_resources.resource_filename("tarbell", "templates/tarbell_config.py.template"))
        loader = jinja2.FileSystemLoader(template_dir)
        env = jinja2.Environment(loader=loader)
        env.filters["pprint_lines"] = pprint_lines  # For dumping context
        content = env.get_template('tarbell_config.py.template').render(context)
        codecs.open(os.path.join(path, "tarbell_config.py"), "w", encoding="utf-8").write(content)
        puts("\n- Done copying configuration file")

Response: Copy a template from Tarbell default to the tarbell_config. py. template file.


Instruction:
Here you have a function in Python 3, explain what it does
def save(self):
        with open(self.path, "w") as f:
            self.config["project_templates"] = list(filter(lambda template: template.get("url"), self.config["project_templates"]))
            yaml.dump(self.config, f, default_flow_style=False)

Response:
Save settings.
            to file.


Instruction:
Can you generate the documentation for the following Python 3 function
def read_file(path, absolute=False, encoding='utf-8'):
    site = g.current_site
    if not absolute:
        path = os.path.join(site.path, path)

    try:
        return codecs.open(path, 'r', encoding).read()
    except IOError:
        return None

Response: Read the file at path.