fix intersphinx config, use intersphinx to fix broken links in comp patterns

Author: scottyhq

_config.yml

@@ -91,23 +91,23 @@ sphinx:
 
     intersphinx_mapping:
       xarray:
-        - https://docs.xarray.dev/en/latest/
+        - https://docs.xarray.dev/en/stable
         - null
       numpy:
         - https://numpy.org/doc/stable
         - null
+      pandas:
+        - https://pandas.pydata.org/docs
+        - null
       scipy:
         - https://docs.scipy.org/doc/scipy
         - null
-      matplotlib:
-        - https://matplotlib.org/stable/
+      python:
+        - https://docs.python.org/3
         - null
       dask:
-        - https://docs.dask.org/en/latest
+        - https://docs.dask.org/en/stable
         - null
-      python:
-        - https://docs.python.org/3/
-        - null
-      pandas:
-        - https://pandas.pydata.org/pandas-docs/stable
+      matplotlib:
+        - https://matplotlib.org/stable
         - null

intermediate/01-high-level-computation-patterns.ipynb

@@ -79,16 +79,16 @@
     "\n",
     "Xarray provides methods for high-level analysis patterns:\n",
     "\n",
-    "1. `rolling` :\n",
-    "   [Operate on rolling or sliding (fixed length, overlapping) windows of your data e.g. running mean.](https://docs.xarray.dev/en/stable/user-guide/computation.html#rolling-window-operations)\n",
-    "1. `coarsen` :\n",
-    "   [Operate on blocks (fixed length) of your data (downsample).](https://docs.xarray.dev/en/stable/user-guide/computation.html#coarsen-large-arrays)\n",
-    "1. `groupby` :\n",
-    "   [Parse data into groups (using an exact value) and operate on each one (reduce data).](https://docs.xarray.dev/en/stable/groupby.html)\n",
-    "1. `groupby_bins`: [GroupBy after discretizing a numeric (non-exact, e.g. float) variable.](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.groupby_bins.html)\n",
-    "1. `resample` :\n",
-    "   [Groupby specialized for time axes. Either downsample or upsample your data.](https://docs.xarray.dev/en/stable/user-guide/time-series.html#resampling-and-grouped-operations)\n",
-    "1. `weighted`: [Weight your data before reducing.](https://docs.xarray.dev/en/stable/user-guide/computation.html#weighted-array-reductions) \n",
+    "1. [`rolling`](<inv:xarray#*rolling-window-operations>) :\n",
+    "   Operate on rolling or sliding (fixed length, overlapping) windows of your data e.g. running mean.\n",
+    "1. [`coarsen`](<inv:xarray#*coarsen-large-arrays>) :\n",
+    "   Operate on blocks (fixed length) of your data (downsample).\n",
+    "1. [`groupby`](<inv:xarray:py:method:#*.DataArray.groupby>) :\n",
+    "   Parse data into groups (using an exact value) and operate on each one (reduce data).\n",
+    "1. [`groupby_bins`](<inv:xarray:py:method:#*.DataArray.groupby_bins>): GroupBy after discretizing a numeric (non-exact, e.g. float) variable.\n",
+    "1. [`resample`](<inv:xarray#*resampling-and-grouped-operations>) :\n",
+    "   [Groupby specialized for time axes. Either downsample or upsample your data.]\n",
+    "1. [`weighted`](<inv:xarray#*weighted-array-reductions>): Weight your data before reducing.\n",
     "\n",
     "\n",
     "```{note}\n",
@@ -352,21 +352,21 @@
     "\n",
     "These are sequential windowed operations with a window of a fixed size.\n",
     "\n",
-    "1. `rolling` :\n",
-    "   [Operate on rolling or sliding (fixed length, overlapping) windows of your data e.g. running mean.](https://docs.xarray.dev/en/stable/user-guide/computation.html#rolling-window-operations)\n",
-    "1. `coarsen` :\n",
-    "   [Operate on blocks (fixed length) of your data (downsample).](https://docs.xarray.dev/en/stable/user-guide/computation.html#coarsen-large-arrays)\n",
+    "1. [`rolling`](<inv:xarray#*rolling-window-operations>) :\n",
+    "   Operate on rolling or sliding (fixed length, overlapping) windows of your data e.g. running mean.\n",
+    "1. [`coarsen`](<inv:xarray#*coarsen-large-arrays>) :\n",
+    "   Operate on blocks (fixed length) of your data (downsample).\n",
     "\n",
     "\n",
     "### Label space\n",
     "\n",
     "These are windowed operations with irregular windows based on your data. Members of a single group may be non-sequential and scattered through the dataset.\n",
     "\n",
