
    2.aN                     ~    d dl Z d dlZddlmZmZmZ ddlmZ  e j                  e	      Z
 G d d      Zd Z	 	 d	dZy)
    N   )autherrorsutils)DEFAULT_DATA_CHUNK_SIZEc                   
   e Zd Z ej                  d      efd       Z ej                  d      d        ZddZ	 	 ddZ		 	 ddZ
	 	 ddZ	 	 dd	Z	 	 dd
Z	 	 ddZ ej                  d      d        Z ej                   d       ej                  d      dd              ZddZ ej                   d      dd       Z	 	 ddZ	 	 ddZ ej                  d      dd       ZddZ ej                  d      dd       Zy)ImageApiMixinimagec                 n    | j                  | j                  d|      d      }| j                  ||d      S )a  
        Get a tarball of an image. Similar to the ``docker save`` command.

        Args:
            image (str): Image name to get
            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:
            (generator): A stream of raw archive data.

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.

        Example:

            >>> image = client.api.get_image("busybox:latest")
            >>> f = open('/tmp/busybox-latest.tar', 'wb')
            >>> for chunk in image:
            >>>   f.write(chunk)
            >>> f.close()
        z/images/{0}/getT)streamF)_get_url_stream_raw_result)selfr
   
chunk_sizeress       2/usr/lib/python3/dist-packages/docker/api/image.py	get_imagezImageApiMixin.get_image   s7    4 ii		"3U;DiI&&sJ>>    c                 h    | j                  | j                  d|            }| j                  |d      S )a#  
        Show the history of an image.

        Args:
            image (str): The image to show history for

        Returns:
            (str): The history of the image

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        z/images/{0}/historyT)r   r   _result)r   r
   r   s      r   historyzImageApiMixin.history)   s/     ii		"7?@||C&&r   Nc                 T   |rdnd|rdndd}|r2t        j                  | j                  d      r||d<   n|r||d<   nd|i}|rt        j                  |      |d<   | j	                  | j                  | j                  d      |	      d
      }|r|D cg c]  }|d   	 c}S |S c c}w )a  
        List images. Similar to the ``docker images`` command.

        Args:
            name (str): Only show images belonging to the repository ``name``
            quiet (bool): Only return numeric IDs as a list.
            all (bool): Show intermediate image layers. By default, these are
                filtered out.
            filters (dict): Filters to be processed on the image list.
                Available filters:
                - ``dangling`` (bool)
                - `label` (str|list): format either ``"key"``, ``"key=value"``
                    or a list of such.

        Returns:
            (dict or list): A list if ``quiet=True``, otherwise a dict.

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
           r   )only_idsall1.25filter	referencefiltersz/images/jsonparamsTId)r   
version_lt_versionconvert_filtersr   r   r   )r   namequietr   r    r"   r   xs           r   imageszImageApiMixin.images;   s    . #1
 v6#'x +/GK(*D1G % 5 5g >F9ll499TYY~%>v9N!%()AdG))
 *s   B%c           
         |s|st        j                  d      | j                  d      }t        |||t	        |t
              r|nd|      }ddi}	|s|j                  d      dk7  r#| j                  | j                  |d|	            S t	        |t
              r;t        |d
      5 }
| j                  | j                  ||
||	d            cddd       S |rd|	d<   | j                  | j                  ||||	            S # 1 sw Y   yxY w)ad  
        Import an image. Similar to the ``docker import`` command.

        If ``src`` is a string or unicode string, it will first be treated as a
        path to a tarball on the local system. If there is an error reading
        from that file, ``src`` will be treated as a URL instead to fetch the
        image from. You can also pass an open file handle as ``src``, in which
        case the data will be read from that file.

        If ``src`` is unset but ``image`` is set, the ``image`` parameter will
        be taken as the name of an existing image to import from.

        Args:
            src (str or file): Path to tarfile, URL, or file-like object
            repository (str): The repository to create
            tag (str): The tag to apply
            image (str): Use another image like the ``FROM`` Dockerfile
                parameter
        z(Must specify src or image to import from/images/createNsrcchangesContent-Typeapplication/tarfromSrc-)datar"   rbr4   r"   headerstimeoutchunkedzTransfer-Encoding)r4   r"   r7   )
