cTuning
Sign in

cMeta open-source categories, artifacts and automations

One category from internal.

← All categories

report

Generated reports kept alongside the runs that produced them.

Comes from
(internal)
License
Apache-2.0
UID
bfc4321ed14f4ac5
Copyright
2025-2026 Grigori Fursin and cTuning Labs. See the cMeta COPYRIGHT and LICENSE files for details.

Its own commands

CommandWhat it does
test2
v1.py:64-82
Args:
signature

    def test2(
        self,
        params,  # Input parameters dictionary.
    ):

        """
            Args:
                params: Input parameters dictionary.
            Returns:
                dict: Operation result.
            Raises:
                Exception: Propagated runtime errors, if any.
        """
test
v1.py:39-61
Args:
signature

    def test_(
        self,
        ctx,  # Execution context dictionary with category, command, and control data.
        arg1 = None,  # First positional argument from command input.
        flag1 = False,  # Input parameter used by this function.
    ):

        """
            Args:
                ctx: Execution context dictionary with category, command, and control data.
                arg1: First positional argument from command input.
                flag1: Input parameter used by this function.
            Returns:
                dict: Operation result.
            Raises:
                Exception: Propagated runtime errors, if any.
        """

Common commands

Every category also inherits the commands below, so any artifact can be found, read, created, moved and tagged the same way.

CommandWhat it does
copy (cp)Copy artifact(s).
signature

    def copy__(
        self,
        params: dict,  # cMeta params.
    ):

        """
            Copy artifact(s).

            @base.move_(**params, copy=True)

            Args:
                params (dict): cMeta params.

            Returns:
                dict: A cMeta dictionary (see move_ for details).

            Raises:
                Exception: Propagated runtime errors, if any.
        """
create (add)Create and index an artifact.
signature

    def create_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Tags to add to the artifact.
        meta: dict = {},  # Initial metadata dictionary.
        yaml: bool = False,  # Save metadata as YAML instead of JSON.
        virtual: bool = False,  # Virtual artifact created only in index (such as repo).
        path: str = None,  # Use this path for artifact (useful for virtual artifacts such as repo).
        index: bool = False, # If true and path exists but not index, just add to index
                             # Useful when AI agents create cMeta entries while bypassing cMeta
        desc: dict = None,  # Keys merged into the artifact's _desc.yaml (--desc.<key>=<value>, or a whole @file.yaml holding desc:).
        ai_uses = None,  # AI context: template aliases, artifact aliases or cRefs (comma-separated); True = ask.
        ai = None,  # The short form of ai_uses (-ai, -ai=cmeta,fgg).
        connect = None,  # Connect both ways: names or cRefs (";" between cRefs); True = ask.
        connect_to = None,  # Connect the new artifact to them (its own _desc only): the same forms.
        ct = None,  # The short form of connect_to (--ct=<cRef>).
        dt = None,  # The date in front of the alias: -dt today's (20261105.<alias>), --dt=<date> that one; nothing is added to an alias that starts with a date.
    ):

        """
            Create and index an artifact.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Tags to add to the artifact.
                meta (dict): Initial metadata dictionary.
                yaml (bool): Save metadata as YAML instead of JSON.
                virtual (bool): Virtual artifact created only in index (such as repo).
                path (str | None): Use this path for artifact (useful for virtual artifacts such as repo).
                index (bool): Index an artifact that already exists at `path` without creating it.
                desc (dict | None): Keys merged into the artifact's _desc.yaml.
                ai_uses, ai: The AI context (template aliases, artifact aliases, cRefs); True asks.
                connect: Artifacts to connect both ways - their cRefs go into the new artifact's `connections`
                    and its cRef into theirs; True asks.
                connect_to, ct: Artifacts to connect the new one to, in its own _desc.yaml only.
                dt (bool | str | None): The date in front of the alias: True today's, a text that date; nothing is
                    added to an alias that starts with a date (_alias_with_date).

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **path** (str): Path to the created artifact.
                    - **meta** (dict): Artifact metadata.
                    - **warnings** (list): The warning of a dated category (`dated_aliases: true` in its meta)
                      for an alias without a date, printed too unless quiet; empty otherwise.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
delete (rm|remove|del)Delete and unindex artifact(s).
signature

    def delete_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Optional tag filter.
        sort: bool = True,  # Sort artifacts by alias and UID.
        force: bool = False,  # Force deletion without confirmation.
        f: bool = False,  # Shorthand for force.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        ignore_errors: bool = False,  # Ignore errors when deleting multiple artifacts.
        print_time: bool = False,  # Print time per deletion.
        match: dict = None,  # Value for match.
        match_empty_version: bool = False,  # Value for match empty version.
        all_tags: str = None,  # Value for all tags.
    ):

        """
            Delete and unindex artifact(s).

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Optional tag filter.
                sort (bool): Sort artifacts by alias and UID.
                force (bool): Force deletion without confirmation.
                f (bool): Shorthand for force.
                skip_uids (bool): Skip UIDs when using wildcards.
                ignore_errors (bool): Ignore errors when deleting multiple artifacts.
                print_time (bool): Print time per deletion.
                match (dict | None): Match artifact metadata before deleting.
                match_empty_version (bool): Match artifacts with an empty version value.
                all_tags (str | None): Require all supplied tags when selecting artifacts.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): All matched artifacts.
                    - **deleted_artifacts** (list): Deleted artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
