Signature: client.containers.run(image, command=None, stdout=True, stderr=False, remove=False, **kwargs)
Docstring:
Run a container. By default, it will wait for the container to finish
and return its logs, similar to ``docker run``.

If the ``detach`` argument is ``True``, it will start the container
and immediately return a :py:class:`Container` object, similar to
``docker run -d``.

Example:
    Run a container and get its output:

    >>> import docker
    >>> client = docker.from_env()
    >>> client.containers.run('alpine', 'echo hello world')
    b'hello world\n'

    Run a container and detach:

    >>> container = client.containers.run('bfirsh/reticulate-splines',
                                          detach=True)
    >>> container.logs()
    'Reticulating spline 1...\nReticulating spline 2...\n'

Args:
    image (str): The image to run.
    command (str or list): The command to run in the container.
    auto_remove (bool): enable auto-removal of the container on daemon
        side when the container's process exits.
    blkio_weight_device: Block IO weight (relative device weight) in
        the form of: ``[{"Path": "device_path", "Weight": weight}]``.
    blkio_weight: Block IO weight (relative weight), accepts a weight
        value between 10 and 1000.
    cap_add (list of str): Add kernel capabilities. For example,
        ``["SYS_ADMIN", "MKNOD"]``.
    cap_drop (list of str): Drop kernel capabilities.
    cpu_count (int): Number of usable CPUs (Windows only).
    cpu_percent (int): Usable percentage of the available CPUs
        (Windows only).
    cpu_period (int): The length of a CPU period in microseconds.
    cpu_quota (int): Microseconds of CPU time that the container can
        get in a CPU period.
    cpu_shares (int): CPU shares (relative weight).
    cpuset_cpus (str): CPUs in which to allow execution (``0-3``,
        ``0,1``).
    cpuset_mems (str): Memory nodes (MEMs) in which to allow execution
        (``0-3``, ``0,1``). Only effective on NUMA systems.
    detach (bool): Run container in the background and return a
        :py:class:`Container` object.
    device_cgroup_rules (:py:class:`list`): A list of cgroup rules to
        apply to the container.
    device_read_bps: Limit read rate (bytes per second) from a device
        in the form of: `[{"Path": "device_path", "Rate": rate}]`
    device_read_iops: Limit read rate (IO per second) from a device.
    device_write_bps: Limit write rate (bytes per second) from a
        device.
    device_write_iops: Limit write rate (IO per second) from a device.
    devices (:py:class:`list`): Expose host devices to the container,
        as a list of strings in the form
        ``<path_on_host>:<path_in_container>:<cgroup_permissions>``.

        For example, ``/dev/sda:/dev/xvda:rwm`` allows the container
        to have read-write access to the host's ``/dev/sda`` via a
        node named ``/dev/xvda`` inside the container.
    dns (:py:class:`list`): Set custom DNS servers.
    dns_opt (:py:class:`list`): Additional options to be added to the
        container's ``resolv.conf`` file.
    dns_search (:py:class:`list`): DNS search domains.
    domainname (str or list): Set custom DNS search domains.
    entrypoint (str or list): The entrypoint for the container.
    environment (dict or list): Environment variables to set inside
        the container, as a dictionary or a list of strings in the
        format ``["SOMEVARIABLE=xxx"]``.
    extra_hosts (dict): Addtional hostnames to resolve inside the
        container, as a mapping of hostname to IP address.
    group_add (:py:class:`list`): List of additional group names and/or
        IDs that the container process will run as.
    healthcheck (dict): Specify a test to perform to check that the
        container is healthy.
    hostname (str): Optional hostname for the container.
    init (bool): Run an init inside the container that forwards
        signals and reaps processes
    init_path (str): Path to the docker-init binary
    ipc_mode (str): Set the IPC mode for the container.
    isolation (str): Isolation technology to use. Default: `None`.
    labels (dict or list): A dictionary of name-value labels (e.g.
        ``{"label1": "value1", "label2": "value2"}``) or a list of
        names of labels to set with empty values (e.g.
        ``["label1", "label2"]``)
    links (dict or list of tuples): Either a dictionary mapping name
        to alias or as a list of ``(name, alias)`` tuples.
    log_config (dict): Logging configuration, as a dictionary with
        keys:

        - ``type`` The logging driver name.
        - ``config`` A dictionary of configuration for the logging
          driver.

    mac_address (str): MAC address to assign to the container.
    mem_limit (int or str): Memory limit. Accepts float values
        (which represent the memory limit of the created container in
        bytes) or a string with a units identification char
        (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is
        specified without a units character, bytes are assumed as an
        intended unit.
    mem_swappiness (int): Tune a container's memory swappiness
        behavior. Accepts number between 0 and 100.
    memswap_limit (str or int): Maximum amount of memory + swap a
        container is allowed to consume.
    mounts (:py:class:`list`): Specification for mounts to be added to
        the container. More powerful alternative to ``volumes``. Each
        item in the list is expected to be a
        :py:class:`docker.types.Mount` object.
    name (str): The name for this container.
    nano_cpus (int):  CPU quota in units of 1e-9 CPUs.
    network (str): Name of the network this container will be connected
        to at creation time. You can connect to additional networks
        using :py:meth:`Network.connect`. Incompatible with
        ``network_mode``.
    network_disabled (bool): Disable networking.
    network_mode (str): One of:

        - ``bridge`` Create a new network stack for the container on
          on the bridge network.
        - ``none`` No networking for this container.
        - ``container:<name|id>`` Reuse another container's network
          stack.
        - ``host`` Use the host network stack.

        Incompatible with ``network``.
    oom_kill_disable (bool): Whether to disable OOM killer.
    oom_score_adj (int): An integer value containing the score given
        to the container in order to tune OOM killer preferences.
    pid_mode (str): If set to ``host``, use the host PID namespace
        inside the container.
    pids_limit (int): Tune a container's pids limit. Set ``-1`` for
        unlimited.
    platform (str): Platform in the format ``os[/arch[/variant]]``.
        Only used if the method needs to pull the requested image.
    ports (dict): Ports to bind inside the container.

        The keys of the dictionary are the ports to bind inside the
        container, either as an integer or a string in the form
        ``port/protocol``, where the protocol is either ``tcp`` or
        ``udp``.

        The values of the dictionary are the corresponding ports to
        open on the host, which can be either:

        - The port number, as an integer. For example,
          ``{'2222/tcp': 3333}`` will expose port 2222 inside the
          container as port 3333 on the host.
        - ``None``, to assign a random host port. For example,
          ``{'2222/tcp': None}``.
        - A tuple of ``(address, port)`` if you want to specify the
          host interface. For example,
          ``{'1111/tcp': ('127.0.0.1', 1111)}``.
        - A list of integers, if you want to bind multiple host ports
          to a single container port. For example,
          ``{'1111/tcp': [1234, 4567]}``.

    privileged (bool): Give extended privileges to this container.
    publish_all_ports (bool): Publish all ports to the host.
    read_only (bool): Mount the container's root filesystem as read
        only.
    remove (bool): Remove the container when it has finished running.
        Default: ``False``.
    restart_policy (dict): Restart the container when it exits.
        Configured as a dictionary with keys:

        - ``Name`` One of ``on-failure``, or ``always``.
        - ``MaximumRetryCount`` Number of times to restart the
          container on failure.

        For example:
        ``{"Name": "on-failure", "MaximumRetryCount": 5}``

    security_opt (:py:class:`list`): A list of string values to
        customize labels for MLS systems, such as SELinux.
    shm_size (str or int): Size of /dev/shm (e.g. ``1G``).
    stdin_open (bool): Keep ``STDIN`` open even if not attached.
    stdout (bool): Return logs from ``STDOUT`` when ``detach=False``.
        Default: ``True``.
    stderr (bool): Return logs from ``STDERR`` when ``detach=False``.
        Default: ``False``.
    stop_signal (str): The stop signal to use to stop the container
        (e.g. ``SIGINT``).
    storage_opt (dict): Storage driver options per container as a
        key-value mapping.
    stream (bool): If true and ``detach`` is false, return a log
        generator instead of a string. Ignored if ``detach`` is true.
        Default: ``False``.
    sysctls (dict): Kernel parameters to set in the container.
    tmpfs (dict): Temporary filesystems to mount, as a dictionary
        mapping a path inside the container to options for that path.

        For example:

        .. code-block:: python

            {
                '/mnt/vol2': '',
                '/mnt/vol1': 'size=3G,uid=1000'
            }

    tty (bool): Allocate a pseudo-TTY.
    ulimits (:py:class:`list`): Ulimits to set inside the container, as
        a list of dicts.
    user (str or int): Username or UID to run commands as inside the
        container.
    userns_mode (str): Sets the user namespace mode for the container
        when user namespace remapping option is enabled. Supported
        values are: ``host``
    volume_driver (str): The name of a volume driver/plugin.
    volumes (dict or list): A dictionary to configure volumes mounted
        inside the container. The key is either the host path or a
        volume name, and the value is a dictionary with the keys:

        - ``bind`` The path to mount the volume inside the container
        - ``mode`` Either ``rw`` to mount the volume read/write, or
          ``ro`` to mount it read-only.

        For example:

        .. code-block:: python

            {'/home/user1/': {'bind': '/mnt/vol2', 'mode': 'rw'},
             '/var/www': {'bind': '/mnt/vol1', 'mode': 'ro'}}

    volumes_from (:py:class:`list`): List of container names or IDs to
        get volumes from.
    working_dir (str): Path to the working directory.
    runtime (str): Runtime to use with this container.

Returns:
    The container logs, either ``STDOUT``, ``STDERR``, or both,
    depending on the value of the ``stdout`` and ``stderr`` arguments.

    ``STDOUT`` and ``STDERR`` may be read only if either ``json-file``
    or ``journald`` logging driver used. Thus, if you are using none of
    these drivers, a ``None`` object is returned instead. See the
    `Engine API documentation
    <https://docs.docker.com/engine/api/v1.30/#operation/ContainerLogs/>`_
    for full details.

    If ``detach`` is ``True``, a :py:class:`Container` object is
    returned instead.

Raises:
    :py:class:`docker.errors.ContainerError`
        If the container exits with a non-zero exit code and
        ``detach`` is ``False``.
    :py:class:`docker.errors.ImageNotFound`
        If the specified image does not exist.
    :py:class:`docker.errors.APIError`
        If the server returns an error.
File:      ~/conda/lib/python3.6/site-packages/docker/models/containers.py
Type:      method

[I 10:50:59.099 NotebookApp] Writing notebook server cookie secret to /home/jovyan/.local/share/jupyter/runtime/notebook_cookie_secret
[I 10:50:59.262 NotebookApp] JupyterLab beta preview extension loaded from /opt/conda/lib/python3.6/site-packages/jupyterlab
[I 10:50:59.262 NotebookApp] JupyterLab application directory is /opt/conda/share/jupyter/lab
[I 10:50:59.265 NotebookApp] Serving notebooks from local directory: /home/jovyan
[I 10:50:59.265 NotebookApp] 0 active kernels
[I 10:50:59.265 NotebookApp] The Jupyter Notebook is running at:
[I 10:50:59.265 NotebookApp] http://53b926531746:58938/?token=72f0ac9a4bf481fce1932b2f71b884fd85f5147845be0001
[I 10:50:59.265 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 10:50:59.266 NotebookApp] 
    
    Copy/paste this URL into your browser when you connect for the first time,
    to login with a token:
        http://53b926531746:58938/?token=72f0ac9a4bf481fce1932b2f71b884fd85f5147845be0001&token=72f0ac9a4bf481fce1932b2f71b884fd85f5147845be0001
[I 10:51:22.954 NotebookApp] 302 GET / (172.17.0.1) 0.55ms
[I 10:51:22.958 NotebookApp] 302 GET /tree? (172.17.0.1) 0.61ms
[I 10:52:36.154 NotebookApp] 302 GET / (172.17.0.1) 0.65ms
[I 10:52:36.162 NotebookApp] 302 GET /tree (172.17.0.1) 0.77ms
[W 10:52:41.519 NotebookApp] Forbidden
[W 10:52:41.520 NotebookApp] 403 GET /api/status (172.17.0.1) 0.96ms referer=None