{
  "specversion": 3,
  "name": "Telnet",
  "doc": "A library providing communication over Telnet connections.\n\n``Telnet`` is Robot Framework's standard library that makes it possible to\nconnect to Telnet servers and execute commands on the opened connections.\n\n== Table of contents ==\n\n- `Connections`\n- `Writing and reading`\n- `Configuration`\n- `Terminal emulation`\n- `Logging`\n- `Time string format`\n- `Boolean arguments`\n- `Importing`\n- `Keywords`\n\n= Connections =\n\nThe first step of using ``Telnet`` is opening a connection with `Open\nConnection` keyword. Typically the next step is logging in with `Login`\nkeyword, and in the end the opened connection can be closed with `Close\nConnection`.\n\nIt is possible to open multiple connections and switch the active one\nusing `Switch Connection`. `Close All Connections` can be used to close\nall the connections, which is especially useful in suite teardowns to\nguarantee that all connections are always closed.\n\n= Writing and reading =\n\nAfter opening a connection and possibly logging in, commands can be\nexecuted or text written to the connection for other reasons using `Write`\nand `Write Bare` keywords. The main difference between these two is that\nthe former adds a [#Configuration|configurable newline] after the text\nautomatically.\n\nAfter writing something to the connection, the resulting output can be\nread using `Read`, `Read Until`, `Read Until Regexp`, and `Read Until\nPrompt` keywords. Which one to use depends on the context, but the latest\none is often the most convenient.\n\nAs a convenience when running a command, it is possible to use `Execute\nCommand` that simply uses `Write` and `Read Until Prompt` internally.\n`Write Until Expected Output` is useful if you need to wait until writing\nsomething produces a desired output.\n\nWritten and read text is automatically encoded/decoded using a\n[#Configuration|configured encoding].\n\nThe ANSI escape codes, like cursor movement and color codes, are\nnormally returned as part of the read operation. If an escape code occurs\nin middle of a search pattern it may also prevent finding the searched\nstring. `Terminal emulation` can be used to process these\nescape codes as they would be if a real terminal would be in use.\n\n= Configuration =\n\nMany aspects related the connections can be easily configured either\nglobally or per connection basis. Global configuration is done when\n[#Importing|library is imported], and these values can be overridden per\nconnection by `Open Connection` or with setting specific keywords\n`Set Timeout`, `Set Newline`, `Set Prompt`, `Set Encoding`,\n`Set Default Log Level` and `Set Telnetlib Log Level`.\n\nValues of ``environ_user``, ``window_size``, ``terminal_emulation``, and\n``terminal_type`` can not be changed after opening the connection.\n\n== Timeout ==\n\nTimeout defines how long is the maximum time to wait when reading\noutput. It is used internally by `Read Until`, `Read Until Regexp`,\n`Read Until Prompt`, and `Login` keywords. The default value is 3 seconds.\n\n== Connection Timeout ==\n\nConnection Timeout defines how long is the maximum time to wait when\nopening the telnet connection. It is used internally by `Open Connection`.\nThe default value is the system global default timeout.\n\n== Newline ==\n\nNewline defines which line separator `Write` keyword should use. The\ndefault value is ``CRLF`` that is typically used by Telnet connections.\n\nNewline can be given either in escaped format using ``\\n`` and ``\\r`` or\nwith special ``LF`` and ``CR`` syntax.\n\nExamples:\n| `Set Newline` | \\n  |\n| `Set Newline` | CRLF |\n\n== Prompt ==\n\nOften the easiest way to read the output of a command is reading all\nthe output until the next prompt with `Read Until Prompt`. It also makes\nit easier, and faster, to verify did `Login` succeed.\n\nPrompt can be specified either as a normal string or a regular expression.\nThe latter is especially useful if the prompt changes as a result of\nthe executed commands. Prompt can be set to be a regular expression\nby giving ``prompt_is_regexp`` argument a true value (see `Boolean\narguments`).\n\nExamples:\n| `Open Connection` | lolcathost | prompt=$              |\n| `Set Prompt`      | (> |# )    | prompt_is_regexp=true |\n\n== Encoding ==\n\nTo ease handling text containing non-ASCII characters, all written text is\nencoded and read text decoded by default. The default encoding is UTF-8\nthat works also with ASCII. Encoding can be disabled by using a special\nencoding value ``NONE``. This is mainly useful if you need to get the bytes\nreceived from the connection as-is.\n\nNotice that when writing to the connection, only Unicode strings are\nencoded using the defined encoding. Byte strings are expected to be already\nencoded correctly. Notice also that normal text in data is passed to\nthe library as Unicode and you need to use variables to use bytes.\n\nIt is also possible to configure the error handler to use if encoding or\ndecoding characters fails. Accepted values are the same that encode/decode\nfunctions in Python strings accept. In practice the following values are\nthe most useful:\n\n- ``ignore``: ignore characters that cannot be encoded (default)\n- ``strict``: fail if characters cannot be encoded\n- ``replace``: replace characters that cannot be encoded with a replacement\n  character\n\nExamples:\n| `Open Connection` | lolcathost | encoding=Latin1 | encoding_errors=strict |\n| `Set Encoding` | ISO-8859-15 |\n| `Set Encoding` | errors=ignore |\n\n== Default log level ==\n\nDefault log level specifies the log level keywords use for `logging` unless\nthey are given an explicit log level. The default value is ``INFO``, and\nchanging it, for example, to ``DEBUG`` can be a good idea if there is lot\nof unnecessary output that makes log files big.\n\n== Terminal type ==\n\nBy default the Telnet library does not negotiate any specific terminal type\nwith the server. If a specific terminal type, for example ``vt100``, is\ndesired, the terminal type can be configured in `importing` and with\n`Open Connection`.\n\n== Window size ==\n\nWindow size for negotiation with the server can be configured when\n`importing` the library and with `Open Connection`.\n\n== USER environment variable ==\n\nTelnet protocol allows the ``USER`` environment variable to be sent when\nconnecting to the server. On some servers it may happen that there is no\nlogin prompt, and on those cases this configuration option will allow still\nto define the desired username. The option ``environ_user`` can be used in\n`importing` and with `Open Connection`.\n\n= Terminal emulation =\n\nTelnet library supports terminal\nemulation with [http://pyte.readthedocs.io|Pyte]. Terminal emulation\nwill process the output in a virtual screen. This means that ANSI escape\ncodes, like cursor movements, and also control characters, like\ncarriage returns and backspaces, have the same effect on the result as they\nwould have on a normal terminal screen. For example the sequence\n``acdc\\x1b[3Dbba`` will result in output ``abba``.\n\nTerminal emulation is taken into use by giving ``terminal_emulation``\nargument a true value (see `Boolean arguments`) either in the library\ninitialization or with `Open Connection`.\n\nAs Pyte approximates vt-style terminal, you may also want to set the\nterminal type as ``vt100``. We also recommend that you increase the window\nsize, as the terminal emulation will break all lines that are longer than\nthe window row length.\n\nWhen terminal emulation is used, the `newline` and `encoding` can not be\nchanged anymore after opening the connection.\n\nExamples:\n| `Open Connection` | lolcathost | terminal_emulation=True | terminal_type=vt100 | window_size=400x100 |\n\nAs a prerequisite for using terminal emulation, you need to have Pyte\ninstalled. Due to backwards incompatible changes in Pyte, different\nRobot Framework versions support different Pyte versions:\n\n- Pyte 0.6 and newer are supported by Robot Framework 3.0.3.\n  Latest Pyte version can be installed (or upgraded) with\n  ``pip install --upgrade pyte``.\n- Pyte 0.5.2 and older are supported by Robot Framework 3.0.2 and earlier.\n  Pyte 0.5.2 can be installed with ``pip install pyte==0.5.2``.\n\n= Logging =\n\nAll keywords that read something log the output. These keywords take the\nlog level to use as an optional argument, and if no log level is specified\nthey use the [#Configuration|configured] default value.\n\nThe valid log levels to use are ``TRACE``, ``DEBUG``, ``INFO`` (default),\nand ``WARN``. Levels below ``INFO`` are not shown in log files by default\nwhereas warnings are shown more prominently.\n\nThe [http://docs.python.org/library/telnetlib.html|telnetlib module]\nused by this library has a custom logging system for logging content it\nsends and receives. By default these messages are written using ``TRACE``\nlevel, but the level is configurable with the ``telnetlib_log_level``\noption either in the library initialization, to the `Open Connection`\nor by using the `Set Telnetlib Log Level` keyword to the active\nconnection. Special level ``NONE`` con be used to disable the logging\naltogether.\n\n= Time string format =\n\nTimeouts and other times used must be given as a time string using format\nlike ``15 seconds`` or ``1min 10s``. If the timeout is given as just\na number, for example, ``10`` or ``1.5``, it is considered to be seconds.\nThe time string format is described in more detail in an appendix of\n[http://robotframework.org/robotframework/#user-guide|Robot Framework User Guide].\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. Other strings are considered true regardless\ntheir value, and other argument types are tested using the same\n[http://docs.python.org/library/stdtypes.html#truth|rules as in Python].\n\nTrue examples:\n| `Open Connection` | lolcathost | terminal_emulation=True    | # Strings are generally true.    |\n| `Open Connection` | lolcathost | terminal_emulation=yes     | # Same as the above.             |\n| `Open Connection` | lolcathost | terminal_emulation=${TRUE} | # Python ``True`` is true.       |\n| `Open Connection` | lolcathost | terminal_emulation=${42}   | # Numbers other than 0 are true. |\n\nFalse examples:\n| `Open Connection` | lolcathost | terminal_emulation=False    | # String ``false`` is false.   |\n| `Open Connection` | lolcathost | terminal_emulation=no       | # Also string ``no`` is false. |\n| `Open Connection` | lolcathost | terminal_emulation=${EMPTY} | # Empty string is false.       |\n| `Open Connection` | lolcathost | terminal_emulation=${FALSE} | # Python ``False`` is false.   |\n\nConsidering string ``NONE`` false is new in Robot Framework 3.0.3 and\nconsidering also ``OFF`` and ``0`` false is new in Robot Framework 3.1.",
  "version": "7.2.dev1",
  "generated": "2024-10-02T23:00:47+00:00",
  "type": "LIBRARY",
  "scope": "SUITE",
  "docFormat": "ROBOT",
  "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
  "lineno": 36,
  "tags": [],
  "inits": [
    {
      "name": "__init__",
      "args": [
        {
          "name": "timeout",
          "type": null,
          "defaultValue": "3 seconds",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "timeout=3 seconds"
        },
        {
          "name": "newline",
          "type": null,
          "defaultValue": "CRLF",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "newline=CRLF"
        },
        {
          "name": "prompt",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "prompt=None"
        },
        {
          "name": "prompt_is_regexp",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "prompt_is_regexp=False"
        },
        {
          "name": "encoding",
          "type": null,
          "defaultValue": "UTF-8",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding=UTF-8"
        },
        {
          "name": "encoding_errors",
          "type": null,
          "defaultValue": "ignore",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding_errors=ignore"
        },
        {
          "name": "default_log_level",
          "type": null,
          "defaultValue": "INFO",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "default_log_level=INFO"
        },
        {
          "name": "window_size",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "window_size=None"
        },
        {
          "name": "environ_user",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "environ_user=None"
        },
        {
          "name": "terminal_emulation",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "terminal_emulation=False"
        },
        {
          "name": "terminal_type",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "terminal_type=None"
        },
        {
          "name": "telnetlib_log_level",
          "type": null,
          "defaultValue": "TRACE",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "telnetlib_log_level=TRACE"
        },
        {
          "name": "connection_timeout",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "connection_timeout=None"
        }
      ],
      "returnType": null,
      "doc": "Telnet library can be imported with optional configuration parameters.\n\nConfiguration parameters are used as default values when new\nconnections are opened with `Open Connection` keyword. They can also be\noverridden after opening the connection using the `Set ...` `keywords`.\nSee these keywords as well as `Configuration`, `Terminal emulation` and\n`Logging` sections above for more information about these parameters\nand their possible values.\n\nSee `Time string format` and `Boolean arguments` sections for\ninformation about using arguments accepting times and Boolean values,\nrespectively.\n\nExamples (use only one of these):\n| = Setting = | = Value = | = Value =                | = Value =            | = Value =           | = Comment = |\n| Library     | Telnet    |                          |                      |                     | # default values |\n| Library     | Telnet    | 5 seconds                |                      |                     | # set only timeout |\n| Library     | Telnet    | newline=LF               | encoding=ISO-8859-1  |                     | # set newline and encoding using named arguments |\n| Library     | Telnet    | prompt=$                 |                      |                     | # set prompt |\n| Library     | Telnet    | prompt=(> |# )           | prompt_is_regexp=yes |                     | # set prompt as a regular expression |\n| Library     | Telnet    | terminal_emulation=True  | terminal_type=vt100  | window_size=400x100 | # use terminal emulation with defined window size and terminal type |\n| Library     | Telnet    | telnetlib_log_level=NONE |                      |                     | # disable logging messages from the underlying telnetlib |",
      "shortdoc": "Telnet library can be imported with optional configuration parameters.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 281
    }
  ],
  "keywords": [
    {
      "name": "Close All Connections",
      "args": [],
      "returnType": null,
      "doc": "Closes all open connections and empties the connection cache.\n\nIf multiple connections are opened, this keyword should be used in\na test or suite teardown to make sure that all connections are closed.\nIt is not an error if some of the connections have already been closed\nby `Close Connection`.\n\nAfter this keyword, new indexes returned by `Open Connection`\nkeyword are reset to 1.",
      "shortdoc": "Closes all open connections and empties the connection cache.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 470
    },
    {
      "name": "Close Connection",
      "args": [
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        }
      ],
      "returnType": null,
      "doc": "Closes the current Telnet connection.\n\nRemaining output in the connection is read, logged, and returned.\nIt is not an error to close an already closed connection.\n\nUse `Close All Connections` if you want to make sure all opened\nconnections are closed.\n\nSee `Logging` section for more information about log levels.",
      "shortdoc": "Closes the current Telnet connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 686
    },
    {
      "name": "Execute Command",
      "args": [
        {
          "name": "command",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "command"
        },
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        },
        {
          "name": "strip_prompt",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "strip_prompt=False"
        }
      ],
      "returnType": null,
      "doc": "Executes the given ``command`` and reads, logs, and returns everything until the prompt.\n\nThis keyword requires the prompt to be [#Configuration|configured]\neither in `importing` or with `Open Connection` or `Set Prompt` keyword.\n\nThis is a convenience keyword that uses `Write` and `Read Until Prompt`\ninternally. Following two examples are thus functionally identical:\n\n| ${out} = | `Execute Command`   | pwd |\n\n| `Write`  | pwd                 |\n| ${out} = | `Read Until Prompt` |\n\nSee `Logging` section for more information about log levels and `Read\nUntil Prompt` for more information about the ``strip_prompt`` parameter.",
      "shortdoc": "Executes the given ``command`` and reads, logs, and returns everything until the prompt.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 1054
    },
    {
      "name": "Login",
      "args": [
        {
          "name": "username",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "username"
        },
        {
          "name": "password",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "password"
        },
        {
          "name": "login_prompt",
          "type": null,
          "defaultValue": "login: \\",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "login_prompt=login: \\"
        },
        {
          "name": "password_prompt",
          "type": null,
          "defaultValue": "Password: \\",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "password_prompt=Password: \\"
        },
        {
          "name": "login_timeout",
          "type": null,
          "defaultValue": "1 second",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "login_timeout=1 second"
        },
        {
          "name": "login_incorrect",
          "type": null,
          "defaultValue": "Login incorrect",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "login_incorrect=Login incorrect"
        }
      ],
      "returnType": null,
      "doc": "Logs in to the Telnet server with the given user information.\n\nThis keyword reads from the connection until the ``login_prompt`` is\nencountered and then types the given ``username``. Then it reads until\nthe ``password_prompt`` and types the given ``password``. In both cases\na newline is appended automatically and the connection specific\ntimeout used when waiting for outputs.\n\nHow logging status is verified depends on whether a prompt is set for\nthis connection or not:\n\n1) If the prompt is set, this keyword reads the output until the prompt\nis found using the normal timeout. If no prompt is found, login is\nconsidered failed and also this keyword fails. Note that in this case\nboth ``login_timeout`` and ``login_incorrect`` arguments are ignored.\n\n2) If the prompt is not set, this keywords sleeps until ``login_timeout``\nand then reads all the output available on the connection. If the\noutput contains ``login_incorrect`` text, login is considered failed\nand also this keyword fails.\n\nSee `Configuration` section for more information about setting\nnewline, timeout, and prompt.",
      "shortdoc": "Logs in to the Telnet server with the given user information.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 704
    },
    {
      "name": "Open Connection",
      "args": [
        {
          "name": "host",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "host"
        },
        {
          "name": "alias",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "alias=None"
        },
        {
          "name": "port",
          "type": null,
          "defaultValue": "23",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "port=23"
        },
        {
          "name": "timeout",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "timeout=None"
        },
        {
          "name": "newline",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "newline=None"
        },
        {
          "name": "prompt",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "prompt=None"
        },
        {
          "name": "prompt_is_regexp",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "prompt_is_regexp=False"
        },
        {
          "name": "encoding",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding=None"
        },
        {
          "name": "encoding_errors",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding_errors=None"
        },
        {
          "name": "default_log_level",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "default_log_level=None"
        },
        {
          "name": "window_size",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "window_size=None"
        },
        {
          "name": "environ_user",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "environ_user=None"
        },
        {
          "name": "terminal_emulation",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "terminal_emulation=None"
        },
        {
          "name": "terminal_type",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "terminal_type=None"
        },
        {
          "name": "telnetlib_log_level",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "telnetlib_log_level=None"
        },
        {
          "name": "connection_timeout",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "connection_timeout=None"
        }
      ],
      "returnType": null,
      "doc": "Opens a new Telnet connection to the given host and port.\n\nThe ``timeout``, ``newline``, ``prompt``, ``prompt_is_regexp``,\n``encoding``, ``default_log_level``, ``window_size``, ``environ_user``,\n``terminal_emulation``, ``terminal_type`` and ``telnetlib_log_level``\narguments get default values when the library is [#Importing|imported].\nSetting them here overrides those values for the opened connection.\nSee `Configuration`, `Terminal emulation` and `Logging` sections for\nmore information about these parameters and their possible values.\n\nPossible already opened connections are cached and it is possible to\nswitch back to them using `Switch Connection` keyword. It is possible to\nswitch either using explicitly given ``alias`` or using index returned\nby this keyword. Indexing starts from 1 and is reset back to it by\n`Close All Connections` keyword.",
      "shortdoc": "Opens a new Telnet connection to the given host and port.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 362
    },
    {
      "name": "Read",
      "args": [
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        }
      ],
      "returnType": null,
      "doc": "Reads everything that is currently available in the output.\n\nRead output is both returned and logged. See `Logging` section for more\ninformation about log levels.",
      "shortdoc": "Reads everything that is currently available in the output.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 874
    },
    {
      "name": "Read Until",
      "args": [
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        }
      ],
      "returnType": null,
      "doc": "Reads output until ``expected`` text is encountered.\n\nText up to and including the match is returned and logged. If no match\nis found, this keyword fails. How much to wait for the output depends\non the [#Configuration|configured timeout].\n\nSee `Logging` section for more information about log levels. Use\n`Read Until Regexp` if more complex matching is needed.",
      "shortdoc": "Reads output until ``expected`` text is encountered.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 888
    },
    {
      "name": "Read Until Prompt",
      "args": [
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        },
        {
          "name": "strip_prompt",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "strip_prompt=False"
        }
      ],
      "returnType": null,
      "doc": "Reads output until the prompt is encountered.\n\nThis keyword requires the prompt to be [#Configuration|configured]\neither in `importing` or with `Open Connection` or `Set Prompt` keyword.\n\nBy default, text up to and including the prompt is returned and logged.\nIf no prompt is found, this keyword fails. How much to wait for the\noutput depends on the [#Configuration|configured timeout].\n\nIf you want to exclude the prompt from the returned output, set\n``strip_prompt`` to a true value (see `Boolean arguments`). If your\nprompt is a regular expression, make sure that the expression spans the\nwhole prompt, because only the part of the output that matches the\nregular expression is stripped away.\n\nSee `Logging` section for more information about log levels.",
      "shortdoc": "Reads output until the prompt is encountered.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 1009
    },
    {
      "name": "Read Until Regexp",
      "args": [
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "VAR_POSITIONAL",
          "required": false,
          "repr": "*expected"
        }
      ],
      "returnType": null,
      "doc": "Reads output until any of the ``expected`` regular expressions match.\n\nThis keyword accepts any number of regular expressions patterns or\ncompiled Python regular expression objects as arguments. Text up to\nand including the first match to any of the regular expressions is\nreturned and logged. If no match is found, this keyword fails. How much\nto wait for the output depends on the [#Configuration|configured timeout].\n\nIf the last given argument is a [#Logging|valid log level], it is used\nas ``loglevel`` similarly as with `Read Until` keyword.\n\nSee the documentation of\n[http://docs.python.org/library/re.html|Python re module]\nfor more information about the supported regular expression syntax.\nNotice that possible backslashes need to be escaped in Robot Framework data.\n\nExamples:\n| `Read Until Regexp` | (#|$) |\n| `Read Until Regexp` | first_regexp | second_regexp |\n| `Read Until Regexp` | \\\\d{4}-\\\\d{2}-\\\\d{2} | DEBUG |",
      "shortdoc": "Reads output until any of the ``expected`` regular expressions match.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 972
    },
    {
      "name": "Set Default Log Level",
      "args": [
        {
          "name": "level",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "level"
        }
      ],
      "returnType": null,
      "doc": "Sets the default log level used for `logging` in the current connection.\n\nThe old default log level is returned and can be used to restore the\nlog level later.\n\nSee `Configuration` section for more information about global and\nconnection specific configuration.",
      "shortdoc": "Sets the default log level used for `logging` in the current connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 660
    },
    {
      "name": "Set Encoding",
      "args": [
        {
          "name": "encoding",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "encoding=None"
        },
        {
          "name": "errors",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "errors=None"
        }
      ],
      "returnType": null,
      "doc": "Sets the encoding to use for `writing and reading` in the current connection.\n\nThe given ``encoding`` specifies the encoding to use when written/read\ntext is encoded/decoded, and ``errors`` specifies the error handler to\nuse if encoding/decoding fails. Either of these can be omitted and in\nthat case the old value is not affected. Use string ``NONE`` to disable\nencoding altogether.\n\nSee `Configuration` section for more information about encoding and\nerror handlers, as well as global and connection specific configuration\nin general.\n\nThe old values are returned and can be used to restore the encoding\nand the error handler later. See `Set Prompt` for a similar example.\n\nIf terminal emulation is used, the encoding can not be changed on an open\nconnection.",
      "shortdoc": "Sets the encoding to use for `writing and reading` in the current connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 601
    },
    {
      "name": "Set Newline",
      "args": [
        {
          "name": "newline",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "newline"
        }
      ],
      "returnType": null,
      "doc": "Sets the newline used by `Write` keyword in the current connection.\n\nThe old newline is returned and can be used to restore the newline later.\nSee `Set Timeout` for a similar example.\n\nIf terminal emulation is used, the newline can not be changed on an open\nconnection.\n\nSee `Configuration` section for more information about global and\nconnection specific configuration.",
      "shortdoc": "Sets the newline used by `Write` keyword in the current connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 540
    },
    {
      "name": "Set Prompt",
      "args": [
        {
          "name": "prompt",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "prompt"
        },
        {
          "name": "prompt_is_regexp",
          "type": null,
          "defaultValue": "False",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "prompt_is_regexp=False"
        }
      ],
      "returnType": null,
      "doc": "Sets the prompt used by `Read Until Prompt` and `Login` in the current connection.\n\nIf ``prompt_is_regexp`` is given a true value (see `Boolean arguments`),\nthe given ``prompt`` is considered to be a regular expression.\n\nThe old prompt is returned and can be used to restore the prompt later.\n\nExample:\n| ${prompt} | ${regexp} = | `Set Prompt` | $ |\n| `Do Something` |\n| `Set Prompt` | ${prompt} | ${regexp} |\n\nSee the documentation of\n[http://docs.python.org/library/re.html|Python re module]\nfor more information about the supported regular expression syntax.\nNotice that possible backslashes need to be escaped in Robot Framework data.\n\nSee `Configuration` section for more information about global and\nconnection specific configuration.",
      "shortdoc": "Sets the prompt used by `Read Until Prompt` and `Login` in the current connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 563
    },
    {
      "name": "Set Telnetlib Log Level",
      "args": [
        {
          "name": "level",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "level"
        }
      ],
      "returnType": null,
      "doc": "Sets the log level used for `logging` in the underlying ``telnetlib``.\n\nNote that ``telnetlib`` can be very noisy thus using the level ``NONE``\ncan shutdown the messages generated by this library.",
      "shortdoc": "Sets the log level used for `logging` in the underlying ``telnetlib``.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 642
    },
    {
      "name": "Set Timeout",
      "args": [
        {
          "name": "timeout",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "timeout"
        }
      ],
      "returnType": null,
      "doc": "Sets the timeout used for waiting output in the current connection.\n\nRead operations that expect some output to appear (`Read Until`, `Read\nUntil Regexp`, `Read Until Prompt`, `Login`) use this timeout and fail\nif the expected output does not appear before this timeout expires.\n\nThe ``timeout`` must be given in `time string format`. The old timeout\nis returned and can be used to restore the timeout later.\n\nExample:\n| ${old} =       | `Set Timeout` | 2 minute 30 seconds |\n| `Do Something` |\n| `Set Timeout`  | ${old}  |\n\nSee `Configuration` section for more information about global and\nconnection specific configuration.",
      "shortdoc": "Sets the timeout used for waiting output in the current connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 514
    },
    {
      "name": "Switch Connection",
      "args": [
        {
          "name": "index_or_alias",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "index_or_alias"
        }
      ],
      "returnType": null,
      "doc": "Switches between active connections using an index or an alias.\n\nAliases can be given to `Open Connection` keyword which also always\nreturns the connection index.\n\nThis keyword returns the index of previous active connection.\n\nExample:\n| `Open Connection`   | myhost.net              |          |           |\n| `Login`             | john                    | secret   |           |\n| `Write`             | some command            |          |           |\n| `Open Connection`   | yourhost.com            | 2nd conn |           |\n| `Login`             | root                    | password |           |\n| `Write`             | another cmd             |          |           |\n| ${old index}=       | `Switch Connection`     | 1        | # index   |\n| `Write`             | something               |          |           |\n| `Switch Connection` | 2nd conn                |          | # alias   |\n| `Write`             | whatever                |          |           |\n| `Switch Connection` | ${old index}            | | # back to original |\n| [Teardown]          | `Close All Connections` |          |           |\n\nThe example above expects that there were no other open\nconnections when opening the first one, because it used index\n``1`` when switching to the connection later. If you are not\nsure about that, you can store the index into a variable as\nshown below.\n\n| ${index} =          | `Open Connection` | myhost.net |\n| `Do Something`      |                   |            |\n| `Switch Connection` | ${index}          |            |",
      "shortdoc": "Switches between active connections using an index or an alias.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 434
    },
    {
      "name": "Write",
      "args": [
        {
          "name": "text",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "text"
        },
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        }
      ],
      "returnType": null,
      "doc": "Writes the given text plus a newline into the connection.\n\nThe newline character sequence to use can be [#Configuration|configured]\nboth globally and per connection basis. The default value is ``CRLF``.\n\nThis keyword consumes the written text, until the added newline, from\nthe output and logs and returns it. The given text itself must not\ncontain newlines. Use `Write Bare` instead if either of these features\ncauses a problem.\n\n*Note:* This keyword does not return the possible output of the executed\ncommand. To get the output, one of the `Read ...` `keywords` must be\nused. See `Writing and reading` section for more details.\n\nSee `Logging` section for more information about log levels.",
      "shortdoc": "Writes the given text plus a newline into the connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 759
    },
    {
      "name": "Write Bare",
      "args": [
        {
          "name": "text",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "text"
        }
      ],
      "returnType": null,
      "doc": "Writes the given text, and nothing else, into the connection.\n\nThis keyword does not append a newline nor consume the written text.\nUse `Write` if these features are needed.",
      "shortdoc": "Writes the given text, and nothing else, into the connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 789
    },
    {
      "name": "Write Control Character",
      "args": [
        {
          "name": "character",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "character"
        }
      ],
      "returnType": null,
      "doc": "Writes the given control character into the connection.\n\nThe control character is prepended with an IAC (interpret as command)\ncharacter.\n\nThe following control character names are supported: BRK, IP, AO, AYT,\nEC, EL, NOP. Additionally, you can use arbitrary numbers to send any\ncontrol character.\n\nExample:\n| Write Control Character | BRK | # Send Break command |\n| Write Control Character | 241 | # Send No operation command |",
      "shortdoc": "Writes the given control character into the connection.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 835
    },
    {
      "name": "Write Until Expected Output",
      "args": [
        {
          "name": "text",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "text"
        },
        {
          "name": "expected",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "expected"
        },
        {
          "name": "timeout",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "timeout"
        },
        {
          "name": "retry_interval",
          "type": null,
          "defaultValue": null,
          "kind": "POSITIONAL_OR_NAMED",
          "required": true,
          "repr": "retry_interval"
        },
        {
          "name": "loglevel",
          "type": null,
          "defaultValue": "None",
          "kind": "POSITIONAL_OR_NAMED",
          "required": false,
          "repr": "loglevel=None"
        }
      ],
      "returnType": null,
      "doc": "Writes the given ``text`` repeatedly, until ``expected`` appears in the output.\n\n``text`` is written without appending a newline and it is consumed from\nthe output before trying to find ``expected``. If ``expected`` does not\nappear in the output within ``timeout``, this keyword fails.\n\n``retry_interval`` defines the time to wait ``expected`` to appear before\nwriting the ``text`` again. Consuming the written ``text`` is subject to\nthe normal [#Configuration|configured timeout].\n\nBoth ``timeout`` and ``retry_interval`` must be given in `time string\nformat`. See `Logging` section for more information about log levels.\n\nExample:\n| Write Until Expected Output | ps -ef| grep myprocess\\r\\n | myprocess |\n| ...                         | 5 s                          | 0.5 s     |\n\nThe above example writes command ``ps -ef | grep myprocess\\r\\n`` until\n``myprocess`` appears in the output. The command is written every 0.5\nseconds and the keyword fails if ``myprocess`` does not appear in\nthe output in 5 seconds.",
      "shortdoc": "Writes the given ``text`` repeatedly, until ``expected`` appears in the output.",
      "tags": [],
      "source": "/home/peke/Devel/robotframework/src/robot/libraries/Telnet.py",
      "lineno": 798
    }
  ],
  "typedocs": []
}