ob-metaflow-stubs 6.0.3.104__py2.py3-none-any.whl → 6.0.3.106__py2.py3-none-any.whl

metaflow-stubs/plugins/cards/card_client.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.358272                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.915989                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -9,8 +9,8 @@ from __future__ import annotations
 import typing
 if typing.TYPE_CHECKING:
     import metaflow.exception
-    import metaflow.plugins.cards.card_client
     import metaflow
+    import metaflow.plugins.cards.card_client
 
 TYPE_CHECKING: bool
 
@@ -86,6 +86,14 @@ class IncorrectPathspecException(metaflow.exception.MetaflowException, metaclass
     ...
 
 class Card(object, metaclass=type):
+    """
+    `Card` represents an individual Metaflow Card, a single HTML file, produced by
+    the card `@card` decorator. `Card`s are contained by `CardContainer`, returned by
+    `get_cards`.
+    
+    Note that the contents of the card, an HTML file, is retrieved lazily when you call
+    `Card.get` for the first time or when the card is rendered in a notebook.
+    """
     def __init__(self, card_ds, type, path, hash, id = None, html = None, created_on = None, from_resumed = False, origin_pathspec = None):
         ...
     def get_data(self) -> typing.Optional[dict]:
@@ -137,6 +145,29 @@ class Card(object, metaclass=type):
     ...
 
 class CardContainer(object, metaclass=type):
+    """
+    `CardContainer` is an immutable list-like object, returned by `get_cards`,
+    which contains individual `Card`s.
+    
+    Notably, `CardContainer` contains a special
+    `_repr_html_` function which renders cards automatically in an output
+    cell of a notebook.
+    
+    The following operations are supported:
+    ```
+    cards = get_cards(MyTask)
+    
+    # retrieve by index
+    first_card = cards[0]
+    
+    # check length
+    if len(cards) > 1:
+        print('many cards present!')
+    
+    # iteration
+    list_of_cards = list(cards)
+    ```
+    """
     def __init__(self, card_paths, card_ds, origin_pathspec = None):
         ...
     def __len__(self):

metaflow-stubs/plugins/cards/card_creator.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.388138                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.957931                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -15,6 +15,9 @@ current: metaflow.metaflow_current.Current
 ASYNC_TIMEOUT: int
 
 class CardProcessManager(object, metaclass=type):
+    """
+    This class is responsible for managing the card creation processes.
+    """
     ...
 
 class CardCreator(object, metaclass=type):

metaflow-stubs/plugins/cards/card_datastore.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.381570                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.940249                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -25,6 +25,9 @@ CARD_GSROOT: None
 SKIP_CARD_DUALWRITE: bool
 
 class CardNotPresentException(metaflow.exception.MetaflowException, metaclass=type):
+    """
+    This exception is raised with a card is not present in the datastore.
+    """
     def __init__(self, pathspec, card_type = None, card_hash = None, card_id = None):
         ...
     ...
@@ -34,6 +37,9 @@ TEMP_DIR_NAME: str
 NUM_SHORT_HASH_CHARS: int
 
 class CardInfo(tuple, metaclass=type):
+    """
+    CardInfo(type, hash, id, filename)
+    """
     @staticmethod
     def __new__(_cls, type, hash, id, filename):
         """

metaflow-stubs/plugins/cards/card_decorator.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.388843                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.958679                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -14,6 +14,25 @@ if typing.TYPE_CHECKING:
 current: metaflow.metaflow_current.Current
 
 class CardComponentCollector(object, metaclass=type):
+    """
+    This class helps collect `MetaflowCardComponent`s during runtime execution
+    
+    ### Usage with `current`
+    `current.card` is of type `CardComponentCollector`
+    
+    ### Main Usage TLDR
+    - [x] `current.card.append` customizes the default editable card.
+    - [x] Only one card can be default editable in a step.
+    - [x] The card class must have `ALLOW_USER_COMPONENTS=True` to be considered default editable.
+        - [x] Classes with `ALLOW_USER_COMPONENTS=False` are never default editable.
+    - [x] The user can specify an `id` argument to a card, in which case the card is editable through `current.card[id].append`.
+        - [x] A card with an id can be also default editable, if there are no other cards that are eligible to be default editable.
+    - [x] If multiple default-editable cards exist but only one card doesn't have an id, the card without an id is considered to be default editable.
+    - [x] If we can't resolve a single default editable card through the above rules, `current.card`.append calls show a warning but the call doesn't fail.
+    - [x] A card that is not default editable can be still edited through:
+        - [x] its `current.card['myid']`
+        - [x] by looking it up by its type, e.g. `current.card.get(type='pytorch')`.
+    """
     def __init__(self, logger = None, card_creator = None):
         ...
     @staticmethod
@@ -121,6 +140,37 @@ def warning_message(message, logger = None, ts = False):
     ...
 
 class CardDecorator(metaflow.decorators.StepDecorator, metaclass=type):
+    """
+    Creates a human-readable report, a Metaflow Card, after this step completes.
+    
+    Note that you may add multiple `@card` decorators in a step with different parameters.
+    
+    Parameters
+    ----------
+    type : str, default 'default'
+        Card type.
+    id : str, optional, default None
+        If multiple cards are present, use this id to identify this card.
+    options : Dict[str, Any], default {}
+        Options passed to the card. The contents depend on the card type.
+    timeout : int, default 45
+        Interrupt reporting if it takes more than this many seconds.
+    
+    MF Add To Current
+    -----------------
+    card -> metaflow.plugins.cards.component_serializer.CardComponentCollector
+        The `@card` decorator makes the cards available through the `current.card`
+        object. If multiple `@card` decorators are present, you can add an `ID` to
+        distinguish between them using `@card(id=ID)` as the decorator. You will then
+        be able to access that specific card using `current.card[ID].
+    
+        Methods available are `append` and `extend`
+    
+        @@ Returns
+        -------
+        CardComponentCollector
+            The or one of the cards attached to this step.
+    """
     def __init__(self, *args, **kwargs):
         ...
     def step_init(self, flow, graph, step_name, decorators, environment, flow_datastore, logger):

metaflow-stubs/plugins/cards/card_modules/__init__.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.386605                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.956284                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -11,6 +11,32 @@ if typing.TYPE_CHECKING:
     import metaflow
 
 class MetaflowCard(object, metaclass=type):
+    """
+    Metaflow cards derive from this base class.
+    
+    Subclasses of this class are called *card types*. The desired card
+    type `T` is defined in the `@card` decorator as `@card(type=T)`.
+    
+    After a task with `@card(type=T, options=S)` finishes executing, Metaflow instantiates
+    a subclass `C` of `MetaflowCard` that has its `type` attribute set to `T`, i.e. `C.type=T`.
+    The constructor is given the options dictionary `S` that contains arbitrary
+    JSON-encodable data that is passed to the instance, parametrizing the card. The subclass
+    may override the constructor to capture and process the options.
+    
+    The subclass needs to implement a `render(task)` method that produces the card
+    contents in HTML, given the finished task that is represented by a `Task` object.
+    
+    Attributes
+    ----------
+    type : str
+        Card type string. Note that this should be a globally unique name, similar to a
+        Python package name, to avoid name clashes between different custom cards.
+    
+    Parameters
+    ----------
+    options : Dict
+        JSON-encodable dictionary containing user-definable options for the class.
+    """
     def __init__(self, options = {}, components = [], graph = None):
         ...
     def render(self, task: "metaflow.Task") -> str:

metaflow-stubs/plugins/cards/card_modules/basic.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.362546                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.920507                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -13,6 +13,32 @@ if typing.TYPE_CHECKING:
     import metaflow
 
 class MetaflowCard(object, metaclass=type):
+    """
+    Metaflow cards derive from this base class.
+    
+    Subclasses of this class are called *card types*. The desired card
+    type `T` is defined in the `@card` decorator as `@card(type=T)`.
+    
+    After a task with `@card(type=T, options=S)` finishes executing, Metaflow instantiates
+    a subclass `C` of `MetaflowCard` that has its `type` attribute set to `T`, i.e. `C.type=T`.
+    The constructor is given the options dictionary `S` that contains arbitrary
+    JSON-encodable data that is passed to the instance, parametrizing the card. The subclass
+    may override the constructor to capture and process the options.
+    
+    The subclass needs to implement a `render(task)` method that produces the card
+    contents in HTML, given the finished task that is represented by a `Task` object.
+    
+    Attributes
+    ----------
+    type : str
+        Card type string. Note that this should be a globally unique name, similar to a
+        Python package name, to avoid name clashes between different custom cards.
+    
+    Parameters
+    ----------
+    options : Dict
+        JSON-encodable dictionary containing user-definable options for the class.
+    """
     def __init__(self, options = {}, components = [], graph = None):
         ...
     def render(self, task: "metaflow.Task") -> str:
@@ -88,6 +114,14 @@ def read_file(path):
     ...
 
 class DefaultComponent(metaflow.plugins.cards.card_modules.card.MetaflowCardComponent, metaclass=type):
+    """
+    The `DefaultCard` and the `BlankCard` use a JS framework that build the HTML dynamically from JSON.
+    The `DefaultComponent` is the base component that helps build the JSON when `render` is called.
+    
+    The underlying JS framework consists of various types of objects.
+    These can be found in: "metaflow/plugins/cards/ui/types.ts".
+    The `type` attribute in a `DefaultComponent` corresponds to the type of component in the Javascript framework.
+    """
     def __init__(self, title = None, subtitle = None):
         ...
     def render(self):
@@ -197,6 +231,11 @@ class MarkdownComponent(DefaultComponent, metaclass=type):
     ...
 
 class TaskInfoComponent(metaflow.plugins.cards.card_modules.card.MetaflowCardComponent, metaclass=type):
+    """
+    Properties
+        page_content : a list of MetaflowCardComponents going as task info
+        final_component: the dictionary returned by the `render` function of this class.
+    """
     def __init__(self, task, page_title = "Task Info", only_repr = True, graph = None, components = [], runtime = False):
         ...
     def render(self):

metaflow-stubs/plugins/cards/card_modules/card.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.358693                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.916436                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -13,6 +13,32 @@ if typing.TYPE_CHECKING:
 TYPE_CHECKING: bool
 
 class MetaflowCard(object, metaclass=type):
+    """
+    Metaflow cards derive from this base class.
+    
+    Subclasses of this class are called *card types*. The desired card
+    type `T` is defined in the `@card` decorator as `@card(type=T)`.
+    
+    After a task with `@card(type=T, options=S)` finishes executing, Metaflow instantiates
+    a subclass `C` of `MetaflowCard` that has its `type` attribute set to `T`, i.e. `C.type=T`.
+    The constructor is given the options dictionary `S` that contains arbitrary
+    JSON-encodable data that is passed to the instance, parametrizing the card. The subclass
+    may override the constructor to capture and process the options.
+    
+    The subclass needs to implement a `render(task)` method that produces the card
+    contents in HTML, given the finished task that is represented by a `Task` object.
+    
+    Attributes
+    ----------
+    type : str
+        Card type string. Note that this should be a globally unique name, similar to a
+        Python package name, to avoid name clashes between different custom cards.
+    
+    Parameters
+    ----------
+    options : Dict
+        JSON-encodable dictionary containing user-definable options for the class.
+    """
     def __init__(self, options = {}, components = [], graph = None):
         ...
     def render(self, task: "metaflow.Task") -> str:

metaflow-stubs/plugins/cards/card_modules/components.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.360508                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.918396                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -10,8 +10,8 @@ import typing
 if typing.TYPE_CHECKING:
     import metaflow.plugins.cards.card_modules.components
     import typing
-    import metaflow.plugins.cards.card_modules.card
     import metaflow.plugins.cards.card_modules.basic
+    import metaflow.plugins.cards.card_modules.card
 
 class LogComponent(metaflow.plugins.cards.card_modules.basic.DefaultComponent, metaclass=type):
     def __init__(self, data = None):
@@ -126,6 +126,26 @@ class StubComponent(UserComponent, metaclass=type):
     ...
 
 class Artifact(UserComponent, metaclass=type):
+    """
+    A pretty-printed version of any Python object.
+    
+    Large objects are truncated using Python's built-in [`reprlib`](https://docs.python.org/3/library/reprlib.html).
+    
+    Example:
+    ```
+    from datetime import datetime
+    current.card.append(Artifact({'now': datetime.utcnow()}))
+    ```
+    
+    Parameters
+    ----------
+    artifact : object
+        Any Python object.
+    name : str, optional
+        Optional label for the object.
+    compressed : bool, default: True
+        Use a truncated representation.
+    """
     def update(self, artifact):
         ...
     def __init__(self, artifact: typing.Any, name: typing.Optional[str] = None, compressed: bool = True):
@@ -135,6 +155,45 @@ class Artifact(UserComponent, metaclass=type):
     ...
 
 class Table(UserComponent, metaclass=type):
+    """
+    A table.
+    
+    The contents of the table can be text or numerical data, a Pandas dataframe,
+    or other card components: `Artifact`, `Image`, `Markdown` objects.
+    
+    Example: Text and artifacts
+    ```
+    from metaflow.cards import Table, Artifact
+    current.card.append(
+        Table([
+            ['first row', Artifact({'a': 2})],
+            ['second row', Artifact(3)]
+        ])
+    )
+    ```
+    
+    Example: Table from a Pandas dataframe
+    ```
+    from metaflow.cards import Table
+    import pandas as pd
+    import numpy as np
+    current.card.append(
+        Table.from_dataframe(
+            pd.DataFrame(
+                np.random.randint(0, 100, size=(15, 4)),
+                columns=list("ABCD")
+            )
+        )
+    )
+    ```
+    
+    Parameters
+    ----------
+    data : List[List[str or MetaflowCardComponent]], optional
+        List (rows) of lists (columns). Each item can be a string or a `MetaflowCardComponent`.
+    headers : List[str], optional
+        Optional header row for the table.
+    """
     def update(self, *args, **kwargs):
         ...
     def __init__(self, data: typing.Optional[typing.List[typing.List[typing.Union[str, metaflow.plugins.cards.card_modules.card.MetaflowCardComponent]]]] = None, headers: typing.Optional[typing.List[str]] = None, disable_updates: bool = False):
@@ -157,6 +216,55 @@ class Table(UserComponent, metaclass=type):
     ...
 
 class Image(UserComponent, metaclass=type):
+    """
+    An image.
+    
+    `Images can be created directly from PNG/JPG/GIF `bytes`, `PIL.Image`s,
+    or Matplotlib figures. Note that the image data is embedded in the card,
+    so no external files are required to show the image.
+    
+    Example: Create an `Image` from bytes:
+    ```
+    current.card.append(
+        Image(
+            requests.get("https://www.gif-vif.com/hacker-cat.gif").content,
+            "Image From Bytes"
+        )
+    )
+    ```
+    
+    Example: Create an `Image` from a Matplotlib figure
+    ```
+    import pandas as pd
+    import numpy as np
+    current.card.append(
+        Image.from_matplotlib(
+            pandas.DataFrame(
+                np.random.randint(0, 100, size=(15, 4)),
+                columns=list("ABCD"),
+            ).plot()
+        )
+    )
+    ```
+    
+    Example: Create an `Image` from a [PIL](https://pillow.readthedocs.io/) Image
+    ```
+    from PIL import Image as PILImage
+    current.card.append(
+        Image.from_pil_image(
+            PILImage.fromarray(np.random.randn(1024, 768), "RGB"),
+            "From PIL Image"
+        )
+    )
+    ```
+    
+    Parameters
+    ----------
+    src : bytes
+        The image data in `bytes`.
+    label : str
+        Optional label for the image.
+    """
     @staticmethod
     def render_fail_headline(msg):
         ...
@@ -205,6 +313,30 @@ class Image(UserComponent, metaclass=type):
     ...
 
 class Error(UserComponent, metaclass=type):
+    """
+    This class helps visualize Error's on the `MetaflowCard`. It can help catch and print stack traces to errors that happen in `@step` code.
+    
+    ### Parameters
+    - `exception` (Exception) : The `Exception` to visualize. This value will be `repr`'d before passed down to `MetaflowCard`
+    - `title` (str) : The title that will appear over the visualized  `Exception`.
+    
+    ### Usage
+    ```python
+    @card
+    @step
+    def my_step(self):
+        from metaflow.cards import Error
+        from metaflow import current
+        try:
+            ...
+            ...
+        except Exception as e:
+            current.card.append(
+                Error(e,"Something misbehaved")
+            )
+        ...
+    ```
+    """
     def __init__(self, exception, title = None):
         ...
     def render(self, *args, **kwargs):
@@ -212,6 +344,21 @@ class Error(UserComponent, metaclass=type):
     ...
 
 class Markdown(UserComponent, metaclass=type):
+    """
+    A block of text formatted in Markdown.
+    
+    Example:
+    ```
+    current.card.append(
+        Markdown("# This is a header appended from `@step` code")
+    )
+    ```
+    
+    Parameters
+    ----------
+    text : str
+        Text formatted in Markdown.
+    """
     def update(self, text = None):
         ...
     def __init__(self, text = None):
@@ -221,6 +368,39 @@ class Markdown(UserComponent, metaclass=type):
     ...
 
 class ProgressBar(UserComponent, metaclass=type):
+    """
+    A Progress bar for tracking progress of any task.
+    
+    Example:
+    ```
+    progress_bar = ProgressBar(
+        max=100,
+        label="Progress Bar",
+        value=0,
+        unit="%",
+        metadata="0.1 items/s"
+    )
+    current.card.append(
+        progress_bar
+    )
+    for i in range(100):
+        progress_bar.update(i, metadata="%s items/s" % i)
+    
+    ```
+    
+    Parameters
+    ----------
+    max : int
+        The maximum value of the progress bar.
+    label : str, optional
+        Optional label for the progress bar.
+    value : int, optional
+        Optional initial value of the progress bar.
+    unit : str, optional
+        Optional unit for the progress bar.
+    metadata : str, optional
+        Optional additional information to show on the progress bar.
+    """
     def __init__(self, max: int = 100, label: str = None, value: int = 0, unit: str = None, metadata: str = None):
         ...
     def update(self, new_value: int, metadata: str = None):

metaflow-stubs/plugins/cards/card_modules/convert_to_native_type.pyi

@@ -1,13 +1,16 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.382477                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.941188                                        #
 ##################################################################################
 
 from __future__ import annotations
 
 
 class TypeResolvedObject(tuple, metaclass=type):
+    """
+    TypeResolvedObject(data, is_image, is_table)
+    """
     @staticmethod
     def __new__(_cls, data, is_image, is_table):
         """

metaflow-stubs/plugins/cards/card_modules/renderer_tools.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.382651                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.941365                                        #
 ##################################################################################
 
 from __future__ import annotations

metaflow-stubs/plugins/cards/card_modules/test_cards.pyi

@@ -1,7 +1,7 @@
 ##################################################################################
 #                       Auto-generated Metaflow stub file                        #
-# MF version: 2.12.22.1+obcheckpoint(0.0.11);ob(v1)                              #
-# Generated on 2024-09-20T21:46:07.376179                                        #
+# MF version: 2.12.24.1+obcheckpoint(0.0.11);ob(v1)                              #
+# Generated on 2024-10-04T19:10:58.934807                                        #
 ##################################################################################
 
 from __future__ import annotations
@@ -12,6 +12,32 @@ if typing.TYPE_CHECKING:
     import metaflow
 
 class MetaflowCard(object, metaclass=type):
+    """
+    Metaflow cards derive from this base class.
+    
+    Subclasses of this class are called *card types*. The desired card
+    type `T` is defined in the `@card` decorator as `@card(type=T)`.
+    
+    After a task with `@card(type=T, options=S)` finishes executing, Metaflow instantiates
+    a subclass `C` of `MetaflowCard` that has its `type` attribute set to `T`, i.e. `C.type=T`.
+    The constructor is given the options dictionary `S` that contains arbitrary
+    JSON-encodable data that is passed to the instance, parametrizing the card. The subclass
+    may override the constructor to capture and process the options.
+    
+    The subclass needs to implement a `render(task)` method that produces the card
+    contents in HTML, given the finished task that is represented by a `Task` object.
+    
+    Attributes
+    ----------
+    type : str
+        Card type string. Note that this should be a globally unique name, similar to a
+        Python package name, to avoid name clashes between different custom cards.
+    
+    Parameters
+    ----------
+    options : Dict
+        JSON-encodable dictionary containing user-definable options for the class.
+    """
     def __init__(self, options = {}, components = [], graph = None):
         ...
     def render(self, task: "metaflow.Task") -> str:
@@ -132,6 +158,9 @@ class TestJSONComponent(metaflow.plugins.cards.card_modules.card.MetaflowCardCom
     ...
 
 class TestRefreshCard(metaflow.plugins.cards.card_modules.card.MetaflowCard, metaclass=type):
+    """
+    This card takes no components and helps test the `current.card.refresh(data)` interface.
+    """
     def render(self, task) -> str:
         ...
     def render_runtime(self, task, data):
@@ -141,6 +170,10 @@ class TestRefreshCard(metaflow.plugins.cards.card_modules.card.MetaflowCard, met
     ...
 
 class TestRefreshComponentCard(metaflow.plugins.cards.card_modules.card.MetaflowCard, metaclass=type):
+    """
+    This card takes components and helps test the `current.card.components["A"].update()`
+    interface
+    """
     def __init__(self, options = {}, components = [], graph = None):
         ...
     def render(self, task) -> str: