diff --git a/skops/card/_model_card.py b/skops/card/_model_card.py
index c978e670..2d0d64ee 100644
--- a/skops/card/_model_card.py
+++ b/skops/card/_model_card.py
@@ -5,6 +5,7 @@
 import re
 import shutil
 import tempfile
+import joblib
 from dataclasses import dataclass
 from pathlib import Path
 from reprlib import Repr
@@ -15,6 +16,7 @@
 from tabulate import tabulate  # type: ignore
 
 import skops
+from skops.io import load
 
 # Repr attributes can be used to control the behavior of repr
 aRepr = Repr()
@@ -25,7 +27,10 @@
 def wrap_as_details(text: str, folded: bool) -> str:
     if not folded:
         return text
-    return f"<details>\n<summary> Click to expand </summary>\n\n{text}\n\n</details>"
+    return (
+        "<details>\n<summary> Click to expand"
+        f" </summary>\n\n{text}\n\n</details>"
+    )
 
 
 def _clean_table(table: str) -> str:
@@ -92,7 +97,9 @@ def format(self) -> str:
             headers = self.table.keys()
 
         table = _clean_table(
-            tabulate(self.table, tablefmt="github", headers=headers, showindex=False)
+            tabulate(
+                self.table, tablefmt="github", headers=headers, showindex=False
+            )
         )
         return wrap_as_details(table, folded=self.folded)
 
@@ -150,7 +157,9 @@ def metadata_from_config(config_path: Union[str, Path]) -> CardData:
     task = config.get("sklearn", {}).get("task", None)
     if task:
         card_data.tags += [task]
-    card_data.model_file = config.get("sklearn", {}).get("model", {}).get("file")
+    card_data.model_file = (
+        config.get("sklearn", {}).get("model", {}).get("file")
+    )
     example_input = config.get("sklearn", {}).get("example_input", None)
     # Documentation on what the widget expects:
     # https://huggingface.co/docs/hub/models-widgets-examples
@@ -172,7 +181,7 @@ class Card:
 
     Parameters
     ----------
-    model: estimator object
+    model: pathlib.path, str, or sklearn estimator object
         Model that will be documented.
 
     model_diagram: bool, default=True
@@ -254,7 +263,7 @@ def __init__(
         model_diagram: bool = True,
         metadata: Optional[CardData] = None,
     ) -> None:
-        self.model = model
+        self._model = model
         self.model_diagram = model_diagram
         self._eval_results = {}  # type: ignore
         self._template_sections: dict[str, str] = {}
@@ -302,11 +311,15 @@ def add_plot(self, folded=False, **kwargs: str) -> "Card":
             Card object.
         """
         for plot_name, plot_path in kwargs.items():
-            section = PlotSection(alt_text=plot_name, path=plot_path, folded=folded)
+            section = PlotSection(
+                alt_text=plot_name, path=plot_path, folded=folded
+            )
             self._extra_sections.append((plot_name, section))
         return self
 
-    def add_table(self, folded: bool = False, **kwargs: dict["str", list[Any]]) -> Card:
+    def add_table(
+        self, folded: bool = False, **kwargs: dict["str", list[Any]]
+    ) -> Card:
         """Add a table to the model card.
 
         Add a table to the model card. This can be especially useful when you
@@ -373,6 +386,56 @@ def add_metrics(self, **kwargs: str) -> "Card":
             self._eval_results[metric] = value
         return self
 