r   DockerExceptionr   _import_image_params
isinstancestrgetr   _postopen)r   r.   
repositorytagr
   r/   
stream_srcur"   r7   fs              r   import_imagezImageApiMixin.import_imagef   s#   * u((:  II&'%U"3,$

 "#45FJJy)S0<<

14
7  S!c4 A||JJ&'4    /8+,<<

13vw
G  s   &%D  D	c           	          | j                  d      }t        ||d|      }ddi}| j                  | j                  ||||d            S )a@  
        Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but
        allows importing in-memory bytes data.

        Args:
            data (bytes collection): Bytes collection containing valid tar data
            repository (str): The repository to create
            tag (str): The tag to apply
        r,   r3   r-   r0   r1   Nr6   )r   r;   r   r?   )r   r4   rA   rB   r/   rD   r"   r7   s           r   import_image_from_dataz$ImageApiMixin.import_image_from_data   s`     II&'%g
 "#45||JJVWd  
 	
r   c                 ,    | j                  ||||      S )aj  
        Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
        supports importing from a tar file on disk.

        Args:
            filename (str): Full path to a tar file.
            repository (str): The repository to create
            tag (str): The tag to apply

        Raises:
            IOError: File does not exist.
        r.   rA   rB   r/   rF   )r   filenamerA   rB   r/   s        r   import_image_from_filez$ImageApiMixin.import_image_from_file   s%       ZS' ! 
 	
r   c                 .    | j                  |d|||      S )NT)r.   rC   rA   rB   r/   rK   )r   r   rA   rB   r/   s        r   import_image_from_streamz&ImageApiMixin.import_image_from_stream   s&      4JC ! 
 	
r   c                 ,    | j                  ||||      S )a"  
        Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
        supports importing from a URL.

        Args:
            url (str): A URL pointing to a tar file.
            repository (str): The repository to create
            tag (str): The tag to apply
        rJ   rK   )r   urlrA   rB   r/   s        r   import_image_from_urlz#ImageApiMixin.import_image_from_url   s%       
W ! 
 	
r   c                 ,    | j                  ||||      S )aX  
        Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
        supports importing from another image, like the ``FROM`` Dockerfile
        parameter.

        Args:
            image (str): Image name to import from
            repository (str): The repository to create
            tag (str): The tag to apply
        )r
   rA   rB   r/   rK   )r   r
   rA   rB   r/   s        r   import_image_from_imagez%ImageApiMixin.import_image_from_image   s%       JC ! 
 	
r   c                 d    | j                  | j                  | j                  d|            d      S )a  
        Get detailed information about an image. Similar to the ``docker
        inspect`` command, but only for images.

        Args:
            image (str): The image to inspect

        Returns:
            (dict): Similar to the output of ``docker inspect``, but as a
        single dict

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        z/images/{0}/jsonTr   r   r   )r   r
   s     r   inspect_imagezImageApiMixin.inspect_image   s/    " ||IIdii 2E:;T
 	
r   z1.30c                 :   t        j                  |      \  }}i }|t        j                  | |      }|r3||d<   n-t        j	                  d       t        j
                  |      |d<   | j                  d|      }| j                  | j                  ||      d      S )a/  
        Get image digest and platform information by contacting the registry.

        Args:
            image (str): The image name to inspect
            auth_config (dict): Override the credentials that are found in the
                config for this request.  ``auth_config`` should contain the
                ``username`` and ``password`` keys to be valid.

        Returns:
            (dict): A dict containing distribution data

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        X-Registry-AuthSending supplied auth configz/distribution/{0}/json)r7   T)	r   resolve_repository_nameget_config_headerlogdebugencode_headerr   r   r   )r   r
   auth_configregistry_r7   headerrQ   s           r   inspect_distributionz"ImageApiMixin.inspect_distribution   s    & 2259!++D(;F-3)*II45)-););K)HG%&ii0%8||IIc7I+T
 	