find (search)Find artifacts.
signature

    def find_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Comma-separated string or iterable of tags to match.
        sort: bool = None,  # Sort by path (True by default).
        add_index_file: bool = False,  # Add index file information.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        match: dict = None,  # Value for match.
        match_empty_version: bool = False,  # Value for match empty version.
        match_empty_values: bool = False,  # Match when queried values or keys are empty.
        all_tags: str = None,  # Value for all tags.
        load_files = [],  # Load files (omit extension to load either yaml or json)
        follow_migrated: bool = True,  # Follow an old alias left by "migrate" to its artifact.
    ):

        """
            Find artifacts.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Comma-separated string or iterable of tags to match.
                sort (bool): Sort by path (True by default).
                add_index_file (bool): Add index file information.
                skip_uids (bool): Skip UIDs when using wildcards.
                match (dict): Value for match.
                match_empty_version (bool): Value for match empty version.
                match_empty_values (bool): Match artifacts whose queried values or keys are empty.
                all_tags (str): Value for all tags.
                load_files (list): Metadata file basenames to load from each matched artifact.
                follow_migrated (bool): An alias given alone that is a migration stub (left by
                    `migrate`) stands for the artifact it points to, with a notice; False returns
                    the stub itself. A UID always finds exactly what it names.
            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): List of matched artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.                           \
        """
