Lab7

Del A: last ned data om nylige jordskjelv med requests og datetime

Nettsiden til U.S. Geological Survey har åpent tilgjengelig og oppdaterte jordskjelvdata for hele verden. Ta for eksempel denne URL’en: https://earthquake.usgs.gov/fdsnws/event/1/query?format=csv&starttime=2024-03-11T17%3A14%3A55%2B0000&endtime=2024-03-21T17%3A14%3A55%2B0000&minmagnitude=5.8&orderby=magnitude&limit=5000

Om du får spørsmål om å lagre en fil når du trykker på linken over, bør du lagre den som en .csv-fil; for det er nemlig det du får. Om du åpner filen i en teksteditor (f. eks. VSCode) vil du se at den inneholder jordskjelvdata på .csv -format:

time,latitude,longitude,depth,mag,magType,nst,gap,dmin,rms,net,id,updated,place,type,horizontalError,depthError,magError,magNst,status,locationSource,magSource
2024-03-13T15:13:23.771Z,-5.8705,150.6344,50.416,6,mww,112,33,9.887,0.95,us,us6000milg,2024-03-14T15:22:18.952Z,"65 km ESE of Kimbe, Papua New Guinea",earthquake,8.18,4.68,0.044,49,reviewed,us,us
2024-03-14T21:10:24.838Z,29.8022,-42.6586,10,6,mww,179,57,16.293,0.61,us,us6000miy6,2024-03-18T01:11:06.363Z,"northern Mid-Atlantic Ridge",earthquake,9.76,1.795,0.039,62,reviewed,us,us
2024-03-16T00:14:52.156Z,-58.9182,158.3605,10,5.9,mww,58,55,4.443,0.51,us,us6000mj77,2024-03-17T19:46:20.040Z,"Macquarie Island region",earthquake,10.98,1.829,0.071,19,reviewed,us,us
2024-03-13T18:56:13.292Z,-0.1127,125.2136,26.46,5.8,mww,89,67,2.325,1.16,us,us6000minw,2024-03-14T19:00:56.901Z,"106 km SE of Modisi, Indonesia",earthquake,7.48,4.881,0.068,21,reviewed,us,us

Vi fikk altså en liste med fire jordskjelv. Men hvilke jordskjelv er det egentlig vi får? For å undersøke det, kan vi undersøke URL’en vi brukte for å laste ned dataen. Vi kan dele opp URL’en i flere deler:

• https://earthquake.usgs.gov/fdsnws/event/1/query er basen for URL’en. Dette kaller vi for et «API-endepunkt».
• ? betyr at resten av URL’en angir «query parametere» og tilhørende argumenter. Symbolet & brukes for å skille mellom ulike parametere.
• format=csv spesifiserer at vi ønsker dataen i .csv-format.
• starttime=2024-03-11T17%3A14%3A55%2B0000 spesifiserer at vi ønsker jordskjelv som finner sted fra og med 11. mars 2024 kl. 17:14:55 UTC. Dette er en måte å skrive tidspunkt på som kalles ISO 8601, men hvor noen symboler har blitt kodet slik at de tryggere kan brukes i en URL (%3A er en kode for symbolet : og %2B er en kode for symbolet +).
• endtime=2024-03-21T17%3A14%3A55%2B0000 spesifiserer at vi ønsker jordskjelv som finner sted til og med til 21. mars 2024 kl. 17:14:55 UTC.
• minmagnitude=5.8 er en parameter som spesifiserer at vi ønsker jordskjelv med en styrke på 5.8 eller mer på Richters skala.
• orderby=magnitude er en parameter som spesifiserer at vi ønsker jordskjelv sortert etter styrke.
• limit=5000 er en parameter som spesifiserer at vi ønsker maksimalt 5000 jordskjelv.

Det var altså fire jordskjelv som skjedde mellom 11. mars og 21. mars 2024 med en styrke på 5.8 eller høyere, og det er dem vi har fått informasjon om i .csv-filen som vi lastet ned.

For å laste ned data fra internett til et Python-program, bruker vi biblioteket requests.