r   c                 P   i }|:t        j                  | j                  d      rt        j                  d      ||d<   | j                  | j                  d      ||d      }t        j                  | j                  d      r| j                  |d      S | j                  |       y)	a9  
        Load an image that was previously saved using
        :py:meth:`~docker.api.image.ImageApiMixin.get_image` (or ``docker
        save``). Similar to ``docker load``.

        Args:
            data (binary): Image data to be loaded.
            quiet (boolean): Suppress progress details in response.

        Returns:
            (generator): Progress output as JSON objects. Only available for
                         API version >= 1.23

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        Nz1.23z,quiet is not supported in API version < 1.23r(   z/images/loadT)r4   r"   r   decode)
r   r$   r%   r   InvalidVersionr?   r   version_gte_stream_helper_raise_for_status)r   r4   r(   r"   r   s        r   
load_imagezImageApiMixin.load_image#  s    $ v6++B  $F7OjjIIn%D  
 T]]F3&&s4&88s#r   r   c                     | j                  d      }i }|t        j                  |      |d<   | j                  | j	                  ||      d      S )a  
        Delete unused images

        Args:
            filters (dict): Filters to process on the prune list.
                Available filters:
                - dangling (bool):  When set to true (or 1), prune only
                unused and untagged images.

        Returns:
            (dict): A dict containing a list of deleted image IDs and
                the amount of disk space reclaimed in bytes.

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        z/images/pruner    r!   T)r   r   r&   r   r?   )r   r    rQ   r"   s       r   prune_imageszImageApiMixin.prune_imagesF  sP    & ii( % 5 5g >F9||DJJs6J:DAAr   c                 V   t        j                  |      \  }}|xs |xs d}|rd}t        j                  |      \  }	}
||d}i }|t        j                  | |	      }|r3||d<   n-t
        j                  d       t        j                  |      |d<   |:t        j                  | j                  d      rt        j                  d      ||d<   | j                  | j                  d	      |||d
      }| j                  |       |r| j                  ||      S | j!                  |      S )aE  
        Pulls an image. Similar to the ``docker pull`` command.

        Args:
            repository (str): The repository to pull
            tag (str): The tag to pull. If ``tag`` is ``None`` or empty, it
                is set to ``latest``.
            stream (bool): Stream the output as a generator. Make sure to
                consume the generator, otherwise pull might get cancelled.
            auth_config (dict): Override the credentials that are found in the
                config for this request.  ``auth_config`` should contain the
                ``username`` and ``password`` keys to be valid.
            decode (bool): Decode the JSON data from the server into dicts.
                Only applies with ``stream=True``
            platform (str): Platform in the format ``os[/arch[/variant]]``
            all_tags (bool): Pull all image tags, the ``tag`` parameter is
                ignored.

        Returns:
            (generator or str): The output

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.

        Example:

            >>> for line in client.api.pull('busybox', stream=True, decode=True):
            ...     print(json.dumps(line, indent=4))
            {
                "status": "Pulling image (latest) from busybox",
                "progressDetail": {},
                "id": "e72ac664f4f0"
            }
            {
                "status": "Pulling image (latest) from busybox, endpoint: ...",
                "progressDetail": {},
                "id": "e72ac664f4f0"
            }

        latestN)rB   	fromImagerY   rZ   z1.32z0platform was only introduced in API version 1.32platformr,   )r"   r7   r   r8   rf   )r   parse_repository_tagr   r[   r\   r]   r^   r_   r$   r%   r   rh   r?   r   rk   rj   r   )r   rA   rB   r   r`   rg   rr   all_tags	image_tagra   	repo_namer"   r7   rc   responses                  r   pullzImageApiMixin.pull_  sB   V !& : :: F
I*Y*(C":::F) #
 ++D(;F-3)*II45)-););K)HG%&v6++F  "*F:::II&'4  

 	x(&&x&??||H%%r   c                    |st        j                  |      \  }}t        j                  |      \  }}| j	                  d|      }d|i}	i }
|t        j
                  | |      }|r3||