getGet artifact meta. Read if exists, create and read if doesn't exist. The _desc.yaml options of add
signature

    def get_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Tags to add to the artifact (used during creation).
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        yaml: bool = False,  # Save/output metadata as YAML instead of JSON.
        meta: dict = {},  # Initial metadata dictionary (used during creation).
        virtual: bool = False,  # Virtual artifact created only in index (used during creation).
        path: str = None,  # Use this path for artifact (used during creation).
        show_path: bool = False,  # Print path instead of meta
        load_files = [],  # Value for load files.
        desc: dict = None,  # Keys merged into the artifact's _desc.yaml (as add / update).
        ai_uses = None,  # The AI context (as add / update): names, "-name" removes; True = ask.
        ai = None,  # The short form of ai_uses (-ai).
        connect = None,  # Connect both ways (as add / update).
        connect_to = None,  # Connect this artifact to them (its own _desc only).
        ct = None,  # The short form of connect_to (--ct).
        dt = None,  # The date in front of the alias (-dt today's, --dt=<date>): what is read, and what is made when nothing is read.
    ):

        """
            Get artifact meta. Read if exists, create and read if doesn't exist. The _desc.yaml options of add
            and update (desc, ai_uses / ai, connect, connect_to / ct) go to the create of a new artifact and to
            an update of one that exists (2026-11-03: the categories that made dated aliases added through get,
            and "cx work add <name> -ai" failed with "unexpected keyword argument 'ai'"). With `dt` the alias is
            read and made with its date in front (_alias_with_date): "get <name> -dt" reads 20261105.<name> or
            makes it, the same name whether it exists or not.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Tags to add to the artifact (used during creation).
                skip_uids (bool): Skip UIDs when using wildcards.
                yaml (bool): Save/output metadata as YAML instead of JSON.
                meta (dict): Initial metadata dictionary (used during creation).
                virtual (bool): Virtual artifact created only in index (used during creation).
                path (str | None): Use this path for artifact (used during creation).
                show_path (bool): Print path instead of meta
                load_files: Value for load files.
                dt (bool | str | None): The date in front of the alias: True today's, a text that date.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifact** (dict): Matched artifact.
                    - **cmeta** (dict): Artifact metadata.
                    - **created** (bool): True if artifact was created, False if it already existed.
                    - **warnings** (list): The warning of a dated category when the artifact was created with
                      an alias without a date (create_); empty otherwise.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
indexIndex artifact(s).
signature

    def index(
        self,
        params: dict,  # cMeta params.
    ):

        """
            Index artifact(s).

            @base.create_(**params, index=True)

            Args:
                params (dict): cMeta params.

            Returns:
                dict: A cMeta dictionary (see move_ for details).

            Raises:
                Exception: Propagated runtime errors, if any.
        """
infoGet artifact info. The reference printed and copied is {{{<category>::<alias>,<UID>}}} - how memories,
signature

    def info_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        clip: bool = True,  # If True, copy the reference to the clipboard.
        url: bool = False,  # If True, copy URL with detected cRef to the clipboard.
        name: bool = False,  # If True, copy artifact name to the clipboard
        cref: bool = False,  # If True, the old form cRef=<category>,<UID>::<alias>,<UID> instead of {{{<category>::<alias>,<UID>}}}.
        plain: bool = False,  # If True, the reference without the braces: <category>::<alias>,<UID> (what a field of a page takes).
        qplain: bool = False,  # If True, the plain reference in double quotes: "<category>::<alias>,<UID>" (pasted into a command line as one word).
    ):

        """
            Get artifact info. The reference printed and copied is {{{<category>::<alias>,<UID>}}} - how memories,
            records and docs name an artifact (the browse and cref pages make it a link, smart_find_by_cid reads it);
            --plain gives it without the braces (<category>::<alias>,<UID>: what the search of /browse, a picker of a
            page or cx <category> find takes), --qplain the same in double quotes (one word of a command line, a name
            with spaces too), --cref the full cRef=... that info printed up to cMeta 0.38.9.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                clip (bool): If True, copy the reference to the clipboard.
                url (bool): If True, copy URL with detected cRef to the clipboard.
                name (bool): If True, copy artifact name to the clipboard
                cref (bool): If True, print and copy cRef=<full cRef> (the form up to 0.38.9).
                plain (bool): If True, print and copy <category>::<alias>,<UID> - the reference without the braces.
                qplain (bool): If True, the plain reference in double quotes - one word of a command line, whatever the name holds.
            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): List of matched artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
