<jupyter_start><jupyter_text>Tutorial sull'uso dei dati del Copernicus Climate Change Service (C3S)In questo tutorial vedremo come accedere ed elaborare i dati del **Copernicus Climate Change Service (C3S)**, il servizio relativo ai cambiamenti climatici di Copernicus (C3S) che fornisce informazioni autorevoli sul clima passato, presente e futuro. Il C3S è affidato dalla Commissione Europea al Centro Europeo per le Previsioni Meteorologiche a Medio Termine (ECMWF).Uno dei servizi principali del C3S è di mettere a disposizione dati climatici tramite l'archivio Climate Data Store (CDS).Il CDS contiene vari dataset, principalmente:- **Osservazioni**: osservazioni di diversi variabili climatiche misurate tramite sensori satellitari e terrestri.- **Reanalysis**: combina modelli con i dati osservazionali per ottenere la migliore comprensione possibile del clima del passato.- **Seasonal forecasts**: previsioni stagionali delle variabili climatiche.- **Climate projections**: proiezioni a lungo termine, seconda vari scenari.- **Climate indices**: indici composti da diversi input climatici.Lo scopo di questo esercizio è di imparare come cercare ed elaborare dati dal CDS. È composto da tre parti:1. [Archivio dei dati climatici (CDS)](cds) Introduzione e dimostrazione del Climate Data Store del C3S: come cercare dati, come accedere al Forum e al Copernicus Knowledge Base2. [CDS toolbox e applicazioni](toolbox) Esercizi sull'uso del CDS toolbox per elaborare dati.3. [CDS API](api) Uso del CDS API per scaricare dati, esempi sull'uso di Python per fare elaborazioni.   Prima di iniziare Per la parte 1 e 2Registrarsi all'archivio dei dati climatici (CDS): https://cds.climate.copernicus.eu/   Per la parte 3- Installare Anaconda: https://docs.anaconda.com/anaconda/install/- Installare il CDS API: https://cds.climate.copernicus.eu/api-how-to- Installare Cartopy: https://pypi.org/project/Cartopy/- Installare Xarray: http://xarray.pydata.org/en/stable/  Questi blocchi contengono domande a cui vorrei rispondessi! ***  1. Archivio dei dati climatici (CDS)Vai su https://cds.climate.copernicus.eu/. Il catalogo ti permette di cercare dati tramite parole chiave, o applicando i vari filtri. Altrimenti, cliccando su `Search` vedi tutti i dati disponibili. Se clicchi su un dataset puoi trovare più informazioni nelle sezioni `Overview` o `Documentation`. Metti "ERA5" nella barra di ricerca. Poi clicca sul dataset "ERA5 hourly data on pressure levels from 1979 to present". Guardando la sezione di Overview qual è la copertura orizzontale, verticale e temporale del dataset? Ora torna alla pagina principale. Applicando i vari filtri, esistono dati sulla biosfera, per il futuro, su scala europea? Nella finestra `Download data` puoi selezionare i vari parametri dei dati. Poi cliccando su `Submit Form` arrivi alla pagina web dove troverai il link per scaricare i dati. Clicca sul dataset "Climatic suitability for the presence and seasonal activity of the Aedes albopictus mosquito for Europe derived from climate projections" (le condizioni climatiche adatte alla presenza di zanzare Aedes albopictus). Scegli i seguenti parametri, poi scarica i dati:        Variable = Suitability  Experiment = RCP4.5. RCP (Representative Concentration Pathway) è una proiezione sulla concentrazione di gas serra adottata dal IPCC. 4.5 corrisponde al valore del forzante radiativo (in W/m2) per l'anno 2100. RCP 4.5 è considerato dal IPCC come scenario intermedio. RCP 8.5 (chiamato anche "business as usual") invece è considerato il caso peggiore, se non dovesse cambiare niente.  Ensemble statistics = Statistiche dell'insieme  Format = Zip file (.zip)       Qual è la dimensione dei dati scaricati?  Copernicus Knowledge BaseUna fonte di informazione molto utile è il "Copernicus Knowledge Base":https://confluence.ecmwf.int/display/CKB Usa il Copernicus Knowledge Base per trovare documentazione su ERA-5. Qual è il formato dei dati? ***  2. CDS toolbox e applicazioniTorna alla pagina iniziale dell'archivio dei dati climatici (CDS) https://cds.climate.copernicus.eu/ e clicca su `Climate Data Store Toolbox`. Il toolbox è uno strumento per elaborare dati nel CDS. Ti permette anche di creare applicazioni interattive per visualizzare meglio i dati. Ora clicca su `Toolbox Documentation`. Qui trovi una spiegazione sul CDS toolbox e una serie di guide e materiali per imparare ad usarlo (tutorials, how-to guides, learning bundles). Ci sono anche molti scripts esemplificativi di applicazioni che si possono copiare e modificare nel `Toolbox Editor`.Torna alla pagina del toolbox, e ora clicca su `Toolbox Editor`. Qui puoi scrivere le tue applicazioni. Un modo facile per iniziare è prendere un'applicazione già fatta, e modificarla. Per iniziare, clicca due volte su `00 Hello World` sotto `examples`. Ora clicca su `copy` per creare una copia dell'applicazione nel tuo workspace. Così puoi modificare il programma e salvare le modifiche. Usa il programma "00 Hello World" per creare un'app che visualizza la temperatura a due metri di altezza, a scala globale, il 15 agosto 2020. Una volta creata, apri l'app in una finestra grande. Quale paese ha la temperatura più alta: l'India o l'Algeria?  Alcuni altri esempi di applicazioni includono:- 01 Retrieve data *(per scaricare dati)*- 02 Plot map *(per creare una mappa interattiva - con una scelta di parametri input)*- 03 Extract time series and plot graph *(estrarre una serie temporale e creare un grafico)*- 11 Calculate time mean and standard deviation *(calcolare la media e la deviazione standard)*- 12 Calculate climatologies *(calcolare climatologie)*- 21 Calculate regional mean and anomalies *(calcolare la media regonale e le anomalie)*- 31 Calculate trends *(calcolare le tendenze)*- 41 Calculate GDD (Growing Degree Days) *(calcolare la somma termica)* Torna alla pagina iniziale del CDS https://cds.climate.copernicus.eu/ nella sezione `Applications` puoi vedere un elenco di applicazioni fatte con il CDS Toolbox.Nella barra di ricerca, cerca `Urban Heat Island`, e scegli l'applicazione `Urban heat island intensity for European cities from 2008 to 2017 derived from reanalysis`. Nota il fenomeno di UHI per Milano in estate e in inverno. Copia i codici dell'applicazione, e incolla nel tuo ambiente del CDS Toolbox Editor. Ora modifica l'applicazione per abilitare la visualizzazione del fenomeno UHI anche per la primavera e l'autunno. In quale stagione c'è l'effetto più elevato di UHI? Esplora anche le seguenti apps:- ERA-5 esplorazione del clima: https://cds.climate.copernicus.eu/cdsapp!/software/app-era5-explorer?tab=app- Ondate di caldo: https://cds.climate.copernicus.eu/cdsapp!/software/app-health-heat-waves-projections?tab=app - Esposizione al calore: https://cds.climate.copernicus.eu/cdsapp!/software/app-health-temperature-exposure-projections?tab=app - Ambiente adatto alla proliferazione delle zanzare: https://cds.climate.copernicus.eu/cdsapp!/software/app-health-urban-aedes-albopictus-suitability-climatology?tab=app ***  3. CDS APIHai già visto come scaricare i dati tramite l'interfaccia web. Hai anche visto come elaborare i dati tramite il CDS Toolbox. Ora vedremo come puoi accedere ai dati tramite il CDS API e fare elaborazioni in Python dentro il Jupyter Notebook.In questa parte dell'esercizio puoi imparare a:1. Scaricare ed elaborare dati ad alta risoluzione (sis-urban-climate-cities) per creare mappe su Milano    - Fare mappe sulla temperatura e velocità del vento su Milano    - Creare un indice di "wind chill" con questi parametri2. Scaricare ed elaborare dati ERA-5 su Milano per fare analisi del clima per una serie temporale del passato    - Calcolare anomalie    - Calcolare climatologie  Importa librerieEssendoti già registrato nel CDS, la prima cosa da fare se vuoi accedere ai dati tramite il CDS API e fare elaborazione in Python è di importare le varie librerie, tra cui anche quella del CDS API.Lavorerai con i dati in NetCDF, un formato usato soprattutto in ambito scientifico, specialmente nelle applicazioni inerenti il clima, la meteorologia e l'oceanografia. I dati che userai sono "array oriented" ("dati grigliati"). Per elaborare questi dati, useremo una libreria per lavorare con array multidimensionali, in particolare Xarray.Ci servono anche librerie per creare grafici, in questo caso Matplotlib e Cartopy.<jupyter_code># CDS API
import cdsapi

