latest work

Author: patrickburrell

.in

@@ -0,0 +1 @@
+conda activate 100-DAYS-OF-CODE-WITH-PYTHON

.out

@@ -0,0 +1 @@
+conda deactivate

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "/Users/aiuw003/miniconda3/envs/100-DAYS-OF-CODE-WITH-PYTHON/bin/python"
+}

days/01-03-datetimes/code/calc_dts.py

@@ -0,0 +1,24 @@
+from datetime import date, timedelta
+
+start_100days = date(2017, 3, 30)
+pybites_founded = date(2016, 12, 19)
+pycon_date = date(2018, 5, 8)
+
+
+def get_hundred_days_end_date():
+    """Return a string of yyyy-mm-dd"""
+    end_date = start_100days + timedelta(days=100)
+    return end_date.strftime("%Y-%m-%d")
+
+
+def get_days_between_pb_start_first_joint_pycon():
+    """Return the int number of days"""
+    delta = pycon_date - pybites_founded
+    return delta.days
+
+
+end_date = get_hundred_days_end_date()
+print(f"end date: {end_date}")
+
+days = get_days_between_pb_start_first_joint_pycon()
+print(f"days: {days}")

days/01-03-datetimes/code/dt_convert.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+THIS_YEAR = 2018
+
+
+def years_ago(date):
+    """Receives a date string of 'DD MMM, YYYY', for example: 8 Aug, 2015
+       Convert this date str to a datetime object (use strptime).
+       Then extract the year from the obtained datetime object and subtract
+       it from the THIS_YEAR constant above, returning the int difference.
+       So in this example you would get: 2018 - 2015 = 3"""
+    dt = datetime.strptime(date, "%d %b, %Y")
+    years = THIS_YEAR - dt.year
+    return years
+
+
+def convert_eu_to_us_date(date):
+    """Receives a date string in European format of dd/mm/yyyy, e.g. 11/03/2002
+       Convert it to an American date: mm/dd/yyyy (in this case 03/11/2002).%
+       To enforce the use of datetime's strptime / strftime (over slicing)
+       the tests check if a ValueError is raised for invalid day/month/year
+       ranges (no need to code this, datetime does this out of the box)"""
+    dt = datetime.strptime(date, "%d/%m/%Y")
+    american_date = dt.strftime("%m/%d/%Y")
+    return american_date
+
+
+years = years_ago("8 Aug, 2015")
+print(f"years: {years}")
+
+us_date = convert_eu_to_us_date("11/03/2002")
+print(f"date: {us_date}")

days/01-03-datetimes/code/logtimes.py

@@ -0,0 +1,50 @@
+import os
+import urllib.request
+from datetime import datetime, timedelta
+
+SHUTDOWN_EVENT = "Shutdown initiated"
+
+# prep: read in the logfile
+tmp = os.getenv("TMP", "/tmp")
+logfile = os.path.join(tmp, "log")
+urllib.request.urlretrieve(
+    "https://bites-data.s3.us-east-2.amazonaws.com/messages.log", logfile
+)
+
+with open(logfile) as f:
+    loglines = f.readlines()
+
+
+# for you to code:
+
+
+def convert_to_datetime(line):
+    """TODO 1:
+       Extract timestamp from logline and convert it to a datetime object.
+       For example calling the function with:
+       INFO 2014-07-03T23:27:51 supybot Shutdown complete.
+       returns:
+       datetime(2014, 7, 3, 23, 27, 51)
+    """
+    datetime_segment = line.split(" ")[1]
+    dt = datetime.strptime(datetime_segment, "%Y-%m-%dT%H:%M:%S")
+    return dt
+
+
+def time_between_shutdowns(loglines):
+    """TODO 2:
+       Extract shutdown events ("Shutdown initiated") from loglines and
+       calculate the timedelta between the first and last one.
+       Return this datetime.timedelta object.
+    """
+    shutdown_loglines = [line for line in loglines if "Shutdown initiated" in line]
+
+    first_datetime = convert_to_datetime(shutdown_loglines[0])
+    last_datetime = convert_to_datetime(shutdown_loglines[-1])
+
+    delta = last_datetime - first_datetime
+    return delta
+
+
+time_diff = time_between_shutdowns(loglines)
+print(f"The time difference is: {time_diff}")