list (ls)List artifact names.
signature

    def list_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Optional tag filter.
        sort: bool = None,  # Sort by alias or UID.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
    ):

        """
            List artifact names.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Optional tag filter.
                sort (bool): Sort by alias or UID.
                skip_uids (bool): Skip UIDs when using wildcards.
            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): List of matched artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
migrateRename an artifact (or move it to another repository under a new alias) and leave a
signature

    def migrate_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str,  # The artifact to migrate: alias, UID or alias,UID (one artifact, no wildcards).
        arg2: str,  # Its new alias, optionally in another repository: [repo:]alias.
        tags: str = None,  # Prune the source artifact by tags.
    ):

        """
            Rename an artifact (or move it to another repository under a new alias) and leave a
            stub under its old alias that points to it.

            The artifact keeps its UID, as with `move`, so `alias,UID` and UID references to it keep
            working. The stub gets the old alias, a new UID and two keys: `migrated_to`, the new
            `alias,UID`, and `migrated_when`, the date and time of the migration (ISO 8601, UTC).
            A lookup of the old alias alone - `cx task run <old>`, `cx <category> find <old>` - then
            follows the stub to the artifact and prints a notice once. Commands that change
            artifacts (update, tags, move, delete) act on the stub itself, so `cx <category> rm <old>`
            removes it when nobody uses the old alias any more.

            Args:
                ctx (dict): cMeta context.
                arg1 (str): The artifact to migrate: alias, UID or alias,UID (one artifact, no wildcards).
                arg2 (str): Its new alias, optionally in another repository: [repo:]alias.
                tags (str | list | None): Prune the source artifact by tags.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifact** (dict): The migrated artifact (its new alias, the same UID).
                    - **stub_path** (str): Path of the stub left under the old alias.
                    - **stub_meta** (dict): Meta of the stub.
                    - **migrated_to** (str): The new `alias,UID`.
                    - **migrated_when** (str): When, ISO 8601 in UTC.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
move (ren|rename|mv)Rename and/or move artifact(s).
signature

    def move_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str,  # cMeta artifact(s) with wildcards to be renamed or moved.
        arg2: str,  # New cMeta artifact name and/or new repository.
        tags: str = None,  # Prune source artifacts by tags.
        sort: bool = True,  # Sort artifacts by alias and UID when updating in batch.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        ignore_errors: bool = False,  # Ignore errors when updating multiple artifacts.
        copy: bool = False,  # If True, copy artifact instead of moving.
    ):

        """
            Rename and/or move artifact(s).

            Args:
                ctx (dict): cMeta context.
                arg1 (str): cMeta artifact(s) with wildcards to be renamed or moved.
                arg2 (str): New cMeta artifact name and/or new repository.
                tags (str | list | None): Prune source artifacts by tags.
                sort (bool): Sort artifacts by alias and UID when updating in batch.
                skip_uids (bool): Skip UIDs when using wildcards.
                ignore_errors (bool): Ignore errors when updating multiple artifacts.
                copy (bool): If True, copy artifact instead of moving.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): All matched artifacts.
                    - **updated_artifacts** (list): Updated artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
read (load)Read artifact meta.
signature

    def read_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Optional tag filter.
        extra: bool = False,  # Show extra info.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        yaml: bool = False,  # Output as YAML instead of JSON.
        load_files = [],  # Value for load files.
    ):

        """
            Read artifact meta.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Optional tag filter.
                extra (bool): Show extra info.
                skip_uids (bool): Skip UIDs when using wildcards.
                yaml (bool): Output as YAML instead of JSON.
                load_files: Value for load files.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifact** (dict): Matched artifact.
                    - **cmeta** (dict): Artifact metadata.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