# Estrarre i file zip
from zipfile import ZipFile

# Librerie per lavorare con array multidimensionali
import numpy as np
import xarray as xr

# Librerie per creare grafici e visualizzare i dati
import matplotlib.path as mpath
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
import cartopy.feature as cfeature<jupyter_output><empty_output><jupyter_text>Creare mappe con i dati sis-urban-climate-cities Scaricare datiNel CDS https://cds.climate.copernicus.eu/ cerca il dataset `Climate variables for cities in Europe from 2008 to 2017`. Poi, nella finestra di `Download data`, scegli i seguenti parametri:- Variable: `air_temperature`- City: `milan`- Year: `2017`- Month: `01`- Format: `zip`In fondo alla pagina, scegli `Show API request`. Poi copia il codice, e incollalo dentro la cella seguente, cambiando solo il nome del file .zip alla fine del blocco di codici. Poi lancialo per scaricare i dati...<jupyter_code>import cdsapi

c = cdsapi.Client()

c.retrieve(
    'sis-urban-climate-cities',
    {
        'variable': 'air_temperature',
        'city': 'milan',
        'year': '2017',
        'month': '01',
        'format': 'zip',
    },
    './milan/urban_climate_at.zip')<jupyter_output>2020-11-14 19:40:55,639 INFO Welcome to the CDS