• Installer requests
• Sjekk at du klarer å laste ned dataen fra URL’en over og skrive den ut i konsollen. Du kan bruke programmet under:

# Rask sjekk for at vi har klart å installere requests -biblioteket
import requests

url = 'https://earthquake.usgs.gov/fdsnws/event/1/query?format=csv&starttime=2024-03-11T17%3A14%3A55%2B0000&endtime=2024-03-21T17%3A14%3A55%2B0000&minmagnitude=5.8&orderby=magnitude&limit=5000'
headers = {'User-Agent': 'inf100.ii.uib.no mitt_uib_brukernavn'}

response = requests.get(url, headers=headers)
content = response.content.decode('utf-8')
print(content)
# Sjekk at du ser csv-dataen fra over i terminalen

Når du har fått dette til, er det på tide å gjøre det litt mer dynamisk; for eksempel ønsker vi å kunne hente ut jordskjelvdata basert på datoen når programmet kjøres. Umiddelbart ser det ut som vi må gjøre en seriøs streng-manipulasjon for å konstruere URL’en vi trenger; men heldigvis har requests-modulen gjort det enkelt å generere URL’er med parametere. For eksempel vil koden under gi nøyaktig samme resultat som koden over. Sjekk at du også får samme resultat!

import requests

baseurl = 'https://earthquake.usgs.gov/fdsnws/event/1/query'
headers = {'User-Agent': 'inf100.ii.uib.no mitt_uib_brukernavn'}
params = {
    'format': 'csv',
    'starttime': '2024-03-11T17:14:55+0000', # ISO 8601 format
    'endtime': '2024-03-21T17:14:55+0000', # ISO 8601 format
    'minmagnitude': 5.8,
    'orderby': 'magnitude',
    'limit': 5000,
}

response = requests.get(baseurl, params=params, headers=headers)
content = response.content.decode('utf-8')
print(content)

Nå virker det forhåpentligvis litt mer overkommelig å generere URL’er slik vi selv ønsker. Det gjenstår bare å kunne lage en ISO 8601-formatert streng for tidspunktet vi ønsker å hente ut jordskjelvdata for. Til dette formålet bruker vi datetime-modulen.

• Opprett et datetime-objekt for sluttidspunktet med tidspunktet «nå» i UTC tid (datetime.now(timezone.utc)).
• Opprett et datetime-objekt for starttidspunktet med tidspunktet 365 dager før sluttidspunktet.
• Konverter til en ISO 8601-formatert streng: my_iso8601_string = my_datetime_object.strftime('%Y-%m-%dT%H:%M:%S%z')
• Bruk disse strengene i request’en din for å hente ut jordskjelvdata for det siste året.

Test at det fungerer. Helt til slutt, skal vi flytte programmet vårt inn i en funksjon, og gjøre det enda mer dynamisk:

• I filen earthquakes.py, skriv en funksjon get_earthquakes_csv_string med to parametre: n et antall dager og magnitude et flyttall. Funksjonen skal returnere en CSV-formatert streng med informasjon hentet fra U.S. Geological Survey om alle jordskjelv som har skjedd de siste n dagene som hadde en styrke på magnitude eller mer. Dersom det er flere enn 5000 slike jordskjelv, skal kun de 5000 sterkeste av dem inkluderes.

# earthquakes.py
import requests

def get_earthquakes_csv_string(n, magnitude):
    # Din kode her
    ...

if __name__ == "__main__":
    s = get_earthquakes_csv_string(30, 5.8)
    print(s) # vi fjerner print senere, men vi ser nå at vi er på rett vei

Del B: hent ut relevante jordskjelvdata

Vi har så langt fått tak i jordskjelvene som en csv-formatert streng. Nå er tidspunktet for å konvertere fra en slik streng til en liste med oppslagsverk (eller en 2D-liste, om du foretrekker det). Vi kunne kanskje gjort det selv med split og lignende; men legg merke til at CSV-filen kan inneholde komma også i selve stedsnavnene. Da er det ikke så lett å splitte på komma som vi kanskje skulle ønske. Heldigvis har Python en modul for å lese CSV-filer som håndterer dette for oss: csv -modulen.