days/04-06-collections/movie_metadata.csv

@@ -0,0 +1,65 @@
+import re
+
+cars = {
+    "Ford": ["Falcon", "Focus", "Festiva", "Fairlane"],
+    "Holden": ["Commodore", "Captiva", "Barina", "Trailblazer"],
+    "Nissan": ["Maxima", "Pulsar", "350Z", "Navara"],
+    "Honda": ["Civic", "Accord", "Odyssey", "Jazz"],
+    "Jeep": ["Grand Cherokee", "Cherokee", "Trailhawk", "Trackhawk"],
+}
+
+
+def get_all_jeeps(cars=cars):
+    """return a comma  + space (', ') separated string of jeep models
+       (original order)"""
+
+    all_jeeps = ", ".join(cars["Jeep"])
+    return all_jeeps
+
+
+def get_first_model_each_manufacturer(cars=cars):
+    """return a list of matching models (original ordering)"""
+
+    first_models = [v[0] for k, v in cars.items()]
+    return first_models
+
+
+def get_all_matching_models(cars=cars, grep="trail"):
+    """return a list of all models containing the case insensitive
+       'grep' string which defaults to 'trail' for this exercise,
+       sort the resulting sequence alphabetically"""
+
+    # for models in cars.values():
+    #     for model in models:
+    #         m = model
+
+    matching_models = [
+        model
+        for models in cars.values()
+        for model in models
+        if re.search(grep, model, re.IGNORECASE) is not None
+    ]
+    matching_models.sort()
+    return matching_models
+
+
+def sort_car_models(cars=cars):
+    """return a copy of the cars dict with the car models (values)
+       sorted alphabetically"""
+
+    sorted_models = {}
+    for k, v in cars.items():
+        sorted_models[k] = v
+        sorted_models[k].sort()
+    return sorted_models
+
+
+def main():
+    all_jeeps = get_all_jeeps()
+    first_models = get_first_model_each_manufacturer()
+    matching_models = get_all_matching_models()
+    sorted_models = sort_car_models()
+
+
+if __name__ == "__main__":
+    main()

days/07-09-data-structures/code/cars.py

@@ -0,0 +1,40 @@
+from cars import (get_all_jeeps, get_first_model_each_manufacturer,
+                  get_all_matching_models, sort_car_models)
+
+
+def test_get_all_jeeps():
+    expected = 'Grand Cherokee, Cherokee, Trailhawk, Trackhawk'
+    actual = get_all_jeeps()
+    assert type(actual) == str
+    assert actual == expected
+
+
+def test_get_first_model_each_manufacturer():
+    actual = get_first_model_each_manufacturer()
+    expected = ['Falcon', 'Commodore', 'Maxima', 'Civic', 'Grand Cherokee']
+    assert actual == expected
+
+
+def test_get_all_matching_models_default_grep():
+    expected = ['Trailblazer', 'Trailhawk']
+    assert get_all_matching_models() == expected
+
+
+def test_get_all_matching_models_different_grep():
+    expected = ['Accord', 'Commodore', 'Falcon']
+    assert get_all_matching_models(grep='CO') == expected
+
+
+def test_sort_dict_alphabetically():
+    actual = sort_car_models()
+    # Order of keys should not matter, two dicts are equal if they have the
+    # same keys and the same values.
+    # The car models (values) need to be sorted here though
+    expected = {
+        'Ford': ['Fairlane', 'Falcon', 'Festiva', 'Focus'],
+        'Holden': ['Barina', 'Captiva', 'Commodore', 'Trailblazer'],
+        'Honda': ['Accord', 'Civic', 'Jazz', 'Odyssey'],
+        'Jeep': ['Cherokee', 'Grand Cherokee', 'Trackhawk', 'Trailhawk'],
+        'Nissan': ['350Z', 'Maxima', 'Navara', 'Pulsar'],
+    }
+    assert actual == expected