2020-11-14 19:40:55,639 INFO Sending request to https://cds.climate.copernicus.eu/api/v2/resources/sis-urban-climate-cities
2020-11-14 19:40:55,744 INFO Request is queued
2020-11-14 19:40:56,979 INFO Request is running
2020-11-14 19:41:17,125 INFO Request is completed
2020-11-14 19:41:17,125 INFO Downloading http://192.168.3.111/cache-compute-0004/cache/data8/dataset-sis-urban-climate-cities-d48870f7-4ea9-4e84-9dd6-6bf4a67f8b91.zip to ./milan/urban_climate_at.zip (76.3M)
2020-11-14 19:42:45,377 INFO Download rate 885.6K/s<jupyter_text>Ora fai la stessa cosa, ma per la variabile `wind speed`:<jupyter_code>c.retrieve(
    'sis-urban-climate-cities',
    {
        'variable': 'wind_speed',
        'city': 'milan',
        'year': '2017',
        'month': '01',
        'day': '15',
        'format': 'zip',
    },
    './milan/urban_climate_ws.zip')<jupyter_output>2020-11-14 19:42:52,284 INFO Welcome to the CDS
2020-11-14 19:42:52,285 INFO Sending request to https://cds.climate.copernicus.eu/api/v2/resources/sis-urban-climate-cities
2020-11-14 19:42:52,405 INFO Request is queued
2020-11-14 19:42:53,470 INFO Request is running
2020-11-14 19:43:05,954 INFO Request is completed
2020-11-14 19:43:05,954 INFO Downloading http://1192.168.127.125/cache-compute-0008/cache/data8/dataset-sis-urban-climate-cities-17806246-9757-4f7b-96d6-8bcc779748b6.zip to ./milan/urban_climate_ws.zip (91.1M)
2020-11-14 19:44:38,609 INFO Download rate 1006.7K/s<jupyter_text>Una volta scaricati i dati, devi estrarre i file zip:<jupyter_code># Funzione per estrarre i file zip
def zipextract(zip_file):
    with ZipFile(zip_file, 'r') as zipObj: # Crea un Oggetto Zipfile e inseriscici il file zip
        zipObj.extractall('milan') # Estrai tutti i contenuti del file zip nella cartella di default