-    "1. `groupby` :\n",
-    "   [Parse data into groups (using an exact value) and operate on each one (reduce data).](https://docs.xarray.dev/en/stable/groupby.html)\n",
-    "1. `groupby_bins`: [GroupBy after discretizing a numeric (non-exact, e.g. float) variable.](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.groupby_bins.html)\n",
-    "1. `resample` :\n",
-    "   [Groupby specialized for time axes. Either downsample or upsample your data.](https://docs.xarray.dev/en/stable/user-guide/time-series.html#resampling-and-grouped-operations)\n"
+    "1. [`groupby`](<inv:xarray:py:method:#*.DataArray.groupby>) :\n",
+    "   Parse data into groups (using an exact value) and operate on each one (reduce data).\n",
+    "1. [`groupby_bins`](<inv:xarray:py:method:#*.DataArray.groupby_bins> ): GroupBy after discretizing a numeric (non-exact, e.g. float) variable.\n",
+    "1. [`resample`](<inv:xarray#*resampling-and-grouped-operations>) :\n",
+    "   Groupby specialized for time axes. Either downsample or upsample your data.\n"
    ]
   },
   {
@@ -385,7 +385,7 @@
     "\n",
     "## Index space: windows of fixed width\n",
     "\n",
-    "### Sliding windows of fixed length: [`rolling`](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.rolling.html)\n",
+    "### Sliding windows of fixed length: [`rolling`](<inv:xarray:py:method:#*.DataArray.rolling>)\n",
     "\n",
     "- Supports common reductions : `sum`, `mean`, `count`, `std`, `var` etc.\n",
     "- Returns object of same shape as input\n",
@@ -435,11 +435,11 @@
    "source": [
     "#### Apply an existing numpy-only function with `reduce`\n",
     "\n",
-    "In some cases, we may want to apply a sliding window function using rolling that is not built in to Xarray. In these cases we can still leverage the sliding windows of rolling and apply our own function with [`reduce`](https://docs.xarray.dev/en/stable/generated/xarray.core.rolling.DataArrayRolling.reduce.html).\n",
+    "In some cases, we may want to apply a sliding window function using rolling that is not built in to Xarray. In these cases we can still leverage the sliding windows of rolling and apply our own function with [`reduce`](<inv:xarray:py:method:#*.DataArrayRolling.reduce>).\n",
     "\n",
     "The `reduce` method on Xarray objects (e.g. DataArray, Dataset) expects a function that can *receive and return plain arrays (e.g. numpy)*, as in each of the \"windows\" provided by the rolling iterator. This is in contrast to the `map` method on DataArray and Dataset objects, which expects a function that can receive and return Xarray objects.\n",
     "\n",
-    "Here's an example function: [`np.ptp`](https://numpy.org/doc/stable/reference/generated/numpy.ptp.html).\n"
+    "Here's an example function: [`np.ptp`](<inv:numpy:py:function:#*numpy.ptp>).\n"
    ]
   },
   {
@@ -461,7 +461,7 @@
     ":class: tip\n",
     "\n",
     "Calculate the rolling mean in 5 point bins along both latitude and longitude using\n",
-    "[`rolling(...).reduce`](https://docs.xarray.dev/en/stable/generated/xarray.core.rolling.DataArrayRolling.reduce.html)\n",
+    "[`rolling(...).reduce`](<inv:xarray:py:method:#*.DataArrayRolling.reduce>)\n",
     "\n",
     ":::{admonition} Solution\n",
     ":class: dropdown\n",
@@ -486,7 +486,7 @@
    "source": [
     "#### View the `rolling` operation as a Xarray object with `construct`\n",
     "\n",
-    "In the above examples, we plotted the outputs of our rolling operations. Xarray makes it easy to integrate the outputs from `rolling` directly into the DataArray using the [`construct`](https://docs.xarray.dev/en/stable/generated/xarray.core.rolling.DataArrayRolling.construct.html#xarray.core.rolling.DataArrayRolling.construct) method."
+    "In the above examples, we plotted the outputs of our rolling operations. Xarray makes it easy to integrate the outputs from `rolling` directly into the DataArray using the <inv:xarray:py:method:#*.DataArrayRolling.construct> method.\n"
    ]
   },
   {
@@ -588,7 +588,7 @@
     "\n",
     "### Block windows of fixed length: `coarsen`\n",
     "\n",
-    "For non-overlapping windows or \"blocks\" use [`coarsen`](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.coarsen.html). The syntax is very similar to `rolling`. You will need to specify how you want Xarray to handle the `boundary` if the length of the dimension is not a multiple of the block size.\n",
+    "For non-overlapping windows or \"blocks\" use [`coarsen`](<inv:xarray:py:method:#*.DataArray.coarsen>). The syntax is very similar to `rolling`. You will need to specify how you want Xarray to handle the `boundary` if the length of the dimension is not a multiple of the block size.\n",
     "\n",
     "\n",
     "- Supports common reductions : `sum`, `mean`, `count`, `std`, `var` etc.\n",
@@ -759,7 +759,7 @@
    "metadata": {},
    "source": [
     "Note that `coarsen` pads with NaNs. For more control over padding, use\n",
-    "[DataArray.pad](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.pad.html) explicitly."
+    "[DataArray.pad](<inv:xarray:py:method:#*.DataArray.pad>) explicitly."
    ]
   },
   {
@@ -910,8 +910,7 @@
     "1. *Combine* : concatenate results from apply step along a new \"group\" dimension\n",
     "\n",
     "illustrated in this neat schematic from [Project Pythia](https://foundations.projectpythia.org/core/xarray/computation-masking.html#groupby-split-apply-combine):\n",
-    "<img src=\"https://foundations.projectpythia.org/_images/xarray-split-apply-combine.jpeg\" width=30%>\n",
-    "\n",
+    "<img src=\"https://raw.githubusercontent.com/ProjectPythia/pythia-foundations/refs/heads/main/core/xarray/images/xarray-split-apply-combine.jpeg\" width=30%>\n",
     "\n",
     "But really there is a \"hidden\" first step: *identifying* groups (also called \"factorization\" or sometimes \"binning\"). Usually this is the hard part.\n",
     "\n",
@@ -1036,23 +1035,22 @@
     "\n",
     "If the automatic group detection doesn't work for your problem then these functions are useful for constructing specific \"group labels\" in many cases\n",
     "\n",
-    "1. [numpy.digitize](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html)\n",
+    "1. [numpy.digitize](<inv:numpy:py:function:#*numpy.digitize>)\n",
     "   for binning\n",
-    "1. [numpy.searchsorted](https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html)\n",
+    "1. [numpy.searchsorted](<inv:numpy:py:function:#*numpy.searchsorted>)\n",
     "   supports many other data types\n",
-    "1. [pandas.factorize](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.factorize.html)\n",
+    "1. [pandas.factorize](<inv:pandas:py:function:#*pandas.factorize>)\n",
     "   supports characters, strings etc.\n",
-    "1. [pandas.cut](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.cut.html)\n",
+    "1. [pandas.cut](<inv:pandas:py:function:#*pandas.cut>)\n",
     "   for binning\n",
-    "1. [\"Datetime components\"](https://docs.xarray.dev/en/stable/user-guide/time-series.html#datetime-components)  of Xarray DataArrays\n",
-    "1. [DataArray.isin](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.isin.html)\n",
-    "1. [scipy.ndimage.label](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.label.html)\n",
+    "1. [\"Datetime components\"](<inv:xarray#*indexing-using-datetime-components>) of Xarray DataArrays\n",
+    "1. [DataArray.isin](<inv:xarray:py:method:#*.DataArray.isin>)\n",
+    "1. [scipy.ndimage.label](<inv:scipy:py:function:#*scipy.ndimage.label>)\n",
     "1. Do you know of any more? (Send in a pull request to update this list!)\n",
     "\n",
     "\n",
-    "\n",
     "```{tip}\n",
-    "Xarray uses [`pandas.factorize`](https://pandas.pydata.org/docs/reference/api/pandas.factorize.html) for `groupby` and [`pandas.cut`](https://pandas.pydata.org/docs/reference/api/pandas.cut.html) for `groupby_bins`.\n",
+    "Xarray uses `pandas.factorize` for `groupby` and `pandas.cut` for `groupby_bins`.\n",
     "```"
    ]
   },
