chore: fix docs interlinks

Author: cpcloud

docs/_quarto.yml

@@ -238,12 +238,10 @@ quartodoc:
       desc: ""
       package: ibis
       contents:
-        # # Column Selectors
+        # Column Selectors
         - selectors
 
-        # # Schemas
-        #
-        # This module contains APIs for interacting with table schemas.
+        # Schemas
         - expr.schema.Schema
 
         # # Configuration Options
@@ -252,11 +250,5 @@ quartodoc:
         - config.SQL
         - config.ContextAdjustment
 
-        # # Data Types
-        #
-        # This module contains classes for handling the different logical types that
-        # occur in databases.
-        #
-        # All data type constructors take a `nullable: bool` parameter whose default
-        # value is [`True`][True].
+        # Data types
         - expr.datatypes.core

docs/backends/impala.qmd

@@ -107,8 +107,6 @@ render_methods(
     "truncate_table",
     "get_schema",
     "cache_table",
-    "set_options",
-    "set_compression_codec",
 )
 ```
 
@@ -128,7 +126,6 @@ render_methods(
     "partition_schema",
     "partitions",
     "refresh",
-    "stats",
     "describe_formatted",
 )
 ```

docs/concepts/internals.qmd

@@ -25,7 +25,8 @@ The internals are designed to map the Ibis API to the backend.
 ## Expressions
 
 The main user-facing component of Ibis is expressions. The base class of all