at_zip = './milan/urban_climate_at.zip'
ws_zip = './milan/urban_climate_ws.zip'
zipextract(at_zip)
zipextract(ws_zip)<jupyter_output><empty_output><jupyter_text>Poi puoi leggere i file NetCDF in un 'Dataset' di Xarray:<jupyter_code>at_nc = './milan/tas_Milan_UrbClim_2017_01_v1.0.nc'
ws_nc = './milan/sfcWind_Milan_UrbClim_2017_01_v1.0.nc'
at_ds = xr.open_dataset(at_nc)
ws_ds = xr.open_dataset(ws_nc)<jupyter_output><empty_output><jupyter_text>Esamina il contenuto del dataset:<jupyter_code>at_ds
ws_ds<jupyter_output><empty_output><jupyter_text>Per lavorare meglio con i parametri singoli, devi convertire i `Xarray Dataset` in `Xarray Data Array`:<jupyter_code>at_da = at_ds['tas']
ws_da = ws_ds['sfcWind']<jupyter_output><empty_output><jupyter_text>Per vedere le mappe dei vari parametri, rendi monodimensionale la variabile del tempo:<jupyter_code>at_mean = at_da.mean(dim='time')
ws_mean = ws_da.mean(dim='time')<jupyter_output><empty_output><jupyter_text>Ora puoi creare mappe per visualizzare i dati:<jupyter_code>def visualise(variable, longitude, latitude, colourmap, title, label):
    """ 
    Visualizza un Xarray Data Array con la funzione di matplotlib 'pcolormesh'.
    
    Parametri:
        variable: variabile dei dati, per esempio la temperatura dell'aria
        longitude: valori di longitudine per la variabile di dati
        latitude: valori di latitudine per la variabile di dati
        colourmap: mappa di colori per mostrare la gamma di valori
        title: titolo della mappa
        label: etichetta nella legenda, ad esempio 'Temperatura (Kelvin)'
    """
    # creare il pannello della figura 
    fig = plt.figure(figsize=(10,5))
    # creare la mappa usando la proiezione di PlateCarree
    ax = plt.subplot(1,1,1, projection=ccrs.PlateCarree())
    # aggiungere una griglia lat lon
    gl = ax.gridlines(draw_labels=True, linewidth=1, color='gray', alpha=0.5, linestyle='--')
    gl.right_labels = None
    gl.top_labels = None
    # aggiungere un titolo
    ax.set_title(title)
    # creare il grafico
    im = plt.pcolormesh(longitude, latitude,
                        variable, cmap=colourmap, transform=ccrs.PlateCarree())
    # aggiungere la legenda
    cbar = plt.colorbar(im)
    cbar.set_label(label)

    return fig, ax
visualise(at_mean, at_mean.longitude, at_mean.latitude, 'bwr', 
          'Surface Temperature Milan January 2017', 'Surface Temperature (Kelvin)')
visualise(ws_mean, ws_mean.longitude, ws_mean.latitude, 'bwr', 
          'Wind Speed Milan January 2017', 'Wind Speed (m/s)')<jupyter_output><empty_output><jupyter_text>Calcolare indice di wind chillQui vediamo l'esempio di un indice creato da vari parametri. In questo caso l'indice di wind chill, che si può calcolare con la temperatura dell'aria e la velocità del vento, tutte due vicino alla superficie. Esistono vari indici per calcolare il wind chill, noi useremo l'indice del Nord America e del Regno Unito:$\textit{T}_{WC} = 13.12 + 0.6215\textit{T}_{a} - 11.37\upsilon^{0.16} + 0.3965\textit{T}_{a}\upsilon^{0.16}$where:- $\textit{T}_{WC}$ = indice di wind chill- $\textit{T}_{a}$ = temperature dell'aria in Celsius- $\upsilon$ = velocita del vento a 10 m altezza di un anemometro standard, in chilometri all'ora. Per calcolare $\textit{T}_{WC}$ devi prima assicurarti che i dati siano nelle unità giuste. Per la velocità del vento devi convertire da m/s a km/h, e per la temperatura dell'aria da Kelvin a Celsius:<jupyter_code># velocità del vento, convertire da m/s a km/h: si10 * 1000 / (60*60)
