L07-09 - Collections, Strings and Real Data v1.13.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e34762d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# experimental: you can run this cell to see your code full-width\n",
    "from IPython.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "light-reason",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  run this cell without changing it. It only works on Noteable.\n",
    "! printf \"\\n\\nLink below can be send to someone to share your Noteable session:\\n\\nhttps://noteable.edina.ac.uk/user/$(jupyter notebook list | grep -oP '(?<=user\\/).*(?=\\/\\?)' )/tree?token=$( jupyter notebook list | grep -oP '(?<=token=).*(?= ::)' )\\n\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "behind-terry",
   "metadata": {},
   "source": [
    "# Lab for badges 7-9\n",
    "\n",
    "This badge has two sections: \n",
    "\n",
    "1. Solve some simple tasks using list comprehensions\n",
    "2. Build a live 'bus tracker' using a bus data API https://pbs.twimg.com/media/Dape3PaXcAAyYCl.jpg"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "designed-canvas",
   "metadata": {},
   "source": [
    "## Part 1: Small tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "traditional-gather",
   "metadata": {},
   "outputs": [],
   "source": [
    "# given this data, try to answer below challanges. hint: use List comprehensions. \n",
    "# remember that often you you need to split the task into smaller chunks \n",
    "\n",
    "cities_uk = [{'Geo': {'AreaKm2': 1572,\n",
    "                      'Coordinates': {'Latitude': 51.51, 'Longitude': -0.13}},\n",
    "          'Name': 'London',\n",
    "          'Population': 8908081,\n",
    "          'Year_Founded': 47},\n",
    "         {'Geo': {'AreaKm2': 267.77,\n",
    "                  'Coordinates': {'Latitude': 52.48, 'Longitude': -1.9}},\n",
    "          'Name': 'Birmingham',\n",
    "          'Population': 1137100,\n",
    "          'Year_Founded': 601},\n",
    "         {'Geo': {'AreaKm2': 551.7,\n",
    "                  'Coordinates': {'Latitude': 53.8, 'Longitude': -1.55}},\n",
    "          'Name': 'Leeds',\n",
    "          'Population': 789194,\n",
    "          'Year_Founded': 1893},\n",
    "         {'Geo': {'AreaKm2': 3298,\n",
    "                  'Coordinates': {'Latitude': 55.86, 'Longitude': -4.25}},\n",
    "          'Name': 'Glasgow',\n",
    "          'Population': 635640,\n",
    "          'Year_Founded': 1454},\n",
    "         {'Geo': {'AreaKm2': 142.06,\n",
    "                  'Coordinates': {'Latitude': 53.38, 'Longitude': -1.47}},\n",
    "          'Name': 'Sheffield',\n",
    "          'Population': 577800,\n",
    "          'Year_Founded': 701},\n",
    "         {'Geo': {'AreaKm2': 110,\n",
    "                  'Coordinates': {'Latitude': 51.45, 'Longitude': -2.58}},\n",
    "          'Name': 'Bristol',\n",
    "          'Population': 567111,\n",
    "          'Year_Founded': 1155},\n",
    "         {'Geo': {'AreaKm2': 115.6,\n",
    "                  'Coordinates': {'Latitude': 53.47, 'Longitude': -2.23}},\n",
    "          'Name': 'Manchester',\n",
    "          'Population': 547627,\n",
    "          'Year_Founded': 1301},\n",
    "         {'Geo': {'AreaKm2': 111.84,\n",
    "                  'Coordinates': {'Latitude': 53.41, 'Longitude': -2.99}},\n",
    "          'Name': 'Liverpool',\n",
    "          'Population': 513441,\n",
    "          'Year_Founded': 1207},\n",
    "         {'Geo': {'AreaKm2': 259,\n",
    "                  'Coordinates': {'Latitude': 55.95, 'Longitude': -3.2}},\n",
    "          'Name': 'Edinburgh',\n",
    "          'Population': 488050,\n",
    "          'Year_Founded': 601}]\n",
    "\n",
    "cities_scotland = [\n",
    "         {'Geo': {'AreaKm2': 3298,\n",
    "                  'Coordinates': {'Latitude': 55.86, 'Longitude': -4.25}},\n",
    "          'Name': 'Glasgow',\n",
    "          'Population': 635640,\n",
    "          'Year_Founded': 1454},\n",
    "         {'Geo': {'AreaKm2': 259,\n",
    "                  'Coordinates': {'Latitude': 55.95, 'Longitude': -3.2}},\n",
    "          'Name': 'Edinburgh',\n",
    "          'Population': 488050,\n",
    "          'Year_Founded': 601}]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reported-september",
   "metadata": {},
   "source": [
    "# Tasks Group 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "violent-group",
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_cities(some_cities):\n",
    "    return \"banana\" # here write your solution\n",
    "\n",
    "print(number_of_cities(cities_uk)) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aboriginal-devices",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert number_of_cities(cities_scotland) == 2\n",
    "assert number_of_cities(cities_uk) == 9\n",
    "print(\"tests passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "running-local",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cities_starting_with_letter(some_cities, first_letter):\n",
    "    return \"banana\" # here write your solution\n",
    "\n",
    "print(cities_starting_with_letter(cities_uk, \"B\")) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "hourly-server",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert cities_starting_with_letter(cities_uk, \"L\") == ['London', 'Leeds', 'Liverpool']\n",
    "assert cities_starting_with_letter(cities_uk, \"B\") == ['Birmingham', 'Bristol']\n",
    "assert cities_starting_with_letter(cities_scotland, \"L\") == []\n",
    "assert cities_starting_with_letter([], \"L\") == []\n",
    "print(\"tests passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "instrumental-suite",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def number_of_cities_north_of(some_cities, latitude):  \n",
    "    return \"banana\" # here write your solution\n",
    "\n",
    "print(number_of_cities_north_of(cities_uk, 53.0)) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "mathematical-function",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert number_of_cities_north_of(cities_uk, 55.0) == 2\n",
    "assert number_of_cities_north_of(cities_uk, 53.0) == 6\n",
    "assert number_of_cities_north_of(cities_scotland, 55.0) == 2\n",
    "print(\"tests passed\")\n",
    "# for simplicity let's assume everythong north of Gretna Green is in Scotland(Latitude being larger than 55.00) ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "industrial-nightmare",
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_of_cities_north_of(some_cities, latitude): \n",
    "    return \"banana\" # here write your solution. \n",
    "\n",
    "# round the result before returning it\n",
    "print(percent_of_cities_north_of(cities_uk, 55.0)) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "elect-template",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "assert percent_of_cities_north_of(cities_uk, 55.0) == 22\n",
    "assert percent_of_cities_north_of(cities_uk, 53.0) == 67\n",
    "assert percent_of_cities_north_of(cities_scotland, 55.0) == 100\n",
    "print(\"tests passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "disciplinary-enough",
   "metadata": {},
   "outputs": [],
   "source": [
    "def year_founded_of_large_cities(some_cities, minimum_population): \n",
    "    return \"banana\" # here write your solution. \n",
    "\n",
    "print(year_founded_of_large_cities(cities_uk, 1500000)) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "golden-commodity",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert year_founded_of_large_cities(cities_uk, 1500000) == 1\n",
    "assert year_founded_of_large_cities(cities_uk, 1000000) == 2\n",
    "assert year_founded_of_large_cities(cities_uk, 500000) == 8\n",
    "assert year_founded_of_large_cities(cities_scotland, 500000) == 1\n",
    "print(\"tests passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "virgin-oregon",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7da25f4c",
   "metadata": {},
   "source": [
    "# ⛏ Edinburgh Lothian Busses Timetable\n",
    "\n",
    "Below is the API of Lothian Busses, Edinburgh's local bus company. We'd like you to try to understand that data, and then print it in a meaningful way.\n",
    "\n",
    "Some functions are given below which will give you access to a **list of dictionaries**. Each item in a list will be info abotu one bus services leaving soon from a particular busstop. We'll look at the busses going to Business School or University of Edinburgh from Leith (northen part of Edinburgh). \n",
    "\n",
    "Below you will see:\n",
    "\n",
    "- the structure of the data,\n",
    "- some examples\n",
    "- some task\n",
    "\n",
    "Use what you learned up until now to extract and style the bus timetable. Here is a photo of how bus timetable looks like when it is displayed on the digital display at the actual busstop: https://pbs.twimg.com/media/Dape3PaXcAAyYCl.jpg\n",
    "\n",
    "Also this is the link to live api data (remember that pprint in your python code, and jsonviewer extension in your chrome will make it easier to see it in a clear way): https://tfe-opendata.com/api/v1/live_bus_times/36236563\n",
    "\n",
    "To make above JSON data look MUCH BETTER in your browser. Use this Chrome extension: https://chrome.google.com/webstore/detail/json-viewer/gbmdgpbipfallnflgajpaliibnhdgobh \n",
    "\n",
    "Also, here is the official API documentation: https://tfe-opendata.readme.io/docs/live-bus-times\n",
    "\n",
    "**And here's a tracker that someone has built, which is using exactly the same data you will be looking at**\n",
    "\n",
    "http://www.mybustracker.co.uk/?module=mobile&mode=2&busStopService=43&busStopDest=2850816&busStopCode=36235975&subBusStop=Display+Departures\n",
    "\n",
    "or\n",
    "\n",
    "https://www.lothianbuses.com/live-travel-info/live-bus-times/?stop_id=6200243370"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "636eafb2",
   "metadata": {},
   "source": [
    "# Demo code to get you started:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75660fa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests \n",
    "import pprint as pp \n",
    "from datetime import timedelta, date, datetime \n",
    "import pytz # timezones\n",
    "# you might see a pink warning with 'RequestsDependencyWarning'. Just ignore it for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26899eca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_buses_coming_soon( stop_id): \n",
    "    apiurl = f\"https://tfe-opendata.com/api/v1/live_bus_times/{stop_id}\" \n",
    "    print(apiurl)\n",
    "    response = requests.request(\"GET\", apiurl) \n",
    "    all_busses = response.json() \n",
    "    return all_busses"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73342e32",
   "metadata": {},
   "source": [
    "`get_buses_coming_soon` gets all routes from one bus stop. \n",
    "\n",
    "Result is a List of Dictionaries. Where each dictionary is one route (one bus number eg. 22). Route dictionary has just two keys. What are they?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3e2442c",
   "metadata": {},
   "source": [
    "Brace! this will print a lot of data!\n",
    "but have a look at the very beginning of it! What is it? List? Of What? List of Dictionaries?\n",
    "\n",
    "Read below for some hints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "intensive-greece",
   "metadata": {},
   "outputs": [],
   "source": [
    "# eg. 36235975 is an id of a bus stop on Proincess Street\n",
    "# in city center of Edinburgh \n",
    "princess_st_stop_id = 36235975\n",
    "routes = get_buses_coming_soon( princess_st_stop_id )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a7a8b2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint(len(routes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c2cffc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint(routes)\n",
    "\n",
    "# look at this data first. Try to understand what data type it is. \n",
    "# What's most useful is the first character. eg [1,2,3] is a list. {'name': 'Jen'} is a dictionary\n",
    "# [{'name': 'Jen'}, {'name': 'Pim'} ] is a list of dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7594bcb1",
   "metadata": {},
   "source": [
    "Basically the format is:\n",
    "\n",
    "**routes** - a List with all the bus routes that use it\n",
    "\n",
    "..each item in **routes** - a Dictionary describing one route with following keys: **departures**, and **routeName**\n",
    "    \n",
    "....**routeName** is just the name of the bus service, eg. '22'\n",
    "        \n",
    "....**departures** is a List with Dictionaries, each representing info of one incomming bus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7844eeba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# some examples:\n",
    "# one stop\n",
    "first_route = routes[0]\n",
    "pp.pprint(first_route)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3575f79",
   "metadata": {},
   "outputs": [],
   "source": [
    "# first bus service's routeName\n",
    "first_route_name = routes[0]['routeName'] \n",
    "print(first_route_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a59d09",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_route_departures = routes[0]['departures'] \n",
    "print(f\"First Route has number {first_route_name} and has {len(first_route_departures)} vehicles coming soon\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40d5dfa4",
   "metadata": {},
   "source": [
    "All departures for this stop (note that this api uses timezones, so we will have to also)\n",
    "instead of just datetime.now() we will use datetime.now(pytz.timezone('Europe/London'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e793c140",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"next bus of the first route:\") \n",
    "pp.pprint(routes[0]['departures'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead3954b",
   "metadata": {},
   "source": [
    "# Task Group 2: Making formatted strings from data\n",
    "\n",
    "Here are a few tasks to explore the data and list comprehensions:\n",
    "\n",
    "- Write a function to display all route numbers in `routes` variable. What variables will this function take? Make it return a string\n",
    "- Write a function to get all bus destinations in one route. Most bus routes go to only one unique destination, but there are routes where every other bus goes to a different destination. This function will take ONE ROUTE (not a list of all routes) and return a string. Say if the function is called destinations( a_route) you would call it like this: destinations( routes[0] )\n",
    "- write a function which will take one route, and return a timetable for that route as a nicely formatted. Eg: \"Number 22 going to Gyle expected at: 12:32, 12:42, 12:52.\"\n",
    "\n",
    "- extra: Can you now use a list comprehension so that each of your 'one route' functions above is applied to all of the routes.\n",
    "\n",
    "If any of these are too hard, don't worry and keep going through the notebook. More explanations coming.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3efd9f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c657b7f7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "394392f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can add more empty cells with the plus icon"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "848ce4dd",
   "metadata": {},
   "source": [
    "## Bonus: Dealing with time and date. This can be tricky, so see how much time you have left and consider skipping to Tasks Group 3\n",
    "\n",
    "This dataset describes time and date. Usually one needs to prepare such data, eg. adjust time zone.\n",
    "Then you often need to make the data meaningful eg. say how many hours or minutes ago something was.\n",
    "Finally there are ways to show data in more human-friendly ways eg. \"3rd of September\" or \"11:23pm\". To achieve that you usually perform create 'date objects' from your source data, then turn those date objects into format you'd like.\n",
    "\n",
    "eg. string `2023-03-09 18:22:24+00:00` can be turned it in into `datetime.datetime object` (which when printed looks very simmilar `2023-03-09 18:22:24+00:00`), but if you check its type, it will not be `string`.\n",
    "\n",
    "Just like string `\"33\"` and number `33` look the same when printed. But when you add `1` to them one will result in `34` and one will result in an error, or `133`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "theoretical-silicon",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a quick refresh of data :) so they are still up to date\n",
    "princess_st_stop_id = 36235975\n",
    "routes = get_buses_coming_soon( princess_st_stop_id )\n",
    "# run this code any time you want to get most up to date times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c50cc1e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# first route, first vehicle\n",
    "departure_time_from_api = routes[0]['departures'][0]['departureTime']\n",
    "print(departure_time_from_api)\n",
    "print(type(departure_time_from_api)) # what type of variable is departure_time_from_api"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cee3aab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# here's a step-by-step process of taking a complex date format into something simpler:\n",
    "\n",
    "bus_time_object = datetime.fromisoformat(departure_time_from_api) \n",
    "print(bus_time_object)\n",
    "print(type(bus_time_object)) # what type of variable is bus_time_object\n",
    "# time object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "olympic-starter",
   "metadata": {},
   "outputs": [],
   "source": [
    "bus_time_str = bus_time_object.strftime(\"%H:%M\") \n",
    "print(bus_time_str)\n",
    "# object turned back into string, but in the %H:%M string format"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a5b6470",
   "metadata": {},
   "source": [
    "Date objects are useful, because you can turn them into strings in the format of yoru choice. Eg. `3rd Sep 2023` or `03-09-23`.\n",
    "\n",
    "Let's get the time when the bus is due and try some of our newly-learned Date/Time manipulation!\n",
    "\n",
    "Reference of all the posible date time codes is here: https://docs.python.org/3/library/datetime.html#format-codes\n",
    "\n",
    "We'll need to find out what time is it right now in Edinburgh. Then subtract bus time from it to see how much more time is left:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1b8fb4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "time_now_in_edinburgh = datetime.now(pytz.timezone('Europe/London'))\n",
    "time_till_bus = bus_time_object - time_now_in_edinburgh \n",
    "\n",
    "print(time_till_bus)\n",
    "print(type(time_till_bus)) # this is object of type datetime.timedelta\n",
    "\n",
    "print(\"seconds\", time_till_bus.seconds)\n",
    "print(\"minutes\", time_till_bus.seconds // 60)\n",
    "\n",
    "# notice that if time_till_bus looks a bit weird (eg. it is -1 day and 23h 57m) it means that the bus has already left.\n",
    "# we will deal with this below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tribal-design",
   "metadata": {},
   "outputs": [],
   "source": [
    "# eg. turn '2023-03-09T18:22:24+00:00' into '18:22'\n",
    "def date_into_human_form(time_from_api):\n",
    "    bus_time_object = datetime.fromisoformat(time_from_api) \n",
    "    bus_time_str = bus_time_object.strftime(\"%H:%M\") \n",
    "    return bus_time_str\n",
    "\n",
    "print(date_into_human_form('2023-03-09T18:22:24+00:00'))\n",
    "print(date_into_human_form(departure_time_from_api))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "attempted-geometry",
   "metadata": {},
   "outputs": [],
   "source": [
    "# eg. if the time is 18:10 turn '2023-03-09T18:22:24+00:00' into 12 (because it is in 12 minutes)\n",
    "\n",
    "def date_into_minutes_from_now(time_from_api):\n",
    "    bus_time_object = datetime.fromisoformat(time_from_api)\n",
    "    time_now = datetime.now(pytz.timezone('Europe/London'))\n",
    "    \n",
    "    # depending if bus is in the future, or not, calculate it's arrival differently:    \n",
    "    if bus_time_object >= time_now:\n",
    "        #  if now is 12:30 and bus is at 12:34, then it is in 4 minutes      \n",
    "        time_till = bus_time_object - time_now \n",
    "        return time_till.seconds // 60\n",
    "    else:\n",
    "        #  if now is 12:30 and bus was at 12:20, then it is in -10 minutes      \n",
    "        time_till = (time_now - bus_time_object)\n",
    "        return  time_till.seconds // 60 * -1\n",
    "\n",
    "print(\"departure time\", departure_time_from_api)\n",
    "print(\"minutes from now\", date_into_minutes_from_now(departure_time_from_api))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea4142a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's turn data into something meaningful:\n",
    "first_route_name = routes[0]['routeName']\n",
    "first_bus_time = routes[0]['departures'][0]['departureTime']\n",
    "first_bus_human = date_into_human_form(first_bus_time)\n",
    "first_bus_in_minutes = date_into_minutes_from_now(first_bus_time)\n",
    "\n",
    "print(first_route_name)\n",
    "print( first_bus_time)\n",
    "print( first_bus_human)\n",
    "print( first_bus_in_minutes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75861a6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# and let's present it as a string\n",
    "print(f\"Next bus number {first_route_name} is at {first_bus_human:*^13} (in {first_bus_in_minutes:.0f} minutes)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39a2c863",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this could be further improved with a function which turns \n",
    "# 3 into 'in 3 minutes', 0 to 'DUE' and -10 into '10 minutes ago'\n",
    "def minutes_to_word(minutes):\n",
    "    if minutes == 0:\n",
    "        return \"DUE\"\n",
    "    elif minutes < 0:\n",
    "        return f\"{minutes * -1} minutes ago\"\n",
    "    else:\n",
    "        return f\"in {minutes} minutes\"\n",
    "\n",
    "when = minutes_to_word(first_bus_in_minutes)\n",
    "print(f\"Next bus number {first_route_name} is at {bus_time_str:*^13} ({when})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6516853a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0dbe58f5",
   "metadata": {},
   "source": [
    "# Task Group 3:\n",
    "\n",
    "- Try to use a list comprehension to create a string desctiption (like above) for each departure for the first route. Make the desciption meaningful, and try to use Date/Time information. Remember that the easiest way to do it is by creating a function that takes a departure and turns it into a string, a bit like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e8ab93c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# example: show destination of each departure\n",
    "def where_it_goes(departure):\n",
    "    # you might want to change this function\n",
    "    return f\"Bus {departure['routeName']} to {departure['destination']} at {departure['displayTime']}\" \n",
    "\n",
    "def route_into_destinations(route):\n",
    "    return [\n",
    "        where_it_goes(departure)\n",
    "        for departure in route['departures']\n",
    "    ]\n",
    "\n",
    "route_into_destinations(routes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3373d670",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16fec8d8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3702339",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "joined-diversity",
   "metadata": {},
   "source": [
    "## Presenting data in a prettier format: ⭐️"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c78927c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# advanced, but fun, for those who like using functions:\n",
    "# you can try to split your data presentation into stages.\n",
    "# you could print from your functions, but it's cleaner to return strings and print them outside \n",
    "\n",
    "def bus_route_report(route_info):\n",
    "    return f\"🚌 {route_info['routeName']:>5} has {len(route_info['departures']):2} buses incomming 💨\"\n",
    "\n",
    "def all_services_as_lines(some_routes):\n",
    "    return [\n",
    "         bus_route_report(route)\n",
    "         for route in some_routes   \n",
    "    ]\n",
    "\n",
    "pp.pprint( all_services_as_lines(routes) ) # this will print a list of strings like ['a','b','c']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67c77fa",
   "metadata": {},
   "source": [
    "### bonus code: Connect List to strings, using Enter (new line)\n",
    "\n",
    "To connect a list of stings into one string, using some delimited/connector:\n",
    "\n",
    "`\"some_delimiter\".join(some_list)`\n",
    "\n",
    "eg.\n",
    "\n",
    "`\":)\".join([\"banana\",\"kiwi\",\"plum\"])`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cf1a650",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit = [\"banana\",\"kiwi\",\"plum\"]\n",
    "print(\" ⭐️ \".join(fruit))\n",
    "print(\"**\".join(fruit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e518fd4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Applied to our previous data\n",
    "print( \"\\n\".join(all_services_as_lines(routes) ))\n",
    "# notice we are not using pp.pprint() because it will try to be 'too helpful'. try it and see the difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "working-scotland",
   "metadata": {},
   "outputs": [],
   "source": [
    "# or as a pretty function:\n",
    "\n",
    "def all_services_formatted(some_routes):\n",
    "    return \"\\n\".join(all_services_as_lines(some_routes))\n",
    "\n",
    "print(all_services_formatted(routes))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0caaf5",
   "metadata": {},
   "source": [
    "# If you still have time: Try to recreate ANYTHING SIMMILAR to the bus tracker in the picture: https://pbs.twimg.com/media/Dape3PaXcAAyYCl.jpg\n",
    "\n",
    "Do not worry about the details, Or making it exactly like this - just try to get something working and try to make it look like nice. Try to play with it, and try to use as many skills you learned during this badge as you can.\n",
    "\n",
    "\n",
    "\n",
    "We already wrote for you some the code to get the busses comming to Business School from Leith.\n",
    "You just need to format the results, so they look prettier :)\n",
    "this is the method to get the next busses. No need to change it.\n",
    "\n",
    "\n",
    "for example:\n",
    "\n",
    "```\n",
    "Next busses nr 17 are coming in 5,25,55 minutes\n",
    "Next busses nr 21 are coming in 15,45 minutes\n",
    "Next busses nr 44 are coming in 2,42 minutes\n",
    "```\n",
    "\n",
    "or even:\n",
    "\n",
    "```\n",
    "Services leaving from this busstop: 17,21,44\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "812ec99a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51e8197",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dff0e12",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}