splink 5.0.0.dev4__tar.gz → 5.0.0.dev5__tar.gz

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/.gitignore

@@ -169,7 +169,12 @@ cython_debug/
 # html files opt-in only
 *.html
 !splink/**/templates/**/*.html
-!docs/**/*.html
+!docs/demos/examples/**/*.html
+!docs/demos/tutorials/**/*.html
+!docs/overrides/**/*.html
+
+# don't store ipynb here
+*.ipynb
 
 .DS_Store
 

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: splink
-Version: 5.0.0.dev4
+Version: 5.0.0.dev5
 Summary: Fast probabilistic data linkage at scale
 Project-URL: Homepage, https://github.com/moj-analytical-services/splink
 Project-URL: Repository, https://github.com/moj-analytical-services/splink
@@ -9,11 +9,12 @@ Author-email: Robin Linacre <robinlinacre@hotmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: <4.0.0,>=3.10.0
-Requires-Dist: altair>=5.0.1
 Requires-Dist: duckdb>=0.9.2
-Requires-Dist: igraph>=0.11.2
-Requires-Dist: jinja2>=3.0.3
 Requires-Dist: sqlglot>=17.6.0
+Provides-Extra: altair
+Requires-Dist: altair>=5.0.1; extra == 'altair'
+Provides-Extra: igraph
+Requires-Dist: igraph>=0.11.2; extra == 'igraph'
 Provides-Extra: postgres
 Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgres'
 Requires-Dist: sqlalchemy>=2.0.0; extra == 'postgres'

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "splink"
-version = "5.0.0.dev4"
+version = "5.0.0.dev5"
 description = "Fast probabilistic data linkage at scale"
 authors = [
     { name = "Robin Linacre", email = "robinlinacre@hotmail.com" },
@@ -16,12 +16,11 @@ license = "MIT"
 dependencies = [
     "duckdb>=0.9.2",
     "sqlglot>=17.6.0",
-    "altair>=5.0.1",
-    "Jinja2>=3.0.3",
-    "igraph>=0.11.2",
 ]
 
 [project.optional-dependencies]
+altair = ["altair>=5.0.1"]
+igraph = ["igraph>=0.11.2"]
 pyspark = ["pyspark>=3.5.0"]
 spark = ["pyspark>=3.5.0"]
 # sqlite doesn't _require_ this functionality, but it's used if we want to use fuzzy levels
@@ -38,14 +37,6 @@ Repository = "https://github.com/moj-analytical-services/splink"
 # allows us to easily check package functionality with just these installed
 # (and not the rest of our required dependencies)
 core = ["sqlglot", "duckdb"]
-demos = [
-    "ipywidgets>=8.1.7",
-    "jupytext>=1.18.1",
-    "nbmake>=1.5.5",
-    "pseudopeople>=1.2.6",
-    "pytest-xdist>=3.6.1",
-    { "include-group" = "pandas" },
-]
 # dev deliberately doesn't include spark, so we can opt in to different spark versions
 dev = [
     { "include-group" = "linting" },
@@ -57,6 +48,7 @@ spark-3 = [
 ]
 spark-4 = ["pyspark>=4.0.0"]
 docs = [
+    "altair>=5.0.1",
     "griffe>=1.4.0",
     # keep jinja2 relaxed so it doesn't constrain us in rest of dev
     "Jinja2>=3.1.6",
@@ -84,6 +76,7 @@ sqlite = [
     "rapidfuzz>=3.10.0",
 ]
 testing-core = [
+    "igraph>=0.11.2",
     "pytest>=7.3",
     "pyarrow>=15.0.0",
     "networkx>=2.5.1",
@@ -181,9 +174,6 @@ markers = [
 [tool.mypy]
 python_version = "3.10"
 packages = "splink"
-# for now at least allow implicit optionals
-# to cut down on noise. Easy to fix.
-implicit_optional = true
 # for now, ignore missing imports
 # can remove later and install stubs, where existent
 ignore_missing_imports = true
@@ -205,3 +195,6 @@ disallow_any_generics = true
 # disallow_untyped_calls = true
 disallow_incomplete_defs = true
 # disallow_untyped_defs = true
+
+[tool.ty.rules]
+unresolved-import = "ignore"

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/__init__.py

@@ -56,7 +56,7 @@ def __getattr__(name):
     raise AttributeError(f"module 'splink' has no attribute '{name}'") from None
 
 
-__version__ = "5.0.0.dev4"
+__version__ = "5.0.0.dev5"
 
 
 __all__ = [

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/backends/duckdb.py

@@ -2,5 +2,6 @@ from splink.internals.duckdb.database_api import DuckDBAPI
 from splink.internals.duckdb.database_api_with_profiling import (
     DuckDBAPIWithProfiling,
 )
+from splink.internals.duckdb.parquet_write_options import ParquetWriteOptions
 
-__all__ = ["DuckDBAPI", "DuckDBAPIWithProfiling"]
+__all__ = ["DuckDBAPI", "DuckDBAPIWithProfiling", "ParquetWriteOptions"]

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/accuracy.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 def truth_space_table_from_labels_with_predictions_sqls(
     threshold_actual: float = 0.5,
     match_weight_round_to_nearest: float | None = None,
-    total_labels: int = None,
+    total_labels: int | None = None,
     positives_not_captured_by_blocking_rules_scored_as_zero: bool = True,
 ) -> list[dict[str, str]]:
     """
@@ -336,7 +336,7 @@ def truth_space_table_from_labels_column(
     linker: "Linker",
     label_colname: str,
     threshold_actual: float = 0.5,
-    match_weight_round_to_nearest: float = None,
+    match_weight_round_to_nearest: float | None = None,
     positives_not_captured_by_blocking_rules_scored_as_zero: bool = True,
 ) -> SplinkDataFrame:
     # First we need to calculate the number of implicit true negatives

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/blocking_analysis.py

@@ -40,6 +40,7 @@ from splink.internals.em_sampling import (
 from splink.internals.input_column import InputColumn
 from splink.internals.misc import (
     calculate_cartesian,
+    ensure_is_list,
 )
 from splink.internals.pipeline import CTEPipeline
 from splink.internals.splink_dataframe import SplinkDataFrame
@@ -594,16 +595,13 @@ def _cumulative_comparisons_to_be_scored_from_blocking_rules(
     return counts_data
 
 
+BlockingRuleLike = BlockingRuleCreator | BlockingRule | str | dict[str, Any]
+
+
 def count_comparisons_from_blocking_rules(
     splink_dataframe_or_dataframes: SplinkDataFrame | Sequence[SplinkDataFrame],
     *,
-    blocking_rules: Union[
-        BlockingRuleCreator,
-        BlockingRule,
-        str,
-        Dict[str, Any],
-        Iterable[Union[BlockingRuleCreator, BlockingRule, str, Dict[str, Any]]],
-    ],
+    blocking_rules: BlockingRuleLike | Iterable[BlockingRuleLike],
     link_type: user_input_link_type_options,
     unique_id_column_name: str = "unique_id",
     source_dataset_column_name: Optional[str] = None,
@@ -651,14 +649,9 @@ def count_comparisons_from_blocking_rules(
     # Allow either a single blocking rule or an iterable of them.  A single rule
     # may be a dict, which is itself iterable, so we must detect the single-rule
     # types explicitly rather than relying on iterability.
-    if isinstance(blocking_rules, (str, dict, BlockingRuleCreator, BlockingRule)):
-        blocking_rules_iterable: Iterable[
-            Union[BlockingRuleCreator, BlockingRule, str, Dict[str, Any]]
-        ] = [blocking_rules]
-    else:
-        blocking_rules_iterable = list(blocking_rules)
+    blocking_rules_iterable: Iterable[BlockingRuleLike] = ensure_is_list(blocking_rules)
 
-    blocking_rules_as_br: List[BlockingRule] = []
+    blocking_rules_as_br: list[BlockingRule] = []
     for br_input in blocking_rules_iterable:
         blocking_rules_as_br.append(
             _as_blocking_rule(br_input, db_api.sql_dialect.sql_dialect_str)
@@ -686,13 +679,7 @@ def count_comparisons_from_blocking_rules(
 def chart_comparisons_from_blocking_rules(
     splink_dataframe_or_dataframes: SplinkDataFrame | Sequence[SplinkDataFrame],
     *,
-    blocking_rules: Union[
-        BlockingRuleCreator,
-        BlockingRule,
-        str,
-        Dict[str, Any],
-        Iterable[Union[BlockingRuleCreator, BlockingRule, str, Dict[str, Any]]],
-    ],
+    blocking_rules: BlockingRuleLike | Iterable[BlockingRuleLike],
     link_type: user_input_link_type_options,
     unique_id_column_name: str = "unique_id",
     source_dataset_column_name: Optional[str] = None,

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/blocking_rule_creator_utils.py

@@ -12,11 +12,12 @@ from .blocking_rule_library import CustomRule
 def to_blocking_rule_creator(
     blocking_rule_creator: Union[dict[str, Any], str, BlockingRuleCreator],
 ) -> BlockingRuleCreator:
+    if isinstance(blocking_rule_creator, BlockingRuleCreator):
+        return blocking_rule_creator
     if isinstance(blocking_rule_creator, dict):
         return CustomRule(**blocking_rule_creator)
-    if isinstance(blocking_rule_creator, str):
-        return CustomRule(blocking_rule_creator)
-    return blocking_rule_creator
+    # assume it is a string
+    return CustomRule(blocking_rule_creator)
 
 
 def blocking_rule_args_to_list_of_blocking_rules(

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/blocking_rule_library.py

@@ -12,7 +12,7 @@ from splink.internals.dialects import SplinkDialect
 def _translate_sql_string(
     sqlglot_base_dialect_sql: str,
     to_sqlglot_dialect: str,
-    from_sqlglot_dialect: str = None,
+    from_sqlglot_dialect: str | None = None,
 ) -> str:
     tree = parse_one(sqlglot_base_dialect_sql, read=from_sqlglot_dialect)
 
@@ -38,7 +38,7 @@ class CustomRule(BlockingRuleCreator):
     def __init__(
         self,
         blocking_rule: str,
-        sql_dialect: str = None,
+        sql_dialect: str | None = None,
         arrays_to_explode: list[str] | None = None,
     ):
         """
@@ -115,7 +115,8 @@ class _Merge(BlockingRuleCreator):
                 f"Must provide at least one blocking rule to {type(self)}()"
             )
         blocking_rule_creators = [
-            CustomRule(**br) if isinstance(br, dict) else br for br in blocking_rules
+            CustomRule(**br) if not isinstance(br, BlockingRuleCreator) else br
+            for br in blocking_rules
         ]
         self.blocking_rules = blocking_rule_creators
 

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/cache_dict_with_logging.py

@@ -26,14 +26,14 @@ class CacheDictWithLogging(TypedUserDict):
         # without modifying the version in the cache
         return copy(splink_dataframe)
 
-    def __setitem__(self, key, value):
-        if not isinstance(value, SplinkDataFrame):
+    def __setitem__(self, key, item):
+        if not isinstance(item, SplinkDataFrame):
             raise TypeError("Cached items must be of type SplinkDataFrame")
 
-        super().__setitem__(key, value)
+        super().__setitem__(key, item)
 
         logger.log(
-            1, f"Setting cache for {key} with physical name {value.physical_name}"
+            1, f"Setting cache for {key} with physical name {item.physical_name}"
         )
 
     def invalidate_cache(self):

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/charts.py

@@ -13,28 +13,22 @@ from typing import (
     Protocol,
     Sequence,
     TypeVar,
-    Union,
     cast,
 )
 
+from splink.internals.html_utils import chart_html, load_chart_libraries
 from splink.internals.misc import read_resource
 
 if TYPE_CHECKING:
-    from altair import SchemaBase
-
     from splink.internals.comparison_level import ComparisonLevelDetailedRecord
     from splink.internals.em_training_session import (
         ModelParameterIterationDetailedRecord,
     )
     from splink.internals.settings import ModelParameterDetailedRecord
 else:
-    SchemaBase = None
-
     ComparisonLevelDetailedRecord = None
     ModelParameterDetailedRecord = None
     ModelParameterIterationDetailedRecord = None
-# type alias:
-ChartReturnType = Union[dict[Any, Any], SchemaBase]
 
 
 def load_chart_definition(filename):
@@ -43,23 +37,7 @@ def load_chart_definition(filename):
 
 
 def _load_external_libs():
-    to_load = {
-        "vega-embed": "internals/files/external_js/vega-embed@6.20.2",
-        "vega-lite": "internals/files/external_js/vega-lite@5.2.0",
-        "vega": "internals/files/external_js/vega@5.31.0",
-    }
-    return {k: read_resource(v) for k, v in to_load.items()}
-
-
-def altair_or_json(
-    chart_dict: dict[Any, Any], as_dict: bool = False
-) -> ChartReturnType:
-    from altair import Chart
-
-    if not as_dict:
-        return Chart.from_dict(chart_dict)
-
-    return chart_dict
+    return load_chart_libraries()
 
 
 class AsDictable(Protocol):
@@ -121,7 +99,16 @@ class SplinkChart(ABC, Generic[T]):
 
     @property
     def altair_chart(self):
-        from altair import Chart
+        try:
+            from altair import Chart
+        except ModuleNotFoundError as exc:
+            if exc.name != "altair":
+                raise
+            raise ModuleNotFoundError(
+                "`altair_chart` requires the optional Altair dependency. "
+                "Notebook display and basic HTML export do not require Altair.",
+                name="altair",
+            ) from exc
 
         return Chart.from_dict(self.chart_dict)
 
@@ -152,8 +139,27 @@ class SplinkChart(ABC, Generic[T]):
         self.height = height
         # TODO: return self?
 
+    def to_html(self, *, inline: bool = False) -> str:
+        """Return a complete HTML document, with CDN or bundled (inline) libraries."""
+        return chart_html(self.chart_dict, inline=inline, fullhtml=True)
+
     def save(self, *args, **kwargs):
-        self.altair_chart.save(*args, **kwargs)
+        """Save basic HTML natively; delegate advanced requests to optional Altair."""
+        target = args[0] if args else kwargs.get("fp")
+        basic = len(args) <= 1 and not (args and "fp" in kwargs)
+        basic = basic and not (kwargs.keys() - {"fp", "format", "inline"})
+        fmt = kwargs.get("format")
+        if fmt is None and isinstance(target, (str, os.PathLike)):
+            fmt = os.path.splitext(os.fspath(target))[1][1:].lower()
+        if basic and fmt in ("html", "htm") and target is not None:
+            content = self.to_html(inline=kwargs.get("inline", False))
+            if hasattr(target, "write"):
+                target.write(content)
+            else:
+                with open(target, "w", encoding="utf-8") as stream:
+                    stream.write(content)
+            return
+        return self.altair_chart.save(*args, **kwargs)
 
     def save_offline_chart(
         self,
@@ -185,23 +191,26 @@ class SplinkChart(ABC, Generic[T]):
                 f"or set overwrite=True to overwrite."
             )
 
-        template = read_resource("internals/files/templates/single_chart_template.html")
-
-        fmt_dict = _load_external_libs()
-
-        fmt_dict["mychart"] = json.dumps(self.chart_dict)
-
         with open(filename, "w", encoding="utf-8") as f:
-            f.write(template.format(**fmt_dict))
+            f.write(self.to_html(inline=True))
 
         if print_msg:
             print(f"Chart saved to {filename}")  # noqa: T201
             print(iframe_message.format(filename=filename))  # noqa: T201
 
-    # allows rich representation of altair chart in IPython environments: https://ipython.readthedocs.io/en/stable/config/integrating.html
-    def _repr_mimebundle_(self, *args, **kwargs):
-        # let altair handle the display for us
-        return self.altair_chart._repr_mimebundle_(*args, **kwargs)
+    def _repr_mimebundle_(self, include=None, exclude=None):
+        requested = {"text/html", "text/plain"}
+        if include is not None:
+            requested.intersection_update(include)
+        requested.difference_update(exclude or ())
+        result = {}
+        if "text/plain" in requested:
+            result["text/plain"] = (
+                "SplinkChart (use .to_html() or .save() to export HTML)"
+            )
+        if "text/html" in requested:
+            result["text/html"] = chart_html(self.chart_dict)
+        return result
 
 
 class MatchWeightsChart(SplinkChart[ComparisonLevelDetailedRecord]):
@@ -702,44 +711,3 @@ class TFAdjustmentChart(SplinkChart[ChartRecord]):
         chart_spec["config"]["params"][0]["bind"]["options"] = self.tf_levels
         chart_spec["config"]["params"][0]["bind"]["labels"] = self.labels
         return chart_spec
-
-
-def _comparator_score_chart(similarity_records, distance_records, as_dict=False):
-    chart_path = "comparator_score_chart.json"
-    chart = load_chart_definition(chart_path)
-
-    chart["datasets"]["data-similarity"] = similarity_records
-    chart["datasets"]["data-distance"] = distance_records
-
-    return altair_or_json(chart, as_dict=as_dict)
-
-
-def _comparator_score_threshold_chart(
-    similarity_records,
-    distance_records,
-    similarity_threshold,
-    distance_threshold,
-    as_dict=False,
-):
-    chart_path = "comparator_score_threshold_chart.json"
-    chart = load_chart_definition(chart_path)
-
-    chart["params"][0]["value"] = similarity_threshold
-    chart["params"][1]["value"] = distance_threshold
-
-    chart["hconcat"][0]["layer"][0]["title"]["subtitle"] = f">= {similarity_threshold}"
-    chart["hconcat"][1]["layer"][0]["title"]["subtitle"] = f"<= {distance_threshold}"
-
-    chart["datasets"]["data-similarity"] = similarity_records
-    chart["datasets"]["data-distance"] = distance_records
-
-    return altair_or_json(chart, as_dict=as_dict)
-
-
-def _phonetic_match_chart(records, as_dict=False):
-    chart_path = "phonetic_match_chart.json"
-    chart = load_chart_definition(chart_path)
-
-    chart["datasets"]["data-phonetic"] = records
-
-    return altair_or_json(chart, as_dict=as_dict)

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/cluster_studio.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import json
 import os
 import random
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 from splink.internals.exceptions import SplinkException
+from splink.internals.html_utils import json_for_html, render_html_template
 from splink.internals.misc import EverythingEncoder, read_resource
 from splink.internals.pipeline import CTEPipeline
 from splink.internals.splink_dataframe import SplinkDataFrame
@@ -351,14 +351,11 @@ def render_splink_cluster_studio_html(
     sampling_method: SamplingMethods = "random",
     sample_size: int = 10,
     sample_seed: int | None = None,
-    cluster_ids: list[str] = None,
-    cluster_names: list[str] = None,
+    cluster_ids: list[str] | None = None,
+    cluster_names: list[str] | None = None,
     overwrite: bool = False,
-    _df_cluster_metrics: SplinkDataFrame = None,
+    _df_cluster_metrics: SplinkDataFrame | None = None,
 ) -> str:
-    from jinja2 import Template
-
-    bundle_observable_notebook = True
 
     svu_options = {
         "cluster_colname": "cluster_id",
@@ -380,23 +377,23 @@ def render_splink_cluster_studio_html(
     edges_recs = df_edges_as_records(linker, df_predicted_edges, df_nodes)
 
     # Render template with cluster, nodes and edges
-    template_path = "internals/files/splink_cluster_studio/cluster_template.j2"
-    template = Template(read_resource(template_path))
+    template_path = "internals/files/splink_cluster_studio/cluster_template.html"
 
     template_data: dict[str, Any] = {
-        "raw_edge_data": json.dumps(edges_recs, cls=EverythingEncoder),
-        "raw_node_data": json.dumps(nodes_recs, cls=EverythingEncoder),
-        "raw_clusters_data": json.dumps(cluster_recs, cls=EverythingEncoder),
-        "splink_settings": json.dumps(
+        "raw_edge_data": json_for_html(edges_recs, cls=EverythingEncoder),
+        "raw_node_data": json_for_html(nodes_recs, cls=EverythingEncoder),
+        "raw_clusters_data": json_for_html(cluster_recs, cls=EverythingEncoder),
+        "splink_settings": json_for_html(
             linker._settings_obj._as_completed_dict(), cls=EverythingEncoder
         ),
-        "svu_options": json.dumps(svu_options, cls=EverythingEncoder),
+        "svu_options": json_for_html(svu_options, cls=EverythingEncoder),
     }
 
+    template_data["named_clusters"] = "null"
     if cluster_names:
         named_clusters_dict = dict(zip(cluster_ids, cluster_names))
 
-        template_data["named_clusters"] = json.dumps(
+        template_data["named_clusters"] = json_for_html(
             named_clusters_dict, cls=EverythingEncoder
         )
 
@@ -411,9 +408,7 @@ def render_splink_cluster_studio_html(
     for k, v in files.items():
         template_data[k] = read_resource(v)
 
-    template_data["bundle_observable_notebook"] = bundle_observable_notebook
-
-    rendered = template.render(**template_data)
+    rendered = render_html_template(template_path, template_data)
 
     if os.path.isfile(out_path) and not overwrite:
         raise ValueError(

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/column_expression.py

@@ -17,7 +17,7 @@ from splink.internals.sql_transform import (
 
 
 class ColumnExpressionOperation(Protocol):
-    def __call__(self, name: str, sql_dialect: SplinkDialect) -> str: ...
+    def __call__(self, name: str, *, sql_dialect: SplinkDialect) -> str: ...
 
 
 class ColumnExpression:
@@ -44,7 +44,7 @@ class ColumnExpression:
     level creator into a `Linker`.
     """
 
-    def __init__(self, sql_expression: str, sql_dialect: SplinkDialect = None):
+    def __init__(self, sql_expression: str, sql_dialect: SplinkDialect | None = None):
         self.raw_sql_expression = sql_expression
         self.operations: list[ColumnExpressionOperation] = []
         if sql_dialect is not None:
@@ -233,11 +233,11 @@ class ColumnExpression:
         self,
         name: str,
         sql_dialect: SplinkDialect,
-        date_format: str = None,
+        date_format: str | None = None,
     ) -> str:
         return sql_dialect.try_parse_date(name, date_format=date_format)
 
-    def try_parse_date(self, date_format: str = None) -> "ColumnExpression":
+    def try_parse_date(self, date_format: str | None = None) -> "ColumnExpression":
         """Applies a 'try parse date' transform to the input expression.
 
         Args:
@@ -257,11 +257,13 @@ class ColumnExpression:
         self,
         name: str,
         sql_dialect: SplinkDialect,
-        timestamp_format: str = None,
+        timestamp_format: str | None = None,
     ) -> str:
         return sql_dialect.try_parse_timestamp(name, timestamp_format=timestamp_format)
 
-    def try_parse_timestamp(self, timestamp_format: str = None) -> "ColumnExpression":
+    def try_parse_timestamp(
+        self, timestamp_format: str | None = None
+    ) -> "ColumnExpression":
         """Applies a 'try parse timestamp' transform to the input expression.
 
         Args:

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/comparison.py

@@ -71,14 +71,14 @@ class Comparison:
         self,
         comparison_levels: List[ComparisonLevel | dict[str, Any]],
         sqlglot_dialect: str,
-        output_column_name: str = None,
-        comparison_description: str = None,
-        column_info_settings: ColumnInfoSettings = None,
+        output_column_name: str | None = None,
+        comparison_description: str | None = None,
+        column_info_settings: ColumnInfoSettings | None = None,
     ):
         sql_dialect = SplinkDialect.from_string(sqlglot_dialect)
         comparison_levels_as_objs: list[ComparisonLevel] = [
             ComparisonLevel(**cl, sql_dialect=sql_dialect)
-            if isinstance(cl, dict)
+            if not isinstance(cl, ComparisonLevel)
             else cl
             for cl in comparison_levels
         ]

{splink-5.0.0.dev4 → splink-5.0.0.dev5}/splink/internals/comparison_creator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union, final
+from typing import Any, List, Optional, cast, final
 
 from splink.internals.column_expression import ColumnExpression
 from splink.internals.exceptions import SplinkException
@@ -19,9 +19,7 @@ class ComparisonCreator(ABC):
 
     def __init__(
         self,
-        col_name_or_names: Union[
-            Dict[str, Union[str, ColumnExpression]], Union[str, ColumnExpression]
-        ],
+        col_name_or_names: dict[str, str | ColumnExpression] | str | ColumnExpression,
     ):
         """
         Class to author Comparisons
@@ -30,7 +28,7 @@ class ComparisonCreator(ABC):
                 Can be a single item or a dict.
         """
         # if it's not a dict, assume it is a single expression-like
-        if not isinstance(col_name_or_names, dict):
+        if isinstance(col_name_or_names, (str, ColumnExpression)):
             cols = {self.DEFAULT_COL_EXP_KEY: col_name_or_names}
         else:
             cols = col_name_or_names
@@ -80,9 +78,13 @@ class ComparisonCreator(ABC):
 
         if self.term_frequency_adjustments:
             for cl in comparison_levels:
+                # we can fix the cast with TypeIs, but requires typing_extensions
+                # before python 3.13
                 if (
                     hasattr(cl, "col_expression")
-                    and cl.col_expression.is_pure_column_or_column_reference
+                    and cast(
+                        ColumnExpression, cl.col_expression
+                    ).is_pure_column_or_column_reference
                     and cl.is_exact_match_level
                 ):
                     cl.term_frequency_adjustments = True