ws_kmh = ws_mean * 3600 / 1000
# temperatura dell'aria, convertire da Kelvin a Celsius: t2m - 273.15
at_cel = at_mean - 273.15<jupyter_output><empty_output><jupyter_text>Poi puoi applicare la formula per calcolare il wind chill:<jupyter_code>twc = 13.12 + (0.6215*at_cel) - (11.37*(ws_kmh**0.16)) + (0.3965*at_cel*(ws_kmh**0.16))<jupyter_output><empty_output><jupyter_text>Alla fine puoi creare una mappa del wind chill a gennaio 2017 a Milano:<jupyter_code>visualise(twc, twc.longitude, twc.latitude, 'viridis', 
          'Wind Chill Milan January 2017', 'Wind Chill Index')<jupyter_output><empty_output><jupyter_text>La mappa di wind chill assomiglia più a quella sulla temperatura o sul vento? Per rispondere meglio, cambia la mappa di colori con quella usata per le mappe su temperatura e vento.  Calcolare anomalie e climatologie per Milano con dati ERA-5 Scaricare datiNel CDS https://cds.climate.copernicus.eu/ cerca il dataset `ERA5-Land monthly averaged data from 1981 to present`. Poi, nella finestra `Download data`, scegli i seguenti parametri:- Product type: `Monthly averaged reanalysis`- Variable: `2m temperature`- Year: `1981 to 2019`- Month: `all`- Time: `00:00` (default)- Geographical area: North: `45.5`, East: `9.3`, South: `45.4`, West: `9.1` - Format: `NetCDF`In fondo alla pagina, scegli `Show API request`. Poi copia il codice, e incollalo dentro la cella seguente, cambiando solo il nome del file .zip alla fine del blocco di codici. Poi lancialo per scaricare i dati...<jupyter_code>import cdsapi

c = cdsapi.Client()

c.retrieve(
    'reanalysis-era5-land-monthly-means',
    {
        'format': 'netcdf',
        'product_type': 'monthly_averaged_reanalysis',
        'variable': '2m_temperature',
        'year': [
            '1981', '1982', '1983',
            '1984', '1985', '1986',
            '1987', '1988', '1989',
            '1990', '1991', '1992',
            '1993', '1994', '1995',
            '1996', '1997', '1998',
            '1999', '2000', '2001',
            '2002', '2003', '2004',
            '2005', '2006', '2007',
            '2008', '2009', '2010',
            '2011', '2012', '2013',
            '2014', '2015', '2016',
            '2017', '2018', '2019',
        ],
        'month': [
            '01', '02', '03',
            '04', '05', '06',
            '07', '08', '09',
            '10', '11', '12',
        ],
        'time': '00:00',
        'area': [
            45.5, 9.1, 45.4,
            9.3,
        ],
    },
    './milan/ERA5_Land_t2m_Milan.nc')<jupyter_output>2020-11-15 15:32:42,095 INFO Welcome to the CDS
2020-11-15 15:32:42,095 INFO Sending request to https://cds.climate.copernicus.eu/api/v2/resources/reanalysis-era5-land-monthly-means
2020-11-15 15:32:42,354 INFO Request is queued
2020-11-15 15:32:43,403 INFO Request is running
2020-11-15 15:37:00,818 INFO Request is completed
2020-11-15 15:37:00,819 INFO Downloading http://136.156.133.41/cache-compute-0013/cache/data5/adaptor.mars.internal-1605454361.3754423-29859-21-b3b08691-145f-487b-92a0-b63573be40c2.nc to ./milan/ERA5_Land_t2m_Milan.nc (8.4K)
2020-11-15 15:37:00,941 INFO Download rate 68.9K/s<jupyter_text>Segui gli stessi passi di prima per creare un Xarray Dataset dei dati, poi un Xarray Data Array per la variabile `2m temperature` o `t2m` come il nome dato nel file NetCDF.<jupyter_code>t2m_nc = './milan/ERA5_Land_t2m_Milan.nc'
t2m_ds = xr.open_dataset(t2m_nc)
t2m_ds
# Per lavorare meglio con il parametro singolo, si converte in Xarray Data Array:
t2m_da = t2m_ds['t2m']<jupyter_output><empty_output><jupyter_text>Questi dati hanno una risoluzione spaziale molto inferiore rispetto a quella del sis-urban-climate-cities. Però in questo caso non vuoi creare una mappa, ma lavorare con una serie temporale su un punto, cioè un unico "pixel" su Milano. Quindi devi rendere monodimensionale la variabile dello spazio:<jupyter_code>t2m = t2m_da.mean(["longitude", "latitude"])<jupyter_output><empty_output><jupyter_text>Fare grafici di serie temporali: trend e anomalieOra puoi vedere come cambia la temperatura di Milano nella serie temporale dal 1981 al 2019.<jupyter_code>fig = plt.figure(figsize=(8,5))
ax = plt.subplot()
ax.set_ylabel('t2m')
ax.set_xlabel('time')
ax.plot(t2m.time, t2m, color='green', label='2m Temperature Milan')
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels)
ax.set_title('2m Temperature in Milan from 1981 to 2019')<jupyter_output><empty_output><jupyter_text>In questo grafico è difficile notare tendenze della temperatura, perché c'è una differenza stagionale troppo grande per percepire differenze sottili. Per rimuovere le variazioni stagionali, esamina la media annuale:<jupyter_code>t2m_y = t2m.groupby('time.year').mean('time')<jupyter_output><empty_output><jupyter_text>Inoltre, invece di vedere le temperature assolute, analizza le anomalie rispetto a una media. Per farlo, devi prima calcolare la media per un periodo di riferimento. Un periodo usato frequentemente è quello dal 1981 al 2010:<jupyter_code>ref = t2m_y.where((t2m_y.year > 1980) & (t2m_y.year < 2011), drop=True)
ref = ref.mean(dim="year")
anom = t2m_y - ref
# Creare una linea orizzontale tratteggiata per indicare la media dell'anomalia
mean_line = xr.DataArray(0.0, coords=[('year', np.arange(1981,2010))])