reindexRefresh the index record(s) of artifact(s) from their folders, changing no file.
signature

    def reindex_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias, UID, alias,UID or repo:alias (wildcards allowed); nothing names every artifact of the category.
        tags: str = None,  # Prune the artifacts by tags, as in find (a tag with a leading "-" excludes).
        sort: bool = True,  # Sort the artifacts by alias and UID.
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        ignore_errors: bool = False,  # Go on past an artifact that cannot be reindexed and report it at the end.
    ):

        """
            Refresh the index record(s) of artifact(s) from their folders, changing no file.

            The meta file of each artifact is read from its folder on disk and the artifact's record in the
            index of the category is rewritten from it: the alias is the folder's name, every other alias
            that still pointed at the artifact's UID is dropped, and the path, the meta and the sharding
            depth are what a full `cx --reindex` records. The meta file is read, never written (an empty
            `update` rewrites it). Use it after a meta file was edited by hand, after a folder was renamed,
            moved or copied in from another machine, or when a lookup looks stale - instead of the whole
            `cx --reindex`.

            The artifact may be named by its alias, UID, alias,UID or repo:alias, with wildcards; nothing
            names every artifact of the category. A folder the index does not know yet (made or renamed by
            hand) is found on disk in the repositories; an artifact whose indexed folder is gone is looked
            for by its UID in its repository. No folder is touched, and the only record ever removed is
            that of an artifact whose folder, still there, holds another artifact now (replaced by hand) -
            said in the output. A folder that cannot be found, a meta without a valid `artifact` UID, or a
            UID found in two existing folders is an error, and the index is left as it was
            (`--ignore_errors` reindexes the other artifacts and reports these).

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias, UID, alias,UID or repo:alias (wildcards allowed); nothing
                    names every artifact of the category.
                tags (str | list | None): Prune the artifacts by tags, as in find (a leading "-" excludes).
                sort (bool): Sort the artifacts by alias and UID.
                skip_uids (bool): Skip UIDs when using wildcards.
                ignore_errors (bool): Go on past an artifact that cannot be reindexed and report it at the end.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error (16: nothing found).
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): The reindexed artifacts, as their new index records.
                    - **dropped_aliases** (dict): Per UID, the (lowercase) aliases dropped because they were not the folder's name.
                    - **dropped_records** (list): The records removed because their folder holds another artifact now (`ref`, `path`, `now`).
                    - **errors** (list): With `ignore_errors`, one dict per artifact that could not be reindexed (`ref`, `path`, `error`).

            Raises:
                Exception: Propagated runtime errors, if any.
        """
setSet artifact meta. Update and read if exists, create and read if doesn't exist. With `dt` the alias
signature

    def set_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Tags to add to the artifact (used during creation).
        skip_uids: bool = False,  # Skip UIDs when using wildcards.
        yaml: bool = False,  # Save/output metadata as YAML instead of JSON.
        meta: dict = {},  # Initial metadata dictionary (used during creation).
        virtual: bool = False,  # Virtual artifact created only in index (used during creation).
        path: str = None,  # Use this path for artifact (used during creation).
        show_path: bool = False,  # Print path instead of meta
        dt = None,  # The date in front of the alias (-dt today's, --dt=<date>): what is read, and what is made when nothing is read.
    ):

        """
            Set artifact meta. Update and read if exists, create and read if doesn't exist. With `dt` the alias
            is read and made with its date in front, as get.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Tags to add to the artifact (used during creation).
                skip_uids (bool): Skip UIDs when using wildcards.
                yaml (bool): Save/output metadata as YAML instead of JSON.
                meta (dict): Initial metadata dictionary (used during creation).
                virtual (bool): Virtual artifact created only in index (used during creation).
                path (str | None): Use this path for artifact (used during creation).
                show_path (bool): Print path instead of meta
                dt (bool | str | None): The date in front of the alias: True today's, a text that date.

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifact** (dict): Matched artifact.
                    - **cmeta** (dict): Artifact metadata.
                    - **created** (bool): True if artifact was created, False if it already existed.
                    - **warnings** (list): The warning of a dated category when the artifact was created with
                      an alias without a date (create_); empty otherwise.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
tagsFind unique tags in artifacts.
signature

    def tags_(
        self,
        ctx: dict,  # cMeta context.
        arg1: str = None,  # Artifact alias or UID.
        tags: str = None,  # Comma-separated string or iterable of tags to match.
        sort: bool = False,  # Value for sort.
    ):

        """
            Find unique tags in artifacts.

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): Artifact alias or UID.
                tags (str | list | None): Comma-separated string or iterable of tags to match.
                sort (bool): Value for sort.
            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): List of matched artifacts.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
testTest category.
signature

    def test(
        self,
        params: dict,  # Parameters dictionary.
    ):

        """
            Test category.

            Args:
                params (dict): Parameters dictionary.
            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.

            Raises:
                Exception: Propagated runtime errors, if any.
        """