d<   n-t        j                  d       t        j                  |      |
d<   | j                  |d|
||	      }| j                  |       |r| j                  ||      S | j                  |      S )a  
        Push an image or a repository to the registry. Similar to the ``docker
        push`` command.

        Args:
            repository (str): The repository to push to
            tag (str): An optional tag to push
            stream (bool): Stream the output as a blocking generator
            auth_config (dict): Override the credentials that are found in the
                config for this request.  ``auth_config`` should contain the
                ``username`` and ``password`` keys to be valid.
            decode (bool): Decode the JSON data from the server into dicts.
                Only applies with ``stream=True``

        Returns:
            (generator or str): The output from the server.

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.

        Example:
            >>> for line in client.api.push('yourname/app', stream=True, decode=True):
            ...   print(line)
            {'status': 'Pushing repository yourname/app (1 tags)'}
            {'status': 'Pushing','progressDetail': {}, 'id': '511136ea3c5a'}
            {'status': 'Image already pushed, skipping', 'progressDetail':{},
             'id': '511136ea3c5a'}
            ...

        z/images/{0}/pushrB   NrY   rZ   )r7   r   r"   rf   )r   rs   r   r[   r   r\   r]   r^   r_   
_post_jsonrk   rj   r   )r   rA   rB   r   r`   rg   ra   rv   rD   r"   r7   rc   rw   s                r   pushzImageApiMixin.push  s    B #88DOJ":::F)II(*53
 ++D(;F-3)*II45)-););K)HG%&??tWVF # 
 	x(&&x&??||H%%r   c                 v    ||d}| j                  | j                  d|      |      }| j                  |d      S )z
        Remove an image. Similar to the ``docker rmi`` command.

        Args:
            image (str): The image to remove
            force (bool): Force removal of the image
            noprune (bool): Do not delete untagged parents
        )forcenoprunez/images/{0}r!   T)_deleter   r   )r   r
   r}   r~   r"   r   s         r   remove_imagezImageApiMixin.remove_image  s<     !W5ll499]E:6lJ||C&&r   c                 |    d|i}|||d<   | j                  | j                  | j                  d      |      d      S )a  
        Search for images on Docker Hub. Similar to the ``docker search``
        command.

        Args:
            term (str): A term to search for.
            limit (int): The maximum number of results to return.

        Returns:
            (list of dicts): The response of the search.

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.
        termlimitz/images/searchr!   TrV   )r   r   r   r"   s       r   searchzImageApiMixin.search  sJ      $#F7O||IIdii 01&IA
 	
r   c                     |||rdndd}| j                  d|      }| j                  ||      }| j                  |       |j                  dk(  S )aH  
        Tag an image into a repository. Similar to the ``docker tag`` command.

        Args:
            image (str): The image to tag
            repository (str): The repository to set for the tag
            tag (str): The tag name
            force (bool): Force

        Returns:
            (bool): ``True`` if successful

        Raises:
            :py:class:`docker.errors.APIError`
                If the server returns an error.

        Example:

            >>> client.api.tag('ubuntu', 'localhost:5000/ubuntu', 'latest',
                           force=True)
        r   r   )rB   repor}   z/images/{0}/tagr!      )r   r?   rk   status_code)r   r
   rA   rB   r}   r"   rQ   r   s           r   rB   zImageApiMixin.tag  sZ    0 QQ

 ii)51jjVj,s##%%r   )NFFN)NNNNNFNNN)N)NFNFNF)NFNF)FFNF)__name__
__module____qualname__r   check_resourcer   r   r   r*   rF   rH   rM   rO   rR   rT   rW   minimum_versionrd   rl   rn   rx   r{   r   r   rB    r   r   r	   r	   
   s   U'"*A ? #?8 U'"' #'")V GK.32h AE'+
. EI'+
& EI)-
 ?C&*
 CG(,
  U'"
 #
( U6"U'" 
 # # 
D!$F U6"B #B0 DH38R&h DH;&z U'"' #'
2 U'"& #&r   r	   c                     	 t        | t              xr t        j                  j	                  |       S # t
        $ r Y yw xY wr   )r<   r=   ospathisfile	TypeError)r.   s    r   is_filer   9  s?    sC   GGNN3	
  s   03 	??c                 ^    | |d}|r||d<   n|rt        |      s||d<   nd|d<   |r||d<   |S )N)r   rB   rq   r2   r3   r/   )r   )r   rB   r
   r.   r/   r"   s         r   r;   r;   C  sO     F #{	WS\yy#yMr   r   )loggingr    r   r   r   	constantsr   	getLoggerr   r]   r	   r   r;   r   r   r   <module>r      sE     	 " " /g!l& l&^ 59!%r   