fig = plt.figure(figsize=(8,5))
ax = plt.subplot()
ax.set_ylabel('t2m anomaly')
ax.set_xlabel('year')
ax.plot(anom.year, anom, color='green', label='2m Temperature Anomalies Milan')
ax.plot(mean_line.year, mean_line, color='red', linestyle='dashed', label='Mean anomaly 1981-2010')
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels)
ax.set_title('2m Temperature Anomalies in Milan from 1981 to 2019')<jupyter_output><empty_output><jupyter_text>Ora vedrai più chiaramente la tendenza della temperatura dal 1980 al 2019.  Calcolare la climatologiaQui farai il calcolo della climatologia mensile. In particolare, calcolerai la media e deviazione standard della temperatura nella seria temporale per ogni singolo mese. Poi farai un confronto fra le temperature mensili del 2019 e la climatologia. Per capire meglio i valori della temperatura, convertili in Celsius:<jupyter_code>t2mC = t2m - 273.15<jupyter_output><empty_output><jupyter_text>Calcola quindi la climatologia:<jupyter_code>t2m_m_m = t2mC.groupby('time.month').mean('time')
t2m_m_sd = t2mC.groupby('time.month').std('time')<jupyter_output><empty_output><jupyter_text>E le temperature del 2019:<jupyter_code>t2m_2019 = t2mC.sel(time='2019')<jupyter_output><empty_output><jupyter_text>Infine, puoi creare un grafico che fa un confronto fra le temperature mensili del 2019 e la climatologia.<jupyter_code>fig = plt.figure(figsize=(10,5))
ax = plt.subplot()
ax.set_ylabel('t2m (Celsius)')
ax.set_xlabel('month')
ax.plot(t2m_m_m.month, t2m_m_m, color='gray', linestyle='dashed', label='t2m mean, shading: +/- SD')
ax.plot(t2m_m_m.month, (t2m_m_m + t2m_m_sd), color='gray', alpha=0.1)
ax.plot(t2m_m_m.month, (t2m_m_m - t2m_m_sd), color='gray', alpha=0.1)
ax.fill_between(t2m_m_m.month, (t2m_m_m + t2m_m_sd), (t2m_m_m - t2m_m_sd), color='gray', alpha=0.1)
ax.plot(t2m_m_m.month, t2m_2019, color='red', label='t2m 2019')
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles, labels)
ax.set_title('t2m climatology (1981 to 2019) compared with 2019')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09655511371252401, 'fraction_numerical': 0.051427550154148606, 'mean_word_length': 4.719907998977766, 'pattern_counts': {'":': 1, '<': 87, '<?xml version=': 0, '>': 87, 'https://': 17, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 3, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 9, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '22', 'dir': 'jupyter-structured-clean-dedup', 'id': '282996', 'license': 'Apache-2.0', 'n_tokens_mistral': 8638, 'n_tokens_neox': 7839, 'n_words': 2474, 'path': '2020-11-C3S-data-tutorial-italiano.ipynb', 'repo_name': 'edupenabad/copernicus-training', 'size': '22381'}