+    @property
+    def model(self):
+        model = self._load_model(self._model)
+        if model is not self._model:
+            self._model = model
+        return model
+
+    @model.setter
+    def model(self, model):
+        self._model = model
+
+    @model.deleter
+    def model(self):
+        del self._model
+
+    def _load_model(self, model: Any) -> Any:
+        """Loads the model if provided a file path, if already a model instance,
+        return it unmodified.
+
+        Parameters
+        ----------
+        model : pathlib.path, str, or sklearn estimator
+            Path/str or the actual model instance. If a Path or str, loads the model on first call.
+
+        Returns
+        -------
+        model : object
+            Model instance.
+
+        """
+        if not isinstance(model, (Path, str)):
+            return model
+
+        model_path = Path(model)
+        if not model_path.exists():
+            raise ValueError("Model file does not exist")
+
+        if model_path.suffix in (".pkl", ".pickle"):
+            model = joblib.load(model_path)
+        elif model_path.suffix == ".skops":
+            model = load(model_path)
+        else:
+            msg = (
+                f"Cannot interpret model suffix {model_path.suffix}, should be"
+                " '.pkl', '.pickle' or '.skops'"
+            )
+            raise ValueError(msg)
+
+        return model
+
     def _generate_card(self) -> ModelCard:
         """Generate the ModelCard object
 
@@ -403,18 +466,23 @@ def _generate_card(self) -> ModelCard:
                     )
                 else:
                     template_sections["get_started_code"] = (
-                        "import joblib\nimport json\nimport pandas as pd\nclf ="
-                        f' joblib.load({model_file})\nwith open("config.json") as'
+                        "import joblib\nimport json\nimport pandas as"
+                        " pd\nclf ="
+                        f" joblib.load({model_file})\nwith"
+                        ' open("config.json") as'
                         " f:\n   "
                         " config ="
                         " json.load(f)\n"
                         'clf.predict(pd.DataFrame.from_dict(config["sklearn"]["example_input"]))'
                     )
         if self.model_diagram is True:
-            model_plot_div = re.sub(r"\n\s+", "", str(estimator_html_repr(self.model)))
+            model_plot_div = re.sub(
+                r"\n\s+", "", str(estimator_html_repr(self.model))
+            )
             if model_plot_div.count("sk-top-container") == 1:
                 model_plot_div = model_plot_div.replace(
-                    "sk-top-container", 'sk-top-container" style="overflow: auto;'
+                    "sk-top-container",
+                    'sk-top-container" style="overflow: auto;',
                 )
             model_plot: str | None = model_plot_div
         else:
@@ -439,7 +507,9 @@ def _generate_card(self) -> ModelCard:
                 f"{tmpdirname}/temporary_template.md",
             )
             #  create a temporary template with the additional plots
-            template_sections["template_path"] = f"{tmpdirname}/temporary_template.md"
+            template_sections[
+                "template_path"
+            ] = f"{tmpdirname}/temporary_template.md"
             # add extra sections at the end of the template
             with open(template_sections["template_path"], "a") as template:
                 if self._extra_sections:
@@ -520,13 +590,17 @@ def __repr__(self) -> str:
         model = getattr(self, "model", None)
         if model:
             model_str = self._strip_blank(repr(model))
-            model_repr = aRepr.repr(f"  model={model_str},").strip('"').strip("'")
+            model_repr = (
+                aRepr.repr(f"  model={model_str},").strip('"').strip("'")
+            )
         else:
             model_repr = None
 
         # metadata
         metadata_reprs = []
-        for key, val in self.metadata.to_dict().items() if self.metadata else {}:
+        for key, val in (
+            self.metadata.to_dict().items() if self.metadata else {}
+        ):
             if key == "widget":
                 metadata_reprs.append("  metadata.widget={...},")
                 continue
@@ -540,14 +614,18 @@ def __repr__(self) -> str:
         template_reprs = []
         for key, val in self._template_sections.items():
             val = self._strip_blank(repr(val))
-            template_reprs.append(aRepr.repr(f"  {key}={val},").strip('"').strip("'"))
+            template_reprs.append(
+                aRepr.repr(f"  {key}={val},").strip('"').strip("'")
+            )
         template_repr = "\n".join(template_reprs)
 
         # figures
         figure_reprs = []
         for key, val in self._extra_sections:
             val = self._strip_blank(repr(val))
-            figure_reprs.append(aRepr.repr(f"  {key}={val},").strip('"').strip("'"))
+            figure_reprs.append(
+                aRepr.repr(f"  {key}={val},").strip('"').strip("'")
+            )
         figure_repr = "\n".join(figure_reprs)
 
         complete_repr = "Card(\n"
diff --git a/skops/card/tests/test_card.py b/skops/card/tests/test_card.py
index e2ed4596..a92ebe47 100644
--- a/skops/card/tests/test_card.py
+++ b/skops/card/tests/test_card.py
@@ -33,6 +33,19 @@ def model_card(model_diagram=True):
     yield card
 
 
+@pytest.fixture
+def model_card_from_path(suffix, model_diagram=True):
+    model = fit_model()
+    save_file = tempfile.mkstemp(suffix=suffix, prefix="skops-test")[1]
+    if suffix in (".pkl", ".pickle"):
+        with open(save_file, "wb") as f:
+            pickle.dump(model, f)
+    elif suffix == ".skops":
+        dump(model, save_file)
+    card = Card(save_file, model_diagram)
+    yield card
+
+
 @pytest.fixture
 def iris_data():
     X, y = load_iris(return_X_y=True, as_frame=True)
@@ -82,6 +95,24 @@ def _create_model_card_from_saved_model(
     return card
 
 
+def _create_model_card_from_model_path(
+    destination_path,
+    iris_data,
+    save_file,
+):
+    X, y = iris_data
+    hub_utils.init(
+        model=save_file,
+        requirements=[f"scikit-learn=={sklearn.__version__}"],
+        dst=destination_path,
+        task="tabular-classification",
+        data=X,
+    )
+    card = Card(save_file, metadata=metadata_from_config(destination_path))
+    card.save(Path(destination_path) / "README.md")
+    return card
+
+
 @pytest.fixture
 def skops_model_card_metadata_from_config(
     destination_path, iris_estimator, iris_skops_file, iris_data
@@ -100,6 +131,22 @@ def pkl_model_card_metadata_from_config(
     )
 
 
+@pytest.fixture
+def skops_model_card_from_path_metadata_from_config(
+    destination_path, iris_skops_file, iris_data
+):
+    yield _create_model_card_from_model_path(
+        destination_path, iris_data, iris_skops_file
+    )
+
+
+@pytest.fixture
+def pkl_model_card_from_path_metadata_from_config(
+    destination_path, iris_pkl_file, iris_data
+):
+    yield _create_model_card_from_model_path(destination_path, iris_data, iris_pkl_file)
+
+
 @pytest.fixture
 def destination_path():
     with tempfile.TemporaryDirectory(prefix="skops-test") as dir_path:
@@ -111,11 +158,23 @@ def test_save_model_card(destination_path, model_card):
     assert (Path(destination_path) / "README.md").exists()
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_save_model_card_from_path(destination_path, model_card_from_path):
+    model_card_from_path.save(Path(destination_path) / "README.md")
+    assert (Path(destination_path) / "README.md").exists()
+
+
 def test_hyperparameter_table(destination_path, model_card):
     model_card = model_card.render()
     assert "fit_intercept" in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_hyperparameter_table_from_path(model_card_from_path):
+    model_card_from_path = model_card_from_path.render()
+    assert "fit_intercept" in model_card_from_path
+
+
 def _strip_multiple_chars(text, char):
     # _strip_multiple_chars("hi    there") == "hi there"
     # _strip_multiple_chars("|---|--|", "-") == "|-|-|"
@@ -144,17 +203,44 @@ def test_plot_model(destination_path, model_card):
     assert "<style>" in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_plot_model_from_path(destination_path, model_card_from_path):
+    model_card_from_path = model_card_from_path.render()
+    assert "<style>" in model_card_from_path
+
+
 def test_plot_model_false(destination_path, model_card):
     model = fit_model()
     model_card = Card(model, model_diagram=False).render()
     assert "<style>" not in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_plot_model_false_from_path(suffix, destination_path, model_card_from_path):
+    model = fit_model()
+    save_file = tempfile.mkstemp(suffix=suffix, prefix="skops-test")[1]
+    if suffix in (".pkl", ".pickle"):
+        with open(save_file, "wb") as f:
+            pickle.dump(model, f)
+    elif suffix == ".skops":
+        dump(model, save_file)
+    model_card_from_path = Card(save_file, model_diagram=False).render()
+    assert "<style>" not in model_card_from_path
+
+
 def test_add(destination_path, model_card):
     model_card = model_card.add(model_description="sklearn FTW").render()
     assert "sklearn FTW" in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_add_from_path(destination_path, model_card_from_path):
+    model_card_from_path = model_card_from_path.add(
+        model_description="sklearn FTW"
+    ).render()
+    assert "sklearn FTW" in model_card_from_path
+
+
 def test_template_sections_not_mutated_by_save(destination_path, model_card):
     template_sections_before = copy.deepcopy(model_card._template_sections)
     model_card.save(Path(destination_path) / "README.md")
@@ -162,6 +248,16 @@ def test_template_sections_not_mutated_by_save(destination_path, model_card):
     assert template_sections_before == template_sections_after
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_template_sections_not_mutated_by_save_from_path(
+    destination_path, model_card_from_path
+):
+    template_sections_before = copy.deepcopy(model_card_from_path._template_sections)
+    model_card_from_path.save(Path(destination_path) / "README.md")
+    template_sections_after = copy.deepcopy(model_card_from_path._template_sections)
+    assert template_sections_before == template_sections_after
+
+
 def test_add_plot(destination_path, model_card):
     plt.plot([4, 5, 6, 7])
     plt.savefig(Path(destination_path) / "fig1.png")
@@ -169,6 +265,14 @@ def test_add_plot(destination_path, model_card):
     assert "![fig1](fig1.png)" in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_add_plot_from_path(destination_path, model_card_from_path):
+    plt.plot([4, 5, 6, 7])
+    plt.savefig(Path(destination_path) / "fig1.png")
+    model_card_from_path = model_card_from_path.add_plot(fig1="fig1.png").render()
+    assert "![fig1](fig1.png)" in model_card_from_path
+
+
 def test_temporary_plot(destination_path, model_card):
     # test if the additions are made to a temporary template file
     # and not to default template or template provided
@@ -186,6 +290,24 @@ def test_temporary_plot(destination_path, model_card):
     assert default_template == default_template_post
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_temporary_plot_from_path(destination_path, model_card_from_path):
+    # test if the additions are made to a temporary template file
+    # and not to default template or template provided
+    root = skops.__path__
+    # read original template
+    with open(Path(root[0]) / "card" / "default_template.md") as f:
+        default_template = f.read()
+    plt.plot([4, 5, 6, 7])
+    plt.savefig(Path(destination_path) / "fig1.png")
+    model_card_from_path.add_plot(fig1="fig1.png")
+    model_card_from_path.save(Path(destination_path) / "README.md")
+    # check if default template is not modified
+    with open(Path(root[0]) / "card" / "default_template.md") as f:
+        default_template_post = f.read()
+    assert default_template == default_template_post
+
+
 def test_metadata_keys(destination_path, model_card):
     # test if the metadata is added on top of the card
     model_card.metadata.tags = "dummy"
@@ -193,12 +315,27 @@ def test_metadata_keys(destination_path, model_card):
     assert "tags: dummy" in model_card
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_metadata_keys_from_path(destination_path, model_card_from_path):
+    # test if the metadata is added on top of the card
+    model_card_from_path.metadata.tags = "dummy"
+    model_card_from_path = model_card_from_path.render()
+    assert "tags: dummy" in model_card_from_path
+
+
 def test_default_sections_save(model_card):
     # test if the plot and hyperparameters are only added during save
     assert "<style>" not in str(model_card)
     assert "fit_intercept" not in str(model_card)
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_default_sections_save_from_path(model_card_from_path):
+    # test if the plot and hyperparameters are only added during save
+    assert "<style>" not in str(model_card_from_path)
+    assert "fit_intercept" not in str(model_card_from_path)
+
+
 def test_add_metrics(destination_path, model_card):
     model_card.add_metrics(**{"acc": 0.1})
     model_card.add_metrics(f1=0.1)
@@ -206,6 +343,14 @@ def test_add_metrics(destination_path, model_card):
     assert ("acc" in card) and ("f1" in card) and ("0.1" in card)
 
 
+@pytest.mark.parametrize("suffix", [".pkl", ".pickle", ".skops"])
+def test_add_metrics_from_path(destination_path, model_card_from_path):
+    model_card_from_path.add_metrics(**{"acc": 0.1})
+    model_card_from_path.add_metrics(f1=0.1)
+    card = model_card_from_path.render()
+    assert ("acc" in card) and ("f1" in card) and ("0.1" in card)
+
+
 def test_code_autogeneration(destination_path, pkl_model_card_metadata_from_config):
     # test if getting started code is automatically generated
     metadata = metadata_load(local_path=Path(destination_path) / "README.md")
@@ -229,6 +374,31 @@ def test_code_autogeneration_skops(
         assert 'style="overflow: auto;' in read_buffer
 
 
+def test_code_autogeneration_from_path(
+    destination_path, pkl_model_card_from_path_metadata_from_config
+):
+    # test if getting started code is automatically generated
+    metadata = metadata_load(local_path=Path(destination_path) / "README.md")
+    filename = metadata["model_file"]
+    with open(Path(destination_path) / "README.md") as f:
+        assert f"joblib.load({filename})" in f.read()
+
+
+def test_code_autogeneration_skops_from_path(
+    destination_path, skops_model_card_from_path_metadata_from_config
+):
+    # test if getting started code is automatically generated for skops format
+    metadata = metadata_load(local_path=Path(destination_path) / "README.md")
+    filename = metadata["model_file"]
+    with open(Path(destination_path) / "README.md") as f:
+        read_buffer = f.read()
+        assert f'clf = load("{filename}")' in read_buffer
+
+        # test if the model doesn't overflow the huggingface models page
+        assert read_buffer.count("sk-top-container") == 1
+        assert 'style="overflow: auto;' in read_buffer
+
+
 def test_metadata_from_config_tabular_data(
     pkl_model_card_metadata_from_config, destination_path
 ):
@@ -250,6 +420,27 @@ def test_metadata_from_config_tabular_data(
         assert tag in metadata["tags"]
 
 
+def test_metadata_from_config_tabular_data_from_path(
+    pkl_model_card_from_path_metadata_from_config, destination_path
+):
+    # test if widget data is correctly set in the README
+    metadata = metadata_load(local_path=Path(destination_path) / "README.md")
+    assert "widget" in metadata
+
+    expected_data = {
+        "structuredData": {
+            "petal length (cm)": [1.4, 1.4, 1.3],
+            "petal width (cm)": [0.2, 0.2, 0.2],
+            "sepal length (cm)": [5.1, 4.9, 4.7],
+            "sepal width (cm)": [3.5, 3.0, 3.2],
+        }
+    }
+    assert metadata["widget"] == expected_data
+
+    for tag in ["sklearn", "skops", "tabular-classification"]:
+        assert tag in metadata["tags"]
+
+
 class TestCardRepr:
     """Test __str__ and __repr__ methods of Card, which are identical for now"""
 
@@ -288,14 +479,12 @@ def test_very_long_lines_are_shortened(self, card: Card, meth):
         card.add(my_section="very long line " * 100)
         result = meth(card)
         expected = (
-            "Card(\n  model=LinearRegression(fit_intercept=False),\n"
-            "  model_description='A description',\n  model_card_authors='Jane Doe',\n"
-            "  my_section='very long line very lon...line very long line very long line"
-            " ',\n"
-            "  roc_curve='ROC_curve.png',\n"
-            "  confusion_matrix='confusion_matrix.jpg',\n"
-            "  search_results=Table(3x2),\n"
-            ")"
+            "Card(\n  model=LinearRegression(fit_intercept=False),\n "
+            " model_description='A description',\n  model_card_authors='Jane"
+            " Doe',\n  my_section='very long line very lon...line very long"
+            " line very long line ',\n  roc_curve='ROC_curve.png',\n "
+            " confusion_matrix='confusion_matrix.jpg',\n "
+            " search_results=Table(3x2),\n)"
         )
         assert result == expected
 
@@ -439,6 +628,204 @@ def test_folded(self, folded):
             assert "<details>" not in output
 
 
+class TestModelPathCardRepr:
+    @pytest.fixture
+    def card(self):
+        model = LinearRegression(fit_intercept=False)
+        pkl_file = tempfile.mkstemp(suffix=".pkl", prefix="skops-test")[1]
+        with open(pkl_file, "wb") as f:
+            pickle.dump(model, f)
+        card = Card(model=pkl_file)
+        card.add(
+            model_description="A description",
+            model_card_authors="Jane Doe",
+        )
+        card.add_plot(
+            roc_curve="ROC_curve.png",
+            confusion_matrix="confusion_matrix.jpg",
+        )
+        card.add_table(search_results={"split": [1, 2, 3], "score": [4, 5, 6]})
+        return card
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_card_repr(self, card: Card, meth):
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  model_description='A description',\n"
+            "  model_card_authors='Jane Doe',\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_very_long_lines_are_shortened(self, card: Card, meth):
+        card.add(my_section="very long line " * 100)
+        result = meth(card)
+        expected = (
+            "Card(\n  model=LinearRegression(fit_intercept=False),\n "
+            " model_description='A description',\n  model_card_authors='Jane"
+            " Doe',\n  my_section='very long line very lon...line very long"
+            " line very long line ',\n  roc_curve='ROC_curve.png',\n "
+            " confusion_matrix='confusion_matrix.jpg',\n "
+            " search_results=Table(3x2),\n)"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_without_model_attribute(self, card: Card, meth):
+        del card.model
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model_description='A description',\n"
+            "  model_card_authors='Jane Doe',\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_no_template_sections(self, card: Card, meth):
+        card._template_sections = {}
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_no_extra_sections(self, card: Card, meth):
+        card._extra_sections = []
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  model_description='A description',\n"
+            "  model_card_authors='Jane Doe',\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_template_section_val_not_str(self, card: Card, meth):
+        card._template_sections["model_description"] = [1, 2, 3]  # type: ignore
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  model_description=[1, 2, 3],\n"
+            "  model_card_authors='Jane Doe',\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_extra_sections_val_not_str(self, card: Card, meth):
+        card._extra_sections.append(("some section", {1: 2}))
+        result = meth(card)
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  model_description='A description',\n"
+            "  model_card_authors='Jane Doe',\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            "  some section={1: 2},\n"
+            ")"
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize("meth", [repr, str])
+    def test_with_metadata(self, card: Card, meth):
+        from modelcards import CardData
+
+        metadata = CardData(
+            language="fr",
+            license="bsd",
+            library_name="sklearn",
+            tags=["sklearn", "tabular-classification"],
+            foo={"bar": 123},
+            widget={"something": "very-long"},
+        )
+        card.metadata = metadata
+        expected = (
+            "Card(\n"
+            "  model=LinearRegression(fit_intercept=False),\n"
+            "  metadata.language=fr,\n"
+            "  metadata.license=bsd,\n"
+            "  metadata.library_name=sklearn,\n"
+            "  metadata.tags=['sklearn', 'tabular-classification'],\n"
+            "  metadata.foo={'bar': 123},\n"
+            "  metadata.widget={...},\n"
+            "  model_description='A description',\n"
+            "  model_card_authors='Jane Doe',\n"
+            "  roc_curve='ROC_curve.png',\n"
+            "  confusion_matrix='confusion_matrix.jpg',\n"
+            "  search_results=Table(3x2),\n"
+            ")"
+        )
+        result = meth(card)
+        assert result == expected
+
+
+class TestCardModelAttribute:
+    def test_model_estimator(self):
+        model0 = LinearRegression()
+
+        card = Card(model0)
+        assert card.model is model0
+
+        # re-assigning the model works
+        model1 = LogisticRegression()
+        card.model = model1
+        assert card.model is model1
+
+        # re-assigning back to original works
+        card.model = model0
+        assert card.model is model0
+
+    def test_model_is_str_pickle(self, tmp_path):
+        model0 = LinearRegression(n_jobs=123)
+        f_name0 = tmp_path / "lin_reg.pickle"
+        with open(f_name0, "wb") as f:
+            pickle.dump(model0, f)
+
+        card = Card(f_name0)
+        assert isinstance(card.model, LinearRegression)
+        assert card.model.n_jobs == 123
+
+        # re-assigning the model works
+        model1 = LogisticRegression(n_jobs=456)
+        f_name1 = tmp_path / "log_reg.pickle"
+        with open(f_name1, "wb") as f:
+            pickle.dump(model1, f)
+
+        card.model = f_name1
+        assert isinstance(card.model, LogisticRegression)
+        assert card.model.n_jobs == 456
+
+        # re-assigning back to original works
+        card.model = f_name0
+        assert isinstance(card.model, LinearRegression)
+        assert card.model.n_jobs == 123
+
+
 class TestTableSection:
     @pytest.fixture
     def table_dict(self):