• Bruk csv-modulen for å konvertere csv-strengen til en liste med oppslagsverk. Strengen benytter komma (,) som skilletegn («delimiter») og hermetegn (") som grupperingssymbol («quotechar»).

Det vi egentlig ønsker å hente ut fra datasettet er en liste med tupler (lengdegrad, breddegrad, styrke), slik at vi kan plotte punktene.

• I earthquakes.py, lag en funksjon get_earthquake_list som tar inn en csv-formatert streng csv_string og returnerer en liste med jordskjelv. Hvert jordskjelv skal være en tuple med lengdegrad, breddegrad og styrke som flyttall.

For å teste funksjonen kan du laste ned og kjøre test_get_earthquake_list.py.

Del C: plot jordskjelvdata

Nå som vi har fått tak i dataen vi ønsker, skal vi plotte den med pyplot fra det eksterne biblioteket matplotlib.

I earthquakes.py, lag en funksjon plot_earthquakes som tar inn en liste med koordinater data_points og plotter dem med plt.scatter som blå prikker. Merk at data_points er en liste med tupler (lengdegrad, breddegrad, styrke), mens plt.scatter tar inn to lister xs og ys som henholdsvis inneholder x- og y-verdiene til punktene. Du kan bruke en for-løkke for å hente ut x- og y-verdiene fra data_points og legge dem i hver sin liste.

For å få et bedre inntrykk av hvor jordskjelvene har skjedd, ønsker vi å skalere størrelsen på prikkene etter styrken på jordskjelvet. Dette kan gjøres ved å gi argumentet s til scatter-funksjonen. For å få en synlig størrelsesforskjell, kan du prøve å skalere styrken opphøyd i andre. Dette kan gjøres ved å lage en liste sizes som inneholder styrken opphøyd i andre for hvert jordskjelv, og gi denne listen som argument til s i scatter-funksjonen.

Vi kan også sette alpha=0.3 for å gjøre prikkene litt gjennomsiktige, slik at vi lettere kan se hvor det er flest jordskjelv.

For å teste at alt henger sammen, går vi til if __name__ == '__main__':-blokken som skal være på slutten av filen. Her kaller du først get_earthquakes_string med styrke 4 og 50 dager som argument. Deretter kaller du parse_earthquakes med resultatet av get_earthquakes_string som argument, og så gir du det resultatet til plot_earthquakes. Så kaller du plt.show() for å vise plottet.

Når du er ferdig skal programmet produsere noe som ser noenlunde slik ut (dette ble kjørt 19. mars 2024):

Men dette er jo bare en haug med prikker? Ja, det er jo allerede litt kult, og om vi legger godviljen til kan vi skimte konturene av noen kontinenter og land. Vi ønsker likevel å gi prikkene litt mer mening og kontekst, og dette skal vi gjøre videre.

Del D: last inn kystlinjer

Ditt neste oppdrag vil være å finne fram et datasett av verdens kystlinjer, og så hente ut dataen vi har behov for slik vi gjorde for jordskjelvene. Først går du til Martyn Afford sitt prosjekt natural-earth-geojson, og laster ned ne_110m_coastline.json fra mappen /110m/physical. Du må klikke på «download raw file» oppe til høyre når du får opp kartet.

Det du har lastet ned nå, er en tekst-fil som inneholder koordinater for hele verdens kystlinjer. Dette er en JSON-fil, som er en måte å lagre data på som er veldig likt Python sine oppslagsverk. En forenklet versjon av filen ser slik ut, hvis vi legger til litt ekstra mellomrom og linjeskift for å gjøre det lettere å lese:

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "scalerank": 1,
        "featurecla": "Coastline",
        "min_zooom": 1.0
      },
      "geometry": {
        "type": "LineString",
        "coordinates": [
          [ -163.71289567772871, -78.595667413241543 ],
          [ -159.482404548154477, -79.046337579258974 ],
          [ -163.027407803377002, -78.928773695794959 ]
        ]
      }
    },
    {
      "type": "Feature",
      "properties": {
        "scalerank": 0,
        "featurecla": "Coastline",
        "min_zooom": 0.0
      },
      "geometry": {
        "type": "LineString",
        "coordinates": [
          [ -6.197884894220991, 53.867565009163364 ],
          [ -9.977085740590269, 51.820454820353078 ],
          [ -7.572167934591064, 55.131622219454869 ]
        ]
      }
    },
  ]
}

