python_installation_instructions_and_verification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9d011ac6-e92d-40ac-bcfa-52ac75002628",
   "metadata": {},
   "source": [
    "<font size=\"7\"> <div align=\"center\">Python™ for Earth Scientists</div></font>\n",
    "<font size=\"6\"> <div align=\"center\">Package Installation and Verification</div></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d23fc2f6-b829-4d68-9a63-72edef8fecfc",
   "metadata": {},
   "source": [
    "**Note: After publishing this repository several excellent suggestions were made in the [discussions](https://github.com/mstudinger/Python-Installation-for-Earth-Scientists/discussions) on how to avoid the issues I've experienced with package management. [Make sure to check them out.](https://github.com/mstudinger/Python-Installation-for-Earth-Scientists/discussions)**\n",
    "\n",
    "Managing Python™ packages can be a daunting task. Often, numerous incompatibilities exist between Python™ packages commonly used in Earth sciences (see example about GDAL and Xarray in Jupyter notebook). Commonly required tasks vary depending on the user's need. Here are some capabilities I need for my workflow that are not covered by the standard [Anaconda](https://www.anaconda.com/) package installation:  \n",
    "* geodetic 2-D and 3-D coordinate transformations\n",
    "* geodetic computations\n",
    "* handling commonly used data formats such as GeoData frames\n",
    "* image processing using sophisticated tools available in dedicated packages such as OpenCV ([Open Source Computer Vision Library](https://opencv.org/))\n",
    "* work specific tools, such as AI-based tools e.g., [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything)\n",
    "* collaborative code developing and open sharing of code in commonly used repositories such as [GitHub](https://github.com/)\n",
    "\n",
    "This Jupyter notebook contains instructions for installing essential Python™ packages for Earth scientists and test the functionality of the installed packages. You can run individual cells in this notebook for checking the packages you would like to verify. This Jupyter notebook and the corresponding Python™ script have been tested under the following environments:  \n",
    "* Windows 11 Pro (23H2)        Python™ 3.11.7\n",
    "* Windows 10 Enterprise (21H2) Python™ 3.9.13\n",
    "* Linux POSIX Release: 5.15.146.1-microsoft-standard-WSL2 Python™ 3.11.7\n",
    "* Linux POSIX Release: 5.10.198-187.748.amzn2.x86_64 Python™ 3.11.8 (selected packages tested on the [CryoCloud JupyterHub](https://cryointhecloud.com))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d13d951-2317-4197-b079-cc11048d17f0",
   "metadata": {},
   "source": [
    "## 1. Determine if code is run from a classic Jupyter Notebook, JupyterLab, or Python™"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3c308bb7-7f9d-4f21-bfea-2544f4bad9d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import psutil\n",
    "\n",
    "parent_process = psutil.Process().parent().cmdline()[-1]\n",
    "\n",
    "if 'jupyter-lab' in parent_process:\n",
    "    env_str = 'JupyterLab'\n",
    "    ENVIRONMENT = 'Jupyterlab'\n",
    "elif 'jupyter-notebook' in parent_process:\n",
    "    env_str = 'Jupyter Classic Notebook'\n",
    "    ENVIRONMENT = 'JupyterNB'\n",
    "elif \"spyder-script.py\" in parent_process:\n",
    "    env_str = 'Windows-Python™ (Spyder)'\n",
    "    ENVIRONMENT = 'Windows-Python-Spyder'\n",
    "elif parent_process == '-bash':\n",
    "    env_str = 'Linux-Python™ (command line)'\n",
    "    ENVIRONMENT = 'Linux-Python-cmdline'\n",
    "elif \"8890\" in parent_process:\n",
    "    env_str = 'Linux-Python™ (JupyterLab)'\n",
    "    ENVIRONMENT = 'Linux-JupyterLab'\n",
    "elif 'anaconda3' in parent_process:\n",
    "    env_str = 'Windows-Python™(command line)'\n",
    "    ENVIRONMENT = 'Windows-Python-cmdline'\n",
    "elif 'jupyterhub-singleuser' in parent_process:\n",
    "    env_str = 'CryoCloud-JupyterLab'\n",
    "    ENVIRONMENT = 'CryoCloud-JupyterLab'\n",
    "else:\n",
    "    env_str = 'Python™'\n",
    "    ENVIRONMENT = \"Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e3fceaf-e262-4988-bfb9-57df0318fd8a",
   "metadata": {},
   "source": [
    "## 2. Get name of computer and operating system information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d7b39f4f-db69-4977-99ec-31d8cb191f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Platform and Operating System:\n",
      "\n",
      "Computer name     : ALETSCH-V\n",
      "Operating system  : Linux POSIX, Release 5.15.146.1-microsoft-standard-WSL2 \n",
      "Python environment: Linux-Python™ (JupyterLab)\n"
     ]
    }
   ],
   "source": [
    "# get computer name and OS\n",
    "import os\n",
    "import socket\n",
    "import platform\n",
    "\n",
    "if platform.system() == \"Windows\":\n",
    "    win32 = platform.win32_ver(release='', version='', csd='', ptype='')\n",
    "    ver_str = f'({win32[1]:s})'\n",
    "else:\n",
    "    ver_str = ''\n",
    "\n",
    "print('\\nPlatform and Operating System:\\n')\n",
    "print(f'Computer name     : {socket.gethostname():s}')\n",
    "print(f'Operating system  : {platform.system():s} {os.name.upper():s}, Release {platform.release():s} {ver_str:s}')\n",
    "print(f'Python environment: {env_str:s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c263f5d-76e6-4c43-9bfb-21ab72da518f",
   "metadata": {},
   "source": [
    "## 3. Get Python™ version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7956214b-c46d-467f-87bb-ffe9f8432bd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Python™ and JupyterLab versions:\n",
      "\n",
      "Python™ version:      3.11.7\n",
      "JupyterLab version:   4.0.11\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import jupyterlab\n",
    "\n",
    "python_version        = sys.version\n",
    "python_version_detail = python_version.split(\" | \",-1) # -1 gets all occurences. can set max number of splits\n",
    "\n",
    "print('\\nPython™ and JupyterLab versions:\\n')\n",
    "print(f'Python™ version:      {sys.version_info.major:d}.{sys.version_info.minor:d}.{sys.version_info.micro:d}')\n",
    "if len(python_version_detail) == 3:\n",
    "    print(f'Python™ installation: {python_version_detail[0]:s} {python_version_detail[1]:s}')\n",
    "    print(f'                      {python_version_detail[2]:s}')\n",
    "print(f'JupyterLab version:   {jupyterlab.__version__:s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88158e0b-7aab-4e48-915b-4d631ce6a38d",
   "metadata": {},
   "source": [
    "## 4. Package installation and verification of commonly used modules"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d4ab18-9312-4af3-8ba7-40f120054702",
   "metadata": {},
   "source": [
    "### 4.1. GeoPandas & GDAL/Python™"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "768bb1ae-4e33-4898-93cc-b3b9fd6e4ba2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "GeoPandas & GDAL/Python™:\n",
      "\n",
      "GeoPandas    version:      0.14.2\n",
      "GDAL/Python™ version:      3.6.2\n",
      "geodatasets  version:      2023.12.0\n",
      "GDAL/Python™ verification: GeoTiff projection information contains \"Polar_Stereographic\"\n",
      "GeoPandas    verification: GeoPandas GeoDataFrame has attribute \"area\":\n",
      " \n"
     ]
    },
    {
     "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>BoroCode</th>\n",
       "      <th>BoroName</th>\n",
       "      <th>Shape_Leng</th>\n",
       "      <th>Shape_Area</th>\n",
       "      <th>geometry</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5</td>\n",
       "      <td>Staten Island</td>\n",
       "      <td>330470.010332</td>\n",
       "      <td>1.623820e+09</td>\n",
       "      <td>MULTIPOLYGON (((970217.022 145643.332, 970227....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>Queens</td>\n",
       "      <td>896344.047763</td>\n",
       "      <td>3.045213e+09</td>\n",
       "      <td>MULTIPOLYGON (((1029606.077 156073.814, 102957...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Brooklyn</td>\n",
       "      <td>741080.523166</td>\n",
       "      <td>1.937479e+09</td>\n",
       "      <td>MULTIPOLYGON (((1021176.479 151374.797, 102100...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>Manhattan</td>\n",
       "      <td>359299.096471</td>\n",
       "      <td>6.364715e+08</td>\n",
       "      <td>MULTIPOLYGON (((981219.056 188655.316, 980940....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>Bronx</td>\n",
       "      <td>464392.991824</td>\n",
       "      <td>1.186925e+09</td>\n",
       "      <td>MULTIPOLYGON (((1012821.806 229228.265, 101278...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   BoroCode       BoroName     Shape_Leng    Shape_Area  \\\n",
       "0         5  Staten Island  330470.010332  1.623820e+09   \n",
       "1         4         Queens  896344.047763  3.045213e+09   \n",
       "2         3       Brooklyn  741080.523166  1.937479e+09   \n",
       "3         1      Manhattan  359299.096471  6.364715e+08   \n",
       "4         2          Bronx  464392.991824  1.186925e+09   \n",
       "\n",
       "                                            geometry  \n",
       "0  MULTIPOLYGON (((970217.022 145643.332, 970227....  \n",
       "1  MULTIPOLYGON (((1029606.077 156073.814, 102957...  \n",
       "2  MULTIPOLYGON (((1021176.479 151374.797, 102100...  \n",
       "3  MULTIPOLYGON (((981219.056 188655.316, 980940....  \n",
       "4  MULTIPOLYGON (((1012821.806 229228.265, 101278...  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Installation: conda install geopandas\n",
    "    Installation: conda install geodatasets -c conda-forge # used for testing\n",
    "\"\"\"\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", module=\"gdal\")        # suppresses all warnings from gdal module\n",
    "warnings.filterwarnings(\"ignore\", module=\"geodatasets\") # suppresses all warnings from geodatasets module\n",
    "warnings.filterwarnings(\"ignore\", module=\"paramiko\")    # suppresses all warnings from paramiko module (which would probably be sufficient)\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n",
    "PRINT_GDF = False # will be set to True if a GeoDataFrame is loaded\n",
    "\n",
    "if (ENVIRONMENT == \"Jupyterlab\" or ENVIRONMENT == \"Jupyternotbook\") and (sys.version_info.minor > 9):\n",
    "    print(\" \")\n",
    "    print(f\"WARNING: {env_str:s} and Python™ version {sys.version_info.major:d}.{sys.version_info.minor:d}:\")\n",
    "    print(f\"         GeoPandas & GDAL/Python™ installations have been verified to work with Xarray in Python™ version {sys.version_info.major:d}.{sys.version_info.minor:d}.\")\n",
    "    print(\"         For reasons that are unclear GeoPandas produces a GDAL related errror when executed from JupyterLab or \\n         Jupyter Notebook after Xarray is installed, but works fine when called from the Python™ console or Spyder.\")\n",
    "    print(f'         => Skipping GeoPandas & GDAL/Python™ verification since code is executed from {env_str:s} with Python™ version {sys.version_info.major:d}.{sys.version_info.minor:d}.')\n",
    "    PRINT_GDF = False\n",
    "    \n",
    "elif sys.version_info.minor >= 9:\n",
    "    import geodatasets\n",
    "    import geopandas\n",
    "    import geopandas as gdp\n",
    "    from   osgeo import gdal\n",
    "    from   geodatasets import get_path\n",
    "    print('\\nGeoPandas & GDAL/Python™:\\n')\n",
    "    print(f'GeoPandas    version:      {gdp.__version__:s}')\n",
    "    print(f'GDAL/Python™ version:      {gdal.__version__:s}')\n",
    "    print(f'geodatasets  version:      {geodatasets.__version__:s}')\n",
    "    \n",
    "    # verify GeoPandas\n",
    "    path_to_data = get_path(\"nybb\")\n",
    "    gdf = geopandas.read_file(path_to_data)\n",
    "    \n",
    "    # verify modules\n",
    "    f_name_geotiff = r\".\" + os.sep + \"test_data\" + os.sep + \"GEOTIFF\" + os.sep + \"IOCAM1B_2019_GR_NASA_20190506-131614.4217.tif\"\n",
    "    \n",
    "    cambot = gdal.Open(f_name_geotiff)\n",
    "    cambot_proj = cambot.GetProjection()\n",
    "    \n",
    "    if \"Polar_Stereographic\" in cambot_proj:\n",
    "        print('GDAL/Python™ verification: GeoTiff projection information contains \"Polar_Stereographic\"')\n",
    "    else:\n",
    "        print('GDAL/Python™ verification: ERROR: GeoTiff projection information could not be read')\n",
    "    \n",
    "    # verify GeoPandas\n",
    "    if hasattr(gdf, 'area'):\n",
    "      print('GeoPandas    verification: GeoPandas GeoDataFrame has attribute \"area\":')\n",
    "      PRINT_GDF = True\n",
    "    else:\n",
    "      print('GeoPandas    verification: ERROR: GeoPandas GeoDataFrame has no attribute \"area\"')\n",
    "else:\n",
    "    os.sys.exit(\"The Python™ computing environment or version are not supported. Abort.\")\n",
    "print(\" \")\n",
    "if PRINT_GDF:\n",
    "    display(gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68870a12-7304-4375-9695-9efbb9710db5",
   "metadata": {},
   "source": [
    "### 4.2. OpenCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c0399125-e85a-4d8f-8a01-2122af1b9103",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "OpenCV:\n",
      "\n",
      "OpenCV version: 4.9.0\n",
      "Test image:     3264 × 4896 pixels\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    see: https://opencv.org/get-started/\n",
    "    pip3 install opencv-python\n",
    "    -> Successfully installed opencv-python-4.9.0.80\n",
    "    TODO: unclear if .dll needs to be copied as described in link above \n",
    "\"\"\"\n",
    "import cv2 as cv2\n",
    "import pathlib\n",
    "\n",
    "if platform.system() == \"Windows\":\n",
    "    f_name_jpg = pathlib.Path(r\"./test_data/JPEG/IOCAM0_2019_GR_NASA_20190506-131614.4217.jpg\")\n",
    "elif platform.system() == 'Linux':\n",
    "    f_name_jpg = pathlib.Path(r\"./test_data/JPEG/IOCAM0_2019_GR_NASA_20190506-131614.4217.jpg\")\n",
    "\n",
    "image_bgr  = cv2.imread(str(f_name_jpg))\n",
    "# image      = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)\n",
    "img_size   = image_bgr.shape\n",
    " \n",
    "print('\\nOpenCV:\\n')\n",
    "print(f'OpenCV version: {cv2.__version__:s}')\n",
    "print(f'Test image:     {img_size[0]:d} × {img_size[1]:d} pixels')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b193f8c5-b441-479e-b669-1ad46bc06775",
   "metadata": {},
   "source": [
    "### 4.3. Pytorch, Torchvision, and Torchaudio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "72c6bd8a-cdb4-4d0f-9418-b532ea1d93bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PyTorch & TorchVision:\n",
      "\n",
      "PyTorch     version: 2.3.0\n",
      "Torchvision version: 0.18.0\n",
      "Processing  support: CUDA\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    The SAM Python™ module requires PyTorch and TorchVision. The SAM installation instructions recommend installing\n",
    "    both packages with CUDA support, however, if that causes error messages (particularly on Windows) the solution \n",
    "    is often to install both packages without CUDA support.\n",
    "\n",
    "    Recommended installation with CUDA (GPU) support:\n",
    "    > conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia\n",
    "    Installation without CUDA support (CPU only):\n",
    "    > conda install pytorch torchvision torchaudio cpuonly -c pytorch\n",
    "    To install the SAM Python™ module (see below):\n",
    "    pip install git+https://github.com/facebookresearch/segment-anything.git\n",
    "\n",
    "\"\"\"\n",
    "# verify the installation and check for CUDA support:\n",
    "import torch\n",
    "import torchvision\n",
    "\n",
    "# determine which processing unit to use\n",
    "if torch.cuda.is_available():\n",
    "    processing_unit = \"cuda\" # use graphics processing unit (GPU)\n",
    "else:    \n",
    "    processing_unit = \"cpu\"  # use central processing unit (CPU)\n",
    "    \n",
    "print('\\nPyTorch & TorchVision:\\n')\n",
    "print(f'PyTorch     version: {torch.__version__:s}')\n",
    "print(f'Torchvision version: {torchvision.__version__:s}')\n",
    "print(f'Processing  support: {processing_unit.upper():s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "606f1a5d-e5f0-45e0-8f0f-e637620fb1f1",
   "metadata": {},
   "source": [
    "### 4.4. Segment Anything Model (SAM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1cb2c4c0-13dc-4c23-9822-8b80da2f0387",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Segment Anything Model (SAM):\n",
      "Segment Anything: segment_anything module is imported and in the sys.modules dictionary\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    The SAM Python™ module requires PyTorch and TorchVision (see Section 5 above).\n",
    "    To install the SAM Python™ module use:\n",
    "    pip install git+https://github.com/facebookresearch/segment-anything.git\n",
    "\"\"\"\n",
    "import segment_anything\n",
    "    \n",
    "print('\\nSegment Anything Model (SAM):')\n",
    "\n",
    "modulename = 'segment_anything'\n",
    "if modulename not in sys.modules:\n",
    "    print(f'Segment Anything: ERROR: {modulename:s} module is unavailable')\n",
    "else:\n",
    "    print(f'Segment Anything: {modulename:s} module is imported and in the sys.modules dictionary')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "231f3bf6-569f-4340-b5a7-edc160dd9469",
   "metadata": {},
   "source": [
    "### 4.5. PYPRØJ"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af33dd4-b954-424b-ace3-f56759fab416",
   "metadata": {},
   "source": [
    "PYPRØJ is a Python™ interface to PROJ, a cartographic projections and coordinate transformations library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4566c129-7593-4ced-bac1-bf6084805109",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PYPRØJ & Shapely:\n",
      "\n",
      "PYPRØJ       version: 9.3.1\n",
      "Shapely      version: 2.0.1\n",
      "PYPRØJ  verification: projected geographic coordinates to polar stereographic\n",
      "Shapely verification: calculated buffer area around point geometry\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    PYPRØJ and shapely are installed as part of geopandas. If geopandas is not installed use:\n",
    "    pip install pyproj\n",
    "    Shapely is a Python™ package that uses the GEOS library to perform set-theoretic operations\n",
    "    on planar features. \n",
    "\"\"\"\n",
    "import pyproj\n",
    "import shapely\n",
    "import numpy as np\n",
    "from   shapely import Point\n",
    "\n",
    "# verify PYPRØJ\n",
    "# EPSG:3413 NSIDC Sea Ice Polar Stereographic North/WGS-84 used for Greenland\n",
    "# EPSG:4326 WGS84 - World Geodetic System 1984, used in GPS \n",
    "geo2xy = pyproj.Transformer.from_crs(4326,3413)\n",
    "xy2geo = pyproj.Transformer.from_crs(3413,4326)\n",
    "xy     = geo2xy.transform(70.0, -45.0)\n",
    "lonlat = xy2geo.transform(xy[0],xy[1])\n",
    "\n",
    "# verify Shapely\n",
    "patch = Point(0.0, 0.0).buffer(1.0)\n",
    "path_area = patch.area # result should be Pi\n",
    "\n",
    "print('\\nPYPRØJ & Shapely:\\n')\n",
    "print(f'PYPRØJ       version: {pyproj.proj_version_str:s}')\n",
    "print(f'Shapely      version: {shapely.__version__:s}')\n",
    "if lonlat[1] == -45:\n",
    "    print('PYPRØJ  verification: projected geographic coordinates to polar stereographic')\n",
    "if (np.isfinite(path_area)) & (path_area > 0):\n",
    "    print('Shapely verification: calculated buffer area around point geometry')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce7f6348-784a-459d-bf05-2e765c8c6d70",
   "metadata": {},
   "source": [
    "### 4.6. PyCRS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08bba4f0-adf1-4932-a111-51ebd97ca232",
   "metadata": {},
   "source": [
    "PyCRS is a pure Python GIS package for reading, writing, and converting between various common coordinate reference system (CRS) string and data source formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5c95fe6a-6d10-4efc-8565-2d25d2fbf474",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PyCRS version: 1.0.2\n"
     ]
    }
   ],
   "source": [
    "import pycrs \n",
    "print(f'\\nPyCRS version: {pycrs.__version__:s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7f5fbf9-1be1-435d-bc23-777dd99aa5d2",
   "metadata": {},
   "source": [
    "### 4.7. PyMap3D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "027c37c6-21cf-4f8c-a6ae-bf7dcde00e72",
   "metadata": {},
   "source": [
    "PyMap3D is a Python™ (optional Numpy) toolbox for 3D geographic coordinate transformations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3f68e5be-accc-49cf-8fb1-86472198d087",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PyMap3D version: 3.1.0\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    PyMap3D is a Python™ (optional Numpy) toolbox for 3D geographic coordinate transformations and geodesy.\n",
    "    It supports various coordinate systems, ellipsoids, and Vincenty functions, and has a similar syntax \n",
    "    to the MATLAB®  Mapping Toolbox.\n",
    "    Installation: conda install -c conda-forge pymap3d\n",
    "\"\"\"\n",
    "import pymap3d\n",
    "\n",
    "print(f'\\nPyMap3D version: {pymap3d.__version__:s}') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69760a17-3b72-4b03-8673-a8625cd78e58",
   "metadata": {},
   "source": [
    "### 4.8. Python™ implementation of Scientific Colour Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dedb0089-47d0-4a47-826c-ab31c1c64a08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Python™ implementation of the Scientific Colour Maps:\n",
      "cmcrameri version: 1.8\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Python™ implementation of the Scientific Colour Maps version 8.0 (2023-06-14).\n",
    "    Installation: conda install -c conda-forge cmcrameri\n",
    "\"\"\"\n",
    "import cmcrameri\n",
    "\n",
    "print('\\nPython™ implementation of the Scientific Colour Maps:')\n",
    "print(f'cmcrameri version: {cmcrameri.__version__:s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "059f9bcc-d819-4fa9-a4e7-43faa1796b77",
   "metadata": {},
   "source": [
    "### 4.9. laspy & lazrs-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6bce5ff5-9ba2-4cdc-85a1-6963b5d7a854",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "laspy version: 2.5.3\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    laspy is a Python™ module that reads and writes LAS and LAZ files, which are common formats for lidar pointcloud and full waveform data.\n",
    "    Installation: conda install -c conda-forge laspy\n",
    "    See also: https://github.com/LAStools/LAStools\n",
    "\"\"\"\n",
    "import laspy\n",
    "\n",
    "print(f'\\nlaspy version: {laspy.__version__:s}') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f56e12f0-2593-4630-86ff-e5c2f62c6e94",
   "metadata": {},
   "source": [
    "### 4.10. Xarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ec7442c2-7204-4bd3-a3e3-5d775d2f8cce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Xarray version: 2023.6.0\n"
     ]
    }
   ],
   "source": [
    "# Xarray\n",
    "\"\"\"\n",
    "    Xarray is a Python™ library that provides a common interface for working with n-dimensional arrays and datasets.\n",
    "    Installation: conda install -c conda-forge xarray dask netCDF4 bottleneck\n",
    "\"\"\"\n",
    "import xarray\n",
    "\n",
    "print(f'\\nXarray version: {xarray.__version__:s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0770bcf6-16e2-4f0a-8532-3146c5e1cc70",
   "metadata": {},
   "source": [
    "## 5.1. Extensions for JupyterLab"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c00b180-2acd-4d54-b3e7-11b8a42a0323",
   "metadata": {},
   "source": [
    "### 5.11. jupyterlab-git "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4b889919-bc9d-4994-b2d6-d90bde53281a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jupyterlab-git            0.50.0             pyhd8ed1ab_1    conda-forge\n"
     ]
    }
   ],
   "source": [
    "# jupyterlab-git\n",
    "\"\"\"\n",
    "    jupyterlab-git enables git status support from within JupyterLab.\n",
    "    Installation: conda install -c conda-forge jupyterlab-git\n",
    "\"\"\"\n",
    "if platform.system() == \"Linux\":\n",
    "    !conda list | grep jupyterlab-git\n",
    "else:\n",
    "    print('Check if jupyterlab-git is listed when running command \"conda list\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eddd01bf-6fc4-4fa5-a2d9-bd7b6a1e270b",
   "metadata": {},
   "source": [
    "### 5.12. jupyterlab-spellchecker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b3a89ba4-a914-4722-8323-b5102e9ca81d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jupyterlab-spellchecker   0.8.4              pyhd8ed1ab_0    conda-forge\n"
     ]
    }
   ],
   "source": [
    "# jupyterlab-spellchecker\n",
    "\"\"\"\n",
    "    jupyterlab-spellchecker highlights misspelled words in markdown cells within notebooks and in the text files.\n",
    "    Installation: conda install -c conda-forge jupyterlab-spellchecker\n",
    "\"\"\"\n",
    "if platform.system() == \"Linux\":\n",
    "    !conda list | grep jupyterlab-spellchecker\n",
    "else:\n",
    "    print('Check if jupyterlab-spellchecker is listed when running command \"conda list\"')\n"
   ]
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}