floatoftheday.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Tweet Argo float of the day, v4.2\n",
    "\n",
    "https://twitter.com/argobot84\n",
    "\n",
    "https://github.com/euroargodev/floatoftheday"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "import tweepy\n",
    "from ftplib import FTP\n",
    "from shutil import move\n",
    "\n",
    "import xarray as xr\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import gsw\n",
    "import argopy\n",
    "from argopy import DataFetcher as ArgoDataFetcher\n",
    "from argopy.stores import ArgoIndex, httpstore\n",
    "from argopy.related import load_dict, mapp_dict, ArgoNVSReferenceTables\n",
    "# argopy.set_options(ftp='ftp://ftp.ifremer.fr/ifremer/argo')\n",
    "\n",
    "import matplotlib\n",
    "matplotlib.use('Agg')\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "# from matplotlib import image\n",
    "from PIL import Image, ImageFont, ImageDraw\n",
    "import textwrap\n",
    "\n",
    "import cmocean\n",
    "from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER\n",
    "import cartopy.crs as ccrs\n",
    "import cartopy.feature as cfeature\n",
    "land_feature = cfeature.NaturalEarthFeature(category='physical', name='land',\n",
    "                                                scale='50m', facecolor=[0.4, 0.6, 0.7])\n",
    "import seaborn as sns\n",
    "sns.set_style(\"whitegrid\")\n",
    "SMALL_SIZE = 8\n",
    "MEDIUM_SIZE = 10\n",
    "BIGGER_SIZE = 12\n",
    "plt.rc('font', size=MEDIUM_SIZE)  # controls default text sizes\n",
    "plt.rc('axes', titlesize=BIGGER_SIZE)  # fontsize of the axes title\n",
    "plt.rc('axes', labelsize=SMALL_SIZE)  # fontsize of the x and y labels\n",
    "plt.rc('xtick', labelsize=SMALL_SIZE)  # fontsize of the tick labels\n",
    "plt.rc('ytick', labelsize=SMALL_SIZE)  # fontsize of the tick labels\n",
    "plt.rc('legend', fontsize=SMALL_SIZE)  # legend fontsize\n",
    "plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
    "\n",
    "import warnings; warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "SYSTEM\n",
      "------\n",
      "commit: None\n",
      "python: 3.8.17 | packaged by conda-forge | (default, Jun 16 2023, 07:11:34) \n",
      "[Clang 14.0.6 ]\n",
      "python-bits: 64\n",
      "OS: Darwin\n",
      "OS-release: 21.6.0\n",
      "machine: x86_64\n",
      "processor: i386\n",
      "byteorder: little\n",
      "LC_ALL: en_US.UTF-8\n",
      "LANG: en_US.UTF-8\n",
      "LOCALE: en_US.UTF-8\n",
      "libhdf5: 1.14.2\n",
      "libnetcdf: 4.9.2\n",
      "\n",
      "INSTALLED VERSIONS: CORE\n",
      "------------------------\n",
      "aiohttp     : 3.8.5       \n",
      "argopy      : 0.1.14      \n",
      "erddapy     : 2.2.0       \n",
      "fsspec      : 2023.9.1    \n",
      "netCDF4     : 1.6.4       \n",
      "packaging   : 23.1        \n",
      "requests    : 2.31.0      \n",
      "scipy       : 1.10.1      \n",
      "toolz       : 0.12.0      \n",
      "xarray      : 2023.1.0    \n",
      "\n",
      "INSTALLED VERSIONS: EXT.UTIL\n",
      "----------------------------\n",
      "gsw         : 3.6.17      \n",
      "tqdm        : 4.66.1      \n",
      "zarr        : -           \n",
      "\n",
      "INSTALLED VERSIONS: EXT.PERF\n",
      "----------------------------\n",
      "dask        : -           \n",
      "distributed : -           \n",
      "pyarrow     : -           \n",
      "\n",
      "INSTALLED VERSIONS: EXT.PLOT\n",
      "----------------------------\n",
      "IPython     : 8.12.2      \n",
      "cartopy     : 0.21.1      \n",
      "ipykernel   : 6.25.2      \n",
      "ipywidgets  : 8.1.1       \n",
      "matplotlib  : 3.4.3       \n",
      "pyproj      : 3.5.0       \n",
      "seaborn     : 0.12.2      \n",
      "\n",
      "INSTALLED VERSIONS: DEV\n",
      "-----------------------\n",
      "aiofiles    : -           \n",
      "black       : 23.9.1      \n",
      "bottleneck  : -           \n",
      "cfgrib      : -           \n",
      "cftime      : 1.6.2       \n",
      "conda       : -           \n",
      "flake8      : -           \n",
      "nc_time_axis: -           \n",
      "numpy       : 1.24.4      \n",
      "pandas      : 1.5.3       \n",
      "pip         : 23.2.1      \n",
      "pytest      : -           \n",
      "pytest_cov  : -           \n",
      "pytest_env  : -           \n",
      "pytest_localftpserver: -           \n",
      "setuptools  : 68.2.2      \n",
      "sphinx      : -           \n",
      "\n",
      "INSTALLED VERSIONS: PIP\n",
      "-----------------------\n",
      "pytest-reportlog: -           \n"
     ]
    }
   ],
   "source": [
    "import argopy\n",
    "argopy.show_versions()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_basicmetadata(wmo):\n",
    "    uri = 'https://fleetmonitoring.euro-argo.eu/floats/basic/{}'.format\n",
    "    data = httpstore(cache=True).open_mfjson([uri(wmo)], errors=\"raise\", url_follow=True)\n",
    "    print(data)\n",
    "    meta = {'pi': '?', 'project': '?'}\n",
    "    meta['pi'] = data[0]['owner']\n",
    "    # if 'deployment' in data[0]:\n",
    "        # if 'principalInvestigatorName' in data[0]['deployment']:\n",
    "        #     meta['pi'] = data[0]['deployment']['principalInvestigatorName']\n",
    "    if 'projectName' in data[0] and data[0]['projectName']:\n",
    "        meta['project'] = data[0]['projectName']\n",
    "    elif 'projects' in data[0]:\n",
    "        meta['project'] = data[0]['projects'][0]\n",
    "    return meta\n",
    "\n",
    "def get_float_model(profiler_code):\n",
    "    R8 = ArgoNVSReferenceTables().tbl(8)\n",
    "    return R8[R8['altLabel']==str(profiler_code)]['prefLabel'].values[0]\n",
    "\n",
    "def get_metadata(wmo):\n",
    "    uri = 'https://fleetmonitoring.euro-argo.eu/floats/{}'.format\n",
    "    data = httpstore(cache=True).open_mfjson([uri(wmo)], errors=\"raise\", url_follow=True)\n",
    "    # print(data)\n",
    "    meta = {'pi': '?', 'project': '?', 'profiler_code': '?', 'profiler': '?'}\n",
    "\n",
    "    if data[0]['owner']:\n",
    "        meta['pi'] = data[0]['owner']\n",
    "    elif 'deployment' in data[0]:\n",
    "        if 'principalInvestigatorName' in data[0]['deployment'] and data[0]['deployment']['principalInvestigatorName']:\n",
    "            meta['pi'] = data[0]['deployment']['principalInvestigatorName']\n",
    "\n",
    "    if 'projectName' in data[0] and data[0]['projectName']:\n",
    "        meta['project'] = data[0]['projectName']\n",
    "    elif 'projects' in data[0]:\n",
    "        meta['project'] = data[0]['projects'][0]\n",
    "\n",
    "    for param in data[0]['configurations']['techs']:\n",
    "        if param['id'] == 13:\n",
    "            meta['profiler_code'] = param['value']\n",
    "            try:\n",
    "                meta['profiler'] = get_float_model(meta['profiler_code'])\n",
    "            except:\n",
    "                print(meta)\n",
    "                print(\"%s not found in R08\" % meta['profiler_code'])\n",
    "                meta['profiler'] = 'Unknown'\n",
    "\n",
    "    return meta\n",
    "\n",
    "def download_one_random_profile_data(start, end):\n",
    "    \"\"\"Load a random Argo profile reported between 2 dates\"\"\"\n",
    "    print(\"Loading profile index ...\")\n",
    "    # daily_df = ArgoDataFetcher(src='gdac').region([-180, 180, -90, 90, 0, 2000, start.strftime('%Y-%m-%d'), end.strftime('%Y-%m-%d')]).index\n",
    "    daily_df = ArgoIndex(index_file='ar_index_this_week_prof.txt', convention='core').search_tim([-180, 180, -90, 90, DATE_start.strftime('%Y-%m-%d'), DATE_end.strftime('%Y-%m-%d')]).to_dataframe()\n",
    "    \n",
    "    # Gather coordinate of all profiles\n",
    "    week_lon = daily_df['longitude'].values\n",
    "    week_lat = daily_df['latitude'].values\n",
    "    week_data = [week_lon, week_lat]\n",
    "\n",
    "    def get_a_random_profile(this_df):\n",
    "        \"\"\"Randomly select one profile and download data\"\"\"\n",
    "        this_df = this_df.sample(1)\n",
    "        this_df['cyc'] = this_df['file'].apply(lambda x: int(x.split(\"/\")[-1].split(\"_\")[-1].replace(\".nc\",\"\").replace(\"A\",\"\").replace(\"D\",\"\").replace(\"B\",\"\")))\n",
    "        wmo, cyc = this_df['wmo'].values[0], this_df['cyc'].values[0]\n",
    "        print(\"Loading profile:\", wmo, cyc)\n",
    "\n",
    "        # Load and return profile:\n",
    "        try:\n",
    "            ds = ArgoDataFetcher(src='gdac').profile(this_df['wmo'].values[0], this_df['cyc'].values[0]).load().data\n",
    "            # raise\n",
    "        except:\n",
    "            ds = None\n",
    "        return ds, this_df\n",
    "\n",
    "    MaxTry, itry = 10, 0\n",
    "    while itry < MaxTry:\n",
    "        ds, this_df = get_a_random_profile(daily_df)\n",
    "        if not ds:\n",
    "            print(\"%i/%i: An error happened when downloading this data\" % (itry+1, MaxTry))\n",
    "            itry += 1\n",
    "        else:\n",
    "            print(\"%i/%i: Succeeded in downloading this data !\" % (itry+1, MaxTry))            \n",
    "            try:        \n",
    "                ds = ds.argo.point2profile()\n",
    "                break\n",
    "            except:\n",
    "                print(\"%i/%i: An error happened when processing this data\" % (itry+1, MaxTry))\n",
    "                itry += 1\n",
    "                \n",
    "    if itry == MaxTry:\n",
    "        raise ValueError(\"All attempts (N=%i) to download data failed !\" % MaxTry)\n",
    "\n",
    "    print(\"Post-processing data...\")\n",
    "    ds = ds.isel(N_PROF=[-1])  # The last profile to date\n",
    "    ds.attrs['quadrant'] = 'E' if ds['LONGITUDE'] > 0 else 'W'\n",
    "    ds.attrs['hemisphere'] = 'N' if ds['LATITUDE'] > 0 else 'S'\n",
    "    wmo = np.unique(ds['PLATFORM_NUMBER'])[0]\n",
    "    meta = get_metadata(wmo)\n",
    "    ds.attrs['float_model'] = meta['profiler']\n",
    "    ds.attrs['pi_name'] = meta['pi']\n",
    "    ds.attrs['project_name'] = meta['project']\n",
    "    \n",
    "    return week_data, this_df, ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set of Argo logo colors:\n",
    "COLORS = {'CYAN': (18/256, 235/256, 229/256), \n",
    "          'BLUE': (16/256, 137/256, 182/256), \n",
    "          'DARKBLUE': (10/256, 89/256, 162/256), \n",
    "          'YELLOW': (229/256, 174/256, 41/256),\n",
    "          'DARKYELLOW': (224/256, 158/256, 37/256),\n",
    "         }\n",
    "argo2rgba = lambda x: tuple([int(v*255) for v  in matplotlib.colors.to_rgba(COLORS[x])])\n",
    "\n",
    "\n",
    "def get_a_title(profile_df, nlines=3):\n",
    "    dac = profile_df['file'].values[0].split('/')[0]\n",
    "    wmo, cyc = profile_df['wmo'].values[0], profile_df['cyc'].values[0]\n",
    "    lon, lat = profile_df['longitude'].values[0], profile_df['latitude'].values[0]\n",
    "    when = pd.to_datetime(profile_df['date'].values[0]).strftime('%A %d of %B %Y, %H:%M:%S UTC')\n",
    "    hemisphere = 'N' if lat > 0 else 'S'\n",
    "    quadrant = 'E' if lon > 0 else 'W'\n",
    "    where = \"%0.3f%s, %0.3f%s\" % (np.abs(lat), hemisphere, \n",
    "                                  np.abs(lon), quadrant,\n",
    "                                 )\n",
    "    if nlines == 3:        \n",
    "        profile_title = \"Float %s - Cycle %i\\nDate: %s\\nPosition: %s\" % (wmo, cyc, when, where)\n",
    "    elif nlines == 2:\n",
    "        profile_title = \"Float %s - Cycle %i\\nDate: %s / Position: %s\" % (wmo, cyc, when, where)\n",
    "    else:\n",
    "        profile_title = \"Float %s - Cycle %i / Date: %s / Position: %s\" % (wmo, cyc, when, where)\n",
    "    return profile_title\n",
    "\n",
    "\n",
    "def plot_profile(this_ds, x='TEMP', y='PRES', title='?', dpi=120):\n",
    "    aspect, size = 0.6, 10\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, dpi=dpi, figsize=(aspect*size, size))\n",
    "    ax.plot(this_ds[x], this_ds[y], marker='.', color=COLORS['DARKYELLOW'])\n",
    "    xmin, xmax = ax.get_xlim()\n",
    "    ymin, ymax = ax.get_ylim()\n",
    "    ax.set_ylim([0, ymax])\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_title(title, color=COLORS['DARKBLUE'])\n",
    "    # ax.xaxis.label.set_color(COLORS['BLUE'])\n",
    "    # ax.yaxis.label.set_color(COLORS['BLUE'])\n",
    "    # ax.tick_params(axis='x', colors=COLORS['BLUE'])\n",
    "    # ax.tick_params(axis='y', colors=COLORS['BLUE'])\n",
    "    ax.grid(color=COLORS['BLUE'], linestyle='--', linewidth=.2)\n",
    "    ax.tick_params(color=COLORS['BLUE'], labelcolor=COLORS['BLUE'])\n",
    "    for spine in ax.spines.values():\n",
    "        spine.set_edgecolor(COLORS['DARKBLUE'])\n",
    "    \n",
    "    ax.text(xmin+(xmax-xmin)/2, ymax, r\"$%s\\rightarrow$\" % x, fontsize=8, color=COLORS['BLUE'], horizontalalignment='center', verticalalignment='bottom')\n",
    "    ax.text(xmin+0.01*(xmax-xmin), ymax/2, r\"$\\leftarrow %s$\" % y, fontsize=8, color=COLORS['BLUE'], rotation=90, horizontalalignment='left', verticalalignment='top')\n",
    "\n",
    "    # print((aspect*size, size))\n",
    "    # print((aspect*size*dpi, size*dpi))\n",
    "    # print(\"Dot per inch(DPI) for the figure is: \", fig.dpi)\n",
    "    # bbox = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())\n",
    "    # print(\"Axis sizes are (in pixels):\", bbox.width*dpi, bbox.height*dpi)\n",
    "    \n",
    "    \n",
    "def plot_map(this_ds, this_week_data, dpi=240, title='?'):\n",
    "    week_lon, week_lat = this_week_data\n",
    "\n",
    "    aspect, size = 1, 10\n",
    "    fig = plt.figure(figsize=(aspect*size, size), dpi=dpi)\n",
    "    ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree())\n",
    "    ax.add_feature(land_feature, color=COLORS['BLUE'], edgecolor=COLORS['CYAN'], linewidth=.1, alpha=0.3)\n",
    "\n",
    "    plt.plot(week_lon, week_lat, '.', markersize=3, color=COLORS['YELLOW'])\n",
    "    plt.plot(this_ds['LONGITUDE'], this_ds['LATITUDE'], color='r', marker='.', markersize=12, markeredgecolor='r')\n",
    "\n",
    "    gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=0.5, color=COLORS['BLUE'], alpha=0.7, linestyle=':')\n",
    "    gl.xlabels_top = False\n",
    "    gl.ylabels_left = False\n",
    "    gl.xlocator = mticker.FixedLocator(np.arange(-180, 180 + 1, 30))\n",
    "    gl.ylocator = mticker.FixedLocator(np.arange(-90, 90 + 1, 15))\n",
    "    gl.xformatter = LONGITUDE_FORMATTER\n",
    "    gl.yformatter = LATITUDE_FORMATTER    \n",
    "    gl.xlabel_style = {'color': COLORS['BLUE'], 'fontsize': 6}\n",
    "    gl.ylabel_style = {'color': COLORS['BLUE'], 'fontsize': 6}\n",
    "    extent = [-179.9, 180, -80, 80]\n",
    "    ax.set_extent(extent)\n",
    "    ax.set_title(title, color=COLORS['DARKBLUE'])\n",
    "    for spine in ax.spines.values():\n",
    "        spine.set_edgecolor(COLORS['DARKBLUE'])\n",
    "\n",
    "def add_lowerband(mfname, outfname, band_height=70, color=(255, 255, 255, 255)):\n",
    "    \"\"\" Add lower band to a figure\n",
    "        Parameters\n",
    "        ----------\n",
    "        mfname : string\n",
    "            source figure file\n",
    "        outfname : string\n",
    "            output figure file\n",
    "    \"\"\"\n",
    "    image = Image.open(mfname, 'r')\n",
    "    image_size = image.size\n",
    "    width = image_size[0]\n",
    "    height = image_size[1]\n",
    "    background = Image.new('RGBA', (width, height + band_height), color)\n",
    "    background.paste(image, (0, 0))\n",
    "    background.save(outfname)\n",
    "\n",
    "def add_2logo(mfname, outfname, logo_height=70, font_size=12, txt_color=argo2rgba('DARKBLUE')):\n",
    "    \"\"\" Add 2 logos and text to a figure\n",
    "        Parameters\n",
    "        ----------\n",
    "        mfname : string\n",
    "            source figure file\n",
    "        outfname : string\n",
    "            output figure file\n",
    "    \"\"\"\n",
    "\n",
    "    font_path = \"img/Calibri_Regular.ttf\"\n",
    "    lfname2 = \"img/logo_argofrance.png\"\n",
    "    lfname1 = \"img/logo_argo.png\"\n",
    "\n",
    "    mimage = Image.open(mfname)\n",
    "\n",
    "    # Open logo images:\n",
    "    limage1 = Image.open(lfname1)\n",
    "    limage2 = Image.open(lfname2)\n",
    "\n",
    "    # Resize logos to match the requested logo_height:\n",
    "    aspect_ratio = limage1.size[1] / limage1.size[0]  # height/width\n",
    "    simage1 = limage1.resize((int(logo_height / aspect_ratio), logo_height))\n",
    "\n",
    "    aspect_ratio = limage2.size[1] / limage2.size[0]  # height/width\n",
    "    simage2 = limage2.resize((int(logo_height / aspect_ratio), logo_height))\n",
    "\n",
    "    # Paste logos along the lower white band of the main figure:\n",
    "    box = (0, mimage.size[1] - logo_height)\n",
    "    mimage.paste(simage1, box)\n",
    "\n",
    "    box = (simage1.size[0], mimage.size[1] - logo_height)\n",
    "    mimage.paste(simage2, box)\n",
    "\n",
    "    txtA = \"Argo is an international program that collects information from inside \" \\\n",
    "           \"the ocean using a fleet of robotic instruments that drift with the ocean \" \\\n",
    "           \"currents and move up and down between the surface and a mid-water level.\\n\" \\\n",
    "           \"These data were collected and made freely available by the International \" \\\n",
    "           \"Argo Program and the national programs that contribute to it. \" \\\n",
    "           \"(https://argo.ucsd.edu, https://www.ocean-ops.org). The Argo Program is \" \\\n",
    "           \"part of the Global Ocean Observing System.\\n\" \\\n",
    "           \"This figure was created by the Argo-France program: https://www.argo-france.fr\"\n",
    "    xoffset = 5 + simage1.size[0] + simage2.size[0]\n",
    "\n",
    "    def with_ftsz(txt, ftsz=10, max_char=60, img=None):\n",
    "        \"\"\"Determine the pixel width of a wrapped text over max_char\"\"\"\n",
    "\n",
    "        # Wrap text:\n",
    "        txt = textwrap.fill(txt, width=max_char, break_long_words=True, replace_whitespace=True)\n",
    "\n",
    "        # Get a font:\n",
    "        this_ft = ImageFont.truetype(font=font_path, size=ftsz)  # size – The requested size, in points.\n",
    "\n",
    "        # Print text on the image and read pixel width and height:\n",
    "        draw = ImageDraw.Draw(mimage.copy())\n",
    "        xy = (0,0)  # We don't care where it is in the image, we just need to draw to get the final size\n",
    "        draw.text(xy, txt, font=this_ft)\n",
    "        left, top, right, bottom = draw.multiline_textbbox(xy, txt, font=this_ft)\n",
    "        txt_sz = (right - left, bottom - top)\n",
    "        return txt, txt_sz, this_ft\n",
    "\n",
    "\n",
    "    def wrap_text(caption, max_width_pixel=200, font_size=12, font_path=\"?\", img=None):\n",
    "        \"\"\"Determine the maximum nb of columns for a wrap text\"\"\"\n",
    "        maxc = 50\n",
    "        wrapped_txt, txt_sz, ft = with_ftsz(caption, ftsz=font_size, max_char=maxc, img=img)\n",
    "\n",
    "        too_large = txt_sz[0] > max_width_pixel\n",
    "        while not too_large:\n",
    "            maxc += 1\n",
    "            wrapped_txt, txt_sz, ft = with_ftsz(caption, ftsz=font_size, max_char=maxc, img=img)\n",
    "            too_large = txt_sz[0] > max_width_pixel\n",
    "        return wrapped_txt, ft\n",
    "\n",
    "    # Print disclaimer:\n",
    "    txtA, fontA = wrap_text(txtA, font_size=font_size, \n",
    "                            max_width_pixel=mimage.size[0]-xoffset-50, font_path=font_path)\n",
    "    posA = (xoffset, mimage.size[1] - logo_height - 1)\n",
    "    drawA = ImageDraw.Draw(mimage)\n",
    "    drawA.text(posA, txtA, txt_color, font=fontA)\n",
    "\n",
    "    # Final save\n",
    "    mimage.save(outfname) \n",
    "    \n",
    "\n",
    "def plot_ts(this_ds, x='PSAL', y='TEMP', title='?', dpi=150):\n",
    "    # with sns.axes_style(\"white\"):\n",
    "    aspect, size = 1, 10\n",
    "    fig, ax = plt.subplots(nrows=1, ncols=1, dpi=dpi, figsize=(aspect*size, size))\n",
    "    ax.plot(this_ds[x], this_ds[y], '.-', color=COLORS['DARKYELLOW'])\n",
    "\n",
    "    # Add in-situ density contours\n",
    "    Smin, Smax = ax.get_xlim()\n",
    "    Tmin, Tmax = ax.get_ylim()\n",
    "    Sdim = int(round((Smax-Smin)/0.1+1, 0))\n",
    "    Tdim = int(round((Tmax-Tmin)+1, 0))\n",
    "    Saxe = np.linspace(Smin, Smax, Sdim)\n",
    "    Taxe = np.linspace(Tmin, Tmax, Tdim)\n",
    "    Sv, Tv = np.meshgrid(Saxe, Taxe, sparse=False, indexing='ij')\n",
    "    RHOi = gsw.rho(Sv, Tv, 0) - 1000\n",
    "    print(np.max(RHOi), np.min(RHOi))\n",
    "    # Major density contours with labels:\n",
    "    cs = ax.contour(Sv, Tv, RHOi, levels=np.arange(10,40,.4), linestyle='-', linewidths=0.5, colors=[COLORS['BLUE']])\n",
    "    ax.clabel(cs, fontsize=8, inline=1, fmt='%0.2f')\n",
    "    # Minor density contours:\n",
    "    ax.contour(Sv, Tv, RHOi, levels=np.arange(10,40,.1), linestyle='-', linewidths=0.1, colors=[COLORS['BLUE']], alpha=0.5)\n",
    "    \n",
    "    #\n",
    "    ax.text(Smin+(Smax-Smin)/2, Tmin + 0.01*(Smax-Smin), r\"$%s\\rightarrow$\" % x, fontsize=8, color=COLORS['BLUE'], horizontalalignment='right', verticalalignment='bottom')\n",
    "    ax.text(Smin+0.005*(Smax-Smin), Tmin+(Tmax-Tmin)/2, r\"$%s\\rightarrow$\" % y, fontsize=8, color=COLORS['BLUE'], rotation=90, horizontalalignment='left', verticalalignment='top')\n",
    "    ax.grid(None)\n",
    "    ax.tick_params(color=COLORS['BLUE'], labelcolor=COLORS['BLUE'])\n",
    "    ax.set_title(title, color=COLORS['DARKBLUE'])\n",
    "    for spine in ax.spines.values():\n",
    "        spine.set_edgecolor(COLORS['DARKBLUE']) \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Tweet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def tweet_this(imlist, this_ds, profile_df, caption_only=False):\n",
    "\n",
    "    # Init the Tweeter API\n",
    "    consumer_key, consumer_secret, access_token, access_token_secret = os.environ['TWITTER_SECRET'].split(':')\n",
    "    \n",
    "    auth = tweepy.OAuthHandler(\n",
    "            consumer_key,\n",
    "            consumer_secret\n",
    "            )\n",
    "    auth.set_access_token(\n",
    "            access_token,\n",
    "            access_token_secret\n",
    "            )\n",
    "    api = tweepy.API(auth)\n",
    "\n",
    "    client = tweepy.Client(\n",
    "        consumer_key=consumer_key, consumer_secret=consumer_secret,\n",
    "        access_token=access_token, access_token_secret=access_token_secret\n",
    "    )\n",
    "\n",
    "    \n",
    "    # ## Text of the tweet\n",
    "    \n",
    "    dac = profile_df['file'].values[0].split('/')[0]\n",
    "    wmo, cyc = profile_df['wmo'].values[0], profile_df['cyc'].values[0]\n",
    "    lon, lat = profile_df['longitude'].values[0], profile_df['latitude'].values[0]\n",
    "    when = pd.to_datetime(profile_df['date'].values[0]).strftime('%A %d of %B %Y, %H:%M:%S UTC')\n",
    "    hemisphere = 'N' if lat > 0 else 'S'\n",
    "    quadrant = 'E' if lon > 0 else 'W'\n",
    "    where = \"%0.3f%s, %0.3f%s\" % (np.abs(lat), hemisphere, \n",
    "                                  np.abs(lon), quadrant,\n",
    "                                 )\n",
    "        \n",
    "    # when = pd.to_datetime(str(this_ds['TIME'].values[0])).strftime('%A %d of %B %Y, %H:%M:%S UTC')\n",
    "    # where = \"%0.3f%s, %0.3f%s\" % (np.abs(this_ds['LATITUDE']), this_ds.attrs['hemisphere'], np.abs(this_ds['LONGITUDE']), this_ds.attrs['quadrant'])\n",
    "    long_title = \"▶ Float %s, Cycle %i 🗓%s 🗺%s 📏%i measurements 🤖%s 💳%s\" % (\n",
    "        wmo, cyc,\n",
    "        when, where,\n",
    "        len(this_ds['N_LEVELS']),\n",
    "        \"%s\" % this_ds.attrs['float_model'].split(\" \")[0],\n",
    "        this_ds.attrs['project_name'].strip())\n",
    "\n",
    "    # Could try to add a link to convert UTC to local, eg:\n",
    "    # https://www.google.com/search?q=05%3A21%3A00+UTC+to+local\n",
    "    # http://www.timebie.com/std/gmt.php?q=052100\n",
    "\n",
    "    caption = (f'Here is the Argo profile of the last 24 hours 🎉\\n'\n",
    "               f'{long_title}\\n'\n",
    "               f'#argofloat, #argofloats, '\n",
    "               f'https://fleetmonitoring.euro-argo.eu/float/{wmo} '\n",
    "                )\n",
    "\n",
    "    if len(caption) > 280:\n",
    "        caption = caption[0:280-10-1] + '\\u2026'\n",
    "\n",
    "    # print(len(caption), \"/\", twitter.api.CHARACTER_LIMIT, \"\\n\", caption, \"\\n\")\n",
    "\n",
    "    # ## Attach figures to the tweet\n",
    "    media = []\n",
    "    for fname in imlist:\n",
    "        media.append(api.media_upload(fname, chunked=True).media_id)\n",
    "\n",
    "    # Post it !\n",
    "    if caption_only:\n",
    "        return caption\n",
    "    else:\n",
    "        # resp = api.PostUpdate(caption,\n",
    "        #                       media=media,\n",
    "        #                       latitude=float(lat),\n",
    "        #                       longitude=float(lon),\n",
    "        #                       display_coordinates=True)\n",
    "        response = client.create_tweet(\n",
    "            text=caption,\n",
    "            media_ids=media\n",
    "\n",
    "        )\n",
    "        print(f\"https://twitter.com/user/status/{response.data['id']}\")        \n",
    "        \n",
    "        \n",
    "        return response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading profile index ...\n",
      "Loading profile: 3902554 7\n",
      "1/10: Succeeded in downloading this data !\n",
      "1/10: An error happened when processing this data\n",
      "Loading profile: 5906968 40\n",
      "2/10: Succeeded in downloading this data !\n",
      "Post-processing data...\n"
     ]
    }
   ],
   "source": [
    "DATE_end = pd.to_datetime('now', utc=True)\n",
    "DATE_start = DATE_end - pd.DateOffset(hours=24.0)\n",
    "week_data, df, ds = download_one_random_profile_data(DATE_start, DATE_end)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Create and save figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27.94464383171635 20.493276089799224\n",
      "['TEMP.png', 'PSAL.png', 'TS.png', 'MAP.png']\n"
     ]
    }
   ],
   "source": [
    "vnames = ['TEMP', 'PSAL', 'CNDC', 'DOXY', 'BBP', 'TURBIDITY', 'CHLA', 'CDOM', 'NITRATE', 'BISULFIDE', 'PH_IN_SITU_TOTAL', 'DOWNWELLING_PAR']\n",
    "imlist = []\n",
    "for v in vnames:\n",
    "    if v in ds:\n",
    "        plot_profile(ds, x=v, y='PRES', title=get_a_title(df), dpi=240)\n",
    "        iname = '%s.png' % v\n",
    "        plt.savefig(iname, frameon=True, bbox_inches='tight', facecolor='w', edgecolor='w')\n",
    "        add_lowerband(iname, iname, band_height=100)\n",
    "        add_2logo(iname, iname, logo_height=100, font_size=18)\n",
    "        imlist.append(iname)\n",
    "\n",
    "if 'TEMP' in ds and 'PSAL' in ds:\n",
    "    plot_ts(ds, x='PSAL', y='TEMP', title=get_a_title(df), dpi=160)\n",
    "    iname = 'TS.png'\n",
    "    plt.savefig(iname, frameon=True, bbox_inches='tight', facecolor='w', edgecolor='w')\n",
    "    add_lowerband(iname, iname, band_height=100)\n",
    "    add_2logo(iname, iname, logo_height=100, font_size=18)\n",
    "    imlist.append(iname)\n",
    "\n",
    "plot_map(ds, week_data, dpi=120, title=get_a_title(df, nlines=2))\n",
    "iname = 'MAP.png'\n",
    "plt.savefig(iname, frameon=True, bbox_inches='tight', facecolor='w', edgecolor='w')\n",
    "add_lowerband(iname, iname, band_height=100)\n",
    "add_2logo(iname, iname, logo_height=100, font_size=12)\n",
    "imlist.append(iname)\n",
    "print(imlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>file</th>\n",
       "      <th>date</th>\n",
       "      <th>latitude</th>\n",
       "      <th>longitude</th>\n",
       "      <th>ocean</th>\n",
       "      <th>profiler_code</th>\n",
       "      <th>institution_code</th>\n",
       "      <th>date_update</th>\n",
       "      <th>wmo</th>\n",
       "      <th>cyc</th>\n",
       "      <th>institution</th>\n",
       "      <th>profiler</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>388</th>\n",
       "      <td>kordi/5906968/profiles/R5906968_040.nc</td>\n",
       "      <td>2023-11-09 06:13:29</td>\n",
       "      <td>16.783</td>\n",
       "      <td>134.383</td>\n",
       "      <td>P</td>\n",
       "      <td>844</td>\n",
       "      <td>KO</td>\n",
       "      <td>2023-11-09 11:00:27</td>\n",
       "      <td>5906968</td>\n",
       "      <td>40</td>\n",
       "      <td>KORDI, Korea</td>\n",
       "      <td>Unknown</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                       file                date  latitude  \\\n",
       "388  kordi/5906968/profiles/R5906968_040.nc 2023-11-09 06:13:29    16.783   \n",
       "\n",
       "     longitude ocean  profiler_code institution_code         date_update  \\\n",
       "388    134.383     P            844               KO 2023-11-09 11:00:27   \n",
       "\n",
       "         wmo  cyc   institution profiler  \n",
       "388  5906968   40  KORDI, Korea  Unknown  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ds.data_vars\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Tweet !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://twitter.com/user/status/1722892051472097488\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Response(data={'edit_history_tweet_ids': ['1722892051472097488'], 'id': '1722892051472097488', 'text': 'Here is the Argo profile of the last 24 hours 🎉\\n▶ Float 5906968, Cycle 40 🗓Thursday 09 of November 2023, 06:13:29 UTC 🗺16.783N, 134.383E 📏92 measurements 🤖ARVOR 💳Argo KIOST\\n#argofloat, #argofloats, https://t.co/5zBhIStr0n https://t.co/yQyobxDvVj'}, includes={}, errors=[], meta={})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tweet_this(imlist, ds, df, caption_only=True)\n",
    "tweet_this(imlist, ds, df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "This repository is maintained by:\n",
    "<div>\n",
    "<img src=\"https://github.com/euroargodev/euroargodev.github.io/raw/master/img/logo/logo_argofrance.png\" width=\"200\"/>\n",
    "<img src=\"https://github.com/euroargodev/euroargodev.github.io/raw/master/img/logo/logo-lops.png\" width=\"140\"/>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "argobot"
  },
  "kernelspec": {
   "display_name": "argobot",
   "language": "python",
   "name": "argobot"
  },
  "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.8.17"
  },
  "nteract": {
   "version": "0.12.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}