{
  "specversion": 3,
  "name": "Collections",
  "doc": "A library providing keywords for handling lists and dictionaries.\n\n``Collections`` is Robot Framework's standard library that provides a\nset of keywords for handling Python lists and dictionaries. This\nlibrary has keywords, for example, for modifying and getting\nvalues from lists and dictionaries (e.g. `Append To List`, `Get\nFrom Dictionary`) and for verifying their contents (e.g. `Lists\nShould Be Equal`, `Dictionary Should Contain Value`).\n\n== Table of contents ==\n\n- `Related keywords in BuiltIn`\n- `Using with list-like and dictionary-like objects`\n- `Ignore case`\n- `Boolean arguments`\n- `Data in examples`\n- `Keywords`\n\n= Related keywords in BuiltIn =\n\nFollowing keywords in the BuiltIn library can also be used with\nlists and dictionaries:\n\n| = Keyword Name =             | = Applicable With = |\n| `Create List`                | lists |\n| `Create Dictionary`          | dicts |\n| `Get Length`                 | both  |\n| `Length Should Be`           | both  |\n| `Should Be Empty`            | both  |\n| `Should Not Be Empty`        | both  |\n| `Should Contain`             | both  |\n| `Should Not Contain`         | both  |\n| `Should Contain X Times`     | lists |\n| `Should Not Contain X Times` | lists |\n| `Get Count`                  | lists |\n\n= Using with list-like and dictionary-like objects =\n\nList keywords that do not alter the given list can also be used\nwith tuples, and to some extent also with other iterables.\n`Convert To List` can be used to convert tuples and other iterables\nto Python ``list`` objects.\n\nSimilarly, dictionary keywords can, for most parts, be used with other\nmappings. `Convert To Dictionary` can be used if real Python ``dict``\nobjects are needed.\n\n= Ignore case =\n\nVarious keywords support ignoring case in comparisons by using the optional\n``ignore_case`` argument. Case-insensitivity can be enabled by using\n``ignore_case=True`` (see `Boolean arguments`) and it works recursively.\nWith dictionaries, it is also possible to use special values ``keys`` and\n``values`` to normalize only keys or values, respectively. These options\nthemselves are case-insensitive and also singular forms ``key`` and\n``value`` are supported.\n\nIf a dictionary contains keys that normalize to the same value, e.g.\n``{'a': 1, 'A': 2}``, normalizing keys causes an error.\n\nExamples:\n| `Lists Should Be Equal`        | ${list1} | ${list2} | ignore_case=True   |\n| `Dictionaries Should Be Equal` | ${dict1} | ${dict2} | ignore_case=values |\n\nNotice that some keywords accept also an older ``case_insensitive`` argument\nin addition to ``ignore_case``. The latter is new in Robot Framework 7.0 and\nshould be used unless there is a need to support older versions. The old\nargument is considered deprecated and will eventually be removed.\n\n= Boolean arguments =\n\nSome keywords accept arguments that are handled as Boolean values true or\nfalse. If such an argument is given as a string, it is considered false if\nit is an empty string or equal to ``FALSE``, ``NONE``, ``NO``, ``OFF`` or\n``0``, case-insensitively. Keywords verifying something that allow dropping\nactual and expected values from the possible error message also consider\nstring ``no values`` to be false. Other strings are considered true\nregardless their value, and other argument types are tested using the same\n[http://docs.python.org/library/stdtypes.html#truth|rules as in Python].\n\n| `Should Contain Match` | ${list} | ${pattern} | ignore_case=True  |\n| `Should Contain Match` | ${list} | ${pattern} | ignore_case=False |\n| `Lists Should Be Equal` | ${list1} | ${list2} | Custom error | no values |\n\n= Data in examples =\n\nList related keywords use variables in format ``${Lx}`` in their examples.\nThey mean lists with as many alphabetic characters as specified by ``x``.\nFor example, ``${L1}`` means ``['a']`` and ``${L3}`` means\n``['a', 'b', 'c']``.\n\nDictionary keywords use similar ``${Dx}`` variables. For example, ``${D1}``\nmeans ``{'a': 1}`` and ``${D3}`` means ``{'a': 1, 'b': 2, 'c': 3}``.",
  "version": "7.2.dev1",
  "generated": "2024-10-02T23:00:46+00:00",
  "type": "LIBRARY",
  "scope": "GLOBAL",
  "docFormat": "ROBOT",
  "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
  "lineno": 887,
  "tags": [],
  "inits": [],
  "keywords": [
    {
      "name": "Append To List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*values"
        }
      ],
      "returnType": null,
      "doc": "Adds ``values`` to the end of ``list``.\n\nExample:\n| Append To List | ${L1} | xxx |   |   |\n| Append To List | ${L2} | x   | y | z |\n=>\n| ${L1} = ['a', 'xxx']\n| ${L2} = ['a', 'b', 'x', 'y', 'z']",
      "shortdoc": "Adds ``values`` to the end of ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 40
    },
    {
      "name": "Combine Lists",
      "args": [
        {
          "name": "lists",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*lists"
        }
      ],
      "returnType": null,
      "doc": "Combines the given ``lists`` together and returns the result.\n\nThe given lists are not altered by this keyword.\n\nExample:\n| ${x} = | Combine Lists | ${L1} | ${L2} |       |\n| ${y} = | Combine Lists | ${L1} | ${L2} | ${L1} |\n=>\n| ${x} = ['a', 'a', 'b']\n| ${y} = ['a', 'a', 'b', 'a']\n| ${L1} and ${L2} are not changed.",
      "shortdoc": "Combines the given ``lists`` together and returns the result.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 78
    },
    {
      "name": "Convert To Dictionary",
      "args": [
        {
          "name": "item",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "item"
        }
      ],
      "returnType": null,
      "doc": "Converts the given ``item`` to a Python ``dict`` type.\n\nMainly useful for converting other mappings to normal dictionaries.\nThis includes converting Robot Framework's own ``DotDict`` instances\nthat it uses if variables are created using the ``&{var}`` syntax.\n\nUse `Create Dictionary` from the BuiltIn library for constructing new\ndictionaries.",
      "shortdoc": "Converts the given ``item`` to a Python ``dict`` type.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 506
    },
    {
      "name": "Convert To List",
      "args": [
        {
          "name": "item",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "item"
        }
      ],
      "returnType": null,
      "doc": "Converts the given ``item`` to a Python ``list`` type.\n\nMainly useful for converting tuples and other iterable to lists.\nUse `Create List` from the BuiltIn library for constructing new lists.",
      "shortdoc": "Converts the given ``item`` to a Python ``list`` type.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 32
    },
    {
      "name": "Copy Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "deepcopy",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "deepcopy=False"
        }
      ],
      "returnType": null,
      "doc": "Returns a copy of the given dictionary.\n\nBy default, returns a new dictionary with same items as in the original.\nSet the ``deepcopy`` argument to a true value if also items should\nbe copied.\n\nThe given dictionary is never altered by this keyword.",
      "shortdoc": "Returns a copy of the given dictionary.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 601
    },
    {
      "name": "Copy List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "deepcopy",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "deepcopy=False"
        }
      ],
      "returnType": null,
      "doc": "Returns a copy of the given list.\n\nBy default, returns a new list with same items as in the original.\nSet the ``deepcopy`` argument to a true value if also items should\nbe copied.\n\nThe given list is never altered by this keyword.",
      "shortdoc": "Returns a copy of the given list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 266
    },
    {
      "name": "Count Values In List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "start",
          "type": null,
          "defaultValue": "0",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "start=0"
        },
        {
          "name": "end",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "end=None"
        }
      ],
      "returnType": null,
      "doc": "Returns the number of occurrences of the given ``value`` in ``list``.\n\nThe search can be narrowed to the selected sublist by the ``start`` and\n``end`` indexes having the same semantics as with `Get Slice From List`\nkeyword. The given list is never altered by this keyword.\n\nExample:\n| ${x} = | Count Values In List | ${L3} | b |\n=>\n| ${x} = 1\n| ${L3} is not changed",
      "shortdoc": "Returns the number of occurrences of the given ``value`` in ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 228
    },
    {
      "name": "Dictionaries Should Be Equal",
      "args": [
        {
          "name": "dict1",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dict1"
        },
        {
          "name": "dict2",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dict2"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "values=True"
        },
        {
          "name": "ignore_keys",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_keys=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if the given dictionaries are not equal.\n\nFirst the equality of dictionaries' keys is checked and after that all\nthe key value pairs. If there are differences between the values, those\nare listed in the error message. The types of the dictionaries do not\nneed to be same.\n\n``ignore_keys`` can be used to provide a list of keys to ignore in the\ncomparison. It can be an actual list or a Python list literal. This\noption is new in Robot Framework 6.1. It works recursively with nested\ndictionaries starting from Robot Framework 7.0.\n\nExamples:\n| Dictionaries Should Be Equal | ${dict} | ${expected} |\n| Dictionaries Should Be Equal | ${dict} | ${expected} | ignore_keys=${ignored} |\n| Dictionaries Should Be Equal | ${dict} | ${expected} | ignore_keys=['key1', 'key2'] |\n\nSee `Lists Should Be Equal` for more information about configuring\nthe error message with ``msg`` and ``values`` arguments.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if the given dictionaries are not equal.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 785
    },
    {
      "name": "Dictionary Should Contain Item",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "key"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "An item of ``key`` / ``value`` must be found in a ``dictionary``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "An item of ``key`` / ``value`` must be found in a ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 732
    },
    {
      "name": "Dictionary Should Contain Key",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "key"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``key`` is not found from ``dictionary``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if ``key`` is not found from ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 698
    },
    {
      "name": "Dictionary Should Contain Sub Dictionary",
      "args": [
        {
          "name": "dict1",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dict1"
        },
        {
          "name": "dict2",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dict2"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "values=True"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails unless all items in ``dict2`` are found from ``dict1``.\n\nSee `Lists Should Be Equal` for more information about configuring\nthe error message with ``msg`` and ``values`` arguments.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails unless all items in ``dict2`` are found from ``dict1``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 841
    },
    {
      "name": "Dictionary Should Contain Value",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``value`` is not found from ``dictionary``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if ``value`` is not found from ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 751
    },
    {
      "name": "Dictionary Should Not Contain Key",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "key"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``key`` is found from ``dictionary``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if ``key`` is found from ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 715
    },
    {
      "name": "Dictionary Should Not Contain Value",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``value`` is found from ``dictionary``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if ``value`` is found from ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 768
    },
    {
      "name": "Get Dictionary Items",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "sort_keys",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "sort_keys=True"
        }
      ],
      "returnType": null,
      "doc": "Returns items of the given ``dictionary`` as a list.\n\nUses `Get Dictionary Keys` to get keys and then returns corresponding\nitems. By default, keys are sorted and items returned in that order,\nbut this can be changed by giving ``sort_keys`` a false value.\n\nItems are returned as a flat list so that first item is a key,\nsecond item is a corresponding value, third item is the second key,\nand so on.\n\nThe given ``dictionary`` is never altered by this keyword.\n\nExample:\n| ${sorted} =   | Get Dictionary Items | ${D3} |\n| ${unsorted} = | Get Dictionary Items | ${D3} | sort_keys=False |",
      "shortdoc": "Returns items of the given ``dictionary`` as a list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 653
    },
    {
      "name": "Get Dictionary Keys",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "sort_keys",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "sort_keys=True"
        }
      ],
      "returnType": null,
      "doc": "Returns keys of the given ``dictionary`` as a list.\n\nBy default, keys are returned in sorted order (assuming they are\nsortable), but they can be returned in the original order by giving\n``sort_keys`` a false value.\n\nThe given ``dictionary`` is never altered by this keyword.\n\nExample:\n| ${sorted} =   | Get Dictionary Keys | ${D3} |\n| ${unsorted} = | Get Dictionary Keys | ${D3} | sort_keys=False |",
      "shortdoc": "Returns keys of the given ``dictionary`` as a list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 615
    },
    {
      "name": "Get Dictionary Values",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "sort_keys",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "sort_keys=True"
        }
      ],
      "returnType": null,
      "doc": "Returns values of the given ``dictionary`` as a list.\n\nUses `Get Dictionary Keys` to get keys and then returns corresponding\nvalues. By default, keys are sorted and values returned in that order,\nbut this can be changed by giving ``sort_keys`` a false value.\n\nThe given ``dictionary`` is never altered by this keyword.\n\nExample:\n| ${sorted} =   | Get Dictionary Values | ${D3} |\n| ${unsorted} = | Get Dictionary Values | ${D3} | sort_keys=False |",
      "shortdoc": "Returns values of the given ``dictionary`` as a list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 636
    },
    {
      "name": "Get From Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "key"
        },
        {
          "name": "default",
          "type": null,
          "defaultValue": "",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "default="
        }
      ],
      "returnType": null,
      "doc": "Returns a value from the given ``dictionary`` based on the given ``key``.\n\nIf the given ``key`` cannot be found from the ``dictionary``, this\nkeyword fails. If optional ``default`` value is given, it will be\nreturned instead of failing.\n\nThe given dictionary is never altered by this keyword.\n\nExample:\n| ${value} = | Get From Dictionary | ${D3} | b |\n=>\n| ${value} = 2\n\nSupport for ``default`` is new in Robot Framework 6.0.",
      "shortdoc": "Returns a value from the given ``dictionary`` based on the given ``key``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 674
    },
    {
      "name": "Get From List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "index",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "index"
        }
      ],
      "returnType": null,
      "doc": "Returns the value specified with an ``index`` from ``list``.\n\nThe given list is never altered by this keyword.\n\nIndex ``0`` means the first position, ``1`` the second, and so on.\nSimilarly, ``-1`` is the last position, ``-2`` the second last, and so on.\nUsing an index that does not exist on the list causes an error.\nThe index can be either an integer or a string that can be converted\nto an integer.\n\nExamples (including Python equivalents in comments):\n| ${x} = | Get From List | ${L5} | 0  | # L5[0]  |\n| ${y} = | Get From List | ${L5} | -2 | # L5[-2] |\n=>\n| ${x} = 'a'\n| ${y} = 'd'\n| ${L5} is not changed",
      "shortdoc": "Returns the value specified with an ``index`` from ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 173
    },
    {
      "name": "Get Index From List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "start",
          "type": null,
          "defaultValue": "0",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "start=0"
        },
        {
          "name": "end",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "end=None"
        }
      ],
      "returnType": null,
      "doc": "Returns the index of the first occurrence of the ``value`` on the list.\n\nThe search can be narrowed to the selected sublist by the ``start`` and\n``end`` indexes having the same semantics as with `Get Slice From List`\nkeyword. In case the value is not found, -1 is returned. The given list\nis never altered by this keyword.\n\nExample:\n| ${x} = | Get Index From List | ${L5} | d |\n=>\n| ${x} = 3\n| ${L5} is not changed",
      "shortdoc": "Returns the index of the first occurrence of the ``value`` on the list.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 244
    },
    {
      "name": "Get Match Count",
      "args": [
        {
          "name": "list",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "case_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "case_insensitive: bool | None = None"
        },
        {
          "name": "whitespace_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "whitespace_insensitive: bool | None = None"
        },
        {
          "name": "ignore_case",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case: bool = False"
        },
        {
          "name": "ignore_whitespace",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_whitespace: bool = False"
        }
      ],
      "returnType": null,
      "doc": "Returns the count of matches to ``pattern`` in ``list``.\n\nFor more information on ``pattern``, ``case_insensitive/ignore_case``, and\n``whitespace_insensitive/ignore_whitespace``, see `Should Contain Match`.\n\nExamples:\n| ${count}= | Get Match Count | ${list} | a* | # ${count} will be the count of strings beginning with 'a' |\n| ${count}= | Get Match Count | ${list} | regexp=a.* | # ${matches} will be the count of strings beginning with 'a' (regexp version) |\n| ${count}= | Get Match Count | ${list} | a* | case_insensitive=${True} | # ${matches} will be the count of strings beginning with 'a' or 'A' |",
      "shortdoc": "Returns the count of matches to ``pattern`` in ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 1070
    },
    {
      "name": "Get Matches",
      "args": [
        {
          "name": "list",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "case_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "case_insensitive: bool | None = None"
        },
        {
          "name": "whitespace_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "whitespace_insensitive: bool | None = None"
        },
        {
          "name": "ignore_case",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case: bool = False"
        },
        {
          "name": "ignore_whitespace",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_whitespace: bool = False"
        }
      ],
      "returnType": null,
      "doc": "Returns a list of matches to ``pattern`` in ``list``.\n\nFor more information on ``pattern``, ``case_insensitive/ignore_case``, and\n``whitespace_insensitive/ignore_whitespace``, see `Should Contain Match`.\n\nExamples:\n| ${matches}= | Get Matches | ${list} | a* | # ${matches} will contain any string beginning with 'a' |\n| ${matches}= | Get Matches | ${list} | regexp=a.* | # ${matches} will contain any string beginning with 'a' (regexp version) |\n| ${matches}= | Get Matches | ${list} | a* | ignore_case=True | # ${matches} will contain any string beginning with 'a' or 'A' |",
      "shortdoc": "Returns a list of matches to ``pattern`` in ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 1050
    },
    {
      "name": "Get Slice From List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "start",
          "type": null,
          "defaultValue": "0",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "start=0"
        },
        {
          "name": "end",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "end=None"
        }
      ],
      "returnType": null,
      "doc": "Returns a slice of the given list between ``start`` and ``end`` indexes.\n\nThe given list is never altered by this keyword.\n\nIf both ``start`` and ``end`` are given, a sublist containing values\nfrom ``start`` to ``end`` is returned. This is the same as\n``list[start:end]`` in Python. To get all items from the beginning,\nuse 0 as the start value, and to get all items until and including\nthe end, use ``None`` (default) as the end value.\n\nUsing ``start`` or ``end`` not found on the list is the same as using\nthe largest (or smallest) available index.\n\nExamples (incl. Python equivalents in comments):\n| ${x} = | Get Slice From List | ${L5} | 2      | 4 | # L5[2:4]    |\n| ${y} = | Get Slice From List | ${L5} | 1      |   | # L5[1:None] |\n| ${z} = | Get Slice From List | ${L5} | end=-2 |   | # L5[0:-2]   |\n=>\n| ${x} = ['c', 'd']\n| ${y} = ['b', 'c', 'd', 'e']\n| ${z} = ['a', 'b', 'c']\n| ${L5} is not changed",
      "shortdoc": "Returns a slice of the given list between ``start`` and ``end`` indexes.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 198
    },
    {
      "name": "Insert Into List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "index",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "index"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        }
      ],
      "returnType": null,
      "doc": "Inserts ``value`` into ``list`` to the position specified with ``index``.\n\nIndex ``0`` adds the value into the first position, ``1`` to the second,\nand so on. Inserting from right works with negative indices so that\n``-1`` is the second last position, ``-2`` third last, and so on. Use\n`Append To List` to add items to the end of the list.\n\nIf the absolute value of the index is greater than\nthe length of the list, the value is added at the end\n(positive index) or the beginning (negative index). An index\ncan be given either as an integer or a string that can be\nconverted to an integer.\n\nExample:\n| Insert Into List | ${L1} | 0     | xxx |\n| Insert Into List | ${L2} | ${-1} | xxx |\n=>\n| ${L1} = ['xxx', 'a']\n| ${L2} = ['a', 'xxx', 'b']",
      "shortdoc": "Inserts ``value`` into ``list`` to the position specified with ``index``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 54
    },
    {
      "name": "Keep In Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "keys",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*keys"
        }
      ],
      "returnType": null,
      "doc": "Keeps the given ``keys`` in the ``dictionary`` and removes all other.\n\nIf the given ``key`` cannot be found from the ``dictionary``, it\nis ignored.\n\nExample:\n| Keep In Dictionary | ${D5} | b | x | d |\n=>\n| ${D5} = {'b': 2, 'd': 4}",
      "shortdoc": "Keeps the given ``keys`` in the ``dictionary`` and removes all other.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 586
    },
    {
      "name": "List Should Contain Sub List",
      "args": [
        {
          "name": "list1",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list1"
        },
        {
          "name": "list2",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list2"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "values=True"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if not all elements in ``list2`` are found in ``list1``.\n\nThe order of values and the number of values are not taken into\naccount.\n\nSee `Lists Should Be Equal` for more information about configuring\nthe error message with ``msg`` and ``values`` arguments.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if not all elements in ``list2`` are found in ``list1``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 440
    },
    {
      "name": "List Should Contain Value",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if the ``value`` is not found from ``list``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if the ``value`` is not found from ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 306
    },
    {
      "name": "List Should Not Contain Duplicates",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if any element in the ``list`` is found from it more than once.\n\nThe default error message lists all the elements that were found\nfrom the ``list`` multiple times, but it can be overridden by giving\na custom ``msg``. All multiple times found items and their counts are\nalso logged.\n\nThis keyword works with all iterables that can be converted to a list.\nThe original iterable is never altered.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if any element in the ``list`` is found from it more than once.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 334
    },
    {
      "name": "List Should Not Contain Value",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if the ``value`` is found from ``list``.\n\nUse the ``msg`` argument to override the default error message.\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if the ``value`` is found from ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 320
    },
    {
      "name": "Lists Should Be Equal",
      "args": [
        {
          "name": "list1",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list1"
        },
        {
          "name": "list2",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list2"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": "True",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "values=True"
        },
        {
          "name": "names",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "names=None"
        },
        {
          "name": "ignore_order",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_order=False"
        },
        {
          "name": "ignore_case",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case=False"
        }
      ],
      "returnType": null,
      "doc": "Fails if given lists are unequal.\n\nThe keyword first verifies that the lists have equal lengths, and then\nit checks are all their values equal. Possible differences between the\nvalues are listed in the default error message like ``Index 4: ABC !=\nAbc``. The types of the lists do not need to be the same. For example,\nPython tuple and list with same content are considered equal.\n\nThe error message can be configured using ``msg`` and ``values``\narguments:\n- If ``msg`` is not given, the default error message is used.\n- If ``msg`` is given and ``values`` gets a value considered true\n  (see `Boolean arguments`), the error message starts with the given\n  ``msg`` followed by a newline and the default message.\n- If ``msg`` is given and ``values``  is not given a true value,\n  the error message is just the given ``msg``.\n\nThe optional ``names`` argument can be used for naming the indices\nshown in the default error message. It can either be a list of names\nmatching the indices in the lists or a dictionary where keys are\nindices that need to be named. It is not necessary to name all indices.\nWhen using a dictionary, keys can be either integers\nor strings that can be converted to integers.\n\nExamples:\n| ${names} = | Create List | First Name | Family Name | Email |\n| Lists Should Be Equal | ${people1} | ${people2} | names=${names} |\n| ${names} = | Create Dictionary | 0=First Name | 2=Email |\n| Lists Should Be Equal | ${people1} | ${people2} | names=${names} |\n\nIf the items in index 2 would differ in the above examples, the error\nmessage would contain a row like ``Index 2 (email): name@foo.com !=\nname@bar.com``.\n\nThe optional ``ignore_order`` argument can be used to ignore the order\nof the elements in the lists. Using it requires items to be sortable.\nThis option works recursively with nested lists starting from Robot\nFramework 7.0.\n\nExample:\n| ${list1} = | Create List | apple | cherry | banana |\n| ${list2} = | Create List | cherry | banana | apple |\n| Lists Should Be Equal | ${list1} | ${list2} | ignore_order=True |\n\nThe ``ignore_case`` argument can be used to make comparison case-insensitive.\nSee the `Ignore case` section for more details. This option is new in\nRobot Framework 7.0.",
      "shortdoc": "Fails if given lists are unequal.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 361
    },
    {
      "name": "Log Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "level",
          "type": null,
          "defaultValue": "INFO",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "level=INFO"
        }
      ],
      "returnType": null,
      "doc": "Logs the size and contents of the ``dictionary`` using given ``level``.\n\nValid levels are TRACE, DEBUG, INFO (default), and WARN.\n\nIf you only want to log the size, use keyword `Get Length` from\nthe BuiltIn library.",
      "shortdoc": "Logs the size and contents of the ``dictionary`` using given ``level``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 859
    },
    {
      "name": "Log List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "level",
          "type": null,
          "defaultValue": "INFO",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "level=INFO"
        }
      ],
      "returnType": null,
      "doc": "Logs the length and contents of the ``list`` using given ``level``.\n\nValid levels are TRACE, DEBUG, INFO (default), and WARN.\n\nIf you only want to the length, use keyword `Get Length` from\nthe BuiltIn library.",
      "shortdoc": "Logs the length and contents of the ``list`` using given ``level``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 462
    },
    {
      "name": "Pop From Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "key"
        },
        {
          "name": "default",
          "type": null,
          "defaultValue": "",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "default="
        }
      ],
      "returnType": null,
      "doc": "Pops the given ``key`` from the ``dictionary`` and returns its value.\n\nBy default the keyword fails if the given ``key`` cannot be found from\nthe ``dictionary``. If optional ``default`` value is given, it will be\nreturned instead of failing.\n\nExample:\n| ${val}= | Pop From Dictionary | ${D3} | b |\n=>\n| ${val} = 2\n| ${D3} = {'a': 1, 'c': 3}",
      "shortdoc": "Pops the given ``key`` from the ``dictionary`` and returns its value.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 567
    },
    {
      "name": "Remove Duplicates",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        }
      ],
      "returnType": null,
      "doc": "Returns a list without duplicates based on the given ``list``.\n\nCreates and returns a new list that contains all items in the given\nlist so that one item can appear only once. Order of the items in\nthe new list is the same as in the original except for missing\nduplicates. Number of the removed duplicates is logged.",
      "shortdoc": "Returns a list without duplicates based on the given ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 156
    },
    {
      "name": "Remove From Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "keys",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*keys"
        }
      ],
      "returnType": null,
      "doc": "Removes the given ``keys`` from the ``dictionary``.\n\nIf the given ``key`` cannot be found from the ``dictionary``, it\nis ignored.\n\nExample:\n| Remove From Dictionary | ${D3} | b | x | y |\n=>\n| ${D3} = {'a': 1, 'c': 3}",
      "shortdoc": "Removes the given ``keys`` from the ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 548
    },
    {
      "name": "Remove From List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "index",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "index"
        }
      ],
      "returnType": null,
      "doc": "Removes and returns the value specified with an ``index`` from ``list``.\n\nIndex ``0`` means the first position, ``1`` the second and so on.\nSimilarly, ``-1`` is the last position, ``-2`` the second last, and so on.\nUsing an index that does not exist on the list causes an error.\nThe index can be either an integer or a string that can be converted\nto an integer.\n\nExample:\n| ${x} = | Remove From List | ${L2} | 0 |\n=>\n| ${x} = 'a'\n| ${L2} = ['b']",
      "shortdoc": "Removes and returns the value specified with an ``index`` from ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 135
    },
    {
      "name": "Remove Values From List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "values",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*values"
        }
      ],
      "returnType": null,
      "doc": "Removes all occurrences of given ``values`` from ``list``.\n\nIt is not an error if a value does not exist in the list at all.\n\nExample:\n| Remove Values From List | ${L4} | a | c | e | f |\n=>\n| ${L4} = ['b', 'd']",
      "shortdoc": "Removes all occurrences of given ``values`` from ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 120
    },
    {
      "name": "Reverse List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        }
      ],
      "returnType": null,
      "doc": "Reverses the given list in place.\n\nNote that the given list is changed and nothing is returned. Use\n`Copy List` first, if you need to keep also the original order.\n\n| Reverse List | ${L3} |\n=>\n| ${L3} = ['c', 'b', 'a']",
      "shortdoc": "Reverses the given list in place.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 280
    },
    {
      "name": "Set List Value",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        },
        {
          "name": "index",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "index"
        },
        {
          "name": "value",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "value"
        }
      ],
      "returnType": null,
      "doc": "Sets the value of ``list`` specified by ``index`` to the given ``value``.\n\nIndex ``0`` means the first position, ``1`` the second and so on.\nSimilarly, ``-1`` is the last position, ``-2`` second last, and so on.\nUsing an index that does not exist on the list causes an error.\nThe index can be either an integer or a string that can be converted to\nan integer.\n\nExample:\n| Set List Value | ${L3} | 1  | xxx |\n| Set List Value | ${L3} | -1 | yyy |\n=>\n| ${L3} = ['a', 'xxx', 'yyy']\n\nStarting from Robot Framework 6.1, it is also possible to use the native\nitem assignment syntax. This is equivalent to the above:\n| ${L3}[1] =  | Set Variable | xxx |\n| ${L3}[-1] = | Set Variable | yyy |",
      "shortdoc": "Sets the value of ``list`` specified by ``index`` to the given ``value``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 94
    },
    {
      "name": "Set To Dictionary",
      "args": [
        {
          "name": "dictionary",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "dictionary"
        },
        {
          "name": "key_value_pairs",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*key_value_pairs"
        },
        {
          "name": "items",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_NAMED",
          "required": false,
          "repr": "**items"
        }
      ],
      "returnType": null,
      "doc": "Adds the given ``key_value_pairs`` and/or ``items`` to the ``dictionary``.\n\nIf given items already exist in the dictionary, their values are updated.\n\nIt is easiest to specify items using the ``name=value`` syntax:\n| Set To Dictionary | ${D1} | key=value | second=${2} |\n=>\n| ${D1} = {'a': 1, 'key': 'value', 'second': 2}\n\nA limitation of the above syntax is that keys must be strings.\nThat can be avoided by passing keys and values as separate arguments:\n| Set To Dictionary | ${D1} | key | value | ${2} | value 2 |\n=>\n| ${D1} = {'a': 1, 'key': 'value', 2: 'value 2'}\n\nStarting from Robot Framework 6.1, it is also possible to use the native\nitem assignment syntax. This is equivalent to the above:\n| ${D1}[key] =  | Set Variable | value |\n| ${D1}[${2}] = | Set Variable | value 2 |",
      "shortdoc": "Adds the given ``key_value_pairs`` and/or ``items`` to the ``dictionary``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 518
    },
    {
      "name": "Should Contain Match",
      "args": [
        {
          "name": "list",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "case_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "case_insensitive: bool | None = None"
        },
        {
          "name": "whitespace_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "whitespace_insensitive: bool | None = None"
        },
        {
          "name": "ignore_case",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case: bool = False"
        },
        {
          "name": "ignore_whitespace",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_whitespace: bool = False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``pattern`` is not found in ``list``.\n\nBy default, pattern matching is similar to matching files in a shell\nand is case-sensitive and whitespace-sensitive. In the pattern syntax,\n``*`` matches to anything and ``?`` matches to any single character. You\ncan also prepend ``glob=`` to your pattern to explicitly use this pattern\nmatching behavior.\n\nIf you prepend ``regexp=`` to your pattern, your pattern will be used\naccording to the Python\n[http://docs.python.org/library/re.html|re module] regular expression\nsyntax. Notice that the backslash character often used with regular\nexpressions is an escape character in Robot Framework data and needs\nto be escaped with another backslash like ``regexp=\\\\d{6}``. See\n`BuiltIn.Should Match Regexp` for more details.\n\nMatching is case-sensitive by default, but that can be changed by giving\nthe ``ignore_case`` argument a true value (see `Boolean arguments`).\nThis argument is new in Robot Framework 7.0, but with earlier versions\nit is possible to use ``case_insensitive`` for the same purpose.\n\nIt is possible to ignore all whitespace by giving the ``ignore_whitespace``\nargument a true value. This argument is new in Robot Framework 7.0 as well,\nand with earlier versions it is possible to use ``whitespace_insensitive``.\n\nNotice that both ``case_insensitive`` and ``whitespace_insensitive``\nare considered deprecated. They will eventually be removed.\n\nNon-string values in lists are ignored when matching patterns.\n\nUse the ``msg`` argument to override the default error message.\n\nExamples:\n| Should Contain Match | ${list} | a*              | | | # Match strings beginning with 'a'. |\n| Should Contain Match | ${list} | regexp=a.*      | | | # Same as the above but with regexp. |\n| Should Contain Match | ${list} | regexp=\\\\d{6} | | | # Match strings containing six digits. |\n| Should Contain Match | ${list} | a*  | ignore_case=True       | | # Match strings beginning with 'a' or 'A'. |\n| Should Contain Match | ${list} | ab* | ignore_whitespace=yes  | | # Match strings beginning with 'ab' with possible whitespace ignored. |\n| Should Contain Match | ${list} | ab* | ignore_whitespace=true | ignore_case=true | # Same as the above but also ignore case. |",
      "shortdoc": "Fails if ``pattern`` is not found in ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 981
    },
    {
      "name": "Should Not Contain Match",
      "args": [
        {
          "name": "list",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list"
        },
        {
          "name": "pattern",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "pattern"
        },
        {
          "name": "msg",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "msg=None"
        },
        {
          "name": "case_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "case_insensitive: bool | None = None"
        },
        {
          "name": "whitespace_insensitive",
          "type": {
            "name": "Union",
            "typedoc": null,
            "nested": [
              {
                "name": "bool",
                "typedoc": "boolean",
                "nested": [],
                "union": false
              },
              {
                "name": "None",
                "typedoc": "None",
                "nested": [],
                "union": false
              }
            ],
            "union": true
          },
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "whitespace_insensitive: bool | None = None"
        },
        {
          "name": "ignore_case",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_case: bool = False"
        },
        {
          "name": "ignore_whitespace",
          "type": {
            "name": "bool",
            "typedoc": "boolean",
            "nested": [],
            "union": false
          },
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "ignore_whitespace: bool = False"
        }
      ],
      "returnType": null,
      "doc": "Fails if ``pattern`` is found in ``list``.\n\nExact opposite of `Should Contain Match` keyword. See that keyword\nfor information about arguments and usage in general.",
      "shortdoc": "Fails if ``pattern`` is found in ``list``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 1033
    },
    {
      "name": "Sort List",
      "args": [
        {
          "name": "list_",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "list_"
        }
      ],
      "returnType": null,
      "doc": "Sorts the given list in place.\n\nSorting fails if items in the list are not comparable with each others.\nFor example, sorting a list containing strings and numbers is not possible.\n\nNote that the given list is changed and nothing is returned. Use\n`Copy List` first, if you need to preserve the list also in the original\norder.",
      "shortdoc": "Sorts the given list in place.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Collections.py",
      "lineno": 293
    }
  ],
  "typedocs": [
    {
      "type": "Standard",
      "name": "boolean",
      "doc": "Strings ``TRUE``, ``YES``, ``ON`` and ``1`` are converted to Boolean ``True``,\nthe empty string as well as strings ``FALSE``, ``NO``, ``OFF`` and ``0``\nare converted to Boolean ``False``, and the string ``NONE`` is converted\nto the Python ``None`` object. Other strings and other accepted values are\npassed as-is, allowing keywords to handle them specially if\nneeded. All string comparisons are case-insensitive.\n\nExamples: ``TRUE`` (converted to ``True``), ``off`` (converted to ``False``),\n``example`` (used as-is)\n",
      "usages": [
        "Get Match Count",
        "Get Matches",
        "Should Contain Match",
        "Should Not Contain Match"
      ],
      "accepts": [
        "string",
        "integer",
        "float",
        "None"
      ]
    },
    {
      "type": "Standard",
      "name": "None",
      "doc": "String ``NONE`` (case-insensitive) is converted to Python ``None`` object.\nOther values cause an error.\n",
      "usages": [
        "Get Match Count",
        "Get Matches",
        "Should Contain Match",
        "Should Not Contain Match"
      ],
      "accepts": [
        "string"
      ]
    }
  ]
}