updateUpdate artifact(s).
signature

    def update_(
        self,
        ctx: dict,  # Execution context dictionary with category, command, and control data.
        arg1: str = None,  # First positional argument from command input.
        tags: str = None,  # Value for tags.
        sort: bool = True,  # Value for sort.
        skip_uids: bool = False,  # If True, skip UID validation in wildcard lookups.
        meta: dict = {},  # Metadata dictionary to persist.
        new_tags: str = None,  # Value for new tags.
        replace_lists: bool = False,  # Value for replace lists.
        replace: bool = False,  # Value for replace.
        ignore_errors: bool = False,  # Value for ignore errors.
        create: bool = False,  # Value for create.
        create_params: dict = {},  # Value for create params.
        update_category: bool = False,  # Value for update category.
        match: dict = None,  # Value for match.
        match_empty_version: bool = False,  # Value for match empty version.
        all_tags: str = None,  # Value for all tags.
        desc: dict = None,  # Keys merged into the artifact's _desc.yaml (--desc.<key>=<value>, or a whole @file.yaml holding desc:).
        ai_uses = None,  # AI context to add: template aliases, artifact aliases or cRefs ("-name" removes); True = ask.
        ai = None,  # The short form of ai_uses (-ai, -ai=cmeta,fgg, -ai=-fgg).
        connect = None,  # Connect both ways: names or cRefs (";" between cRefs, "-name" disconnects); True = ask.
        connect_to = None,  # Connect this artifact to them (its own _desc only): the same forms.
        ct = None,  # The short form of connect_to (--ct=<cRef>).
    ):

        """
            Update artifact(s).

            Args:
                ctx (dict): cMeta context.
                arg1 (str | None): cMeta artifact(s) with wildcards.
                tags (str | list | None): Prune artifacts by tags.
                sort (bool): Sort artifacts by alias and UID when updating in batch.
                skip_uids (bool): Skip UIDs when using wildcards.
                meta (dict): Meta dictionary to merge recursively with existing artifact.
                new_tags (str | list | None): Add more tags.
                replace_lists (bool): Replace lists during merging.
                replace (bool): Replace existing meta dictionary entirely.
                ignore_errors (bool): Ignore errors when updating multiple artifacts.
                create (bool): If artifact doesn't exist attempt to create.
                create_params (dict): Pass params to create function.
                update_category (bool): Allow category update in meta.
                match (dict | None): Match artifact metadata before updating.
                match_empty_version (bool): Match artifacts with an empty version value.
                all_tags (str | None): Require all supplied tags when selecting artifacts.
                desc (dict | None): Keys merged into the artifact's _desc.yaml.
                ai_uses, ai: The AI context to add (template aliases, artifact aliases, cRefs; "-name" removes);
                    True asks.
                connect: Artifacts to connect both ways - their cRefs go into this artifact's `connections`
                    and its cRef into theirs ("-name" removes both); True asks.
                connect_to, ct: Artifacts to connect this one to, in its own _desc.yaml only ("-name" removes).

            Returns:
                dict: A cMeta dictionary with the following keys:
                    - **return** (int): 0 if success, >0 if error.
                    - **error** (str): Error message if `return > 0`.
                    - **artifacts** (list): All matched artifacts.
                    - **updated_artifacts** (list): Updated artifacts.
                    - **desc_changes** (list): What the _desc.yaml changes added (+) and removed (-), as lines.

            Raises:
                Exception: Propagated runtime errors, if any.
        """

How to use it

cx report test2
cx report                     # list every command with its help
from cmeta import CMeta
cm = CMeta()
r = cm.access({'category': 'report,bfc4321ed14f4ac5', 'command': 'test2'})

Artifacts

The open-source repositories ship no report artifacts - this category holds what you and your runs create.

cx report list

Source: report on GitHub · its API

Read live from the cMeta index of this server - the same data cx category list shows you locally.