Om vi tolker data’en som om det var Python-kode, ser vi at den er organisert som et stort oppslagsverk som inneholder lister og andre oppslagsverk. Det er en nøkkel "features" hvor tilhørende verdi er en liste; hvert element i denne listen er én øy (eller verdensdel). Hver slik øy er igjen representert som et oppslagsverk, og har en nøkkel "geometry" hvor verdien igjen er et oppslagsverk som inneholder en nøkkel "coordinates" som inneholder en liste med koordinater. Dette er en liste med punkter som danner en kystlinje.

Anta at data er en variabel som inneholder oppslagsverket vist over. Da kan vi hente ut de første koordinatene til den første øyen slik:

>>> data['features'][0]['geometry']['coordinates'][0]
[-163.71289567772871, -78.595667413241543]

Vi kan tolke oppslaget som at vi først åpner «features», så velger vi det første øyen i listen, så åpner vi «geometry» for nevnte øy, så «coordinates», og så henter vi ut det første punktet i listen.

json-modulen fra standardbiblioteket kan brukes for å konvertere en json-streng til et oppslagsverk.

I en funksjon load_coastlines, skal du

• lese inn dataen fra ne_110m_coastline.json som en streng, og
• bruke json-modulen fra standardbiblioteket for å konvertere strengen til et oppslagsverk, og
• returnere en liste med alle øyer. Hver øy skal være representert kun som en liste med koordinater.

Hvis den forenklede JSON-filen over var hele filen, ville altså funksjonen returnert en liste som så slik ut:

[ 
  [ # Første øy
    [ -163.71289567772871, -78.595667413241543 ],
    [ -159.482404548154477, -79.046337579258974 ],
    [ -163.027407803377002, -78.928773695794959 ]
  ],
  [ # Andre øy
    [ -6.197884894220991, 53.867565009163364 ],
    [ -9.977085740590269, 51.820454820353078 ],
    [ -7.572167934591064, 55.131622219454869 ]
  ]
]

Del E: plot kystlinjer

Nå som vi har hentet ut kystlinjene, skal vi plotte dem sammen med jordskjelvdataen. I earthquakes.py, lag en ny funksjon plot_coastlines som tar inn en liste med linjer lines og plotter dem som en linjer med pyplot sin plot-funksjon. Bruk en løkke over linjene for å plotte dem en etter en. Det er ikke så pass mange at det blir en treig løsning slik som i Del C. For å få det til å se ut som eksempelet, må du huske å sette color='grey' som argument til plot-funksjonen. Fargen er ikke et krav, og du får en kul overraskelse om du fjerner color-argumentet.

For å teste funksjonen, kan du legge følgende til i if __name__ == '__main__' -blokken, før kallet til plt.show:

• Et kall til load_coastlines for å laste inn kystlinjene.
• Et kall til plot_coastlines med resultatet fra foregående kall som argument for å plotte kystlinjene.

Når du er ferdig skal programmet produsere noe som ser noenlunde slik ut (hvis du kommenterer bort kallet til plot_earthquakes):

Del F: plot jordskjelvdata og kystlinjer sammen

Nå har vi laget alt vi trenger for å plotte jordskjelv og kystlinjer sammen. Vi skal gjøre dette i if __name__ == '__main__'-biten som vi har brukt så langt. Kommenter inn igjen plot_earthquakes-kallet. Før du har kalt på funksjonene som plotter kystlinjer og jordskjelv, bruk plt.figure(figsize=(12,8)) for å lage en ny figur med størrelse 12x8. Dette er for å få et bedre perspektiv på jordskjelvene i forhold til kystlinjene. Legg også til et rutenett. Husk at plt.show() skal kalles etter alt annet for å vise plottet.

Når programmet ditt produserer noe tilsvarende dette, så er du i mål!