L07-09 - SOLUTIONS - Collections, Strings and Real Data v1.14.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": "436ae634",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint as pp \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6109de29",
   "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": "code",
   "execution_count": null,
   "id": "858b2ab1",
   "metadata": {},
   "outputs": [],
   "source": [
    "cities_scotland[0]['Geo']['Coordinates']['Latitude']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "traditional-gather",
   "metadata": {},
   "outputs": [],
   "source": [
    "len([3,4,5,12,12,2,2,2,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reported-september",
   "metadata": {},
   "source": [
    "### Tasks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "violent-group",
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_cities(some_cities):\n",
    "    return len(some_cities)\n",
    "\n",
    "print(number_of_cities(cities_scotland)) # 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 [\n",
    "        city['Name']\n",
    "        for city in some_cities\n",
    "        if city['Name'][0] == first_letter\n",
    "    ]\n",
    "\n",
    "print(cities_starting_with_letter(cities_uk, \"E\")) # 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",
    "    northern_cities = [\n",
    "        city\n",
    "        for city in some_cities\n",
    "        if city['Geo']['Coordinates']['Latitude'] > latitude\n",
    "    ]\n",
    "    return len(northern_cities)\n",
    "    \n",
    "pp.pprint(number_of_cities_north_of(cities_scotland, 55.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 \n",
    "# in Scotland(Latitude being larger than 55.00) ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0039d969",
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_of_cities_north_of(some_cities, latitude): \n",
    "#     northern_cities = [\n",
    "#         city\n",
    "#         for city in some_cities\n",
    "#         if city['Geo']['Coordinates']['Latitude'] > latitude\n",
    "#     ]\n",
    "#     return round(len(northern_cities) / len(some_cities) * 100)\n",
    "\n",
    "# or\n",
    "\n",
    "    number_northern_cities = number_of_cities_north_of( some_cities, latitude )\n",
    "    return round(number_northern_cities / number_of_cities(some_cities) * 100)\n",
    "\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": "industrial-nightmare",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [5,6,7,8,9,10]\n",
    "# round(5/6 *100)\n"
   ]
  },
  {
   "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": "33ad9d40",
   "metadata": {},
   "outputs": [],
   "source": [
    "def number_of_large_cities(some_cities, minimum_population): \n",
    "    large_cities = [\n",
    "        city\n",
    "        for city in some_cities\n",
    "        if city['Population'] > minimum_population\n",
    "    ]\n",
    "    return len(large_cities)\n",
    "\n",
    "print(number_of_large_cities(cities_uk, 1500000)) # see it work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "disciplinary-enough",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "golden-commodity",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert number_of_large_cities(cities_uk, 1500000) == 1\n",
    "assert number_of_large_cities(cities_uk, 1000000) == 2\n",
    "assert number_of_large_cities(cities_uk, 500000) == 8\n",
    "assert number_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 Princess 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)"
   ]
  },
  {
   "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['routeName'])"
   ]
  },
  {
   "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": "610efc1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_route_departures = routes[0]['departures'] \n",
    "print(f\"The {first_route_name} has {len(first_route_departures)} vehicles coming soon\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a59d09",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Kim\"\n",
    "print(f\"my name is {name}\")"
   ]
  },
  {
   "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:\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\n",
    "- Write a function to get all bus destinations in a route\n",
    "- extra: use the second function and apply it to each route using list comprehension\n",
    "\n",
    "If any of these are too hard, don't worry and keep going through the notebook. More explanations coming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3efd9f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_route_numbers(some_routes):\n",
    "    return [\n",
    "        route['routeName']\n",
    "        for route in some_routes\n",
    "    ]\n",
    "\n",
    "get_route_numbers(routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3f3dfcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def destinations_of_one_route(one_route):\n",
    "    all_departures = one_route['departures']\n",
    "    return [\n",
    "        departure['destination']\n",
    "        for departure in all_departures\n",
    "    ]\n",
    "\n",
    "# or\n",
    "#     return [\n",
    "#         departure['destination']\n",
    "#         for departure in one_route['departures']\n",
    "#     ]\n",
    "\n",
    "destinations_of_one_route(routes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0212fbc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_destinations(some_routes):\n",
    "    return [\n",
    "        destinations_of_one_route(route)\n",
    "        for route in some_routes\n",
    "    ]\n",
    "\n",
    "get_destinations(routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c657b7f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def make_it_double(word):\n",
    "#     return word + word\n",
    "# make_it_double(\"banana\")"
   ]
  },
  {
   "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": [
    "## Dealing with time and date\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": [
    "princess_st_stop_id = 36235975\n",
    "routes = get_buses_coming_soon( princess_st_stop_id )"
   ]
  },
  {
   "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": "2a348ae6",
   "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": "1cee3aab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "olympic-starter",
   "metadata": {},
   "outputs": [],
   "source": [
    "bus_time_str = bus_time_object.strftime(\"%M minutes past %H %Y\") \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",
    "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": "e9131b90",
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime.now()"
   ]
  },
  {
   "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 = time_now_in_edinburgh - bus_time_object\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)"
   ]
  },
  {
   "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 {first_route_name} is at {first_bus_human:*^20} (in {first_bus_in_minutes:.0f} m)\")"
   ]
  },
  {
   "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": [
    "## Tasks:\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",
    "    when_it_leaves = departure['departureTime']\n",
    "    in_minutes = date_into_minutes_from_now(when_it_leaves)\n",
    "    minutes_as_word = minutes_to_word(in_minutes)\n",
    "    return f\"Bus {departure['routeName']} to {departure['destination']} {minutes_as_word}\" \n",
    "\n",
    "def route_into_destinations(one_route):\n",
    "    return [\n",
    "        where_it_goes(departure)\n",
    "        for departure in one_route['departures']\n",
    "    ]\n",
    "\n",
    "def all_routes_into_destinations(some_routes):\n",
    "    return [\n",
    "        route_into_destinations(route)\n",
    "        for route in some_routes\n",
    "    ]\n",
    "\n",
    "all_routes_into_destinations(routes)"
   ]
  },
  {
   "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  💨\"\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": "505daa66",
   "metadata": {},
   "outputs": [],
   "source": [
    "# expanding on our previous code:\n",
    "\n",
    "# def one_bus_report(departure):\n",
    "#     when_it_leaves = departure['departureTime']\n",
    "#     in_minutes = date_into_minutes_from_now(when_it_leaves)\n",
    "#     minutes_as_word = minutes_to_word(in_minutes)\n",
    "#     return f\"Bus {departure['routeName']} to {departure['destination']} {minutes_as_word}\" \n",
    "\n",
    "def one_bus_report(one_bus_info):\n",
    "    when_it_leaves = one_bus_info['departureTime']\n",
    "    in_minutes = date_into_minutes_from_now(when_it_leaves)\n",
    "    human_time = date_into_human_form(when_it_leaves)\n",
    "    minutes_as_word = minutes_to_word(in_minutes)\n",
    "    \n",
    "    report = f\"to {one_bus_info['destination']:.<20}\"\n",
    "    report += f\"{human_time:.>10}\"\n",
    "    report += f\" ({minutes_as_word})\"\n",
    "\n",
    "    return report\n",
    "\n",
    "example_bus = {'departureTime': '2021-10-22T20:20:14+01:00','destination': 'Colinton'}\n",
    "one_bus_report(example_bus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2fc6792",
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_route_info(one_route):\n",
    "    just_next_departure = one_bus_report(one_route['departures'][0])\n",
    "    return f\"Route {one_route['routeName']:>3} {just_next_departure}\"\n",
    "\n",
    "example_route = {\n",
    "    'routeName': 16,\n",
    "    'departures': [\n",
    "                    {'departureTime': '2021-10-22T20:20:14+01:00','destination': 'Colinton'},\n",
    "                    {'departureTime': '2021-10-22T22:54:14+01:00','destination': 'Colinton'}\n",
    "                  ]\n",
    "    }\n",
    "one_route_info(example_route)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "812ec99a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_routes_info(some_routes):\n",
    "    return [\n",
    "        one_route_info(route)\n",
    "        for route in some_routes\n",
    "    ]\n",
    "\n",
    "example_routes = [{\n",
    "    'routeName': 16,\n",
    "    'departures': [\n",
    "                    {'departureTime': '2021-10-22T20:20:14+01:00','destination': 'Colinton'},\n",
    "                    {'departureTime': '2021-10-22T22:54:14+01:00','destination': 'Colinton'}\n",
    "                  ]\n",
    "    },\n",
    "    {\n",
    "    'routeName': 22,\n",
    "    'departures': [\n",
    "                    {'departureTime': '2021-10-22T20:25:10+01:00','destination': 'Gyle'},\n",
    "                    {'departureTime': '2021-10-22T22:57:14+01:00','destination': 'Gyle'}\n",
    "                  ]\n",
    "    }]\n",
    "\n",
    "all_routes_info(example_routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a51e8197",
   "metadata": {},
   "outputs": [],
   "source": [
    "# and now with the real, fresh data:\n",
    "princess_st_stop_id = 36235975\n",
    "routes = get_buses_coming_soon( princess_st_stop_id )\n",
    "\n",
    "all_routes_info(routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dff0e12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# and if we wanted to add more bus departures at the end, like\n",
    "# 'Route  25 to Heriot Watt..............15:31 (and then in 12,32,52 minutes)'\n",
    "# We'd need to change some functions, see below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a06ccf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_bus_just_minutes(one_bus_info):\n",
    "    when_it_leaves = one_bus_info['departureTime']\n",
    "    in_minutes = date_into_minutes_from_now(when_it_leaves)\n",
    "    return in_minutes\n",
    "\n",
    "example_bus = {'departureTime': '2021-10-22T20:20:14+01:00','destination': 'Colinton'}\n",
    "one_bus_just_minutes(example_bus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8675b68",
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_route_info(one_route):\n",
    "    first_departure = one_bus_report(one_route['departures'][0])\n",
    "    other_departures_as_minutes = [\n",
    "        f\"{one_bus_just_minutes(departure)}min\"\n",
    "        for departure in one_route['departures'][1:] # subset, from index 0 till the end\n",
    "    ]\n",
    "    other_dep_as_string = \", \".join(other_departures_as_minutes)\n",
    "    return f\"Route {one_route['routeName']:>3} {first_departure:<50} then {other_dep_as_string:.<25}\"\n",
    "\n",
    "one_route_info(routes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75c639b0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def all_routes_info(some_routes):\n",
    "    routes_info_as_strings = [\n",
    "        one_route_info(route)\n",
    "        for route in some_routes\n",
    "    ]\n",
    "    \n",
    "    result = \"***********************************************************************************************\\n* \"\n",
    "    result += \" *\\n* \".join(routes_info_as_strings)\n",
    "    result += \" *\\n***********************************************************************************************\"\n",
    "    return result\n",
    "\n",
    "print(all_routes_info(routes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e764e8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finally, you could write a function that does it all:\n",
    "# - gets the data\n",
    "# - prepares it, \n",
    "# - returns it as a string:\n",
    "\n",
    "def one_stop_info(stop_number):\n",
    "    some_routes = get_buses_coming_soon( stop_number )\n",
    "    routes_info_as_strings = [\n",
    "        one_route_info(route)\n",
    "        for route in some_routes\n",
    "    ]\n",
    "    \n",
    "    header = f\"STOP ID: {stop_number}\"\n",
    "    result = f\"{header:*^95}\\n* \"\n",
    "    result += \" *\\n* \".join(routes_info_as_strings)\n",
    "    result += \" *\\n***********************************************************************************************\"\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "114d7565",
   "metadata": {},
   "outputs": [],
   "source": [
    "princess_st_stop_id = 36235975\n",
    "print(one_stop_info(princess_st_stop_id))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32e29b13",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6ae4ecb",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}