@@ -1066,10 +1064,9 @@
     "tags": []
    },
    "source": [
-    "#### [\"Datetime components\"](https://docs.xarray.dev/en/stable/user-guide/time-series.html#datetime-components) for creating groups\n",
+    "#### \"Datetime components\" for creating groups\n",
     "\n",
-    "See a full list\n",
-    "[here](https://docs.xarray.dev/en/stable/generated/xarray.core.accessor_dt.DatetimeAccessor.html?highlight=DatetimeAccessor)\n",
+    "See a full list [here](<inv:xarray:py:class#*DatetimeAccessor>)\n",
     "\n",
     "These can be accessed in a few different ways as illustrated below.\n"
    ]
@@ -1229,7 +1226,7 @@
    "source": [
     "##### `floor`, `ceil` and `round` on time\n",
     "\n",
-    "Additional functionality in the [datetime accessor](https://docs.xarray.dev/en/stable/generated/xarray.core.accessor_dt.DatetimeAccessor.html) allows us to effectively \"resample\" our time data to remove roundoff errors in timestamps.\n"
+    "Additional functionality in the [datetime accessor](<inv:xarray:py:class#*DatetimeAccessor>) allows us to effectively \"resample\" our time data to remove roundoff errors in timestamps.\n"
    ]
   },
   {
@@ -1449,16 +1446,16 @@
     "\n",
     "Xarray provides methods for high-level analysis patterns:\n",
     "\n",
-    "1. `rolling` :\n",
-    "   [Operate on rolling (fixed length, overlapping) windows of your data e.g. running mean.](https://docs.xarray.dev/en/stable/user-guide/computation.html#rolling-window-operations)\n",
-    "1. `coarsen` :\n",
-    "   [Operate on blocks (fixed length) of your data (downsample).](https://docs.xarray.dev/en/stable/user-guide/computation.html#coarsen-large-arrays)\n",
-    "1. `groupby` :\n",
-    "   [Parse data into groups (using an exact value) and operate on each one (reduce data).](https://docs.xarray.dev/en/stable/groupby.html)\n",
-    "1. `groupby_bins`: [GroupBy after discretizing a numeric (non-exact, e.g. float) variable.](https://docs.xarray.dev/en/stable/generated/xarray.DataArray.groupby_bins.html)\n",
-    "1. `resample` :\n",
-    "   [Groupby specialized for time axes. Either downsample or upsample your data.](https://docs.xarray.dev/en/stable/user-guide/time-series.html#resampling-and-grouped-operations)\n",
-    "1. `weighted`: [Weight your data before reducing.](https://docs.xarray.dev/en/stable/user-guide/computation.html#weighted-array-reductions)\n",
+    "1. [`rolling`](<inv:xarray#*rolling-window-operations>) :\n",
+    "   Operate on rolling or sliding (fixed length, overlapping) windows of your data e.g. running mean.\n",
+    "1. [`coarsen`](<inv:xarray#*coarsen-large-arrays>) :\n",
+    "   Operate on blocks (fixed length) of your data (downsample).\n",
+    "1. [`groupby`](<inv:xarray:py:method:#*.DataArray.groupby>) :\n",
+    "   Parse data into groups (using an exact value) and operate on each one (reduce data).\n",
+    "1. [`groupby_bins`](<inv:xarray:py:method:#*.DataArray.groupby_bins>): GroupBy after discretizing a numeric (non-exact, e.g. float) variable.\n",
+    "1. [`resample`](<inv:xarray#*resampling-and-grouped-operations>) :\n",
+    "   [Groupby specialized for time axes. Either downsample or upsample your data.]\n",
+    "1. [`weighted`](<inv:xarray#*weighted-array-reductions>): Weight your data before reducing.\n",
     "\n",
     "Xarray also provides a consistent interface to make using those patterns easy:\n",
     "\n",