-expressions in Ibis is the [ibis.expr.types.Expr][] class.
+expressions in Ibis is the
+[`Expr`](../reference/expression-generic.qmd#ibis.expr.types.core.Expr) class.
 
 Expressions provide the user facing API, most of which is defined in
 `ibis/expr/api.py`.
@@ -37,25 +38,19 @@ inputs to `ibis.expr.types.Node` subclasses. Upon construction of a `Node`
 subclass, Ibis performs validation of every input to the node based on the rule
 that was used to declare the input.
 
-Rules are defined in `ibis.expr.rules`
+Rules are defined in `ibis.expr.rules`.
 
-<!-- prettier-ignore-start -->
-### The [`Expr`][ibis.expr.types.Expr] class
-<!-- prettier-ignore-end -->
+### The [`Expr`](../reference/expression-generic.qmd#ibis.expr.types.core.Expr) class
 
 Expressions are a thin but important abstraction over operations, containing
 only type information and shape information, i.e., whether they are tables,
 columns, or scalars.
 
-<!-- prettier-ignore-start -->
 Examples of expression types include
-[`StringValue`][ibis.expr.types.StringValue] and
-[`Table`][ibis.expr.types.Table].
-<!-- prettier-ignore-end -->
+[`StringValue`](../reference/expression-strings.qmd#ibis.expr.types.strings.StringValue) and
+[`Table`](../reference/expression-tables.qmd#ibis.expr.types.relations.Table).
 
-<!-- prettier-ignore-start -->
 ### The `ibis.expr.types.Node` Class
-<!-- prettier-ignore-end -->
 
 `Node` subclasses make up the core set of operations of Ibis. Each node
 corresponds to a particular operation.

docs/posts/_metadata.yml

@@ -2,7 +2,7 @@
 
 # freeze computational output
 # (see https://quarto.org/docs/projects/code-execution.html#freeze)
-freeze: true
+freeze: auto
 
 # Enable banner style title blocks
 title-block-banner: true
@@ -11,6 +11,5 @@ title-block-banner: true
 comments:
   giscus:
     repo: ibis-project/ibis
-    theme: light
     category: Q&A
     reactions-enabled: false

ibis/backends/base/sql/__init__.py

@@ -132,10 +132,10 @@ def raw_sql(self, query: str):
         """Execute a query string and return the cursor used for execution.
 
         ::: {.callout-tip}
-        ## Consider using [`.sql`][ibis.backends.base.sql.BaseSQLBackend.sql] instead
+        ## Consider using [`.sql`](#ibis.backends.base.sql.BaseSQLBackend.sql) instead
 
         If your query is a SELECT statement, you should use the
-        [`.sql`][ibis.backends.base.sql.BaseSQLBackend.sql] method to avoid
+        [backend `.sql`](#ibis.backends.base.sql.BaseSQLBackend.sql) method to avoid
         having to release the cursor returned from this method manually.
 
         ::: {.callout-warning collapse="true"}

ibis/backends/duckdb/__init__.py

@@ -693,13 +693,15 @@ def list_tables(self, like=None, database=None):
         )
         return self._filter_with_like(tables + views + temp_views, like)
 
-    def read_postgres(self, uri, table_name: str | None = None, schema: str = "public"):
+    def read_postgres(
+        self, uri: str, table_name: str | None = None, schema: str = "public"
+    ) -> ir.Table:
         """Register a table from a postgres instance into a DuckDB table.
 
         Parameters
         ----------
         uri
-            The postgres URI in form 'postgres://user:password@host:port'
+            A postgres URI of the form `postgres://user:password@host:port`
         table_name
             The table to read
         schema

ibis/backends/impala/__init__.py

@@ -918,7 +918,7 @@ def insert(
         """Insert data into an existing table.
 
         See
-        [`ImpalaTable.insert`][ibis.backends.impala.client.ImpalaTable.insert]
+        [`ImpalaTable.insert`](../backends/impala.qmd#ibis.backends.impala.client.ImpalaTable.insert)
         for parameters.
 
         Examples

ibis/backends/pyspark/client.py

@@ -48,7 +48,7 @@ def compute_stats(self, noscan: bool = False):
 
         See Also
         --------
-        [`ibis.backends.spark.Backend.compute_stats`][ibis.backends.spark.Backend.compute_stats]
+        [`pyspark.Backend.compute_stats`](../backends/pyspark.qmd#ibis.backends.pyspark.Backend.compute_stats)
         """
         return self._client.compute_stats(self._qualified_name, noscan=noscan)
 

ibis/config.py

@@ -62,7 +62,7 @@ class SQL(Config):
     ----------
     default_limit : int | None
         Number of rows to be retrieved for a table expression without an
-        explicit limit. [`None`][None] means no limit.
+        explicit limit. [](`None`) means no limit.
     default_dialect : str
         Dialect to use for printing SQL when the backend cannot be determined.
     """
@@ -138,7 +138,7 @@ class Options(Config):
     repr : Repr
         Options controlling expression printing.
     verbose : bool
-        Run in verbose mode if [`True`][True]
+        Run in verbose mode if [](`True`)
     verbose_log: Callable[[str], None] | None
         A callable to use when logging.
     graphviz_repr : bool

ibis/expr/api.py

@@ -236,7 +236,7 @@ def schema(
     names: Iterable[str] | None = None,
     types: Iterable[str | dt.DataType] | None = None,
 ) -> sch.Schema:
-    """Validate and return a [`Schema`][ibis.expr.schema.Schema] object.
+    """Validate and return a [`Schema`](./expr.schema.Schema.qmd#ibis.expr.schema.Schema) object.
 
     Parameters
     ----------
@@ -342,10 +342,10 @@ def memtable(
         Do not depend on the underlying storage type (e.g., pyarrow.Table), it's subject
         to change across non-major releases.
     columns
-        Optional [`Iterable`][typing.Iterable] of [`str`][str] column names.
+        Optional [](`typing.Iterable`) of [](`str`) column names.
     schema
-        Optional [`Schema`][ibis.expr.schema.Schema]. The functions use `data`
-        to infer a schema if not passed.
+        Optional [`Schema`](./expr.schema.Schema.qmd#ibis.expr.schema.Schema).
+        The functions use `data` to infer a schema if not passed.
     name
         Optional name of the table.
 
@@ -586,7 +586,7 @@ def or_(*predicates: ir.BooleanValue) -> ir.BooleanValue:
 def random() -> ir.FloatingScalar:
     """Return a random floating point number in the range [0.0, 1.0).
 
-    Similar to [`random.random`][random.random] in the Python standard library.
+    Similar to [](`random.random`) in the Python standard library.
 
     Returns
     -------

ibis/expr/datatypes/core.py

@@ -89,7 +89,7 @@ def from_pyarrow(value, nullable=True):
 class DataType(Concrete, Coercible):
     """Base class for all data types.
 
-    [`DataType`][ibis.expr.datatypes.DataType] instances are immutable.
+    Instances are immutable.
     """
 
     nullable: bool = True
@@ -473,7 +473,7 @@ class Null(Primitive):
 
 @public
 class Boolean(Primitive):
-    """[`True`][True] or [`False`][False] values."""
+    """[](`True`) or [](`False`) values."""
 
     scalar = "BooleanScalar"
     column = "BooleanColumn"

ibis/expr/datatypes/parse.py

@@ -54,7 +54,7 @@ def spaceless_string(*strings: str):
 def parse(
     text: str, default_decimal_parameters: tuple[int | None, int | None] = (None, None)
 ) -> dt.DataType:
-    """Parse a type from a [`str`][str] `text`.
+    """Parse a type from a [](`str`) `text`.
 
     The default `maxsize` parameter for caching is chosen to cache the most
     commonly used types--there are about 30--along with some capacity for less

ibis/expr/datatypes/value.py

@@ -39,7 +39,7 @@ def infer(value: Any) -> dt.DataType:
 # which should trigger infer_map instead
 @infer.register(collections.OrderedDict)
 def infer_struct(value: Mapping[str, Any]) -> dt.Struct:
-    """Infer the [`Struct`][ibis.expr.datatypes.Struct] type of `value`."""
+    """Infer the [`Struct`](./expr.datatypes.core.qmd#ibis.expr.datatypes.Struct) type of `value`."""
     if not value:
         raise TypeError("Empty struct type not supported")
     fields = {name: infer(val) for name, val in value.items()}
@@ -48,7 +48,7 @@ def infer_struct(value: Mapping[str, Any]) -> dt.Struct:
 
 @infer.register(collections.abc.Mapping)
 def infer_map(value: Mapping[Any, Any]) -> dt.Map:
-    """Infer the [`Map`][ibis.expr.datatypes.Map] type of `value`."""
+    """Infer the [`Map`](./expr.datatypes.core.qmd#ibis.expr.datatypes.Map) type of `value`."""
     if not value:
         return dt.Map(dt.null, dt.null)
     try:
@@ -62,7 +62,7 @@ def infer_map(value: Mapping[Any, Any]) -> dt.Map:
 
 @infer.register((list, tuple, set, frozenset))
 def infer_list(values: Sequence[Any]) -> dt.Array:
-    """Infer the [`Array`][ibis.expr.datatypes.Array] type of `value`."""
+    """Infer the [`Array`](./expr.datatypes.core.qmd#ibis.expr.datatypes.Array) type of `value`."""
     if not values:
         return dt.Array(dt.null)
     return dt.Array(highest_precedence(map(infer, values)))
@@ -140,7 +140,7 @@ def infer_enum(_: enum.Enum) -> dt.String:
 
 @infer.register(decimal.Decimal)
 def infer_decimal(value: decimal.Decimal) -> dt.Decimal:
-    """Infer the [`Decimal`][ibis.expr.datatypes.Decimal] type of `value`."""
+    """Infer the [`Decimal`](./expr.datatypes.core.qmd#ibis.expr.datatypes.Decimal) type of `value`."""
     return dt.decimal
 
 

ibis/expr/schema.py

@@ -20,8 +20,9 @@ class Schema(Concrete, Coercible, MapSet):
     """An object for holding table schema information."""
 
     fields: FrozenDict[str, dt.DataType]
-    """A mapping of [`str`][str] to [`DataType`][ibis.expr.datatypes.DataType] objects
-    representing the type of each column."""
+    """A mapping of [](`str`) to
+    [`DataType`](./expr.datatypes.core.qmd#ibis.expr.datatypes.DataType)
+    objects representing the type of each column."""
 
     def __repr__(self) -> str:
         space = 2 + max(map(len, self.names), default=0)

ibis/expr/types/arrays.py

@@ -64,10 +64,10 @@ def __getitem__(self, index: int | ir.IntegerValue | slice) -> ir.Value:
         Returns
         -------
         Value
-            - If `index` is an [`int`][int] or
-              [`IntegerValue`][ibis.expr.types.IntegerValue] then the return
-              type is the element type of `self`.
-            - If `index` is a [`slice`][slice] then the return type is the same
+            - If `index` is an [](`int`) or
+              [`IntegerValue`](./expression-numeric.qmd#ibis.expr.types.IntegerValue)
+              then the return type is the element type of `self`.
+            - If `index` is a [](`slice`) then the return type is the same
               type as the input.
 
         Examples
@@ -351,7 +351,7 @@ def join(self, sep: str | ir.StringValue) -> ir.StringValue:
 
         See Also
         --------
-        [`StringValue.join`][ibis.expr.types.strings.StringValue.join]
+        [`StringValue.join`](./expression-strings.qmd#ibis.expr.types.strings.StringValue.join)
         """
         return ops.ArrayStringJoin(sep, self).to_expr()
 

ibis/expr/types/core.py

@@ -171,7 +171,7 @@ def visualize(
         label_edges
             Show operation input names as edge labels
         verbose
-            Print the graphviz DOT code to stderr if [`True`][True]
+            Print the graphviz DOT code to stderr if [](`True`)
 
         Raises
         ------
@@ -260,10 +260,10 @@ def _find_backend(self, *, use_default: bool = False) -> BaseBackend:
         Parameters
         ----------
         use_default
-            If [`True`][True] and the default backend isn't set, initialize the
+            If [](`True`) and the default backend isn't set, initialize the
             default backend and use that. This should only be set to `True` for
             `.execute()`. For other contexts such as compilation, this option
-            doesn't make sense so the default value is [`False`][False].
+            doesn't make sense so the default value is [](`False`).
 
         Returns
         -------
@@ -566,8 +566,7 @@ def _binop(op_class: type[ops.Binary], left: ir.Value, right: ir.Value) -> ir.Va
     Parameters
     ----------
     op_class
-        The [`Binary`][ibis.expr.operations.Binary] subclass for the
-        operation
+        The `ops.Binary` subclass for the operation
     left
         Left operand
     right

ibis/expr/types/generic.py

@@ -906,7 +906,7 @@ def to_pandas(self, **kwargs) -> pd.Series:
         Parameters
         ----------
         kwargs
-            Same as keyword arguments to [`execute`][ibis.expr.types.core.Expr.execute]
+            Same as keyword arguments to [`execute`](#ibis.expr.types.core.Expr.execute)
 
         Examples
         --------
@@ -1626,9 +1626,9 @@ def literal(value: Any, type: dt.DataType | str | None = None) -> Scalar:
     Ibis supports literal construction of arrays using the following
     functions:
 
-    1. [`ibis.array`][ibis.array]
-    1. [`ibis.struct`][ibis.struct]
-    1. [`ibis.map`][ibis.map]
+    1. [`ibis.array`](./expression-collections.qmd#ibis.array)
+    1. [`ibis.struct`](./expression-collections.qmd#ibis.struct)
+    1. [`ibis.map`](./expression-collections.qmd#ibis.map)
 
     Constructing these types using `literal` will be deprecated in a future
     release.
@@ -1639,7 +1639,7 @@ def literal(value: Any, type: dt.DataType | str | None = None) -> Scalar:
     value
         A Python value
     type
-        An instance of [`DataType`][ibis.expr.datatypes.DataType] or a string
+        An instance of [`DataType`](./expr.datatypes.core.qmd#ibis.expr.datatypes.DataType) or a string
         indicating the ibis type of `value`. This parameter can be used
         in cases where ibis's type inference isn't sufficient for discovering
         the type of `value`.

ibis/expr/types/groupby.py

@@ -215,7 +215,7 @@ def select(self, *exprs, **kwexprs) -> ir.Table:
 
         See Also
         --------
-        [`GroupedTable.mutate`][ibis.expr.types.groupby.GroupedTable.mutate]
+        [`GroupedTable.mutate`](#ibis.expr.types.groupby.GroupedTable.mutate)
         """
         exprs = self._selectables(*exprs, **kwexprs)
         return self.table.select(exprs)
@@ -225,7 +225,7 @@ def _selectables(self, *exprs, **kwexprs):
 
         See Also
         --------
-        [`GroupedTable.mutate`][ibis.expr.types.groupby.GroupedTable.mutate]
+        [`GroupedTable.mutate`](#ibis.expr.types.groupby.GroupedTable.mutate)
         """
         table = self.table
         default_frame = self._get_window()