Update changelog for 5.0.3 release

Signed-off-by: Anca Iordache <anca.iordache@docker.com>

.editorconfig

@@ -9,6 +9,3 @@ max_line_length = 80
 
 [*.md]
 trim_trailing_whitespace = false
-
-[*.{yaml,yml}]
-indent_size = 2

.github/CODEOWNERS

@@ -0,0 +1,6 @@
+# GitHub code owners
+# See https://help.github.com/articles/about-codeowners/
+#
+# KEEP THIS FILE SORTED. Order is important. Last match takes precedence.
+
+*       @aiordache @ulyssessouza

.github/workflows/ci.yml

@@ -2,71 +2,26 @@ name: Python package
 
 on: [push, pull_request]
 
-env:
-  DOCKER_BUILDKIT: '1'
-  FORCE_COLOR: 1
-
 jobs:
-    lint:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: actions/setup-python@v5
-              with:
-                  python-version: '3.x'
-            - run: pip install -U ruff==0.1.8
-            - name: Run ruff
-              run: ruff docker tests
-
     build:
-      runs-on: ubuntu-22.04
-      steps:
-        - uses: actions/checkout@v4
-        - uses: actions/setup-python@v5
-          with:
-            python-version: '3.x'
-        - run: pip3 install build && python -m build .
-        - uses: actions/upload-artifact@v4
-          with:
-            name: dist
-            path: dist
-
-    unit-tests:
         runs-on: ubuntu-latest
         strategy:
+            max-parallel: 1
             matrix:
-                python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+                python-version: [3.6, 3.7, 3.8, 3.9]
 
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v2
             - name: Set up Python ${{ matrix.python-version }}
-              uses: actions/setup-python@v5
+              uses: actions/setup-python@v2
               with:
                   python-version: ${{ matrix.python-version }}
-                allow-prereleases: true
             - name: Install dependencies
               run: |
                   python3 -m pip install --upgrade pip
-                  pip3 install '.[ssh,dev]'
+                  pip3 install -r test-requirements.txt -r requirements.txt
-            - name: Run unit tests
+            - name: Test with pytest
               run: |
                   docker logout
                   rm -rf ~/.docker
                   py.test -v --cov=docker tests/unit
-
-    integration-tests:
-        runs-on: ubuntu-latest
-        strategy:
-            matrix:
-                variant: [ "integration-dind", "integration-dind-ssl", "integration-dind-ssh" ]
-
-        steps:
-            - uses: actions/checkout@v4
-              with:
-                fetch-depth: 0
-                fetch-tags: true
-            - name: make ${{ matrix.variant }}
-              run: |
-                  docker logout
-                  rm -rf ~/.docker
-                  make ${{ matrix.variant }}

.github/workflows/release.yml

@@ -1,53 +0,0 @@
-name: Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Release Tag WITHOUT `v` Prefix (e.g. 6.0.0)"
-        required: true
-      dry-run:
-        description: 'Dry run'
-        required: false
-        type: boolean
-        default: true
-
-env:
-  DOCKER_BUILDKIT: '1'
-  FORCE_COLOR: 1
-
-jobs:
-  publish:
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-
-      - name: Generate Package
-        run: |
-          pip3 install build
-          python -m build .
-        env:
-          # This is also supported by Hatch; see
-          # https://github.com/ofek/hatch-vcs#version-source-environment-variables
-          SETUPTOOLS_SCM_PRETEND_VERSION: ${{ inputs.tag }}
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        if: '! inputs.dry-run'
-        with:
-          password: ${{ secrets.PYPI_API_TOKEN }}
-
-      - name: Create GitHub release
-        uses: ncipollo/release-action@v1
-        if: '! inputs.dry-run'
-        with:
-          artifacts: "dist/*"
-          generateReleaseNotes: true
-          draft: true
-          commit: ${{ github.sha }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-          tag: ${{ inputs.tag }}

.gitignore

@@ -13,10 +13,6 @@ html/*
 _build/
 README.rst
 
-# setuptools_scm
-_version.py
-
 env/
 venv/
 .idea/
-*.iml

.readthedocs.yml

@@ -3,15 +3,8 @@ version: 2
 sphinx:
   configuration: docs/conf.py
 
-build:
-  os: ubuntu-22.04
-  tools:
-    python: '3.12'
-
 python:
+  version: 3.6
   install:
-    - method: pip
+    - requirements: docs-requirements.txt
-      path: .
+    - requirements: requirements.txt
-      extra_requirements:
-        - ssh
-        - docs

CONTRIBUTING.md

@@ -44,7 +44,7 @@ paragraph in the Docker contribution guidelines.
 Before we can review your pull request, please ensure that nothing has been
 broken by your changes by running the test suite. You can do so simply by
 running `make test` in the project root. This also includes coding style using
-`ruff`
+`flake8`
 
 ### 3. Write clear, self-contained commits
 

Dockerfile

@@ -1,13 +1,15 @@
-# syntax=docker/dockerfile:1
+ARG PYTHON_VERSION=3.7
 
-ARG PYTHON_VERSION=3.12
 FROM python:${PYTHON_VERSION}
 
+RUN mkdir /src
 WORKDIR /src
-COPY . .
 
-ARG VERSION=0.0.0.dev0
+COPY requirements.txt /src/requirements.txt
-RUN --mount=type=cache,target=/cache/pip \
+RUN pip install -r requirements.txt
-    PIP_CACHE_DIR=/cache/pip \
+
-    SETUPTOOLS_SCM_PRETEND_VERSION=${VERSION} \
+COPY test-requirements.txt /src/test-requirements.txt
-    pip install .[ssh]
+RUN pip install -r test-requirements.txt
+
+COPY . /src
+RUN pip install .

Dockerfile-docs

@@ -1,6 +1,4 @@
-# syntax=docker/dockerfile:1
+ARG PYTHON_VERSION=3.7
-
-ARG PYTHON_VERSION=3.12
 
 FROM python:${PYTHON_VERSION}
 
@@ -11,12 +9,7 @@ RUN addgroup --gid $gid sphinx \
  && useradd --uid $uid --gid $gid -M sphinx
 
 WORKDIR /src
-COPY . .
+COPY requirements.txt docs-requirements.txt ./
-
+RUN pip install -r requirements.txt -r docs-requirements.txt
-ARG VERSION=0.0.0.dev0
-RUN --mount=type=cache,target=/cache/pip \
-    PIP_CACHE_DIR=/cache/pip \
-    SETUPTOOLS_SCM_PRETEND_VERSION=${VERSION} \
-    pip install .[ssh,docs]
 
 USER sphinx

Jenkinsfile

@@ -0,0 +1,147 @@
+#!groovy
+
+def imageNameBase = "dockerpinata/docker-py"
+def imageNamePy3
+def imageDindSSH
+def images = [:]
+
+def buildImage = { name, buildargs, pyTag ->
+  img = docker.image(name)
+  try {
+    img.pull()
+  } catch (Exception exc) {
+    img = docker.build(name, buildargs)
+    img.push()
+  }
+  if (pyTag?.trim()) images[pyTag] = img.id
+}
+
+def buildImages = { ->
+  wrappedNode(label: "amd64 && ubuntu-2004 && overlay2", cleanWorkspace: true) {
+    stage("build image") {
+      checkout(scm)
+
+      imageNamePy3 = "${imageNameBase}:py3-${gitCommit()}"
+      imageDindSSH = "${imageNameBase}:sshdind-${gitCommit()}"
+      withDockerRegistry(credentialsId:'dockerbuildbot-index.docker.io') {
+        buildImage(imageDindSSH, "-f tests/Dockerfile-ssh-dind .", "")
+        buildImage(imageNamePy3, "-f tests/Dockerfile --build-arg PYTHON_VERSION=3.7 .", "py3.7")
+      }
+    }
+  }
+}
+
+def getDockerVersions = { ->
+  def dockerVersions = ["19.03.12"]
+  wrappedNode(label: "amd64 && ubuntu-2004 && overlay2") {
+    def result = sh(script: """docker run --rm \\
+        --entrypoint=python \\
+        ${imageNamePy3} \\
+        /src/scripts/versions.py
+      """, returnStdout: true
+    )
+    dockerVersions = dockerVersions + result.trim().tokenize(' ')
+  }
+  return dockerVersions
+}
+
+def getAPIVersion = { engineVersion ->
+  def versionMap = [
+    '18.09': '1.39',
+    '19.03': '1.40'
+  ]
+  def result = versionMap[engineVersion.substring(0, 5)]
+  if (!result) {
+    return '1.40'
+  }
+  return result
+}
+
+def runTests = { Map settings ->
+  def dockerVersion = settings.get("dockerVersion", null)
+  def pythonVersion = settings.get("pythonVersion", null)
+  def testImage = settings.get("testImage", null)
+  def apiVersion = getAPIVersion(dockerVersion)
+
+  if (!testImage) {
+    throw new Exception("Need test image object, e.g.: `runTests(testImage: img)`")
+  }
+  if (!dockerVersion) {
+    throw new Exception("Need Docker version to test, e.g.: `runTests(dockerVersion: '19.03.12')`")
+  }
+  if (!pythonVersion) {
+    throw new Exception("Need Python version being tested, e.g.: `runTests(pythonVersion: 'py3.7')`")
+  }
+
+  { ->
+    wrappedNode(label: "amd64 && ubuntu-2004 && overlay2", cleanWorkspace: true) {
+      stage("test python=${pythonVersion} / docker=${dockerVersion}") {
+        checkout(scm)
+        def dindContainerName = "dpy-dind-\$BUILD_NUMBER-\$EXECUTOR_NUMBER-${pythonVersion}-${dockerVersion}"
+        def testContainerName = "dpy-tests-\$BUILD_NUMBER-\$EXECUTOR_NUMBER-${pythonVersion}-${dockerVersion}"
+        def testNetwork = "dpy-testnet-\$BUILD_NUMBER-\$EXECUTOR_NUMBER-${pythonVersion}-${dockerVersion}"
+        withDockerRegistry(credentialsId:'dockerbuildbot-index.docker.io') {
+          try {
+            // unit tests
+            sh """docker run --rm \\
+              -e 'DOCKER_TEST_API_VERSION=${apiVersion}' \\
+              ${testImage} \\
+              py.test -v -rxs --cov=docker tests/unit
+            """
+            // integration tests
+            sh """docker network create ${testNetwork}"""
+            sh """docker run --rm -d --name ${dindContainerName} -v /tmp --privileged --network ${testNetwork} \\
+              ${imageDindSSH} dockerd -H tcp://0.0.0.0:2375
+            """
+            sh """docker run --rm \\
+              --name ${testContainerName} \\
+              -e "DOCKER_HOST=tcp://${dindContainerName}:2375" \\
+              -e 'DOCKER_TEST_API_VERSION=${apiVersion}' \\
+              --network ${testNetwork} \\
+              --volumes-from ${dindContainerName} \\
+              -v $DOCKER_CONFIG/config.json:/root/.docker/config.json \\
+              ${testImage} \\
+              py.test -v -rxs --cov=docker tests/integration
+            """
+            sh """docker stop ${dindContainerName}"""
+            // start DIND container with SSH
+            sh """docker run --rm -d --name ${dindContainerName} -v /tmp --privileged --network ${testNetwork} \\
+              ${imageDindSSH} dockerd --experimental"""
+            sh """docker exec ${dindContainerName} sh -c /usr/sbin/sshd """
+            // run SSH tests only
+            sh """docker run --rm \\
+              --name ${testContainerName} \\
+              -e "DOCKER_HOST=ssh://${dindContainerName}:22" \\
+              -e 'DOCKER_TEST_API_VERSION=${apiVersion}' \\
+              --network ${testNetwork} \\
+              --volumes-from ${dindContainerName} \\
+              -v $DOCKER_CONFIG/config.json:/root/.docker/config.json \\
+              ${testImage} \\
+              py.test -v -rxs --cov=docker tests/ssh
+            """
+          } finally {
+            sh """
+              docker stop ${dindContainerName}
+              docker network rm ${testNetwork}
+            """
+          }
+        }
+      }
+    }
+  }
+}
+
+
+buildImages()
+
+def dockerVersions = getDockerVersions()
+
+def testMatrix = [failFast: false]
+
+for (imgKey in new ArrayList(images.keySet())) {
+  for (version in dockerVersions) {
+    testMatrix["${imgKey}_${version}"] = runTests([testImage: images[imgKey], dockerVersion: version, pythonVersion: imgKey])
+  }
+}
+
+parallel(testMatrix)

MAINTAINERS

@@ -11,19 +11,17 @@
 [Org]
 	[Org."Core maintainers"]
 		people = [
-		    "glours",
+			"aiordache",
-		    "milas",
+			"ulyssessouza",
 		]
 	[Org.Alumni]
 		people = [
-		    "aiordache",
 			"aanand",
 			"bfirsh",
 			"dnephin",
 			"mnowster",
 			"mpetazzoni",
 			"shin-",
-			"ulyssessouza",
 		]
 
 [people]
@@ -54,16 +52,6 @@
 	Email = "dnephin@gmail.com"
 	GitHub = "dnephin"
 
-	[people.glours]
-	Name = "Guillaume Lours"
-	Email = "705411+glours@users.noreply.github.com"
-	GitHub = "glours"
-
-	[people.milas]
-	Name = "Milas Bowman"
-	Email = "devnull@milas.dev"
-	GitHub = "milas"
-
 	[people.mnowster]
 	Name = "Mazz Mosley"
 	Email = "mazz@houseofmnowster.com"

MANIFEST.in

@@ -0,0 +1,9 @@
+include test-requirements.txt
+include requirements.txt
+include README.md
+include README.rst
+include LICENSE
+recursive-include tests *.py
+recursive-include tests/unit/testdata *
+recursive-include tests/integration/testdata *
+recursive-include tests/gpg-keys *

Makefile

@@ -1,75 +1,39 @@
-TEST_API_VERSION ?= 1.45
+TEST_API_VERSION ?= 1.41
-TEST_ENGINE_VERSION ?= 26.1
+TEST_ENGINE_VERSION ?= 20.10.05
-
-ifeq ($(OS),Windows_NT)
-    PLATFORM := Windows
-else
-    PLATFORM := $(shell sh -c 'uname -s 2>/dev/null || echo Unknown')
-endif
-
-ifeq ($(PLATFORM),Linux)
-	uid_args := "--build-arg uid=$(shell id -u) --build-arg gid=$(shell id -g)"
-endif
-
-SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER ?= $(shell git describe --match '[0-9]*' --dirty='.m' --always --tags 2>/dev/null | sed -r 's/-([0-9]+)/.dev\1/' | sed 's/-/+/')
-ifeq ($(SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER),)
-	SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER = "0.0.0.dev0"
-endif
 
 .PHONY: all
 all: test
 
 .PHONY: clean
 clean:
-	-docker rm -f dpy-dind dpy-dind-certs dpy-dind-ssl
+	-docker rm -f dpy-dind-py3 dpy-dind-certs dpy-dind-ssl
 	find -name "__pycache__" | xargs rm -rf
 
 .PHONY: build-dind-ssh
 build-dind-ssh:
-	docker build \
+	docker build -t docker-dind-ssh -f tests/Dockerfile-ssh-dind --build-arg ENGINE_VERSION=${TEST_ENGINE_VERSION} --build-arg API_VERSION=${TEST_API_VERSION} --build-arg APT_MIRROR .
-		--pull \
-		-t docker-dind-ssh \
-		-f tests/Dockerfile-ssh-dind \
-		--build-arg VERSION=${SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER} \
-		--build-arg ENGINE_VERSION=${TEST_ENGINE_VERSION} \
-		--build-arg API_VERSION=${TEST_API_VERSION} \
-		.
 
-.PHONY: build
+.PHONY: build-py3
-build:
+build-py3:
-	docker build \
+	docker build -t docker-sdk-python3 -f tests/Dockerfile --build-arg APT_MIRROR .
-		--pull \
-		-t docker-sdk-python3 \
-		-f tests/Dockerfile \
-		--build-arg VERSION=${SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER} \
-		.
 
 .PHONY: build-docs
 build-docs:
-	docker build \
+	docker build -t docker-sdk-python-docs -f Dockerfile-docs --build-arg uid=$(shell id -u) --build-arg gid=$(shell id -g) .
-		-t docker-sdk-python-docs \
-		-f Dockerfile-docs \
-		--build-arg VERSION=${SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER} \
-		$(uid_args) \
-		.
 
 .PHONY: build-dind-certs
 build-dind-certs:
-	docker build \
+	docker build -t dpy-dind-certs -f tests/Dockerfile-dind-certs .
-		-t dpy-dind-certs \
-		-f tests/Dockerfile-dind-certs \
-		--build-arg VERSION=${SETUPTOOLS_SCM_PRETEND_VERSION_DOCKER} \
-		.
 
 .PHONY: test
-test: ruff unit-test integration-dind integration-dind-ssl
+test: flake8 unit-test-py3 integration-dind integration-dind-ssl
 
-.PHONY: unit-test
+.PHONY: unit-test-py3
-unit-test: build
+unit-test-py3: build-py3
 	docker run -t --rm docker-sdk-python3 py.test tests/unit
 
-.PHONY: integration-test
+.PHONY: integration-test-py3
-integration-test: build
+integration-test-py3: build-py3
 	docker run -t --rm -v /var/run/docker.sock:/var/run/docker.sock docker-sdk-python3 py.test -v tests/integration/${file}
 
 .PHONY: setup-network
@@ -77,113 +41,53 @@ setup-network:
 	docker network inspect dpy-tests || docker network create dpy-tests
 
 .PHONY: integration-dind
-integration-dind: build setup-network
+integration-dind: integration-dind-py3
-	docker rm -vf dpy-dind || :
 
-	docker run \
+.PHONY: integration-dind-py3
-		--detach \
+integration-dind-py3: build-py3 setup-network
-		--name dpy-dind \
+	docker rm -vf dpy-dind-py3 || :
-		--network dpy-tests \
+	docker run -d --network dpy-tests --name dpy-dind-py3 --privileged\
-		--pull=always \
+		docker:${TEST_ENGINE_VERSION}-dind dockerd -H tcp://0.0.0.0:2375 --experimental
-		--privileged \
+	docker run -t --rm --env="DOCKER_HOST=tcp://dpy-dind-py3:2375" --env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}"\
-		docker:${TEST_ENGINE_VERSION}-dind \
+		--network dpy-tests docker-sdk-python3 py.test tests/integration/${file}
-		dockerd -H tcp://0.0.0.0:2375 --experimental
+	docker rm -vf dpy-dind-py3
-
-	# Wait for Docker-in-Docker to come to life
-	docker run \
-		--network dpy-tests \
-		--rm \
-		--tty \
-		busybox \
-		sh -c 'while ! nc -z dpy-dind 2375; do sleep 1; done'
-
-	docker run \
-		--env="DOCKER_HOST=tcp://dpy-dind:2375" \
-		--env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}" \
-		--network dpy-tests \
-		--rm \
-		--tty \
-		docker-sdk-python3 \
-		py.test tests/integration/${file}
-
-	docker rm -vf dpy-dind
 
 
-.PHONY: integration-dind-ssh
+.PHONY: integration-ssh-py3
-integration-dind-ssh: build-dind-ssh build setup-network
+integration-ssh-py3: build-dind-ssh build-py3 setup-network
-	docker rm -vf dpy-dind-ssh || :
+	docker rm -vf dpy-dind-py3 || :
-	docker run -d --network dpy-tests --name dpy-dind-ssh --privileged \
+	docker run -d --network dpy-tests --name dpy-dind-py3 --privileged\
 		docker-dind-ssh dockerd --experimental
-	# start SSH daemon for known key
+	# start SSH daemon
-	docker exec dpy-dind-ssh sh -c "/usr/sbin/sshd -h /etc/ssh/known_ed25519 -p 22"
+	docker exec dpy-dind-py3 sh -c "/usr/sbin/sshd"
-	docker exec dpy-dind-ssh sh -c "/usr/sbin/sshd -h /etc/ssh/unknown_ed25519 -p 2222"
+	docker run -t --rm --env="DOCKER_HOST=ssh://dpy-dind-py3" --env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}"\
-	docker run \
+		--network dpy-tests docker-sdk-python3 py.test tests/ssh/${file}
-		--tty \
+	docker rm -vf dpy-dind-py3
-		--rm \
-		--env="DOCKER_HOST=ssh://dpy-dind-ssh" \
-		--env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}" \
-		--env="UNKNOWN_DOCKER_SSH_HOST=ssh://dpy-dind-ssh:2222" \
-		--network dpy-tests \
-		docker-sdk-python3 py.test tests/ssh/${file}
-	docker rm -vf dpy-dind-ssh
 
 
 .PHONY: integration-dind-ssl
-integration-dind-ssl: build-dind-certs build setup-network
+integration-dind-ssl: build-dind-certs build-py3
 	docker rm -vf dpy-dind-certs dpy-dind-ssl || :
 	docker run -d --name dpy-dind-certs dpy-dind-certs
-
+	docker run -d --env="DOCKER_HOST=tcp://localhost:2375" --env="DOCKER_TLS_VERIFY=1"\
-	docker run \
+		--env="DOCKER_CERT_PATH=/certs" --volumes-from dpy-dind-certs --name dpy-dind-ssl\
-		--detach \
+		--network dpy-tests --network-alias docker -v /tmp --privileged\
-		--env="DOCKER_CERT_PATH=/certs" \
+		docker:${TEST_ENGINE_VERSION}-dind\
-		--env="DOCKER_HOST=tcp://localhost:2375" \
+		dockerd --tlsverify --tlscacert=/certs/ca.pem --tlscert=/certs/server-cert.pem\
-		--env="DOCKER_TLS_VERIFY=1" \
+		--tlskey=/certs/server-key.pem -H tcp://0.0.0.0:2375 --experimental
-		--name dpy-dind-ssl \
+	docker run -t --rm --volumes-from dpy-dind-ssl --env="DOCKER_HOST=tcp://docker:2375"\
-		--network dpy-tests \
+		--env="DOCKER_TLS_VERIFY=1" --env="DOCKER_CERT_PATH=/certs" --env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}"\
-		--network-alias docker \
+		--network dpy-tests docker-sdk-python3 py.test tests/integration/${file}
-		--pull=always \
-		--privileged \
-		--volume /tmp \
-		--volumes-from dpy-dind-certs \
-		docker:${TEST_ENGINE_VERSION}-dind \
-		dockerd \
-			--tlsverify \
-			--tlscacert=/certs/ca.pem \
-			--tlscert=/certs/server-cert.pem \
-			--tlskey=/certs/server-key.pem \
-			-H tcp://0.0.0.0:2375 \
-			--experimental
-
-	# Wait for Docker-in-Docker to come to life
-	docker run \
-		--network dpy-tests \
-		--rm \
-		--tty \
-		busybox \
-		sh -c 'while ! nc -z dpy-dind-ssl 2375; do sleep 1; done'
-
-	docker run \
-		--env="DOCKER_CERT_PATH=/certs" \
-		--env="DOCKER_HOST=tcp://docker:2375" \
-		--env="DOCKER_TEST_API_VERSION=${TEST_API_VERSION}" \
-		--env="DOCKER_TLS_VERIFY=1" \
-		--network dpy-tests \
-		--rm \
-		--volumes-from dpy-dind-ssl \
-		--tty \
-		docker-sdk-python3 \
-		py.test tests/integration/${file}
-
 	docker rm -vf dpy-dind-ssl dpy-dind-certs
 
-.PHONY: ruff
+.PHONY: flake8
-ruff: build
+flake8: build-py3
-	docker run -t --rm docker-sdk-python3 ruff docker tests
+	docker run -t --rm docker-sdk-python3 flake8 docker tests
 
 .PHONY: docs
 docs: build-docs
 	docker run --rm -t -v `pwd`:/src docker-sdk-python-docs sphinx-build docs docs/_build
 
 .PHONY: shell
-shell: build
+shell: build-py3
 	docker run -it -v /var/run/docker.sock:/var/run/docker.sock docker-sdk-python3 python

README.md

@@ -1,17 +1,18 @@
 # Docker SDK for Python
 
-[![Build Status](https://github.com/docker/docker-py/actions/workflows/ci.yml/badge.svg)](https://github.com/docker/docker-py/actions/workflows/ci.yml)
+[![Build Status](https://github.com/docker/docker-py/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/docker/docker-py/actions/workflows/ci.yml/)
 
 A Python library for the Docker Engine API. It lets you do anything the `docker` command does, but from within Python apps – run containers, manage containers, manage Swarms, etc.
 
 ## Installation
 
-The latest stable version [is available on PyPI](https://pypi.python.org/pypi/docker/). Install with pip:
+The latest stable version [is available on PyPI](https://pypi.python.org/pypi/docker/). Either add `docker` to your `requirements.txt` file or install with pip:
 
     pip install docker
 
-> Older versions (< 6.0) required installing `docker[tls]` for SSL/TLS support.
+If you are intending to connect to a docker host via TLS, add `docker[tls]` to your requirements instead, or install with pip:
-> This is no longer necessary and is a no-op, but is supported for backwards compatibility.
+
+    pip install docker[tls]
 
 ## Usage
 

appveyor.yml

@@ -0,0 +1,13 @@
+version: '{branch}-{build}'
+
+install:
+  - "SET PATH=C:\\Python37-x64;C:\\Python37-x64\\Scripts;%PATH%"
+  - "python --version"
+  - "python -m pip install --upgrade pip"
+  - "pip install tox==2.9.1"
+
+# Build the binary after tests
+build: false
+
+test_script:
+  - "tox"

docker/__init__.py

@@ -1,7 +1,10 @@
+# flake8: noqa
 from .api import APIClient
 from .client import DockerClient, from_env
-from .context import Context, ContextAPI
+from .context import Context
+from .context import ContextAPI
 from .tls import TLSConfig
-from .version import __version__
+from .version import version, version_info
 
+__version__ = version
 __title__ = 'docker'

docker/api/__init__.py

@@ -1 +1,2 @@
+# flake8: noqa
 from .client import APIClient

docker/api/build.py

@@ -3,7 +3,11 @@ import logging
 import os
 import random
 
-from .. import auth, constants, errors, utils
+from .. import auth
+from .. import constants
+from .. import errors
+from .. import utils
+
 
 log = logging.getLogger(__name__)
 
@@ -72,7 +76,6 @@ class BuildApiMixin:
             forcerm (bool): Always remove intermediate containers, even after
                 unsuccessful builds
             dockerfile (str): path within the build context to the Dockerfile
-            gzip (bool): If set to ``True``, gzip compression/encoding is used
             buildargs (dict): A dictionary of build arguments
             container_limits (dict): A dictionary of limits applied to each
                 container created by the build process. Valid keys:
@@ -125,16 +128,13 @@ class BuildApiMixin:
             raise errors.DockerException(
                 'Can not use custom encoding if gzip is enabled'
             )
-        if tag is not None:
+
-            if not utils.match_tag(tag):
-                raise errors.DockerException(
-                    f"invalid tag '{tag}': invalid reference format"
-            )
         for key in container_limits.keys():
             if key not in constants.CONTAINER_LIMITS_KEYS:
                 raise errors.DockerException(
-                    f"invalid tag '{tag}': invalid reference format"
+                    f'Invalid container_limits key {key}'
                 )
+
         if custom_context:
             if not fileobj:
                 raise TypeError("You must specify fileobj with custom_context")
@@ -153,7 +153,7 @@ class BuildApiMixin:
                 with open(dockerignore) as f:
                     exclude = list(filter(
                         lambda x: x != '' and x[0] != '#',
-                        [line.strip() for line in f.read().splitlines()]
+                        [l.strip() for l in f.read().splitlines()]
                     ))
             dockerfile = process_dockerfile(dockerfile, path)
             context = utils.tar(
@@ -275,24 +275,10 @@ class BuildApiMixin:
         return self._stream_helper(response, decode=decode)
 
     @utils.minimum_version('1.31')
-    def prune_builds(self, filters=None, keep_storage=None, all=None):
+    def prune_builds(self):
         """
         Delete the builder cache
 
-        Args:
-            filters (dict): Filters to process on the prune list.
-                Needs Docker API v1.39+
-                Available filters:
-                - dangling (bool):  When set to true (or 1), prune only
-                unused and untagged images.
-                - until (str): Can be Unix timestamps, date formatted
-                timestamps, or Go duration strings (e.g. 10m, 1h30m) computed
-                relative to the daemon's local time.
-            keep_storage (int): Amount of disk space in bytes to keep for cache.
-                Needs Docker API v1.39+
-            all (bool): Remove all types of build cache.
-                Needs Docker API v1.39+
-
         Returns:
             (dict): A dictionary containing information about the operation's
                     result. The ``SpaceReclaimed`` key indicates the amount of
@@ -303,20 +289,7 @@ class BuildApiMixin:
                 If the server returns an error.
         """
         url = self._url("/build/prune")
-        if (filters, keep_storage, all) != (None, None, None) \
+        return self._result(self._post(url), True)
-                and utils.version_lt(self._version, '1.39'):
-            raise errors.InvalidVersion(
-                '`filters`, `keep_storage`, and `all` args are only available '
-                'for API version > 1.38'
-            )
-        params = {}
-        if filters is not None:
-            params['filters'] = utils.convert_filters(filters)
-        if keep_storage is not None:
-            params['keep-storage'] = keep_storage
-        if all is not None:
-            params['all'] = all
-        return self._result(self._post(url, params=params), True)
 
     def _set_auth_headers(self, headers):
         log.debug('Looking for auth config')
@@ -340,8 +313,9 @@ class BuildApiMixin:
                 auth_data[auth.INDEX_URL] = auth_data.get(auth.INDEX_NAME, {})
 
             log.debug(
-                "Sending auth config (%s)",
+                'Sending auth config ({})'.format(
-                ', '.join(repr(k) for k in auth_data),
+                    ', '.join(repr(k) for k in auth_data.keys())
+                )
             )
 
             if auth_data:
@@ -361,9 +335,12 @@ def process_dockerfile(dockerfile, path):
         abs_dockerfile = os.path.join(path, dockerfile)
         if constants.IS_WINDOWS_PLATFORM and path.startswith(
                 constants.WINDOWS_LONGPATH_PREFIX):
-            normpath = os.path.normpath(
+            abs_dockerfile = '{}{}'.format(
-                abs_dockerfile[len(constants.WINDOWS_LONGPATH_PREFIX):])
+                constants.WINDOWS_LONGPATH_PREFIX,
-            abs_dockerfile = f'{constants.WINDOWS_LONGPATH_PREFIX}{normpath}'
+                os.path.normpath(
+                    abs_dockerfile[len(constants.WINDOWS_LONGPATH_PREFIX):]
+                )
+            )
     if (os.path.splitdrive(path)[0] != os.path.splitdrive(abs_dockerfile)[0] or
             os.path.relpath(abs_dockerfile, path).startswith('..')):
         # Dockerfile not in context - read data to insert into tar later

docker/api/client.py

@@ -4,28 +4,18 @@ import urllib
 from functools import partial
 
 import requests
-import requests.adapters
 import requests.exceptions
+import websocket
 
 from .. import auth
-from ..constants import (
+from ..constants import (DEFAULT_NUM_POOLS, DEFAULT_NUM_POOLS_SSH,
-    DEFAULT_MAX_POOL_SIZE,
+                         DEFAULT_MAX_POOL_SIZE, DEFAULT_TIMEOUT_SECONDS,
-    DEFAULT_NUM_POOLS,
+                         DEFAULT_USER_AGENT, IS_WINDOWS_PLATFORM,
-    DEFAULT_NUM_POOLS_SSH,
+                         MINIMUM_DOCKER_API_VERSION, STREAM_HEADER_SIZE_BYTES)
-    DEFAULT_TIMEOUT_SECONDS,
+from ..errors import (DockerException, InvalidVersion, TLSParameterError,
-    DEFAULT_USER_AGENT,
+                      create_api_error_from_http_exception)
-    IS_WINDOWS_PLATFORM,
-    MINIMUM_DOCKER_API_VERSION,
-    STREAM_HEADER_SIZE_BYTES,
-)
-from ..errors import (
-    DockerException,
-    InvalidVersion,
-    TLSParameterError,
-    create_api_error_from_http_exception,
-)
 from ..tls import TLSConfig
-from ..transport import UnixHTTPAdapter
+from ..transport import SSLHTTPAdapter, UnixHTTPAdapter
 from ..utils import check_resource, config, update_headers, utils
 from ..utils.json_stream import json_stream
 from ..utils.proxy import ProxyConfig
@@ -170,10 +160,10 @@ class APIClient(
                     base_url, timeout, pool_connections=num_pools,
                     max_pool_size=max_pool_size
                 )
-            except NameError as err:
+            except NameError:
                 raise DockerException(
                     'Install pypiwin32 package to enable npipe:// support'
-                ) from err
+                )
             self.mount('http+docker://', self._custom_adapter)
             self.base_url = 'http+docker://localnpipe'
         elif base_url.startswith('ssh://'):
@@ -182,10 +172,10 @@ class APIClient(
                     base_url, timeout, pool_connections=num_pools,
                     max_pool_size=max_pool_size, shell_out=use_ssh_client
                 )
-            except NameError as err:
+            except NameError:
                 raise DockerException(
                     'Install paramiko package to enable ssh:// support'
-                ) from err
+                )
             self.mount('http+docker://ssh', self._custom_adapter)
             self._unmount('http://', 'https://')
             self.base_url = 'http+docker://ssh'
@@ -194,7 +184,7 @@ class APIClient(
             if isinstance(tls, TLSConfig):
                 tls.configure_client(self)
             elif tls:
-                self._custom_adapter = requests.adapters.HTTPAdapter(
+                self._custom_adapter = SSLHTTPAdapter(
                     pool_connections=num_pools)
                 self.mount('https://', self._custom_adapter)
             self.base_url = base_url
@@ -209,27 +199,28 @@ class APIClient(
             self._version = version
         if not isinstance(self._version, str):
             raise DockerException(
-                'Version parameter must be a string or None. '
+                'Version parameter must be a string or None. Found {}'.format(
-                f'Found {type(version).__name__}'
+                    type(version).__name__
+                )
             )
         if utils.version_lt(self._version, MINIMUM_DOCKER_API_VERSION):
             raise InvalidVersion(
-                f'API versions below {MINIMUM_DOCKER_API_VERSION} are '
+                'API versions below {} are no longer supported by this '
-                f'no longer supported by this library.'
+                'library.'.format(MINIMUM_DOCKER_API_VERSION)
             )
 
     def _retrieve_server_version(self):
         try:
             return self.version(api_version=False)["ApiVersion"]
-        except KeyError as ke:
+        except KeyError:
             raise DockerException(
                 'Invalid response from docker daemon: key "ApiVersion"'
                 ' is missing.'
-            ) from ke
+            )
         except Exception as e:
             raise DockerException(
                 f'Error while fetching server API version: {e}'
-            ) from e
+            )
 
     def _set_request_timeout(self, kwargs):
         """Prepare the kwargs for an HTTP request by inserting the timeout
@@ -257,24 +248,26 @@ class APIClient(
         for arg in args:
             if not isinstance(arg, str):
                 raise ValueError(
-                    f'Expected a string but found {arg} ({type(arg)}) instead'
+                    'Expected a string but found {} ({}) '
+                    'instead'.format(arg, type(arg))
                 )
 
         quote_f = partial(urllib.parse.quote, safe="/:")
         args = map(quote_f, args)
 
-        formatted_path = pathfmt.format(*args)
         if kwargs.get('versioned_api', True):
-            return f'{self.base_url}/v{self._version}{formatted_path}'
+            return '{}/v{}{}'.format(
+                self.base_url, self._version, pathfmt.format(*args)
+            )
         else:
-            return f'{self.base_url}{formatted_path}'
+            return f'{self.base_url}{pathfmt.format(*args)}'
 
     def _raise_for_status(self, response):
         """Raises stored :class:`APIError`, if one occurred."""
         try:
             response.raise_for_status()
         except requests.exceptions.HTTPError as e:
-            raise create_api_error_from_http_exception(e) from e
+            raise create_api_error_from_http_exception(e)
 
     def _result(self, response, json=False, binary=False):
         assert not (json and binary)
@@ -319,16 +312,7 @@ class APIClient(
         return self._create_websocket_connection(full_url)
 
     def _create_websocket_connection(self, url):
-        try:
-            import websocket
         return websocket.create_connection(url)
-        except ImportError as ie:
-            raise DockerException(
-                'The `websocket-client` library is required '
-                'for using websocket connections. '
-                'You can install the `docker` library '
-                'with the [websocket] extra to install it.'
-            ) from ie
 
     def _get_raw_response_socket(self, response):
         self._raise_for_status(response)
@@ -422,10 +406,6 @@ class APIClient(
         yield from response.iter_content(chunk_size, decode)
 
     def _read_from_socket(self, response, stream, tty=True, demux=False):
-        """Consume all data from the socket, close the response and return the
-        data. If stream=True, then a generator is returned instead and the
-        caller is responsible for closing the response.
-        """
         socket = self._get_raw_response_socket(response)
 
         gen = frames_iter(socket, tty)
@@ -440,11 +420,8 @@ class APIClient(
         if stream:
             return gen
         else:
-            try:
+            # Wait for all the frames, concatenate them, and return the result
-                # Wait for all frames, concatenate them, and return the result
             return consume_socket_output(gen, demux=demux)
-            finally:
-                response.close()
 
     def _disable_socket_timeout(self, socket):
         """ Depending on the combination of python version and whether we're
@@ -495,7 +472,7 @@ class APIClient(
             return self._multiplexed_response_stream_helper(res)
         else:
             return sep.join(
-                list(self._multiplexed_buffer_helper(res))
+                [x for x in self._multiplexed_buffer_helper(res)]
             )
 
     def _unmount(self, *args):

docker/api/container.py

@@ -1,14 +1,13 @@
 from datetime import datetime
 
-from .. import errors, utils
+from .. import errors
+from .. import utils
 from ..constants import DEFAULT_DATA_CHUNK_SIZE
-from ..types import (
+from ..types import CancellableStream
-    CancellableStream,
+from ..types import ContainerConfig
-    ContainerConfig,
+from ..types import EndpointConfig
-    EndpointConfig,
+from ..types import HostConfig
-    HostConfig,
+from ..types import NetworkingConfig
-    NetworkingConfig,
-)
 
 
 class ContainerApiMixin:
@@ -113,7 +112,7 @@ class ContainerApiMixin:
 
     @utils.check_resource('container')
     def commit(self, container, repository=None, tag=None, message=None,
-               author=None, pause=True, changes=None, conf=None):
+               author=None, changes=None, conf=None):
         """
         Commit a container to an image. Similar to the ``docker commit``
         command.
@@ -124,7 +123,6 @@ class ContainerApiMixin:
             tag (str): The tag to push
             message (str): A commit message
             author (str): The name of the author
-            pause (bool): Whether to pause the container before committing
             changes (str): Dockerfile instructions to apply while committing
             conf (dict): The configuration for the container. See the
                 `Engine API documentation
@@ -141,7 +139,6 @@ class ContainerApiMixin:
             'tag': tag,
             'comment': message,
             'author': author,
-            'pause': pause,
             'changes': changes
         }
         u = self._url("/commit")
@@ -226,7 +223,7 @@ class ContainerApiMixin:
                          mac_address=None, labels=None, stop_signal=None,
                          networking_config=None, healthcheck=None,
                          stop_timeout=None, runtime=None,
-                         use_config_proxy=True, platform=None):
+                         use_config_proxy=True):
         """
         Creates a container. Parameters are similar to those for the ``docker
         run`` command except it doesn't support the attach options (``-a``).
@@ -259,9 +256,7 @@ class ContainerApiMixin:
 
         .. code-block:: python
 
-            client.api.create_host_config(
+            client.api.create_host_config(port_bindings={1111: ('127.0.0.1', 4567)})
-                port_bindings={1111: ('127.0.0.1', 4567)}
-            )
 
         Or without host port assignment:
 
@@ -320,11 +315,6 @@ class ContainerApiMixin:
                     '/var/www': {
                         'bind': '/mnt/vol1',
                         'mode': 'ro',
-                    },
-                    '/autofs/user1': {
-                        'bind': '/mnt/vol3',
-                        'mode': 'rw',
-                        'propagation': 'shared'
                     }
                 })
             )
@@ -335,11 +325,10 @@ class ContainerApiMixin:
         .. code-block:: python
 
             container_id = client.api.create_container(
-                'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2', '/mnt/vol3'],
+                'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'],
                 host_config=client.api.create_host_config(binds=[
                     '/home/user1/:/mnt/vol2',
                     '/var/www:/mnt/vol1:ro',
-                    '/autofs/user1:/mnt/vol3:rw,shared',
                 ])
             )
 
@@ -407,7 +396,6 @@ class ContainerApiMixin:
                 configuration file (``~/.docker/config.json`` by default)
                 contains a proxy configuration, the corresponding environment
                 variables will be set in the container being created.
-            platform (str): Platform in the format ``os[/arch[/variant]]``.
 
         Returns:
             A dictionary with an image 'Id' key and a 'Warnings' key.
@@ -437,22 +425,16 @@ class ContainerApiMixin:
             stop_signal, networking_config, healthcheck,
             stop_timeout, runtime
         )
-        return self.create_container_from_config(config, name, platform)
+        return self.create_container_from_config(config, name)
 
     def create_container_config(self, *args, **kwargs):
         return ContainerConfig(self._version, *args, **kwargs)
 
-    def create_container_from_config(self, config, name=None, platform=None):
+    def create_container_from_config(self, config, name=None):
         u = self._url("/containers/create")
         params = {
             'name': name
         }
-        if platform:
-            if utils.version_lt(self._version, '1.41'):
-                raise errors.InvalidVersion(
-                    'platform is not supported for API version < 1.41'
-                )
-            params['platform'] = platform
         res = self._post_json(u, data=config, params=params)
         return self._result(res, True)
 
@@ -597,11 +579,8 @@ class ContainerApiMixin:
 
         Example:
 
-            >>> client.api.create_host_config(
+            >>> client.api.create_host_config(privileged=True, cap_drop=['MKNOD'],
-            ...     privileged=True,
+                                       volumes_from=['nostalgic_newton'])
-            ...     cap_drop=['MKNOD'],
-            ...     volumes_from=['nostalgic_newton'],
-            ... )
             {'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True,
              'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False}
 
@@ -687,8 +666,7 @@ class ContainerApiMixin:
             container (str): The container to diff
 
         Returns:
-            (list) A list of dictionaries containing the attributes `Path`
+            (str)
-                and `Kind`.
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -836,15 +814,14 @@ class ContainerApiMixin:
             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, int, or float): Show logs since a given datetime,
+            since (datetime or int): Show logs since a given datetime or
-                integer epoch (in seconds) or float (in fractional seconds)
+                integer epoch (in seconds)
             follow (bool): Follow log output. Default ``False``
-            until (datetime, int, or float): Show logs that occurred before
+            until (datetime or int): Show logs that occurred before the given
-                the given datetime, integer epoch (in seconds), or
+                datetime or integer epoch (in seconds)
-                float (in fractional seconds)
 
         Returns:
-            (generator of bytes or bytes)
+            (generator or str)
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -866,12 +843,10 @@ class ContainerApiMixin:
                 params['since'] = utils.datetime_to_timestamp(since)
             elif (isinstance(since, int) and since > 0):
                 params['since'] = since
-            elif (isinstance(since, float) and since > 0.0):
-                params['since'] = since
             else:
                 raise errors.InvalidArgument(
-                    'since value should be datetime or positive int/float,'
+                    'since value should be datetime or positive int, '
-                    f' not {type(since)}'
+                    'not {}'.format(type(since))
                 )
 
         if until is not None:
@@ -883,12 +858,10 @@ class ContainerApiMixin:
                 params['until'] = utils.datetime_to_timestamp(until)
             elif (isinstance(until, int) and until > 0):
                 params['until'] = until
-            elif (isinstance(until, float) and until > 0.0):
-                params['until'] = until
             else:
                 raise errors.InvalidArgument(
-                    f'until value should be datetime or positive int/float, '
+                    'until value should be datetime or positive int, '
-                    f'not {type(until)}'
+                    'not {}'.format(type(until))
                 )
 
         url = self._url("/containers/{0}/logs", container)
@@ -960,7 +933,7 @@ class ContainerApiMixin:
             return port_settings.get(private_port)
 
         for protocol in ['tcp', 'udp', 'sctp']:
-            h_ports = port_settings.get(f"{private_port}/{protocol}")
+            h_ports = port_settings.get(private_port + '/' + protocol)
             if h_ports:
                 break
 
@@ -976,7 +949,7 @@ class ContainerApiMixin:
             container (str): The container where the file(s) will be extracted
             path (str): Path inside the container where the file(s) will be
                 extracted. Must exist.
-            data (bytes or stream): tar data to be extracted
+            data (bytes): tar data to be extracted
 
         Returns:
             (bool): True if the call succeeds.
@@ -1136,7 +1109,7 @@ class ContainerApiMixin:
         self._raise_for_status(res)
 
     @utils.check_resource('container')
-    def stats(self, container, decode=None, stream=True, one_shot=None):
+    def stats(self, container, decode=None, stream=True):
         """
         Stream statistics for a specific container. Similar to the
         ``docker stats`` command.
@@ -1148,9 +1121,6 @@ class ContainerApiMixin:
                 False by default.
             stream (bool): If set to false, only the current stats will be
                 returned instead of a stream. True by default.
-            one_shot (bool): If set to true, Only get a single stat instead of
-                waiting for 2 cycles. Must be used with stream=false. False by
-                default.
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -1158,30 +1128,16 @@ class ContainerApiMixin:
 
         """
         url = self._url("/containers/{0}/stats", container)
-        params = {
-            'stream': stream
-        }
-        if one_shot is not None:
-            if utils.version_lt(self._version, '1.41'):
-                raise errors.InvalidVersion(
-                    'one_shot is not supported for API version < 1.41'
-                )
-            params['one-shot'] = one_shot
         if stream:
-            if one_shot:
+            return self._stream_helper(self._get(url, stream=True),
-                raise errors.InvalidArgument(
+                                       decode=decode)
-                    'one_shot is only available in conjunction with '
-                    'stream=False'
-                )
-            return self._stream_helper(
-                self._get(url, stream=True, params=params), decode=decode
-            )
         else:
             if decode:
                 raise errors.InvalidArgument(
                     "decode is only available in conjunction with stream=True"
                 )
-            return self._result(self._get(url, params=params), json=True)
+            return self._result(self._get(url, params={'stream': False}),
+                                json=True)
 
     @utils.check_resource('container')
     def stop(self, container, timeout=None):

docker/api/exec_api.py

@@ -1,5 +1,5 @@
-from .. import errors, utils
+from .. import errors
-from ..types import CancellableStream
+from .. import utils
 
 
 class ExecApiMixin:
@@ -125,10 +125,9 @@ class ExecApiMixin:
             detach (bool): If true, detach from the exec command.
                 Default: False
             tty (bool): Allocate a pseudo-TTY. Default: False
-            stream (bool): Return response data progressively as an iterator
+            stream (bool): Stream response data. Default: False
-                of strings, rather than a single string.
             socket (bool): Return the connection socket to allow custom
-                read/write operations. Must be closed by the caller when done.
+                read/write operations.
             demux (bool): Return stdout and stderr separately
 
         Returns:
@@ -162,15 +161,7 @@ class ExecApiMixin:
             stream=True
         )
         if detach:
-            try:
             return self._result(res)
-            finally:
-                res.close()
         if socket:
             return self._get_raw_response_socket(res)
-
+        return self._read_from_socket(res, stream, tty=tty, demux=demux)
-        output = self._read_from_socket(res, stream, tty=tty, demux=demux)
-        if stream:
-            return CancellableStream(output, res)
-        else:
-            return output

docker/api/image.py

@@ -47,7 +47,7 @@ class ImageApiMixin:
             image (str): The image to show history for
 
         Returns:
-            (list): The history of the image
+            (str): The history of the image
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -377,8 +377,7 @@ class ImageApiMixin:
 
         Example:
 
-            >>> resp = client.api.pull('busybox', stream=True, decode=True)
+            >>> for line in client.api.pull('busybox', stream=True, decode=True):
-            ... for line in resp:
             ...     print(json.dumps(line, indent=4))
             {
                 "status": "Pulling image (latest) from busybox",
@@ -457,12 +456,7 @@ class ImageApiMixin:
                 If the server returns an error.
 
         Example:
-            >>> resp = client.api.push(
+            >>> for line in client.api.push('yourname/app', stream=True, decode=True):
-            ...     'yourname/app',
-            ...     stream=True,
-            ...     decode=True,
-            ... )
-            ... for line in resp:
             ...   print(line)
             {'status': 'Pushing repository yourname/app (1 tags)'}
             {'status': 'Pushing','progressDetail': {}, 'id': '511136ea3c5a'}

docker/api/network.py

@@ -1,6 +1,7 @@
-from .. import utils
 from ..errors import InvalidVersion
-from ..utils import check_resource, minimum_version, version_lt
+from ..utils import check_resource, minimum_version
+from ..utils import version_lt
+from .. import utils
 
 
 class NetworkApiMixin:
@@ -215,8 +216,7 @@ class NetworkApiMixin:
     def connect_container_to_network(self, container, net_id,
                                      ipv4_address=None, ipv6_address=None,
                                      aliases=None, links=None,
-                                     link_local_ips=None, driver_opt=None,
+                                     link_local_ips=None, driver_opt=None):
-                                     mac_address=None):
         """
         Connect a container to a network.
 
@@ -235,16 +235,13 @@ class NetworkApiMixin:
                 network, using the IPv6 protocol. Defaults to ``None``.
             link_local_ips (:py:class:`list`): A list of link-local
                 (IPv4/IPv6) addresses.
-            mac_address (str): The MAC address of this container on the
-                network. Defaults to ``None``.
         """
         data = {
             "Container": container,
             "EndpointConfig": self.create_endpoint_config(
                 aliases=aliases, links=links, ipv4_address=ipv4_address,
                 ipv6_address=ipv6_address, link_local_ips=link_local_ips,
-                driver_opt=driver_opt,
+                driver_opt=driver_opt
-                mac_address=mac_address
             ),
         }
 

docker/api/plugin.py

@@ -51,20 +51,19 @@ class PluginApiMixin:
         return True
 
     @utils.minimum_version('1.25')
-    def disable_plugin(self, name, force=False):
+    def disable_plugin(self, name):
         """
             Disable an installed plugin.
 
             Args:
                 name (string): The name of the plugin. The ``:latest`` tag is
                     optional, and is the default if omitted.
-                force (bool): To enable the force query parameter.
 
             Returns:
                 ``True`` if successful
         """
         url = self._url('/plugins/{0}/disable', name)
-        res = self._post(url, params={'force': force})
+        res = self._post(url)
         self._raise_for_status(res)
         return True
 

docker/api/secret.py

@@ -1,6 +1,7 @@
 import base64
 
-from .. import errors, utils
+from .. import errors
+from .. import utils
 
 
 class SecretApiMixin:

docker/api/service.py

@@ -7,7 +7,9 @@ def _check_api_features(version, task_template, update_config, endpoint_spec,
 
     def raise_version_error(param, min_version):
         raise errors.InvalidVersion(
-            f'{param} is not supported in API version < {min_version}'
+            '{} is not supported in API version < {}'.format(
+                param, min_version
+            )
         )
 
     if update_config is not None:
@@ -260,7 +262,7 @@ class ServiceApiMixin:
         return True
 
     @utils.minimum_version('1.24')
-    def services(self, filters=None, status=None):
+    def services(self, filters=None):
         """
         List services.
 
@@ -268,8 +270,6 @@ class ServiceApiMixin:
             filters (dict): Filters to process on the nodes list. Valid
                 filters: ``id``, ``name`` , ``label`` and ``mode``.
                 Default: ``None``.
-            status (bool): Include the service task count of running and
-                desired tasks. Default: ``None``.
 
         Returns:
             A list of dictionaries containing data about each service.
@@ -281,12 +281,6 @@ class ServiceApiMixin:
         params = {
             'filters': utils.convert_filters(filters) if filters else None
         }
-        if status is not None:
-            if utils.version_lt(self._version, '1.41'):
-                raise errors.InvalidVersion(
-                    'status is not supported in API version < 1.41'
-                )
-            params['status'] = status
         url = self._url('/services')
         return self._result(self._get(url, params=params), True)
 

docker/api/swarm.py

@@ -1,8 +1,9 @@
-import http.client as http_client
 import logging
-
+import http.client as http_client
-from .. import errors, types, utils
 from ..constants import DEFAULT_SWARM_ADDR_POOL, DEFAULT_SWARM_SUBNET_SIZE
+from .. import errors
+from .. import types
+from .. import utils
 
 log = logging.getLogger(__name__)
 
@@ -84,7 +85,7 @@ class SwarmApiMixin:
     def init_swarm(self, advertise_addr=None, listen_addr='0.0.0.0:2377',
                    force_new_cluster=False, swarm_spec=None,
                    default_addr_pool=None, subnet_size=None,
-                   data_path_addr=None, data_path_port=None):
+                   data_path_addr=None):
         """
         Initialize a new Swarm using the current connected engine as the first
         node.
@@ -117,9 +118,6 @@ class SwarmApiMixin:
                 networks created from the default subnet pool. Default: None
             data_path_addr (string): Address or interface to use for data path
                 traffic. For example, 192.168.1.1, or an interface, like eth0.
-            data_path_port (int): Port number to use for data path traffic.
-                Acceptable port range is 1024 to 49151. If set to ``None`` or
-                0, the default port 4789 will be used. Default: None
 
         Returns:
             (str): The ID of the created node.
@@ -168,14 +166,6 @@ class SwarmApiMixin:
                 )
             data['DataPathAddr'] = data_path_addr
 
-        if data_path_port is not None:
-            if utils.version_lt(self._version, '1.40'):
-                raise errors.InvalidVersion(
-                    'Data path port is only available for '
-                    'API version >= 1.40'
-                )
-            data['DataPathPort'] = data_path_port
-
         response = self._post_json(url, data=data)
         return self._result(response, json=True)
 

docker/api/volume.py

@@ -1,4 +1,5 @@
-from .. import errors, utils
+from .. import errors
+from .. import utils
 
 
 class VolumeApiMixin:
@@ -55,13 +56,10 @@ class VolumeApiMixin:
 
         Example:
 
-            >>> volume = client.api.create_volume(
+            >>> volume = client.api.create_volume(name='foobar', driver='local',
-            ...     name='foobar',
+                    driver_opts={'foo': 'bar', 'baz': 'false'},
-            ...     driver='local',
+                    labels={"key": "value"})
-            ...     driver_opts={'foo': 'bar', 'baz': 'false'},
+            >>> print(volume)
-            ...     labels={"key": "value"},
-            ... )
-            ... print(volume)
             {u'Driver': u'local',
              u'Labels': {u'key': u'value'},
              u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data',

docker/auth.py

@@ -2,7 +2,8 @@ import base64
 import json
 import logging
 
-from . import credentials, errors
+from . import credentials
+from . import errors
 from .utils import config
 
 INDEX_NAME = 'docker.io'
@@ -21,15 +22,15 @@ def resolve_repository_name(repo_name):
     index_name, remote_name = split_repo_name(repo_name)
     if index_name[0] == '-' or index_name[-1] == '-':
         raise errors.InvalidRepository(
-            f'Invalid index name ({index_name}). '
+            'Invalid index name ({}). Cannot begin or end with a'
-            'Cannot begin or end with a hyphen.'
+            ' hyphen.'.format(index_name)
         )
     return resolve_index_name(index_name), remote_name
 
 
 def resolve_index_name(index_name):
     index_name = convert_to_hostname(index_name)
-    if index_name == f"index.{INDEX_NAME}":
+    if index_name == 'index.' + INDEX_NAME:
         index_name = INDEX_NAME
     return index_name
 
@@ -98,7 +99,9 @@ class AuthConfig(dict):
         for registry, entry in entries.items():
             if not isinstance(entry, dict):
                 log.debug(
-                    f'Config entry for key {registry} is not auth config'
+                    'Config entry for key {} is not auth config'.format(
+                        registry
+                    )
                 )
                 # We sometimes fall back to parsing the whole config as if it
                 # was the auth config by itself, for legacy purposes. In that
@@ -106,11 +109,17 @@ class AuthConfig(dict):
                 # keys is not formatted properly.
                 if raise_on_error:
                     raise errors.InvalidConfigFile(
-                        f'Invalid configuration for registry {registry}'
+                        'Invalid configuration for registry {}'.format(
+                            registry
+                        )
                     )
                 return {}
             if 'identitytoken' in entry:
-                log.debug(f'Found an IdentityToken entry for registry {registry}')
+                log.debug(
+                    'Found an IdentityToken entry for registry {}'.format(
+                        registry
+                    )
+                )
                 conf[registry] = {
                     'IdentityToken': entry['identitytoken']
                 }
@@ -121,15 +130,16 @@ class AuthConfig(dict):
                 # a valid value in the auths config.
                 # https://github.com/docker/compose/issues/3265
                 log.debug(
-                    f'Auth data for {registry} is absent. '
+                    'Auth data for {} is absent. Client might be using a '
-                    f'Client might be using a credentials store instead.'
+                    'credentials store instead.'.format(registry)
                 )
                 conf[registry] = {}
                 continue
 
             username, password = decode_auth(entry['auth'])
             log.debug(
-                f'Found entry (registry={registry!r}, username={username!r})'
+                'Found entry (registry={}, username={})'
+                .format(repr(registry), repr(username))
             )
 
             conf[registry] = {
@@ -267,7 +277,7 @@ class AuthConfig(dict):
         except credentials.StoreError as e:
             raise errors.DockerException(
                 f'Credentials store error: {repr(e)}'
-            ) from e
+            )
 
     def _get_store_instance(self, name):
         if name not in self._stores:
@@ -373,6 +383,7 @@ def _load_legacy_config(config_file):
         }}
     except Exception as e:
         log.debug(e)
+        pass
 
     log.debug("All parsing attempts failed - returning empty config")
     return {}

docker/client.py

@@ -1,5 +1,5 @@
 from .api.client import APIClient
-from .constants import DEFAULT_MAX_POOL_SIZE, DEFAULT_TIMEOUT_SECONDS
+from .constants import (DEFAULT_TIMEOUT_SECONDS, DEFAULT_MAX_POOL_SIZE)
 from .models.configs import ConfigCollection
 from .models.containers import ContainerCollection
 from .models.images import ImageCollection
@@ -71,6 +71,8 @@ class DockerClient:
             timeout (int): Default timeout for API calls, in seconds.
             max_pool_size (int): The maximum number of connections
                 to save in the pool.
+            ssl_version (int): A valid `SSL version`_.
+            assert_hostname (bool): Verify the hostname of the server.
             environment (dict): The environment to read environment variables
                 from. Default: the value of ``os.environ``
             credstore_env (dict): Override environment variables when calling

docker/constants.py

@@ -1,9 +1,8 @@
 import sys
+from .version import version
 
-from .version import __version__
+DEFAULT_DOCKER_API_VERSION = '1.41'
-
+MINIMUM_DOCKER_API_VERSION = '1.21'
-DEFAULT_DOCKER_API_VERSION = '1.45'
-MINIMUM_DOCKER_API_VERSION = '1.24'
 DEFAULT_TIMEOUT_SECONDS = 60
 STREAM_HEADER_SIZE_BYTES = 8
 CONTAINER_LIMITS_KEYS = [
@@ -29,7 +28,7 @@ INSECURE_REGISTRY_DEPRECATION_WARNING = \
 IS_WINDOWS_PLATFORM = (sys.platform == 'win32')
 WINDOWS_LONGPATH_PREFIX = '\\\\?\\'
 
-DEFAULT_USER_AGENT = f"docker-sdk-python/{__version__}"
+DEFAULT_USER_AGENT = f"docker-sdk-python/{version}"
 DEFAULT_NUM_POOLS = 25
 
 # The OpenSSH server default value for MaxSessions is 10 which means we can

docker/context/__init__.py

@@ -1,2 +1,3 @@
-from .api import ContextAPI
+# flake8: noqa
 from .context import Context
+from .api import ContextAPI

docker/context/api.py

@@ -2,14 +2,11 @@ import json
 import os
 
 from docker import errors
-
+from docker.context.config import get_meta_dir
-from .config import (
+from docker.context.config import METAFILE
-    METAFILE,
+from docker.context.config import get_current_context_name
-    get_current_context_name,
+from docker.context.config import write_context_name_to_docker_config
-    get_meta_dir,
+from docker.context import Context
-    write_context_name_to_docker_config,
-)
-from .context import Context
 
 
 class ContextAPI:
@@ -116,8 +113,8 @@ class ContextAPI:
                         names.append(data["Name"])
                     except Exception as e:
                         raise errors.ContextException(
-                            f"Failed to load metafile {filename}: {e}",
+                            "Failed to load metafile {}: {}".format(
-                        ) from e
+                                filename, e))
 
         contexts = [cls.DEFAULT_CONTEXT]
         for name in names:

docker/context/config.py

@@ -1,9 +1,10 @@
-import hashlib
-import json
 import os
+import json
+import hashlib
 
 from docker import utils
-from docker.constants import DEFAULT_UNIX_SOCKET, IS_WINDOWS_PLATFORM
+from docker.constants import IS_WINDOWS_PLATFORM
+from docker.constants import DEFAULT_UNIX_SOCKET
 from docker.utils.config import find_config_file
 
 METAFILE = "meta.json"
@@ -76,6 +77,5 @@ def get_context_host(path=None, tls=False):
     host = utils.parse_host(path, IS_WINDOWS_PLATFORM, tls)
     if host == DEFAULT_UNIX_SOCKET:
         # remove http+ from default docker socket url
-        if host.startswith("http+"):
+        return host.strip("http+")
-            host = host[5:]
     return host

docker/context/context.py

@@ -1,16 +1,12 @@
-import json
 import os
+import json
 from shutil import copyfile, rmtree
-
-from docker.errors import ContextException
 from docker.tls import TLSConfig
-
+from docker.errors import ContextException
-from .config import (
+from docker.context.config import get_meta_dir
-    get_context_host,
+from docker.context.config import get_meta_file
-    get_meta_dir,
+from docker.context.config import get_tls_dir
-    get_meta_file,
+from docker.context.config import get_context_host
-    get_tls_dir,
-)
 
 
 class Context:
@@ -46,9 +42,8 @@ class Context:
         for k, v in endpoints.items():
             if not isinstance(v, dict):
                 # unknown format
-                raise ContextException(
+                raise ContextException("""Unknown endpoint format for
-                    f"Unknown endpoint format for context {name}: {v}",
+                    context {}: {}""".format(name, v))
-                )
 
             self.endpoints[k] = v
             if k != "docker":
@@ -101,9 +96,8 @@ class Context:
                 metadata = json.load(f)
         except (OSError, KeyError, ValueError) as e:
             # unknown format
-            raise Exception(
+            raise Exception("""Detected corrupted meta file for
-                f"Detected corrupted meta file for context {name} : {e}"
+                context {} : {}""".format(name, e))
-            ) from e
 
         # for docker endpoints, set defaults for
         # Host and SkipTLSVerify fields

docker/credentials/__init__.py

@@ -1,8 +1,4 @@
-from .constants import (
+# flake8: noqa
-    DEFAULT_LINUX_STORE,
-    DEFAULT_OSX_STORE,
-    DEFAULT_WIN32_STORE,
-    PROGRAM_PREFIX,
-)
-from .errors import CredentialsNotFound, StoreError
 from .store import Store
+from .errors import StoreError, CredentialsNotFound
+from .constants import *

docker/credentials/errors.py

@@ -13,5 +13,13 @@ class InitializationError(StoreError):
 def process_store_error(cpe, program):
     message = cpe.output.decode('utf-8')
     if 'credentials not found in native keychain' in message:
-        return CredentialsNotFound(f'No matching credentials in {program}')
+        return CredentialsNotFound(
-    return StoreError(f'Credentials store {program} exited with "{message}".')
+            'No matching credentials in {}'.format(
+                program
+            )
+        )
+    return StoreError(
+        'Credentials store {} exited with "{}".'.format(
+            program, cpe.output.decode('utf-8').strip()
+        )
+    )

docker/credentials/store.py

@@ -1,11 +1,11 @@
 import errno
 import json
-import shutil
 import subprocess
-import warnings
 
-from . import constants, errors
+from . import constants
+from . import errors
 from .utils import create_environment_dict
+from .utils import find_executable
 
 
 class Store:
@@ -15,12 +15,13 @@ class Store:
             and erasing credentials using `program`.
         """
         self.program = constants.PROGRAM_PREFIX + program
-        self.exe = shutil.which(self.program)
+        self.exe = find_executable(self.program)
         self.environment = environment
         if self.exe is None:
-            warnings.warn(
+            raise errors.InitializationError(
-                f'{self.program} not installed or not available in PATH',
+                '{} not installed or not available in PATH'.format(
-                stacklevel=1,
+                    self.program
+                )
             )
 
     def get(self, server):
@@ -69,10 +70,6 @@ class Store:
         return json.loads(data.decode('utf-8'))
 
     def _execute(self, subcmd, data_input):
-        if self.exe is None:
-            raise errors.StoreError(
-                f'{self.program} not installed or not available in PATH'
-            )
         output = None
         env = create_environment_dict(self.environment)
         try:
@@ -80,14 +77,18 @@ class Store:
                 [self.exe, subcmd], input=data_input, env=env,
             )
         except subprocess.CalledProcessError as e:
-            raise errors.process_store_error(e, self.program) from e
+            raise errors.process_store_error(e, self.program)
         except OSError as e:
             if e.errno == errno.ENOENT:
                 raise errors.StoreError(
-                    f'{self.program} not installed or not available in PATH'
+                    '{} not installed or not available in PATH'.format(
-                ) from e
+                        self.program
+                    )
+                )
             else:
                 raise errors.StoreError(
-                    f'Unexpected OS error "{e.strerror}", errno={e.errno}'
+                    'Unexpected OS error "{}", errno={}'.format(
-                ) from e
+                        e.strerror, e.errno
+                    )
+                )
         return output

docker/credentials/utils.py

@@ -1,4 +1,32 @@
+import distutils.spawn
 import os
+import sys
+
+
+def find_executable(executable, path=None):
+    """
+    As distutils.spawn.find_executable, but on Windows, look up
+    every extension declared in PATHEXT instead of just `.exe`
+    """
+    if sys.platform != 'win32':
+        return distutils.spawn.find_executable(executable, path)
+
+    if path is None:
+        path = os.environ['PATH']
+
+    paths = path.split(os.pathsep)
+    extensions = os.environ.get('PATHEXT', '.exe').split(os.pathsep)
+    base, ext = os.path.splitext(executable)
+
+    if not os.path.isfile(executable):
+        for p in paths:
+            for ext in extensions:
+                f = os.path.join(p, base + ext)
+                if os.path.isfile(f):
+                    return f
+        return None
+    else:
+        return executable
 
 
 def create_environment_dict(overrides):

docker/errors.py

@@ -1,14 +1,5 @@
 import requests
 
-_image_not_found_explanation_fragments = frozenset(
-    fragment.lower() for fragment in [
-        'no such image',
-        'not found: does not exist or no pull access',
-        'repository does not exist',
-        'was found but does not match the specified platform',
-    ]
-)
-
 
 class DockerException(Exception):
     """
@@ -27,16 +18,17 @@ def create_api_error_from_http_exception(e):
     try:
         explanation = response.json()['message']
     except ValueError:
-        explanation = (response.text or '').strip()
+        explanation = (response.content or '').strip()
     cls = APIError
     if response.status_code == 404:
-        explanation_msg = (explanation or '').lower()
+        if explanation and ('No such image' in str(explanation) or
-        if any(fragment in explanation_msg
+                            'not found: does not exist or no pull access'
-               for fragment in _image_not_found_explanation_fragments):
+                            in str(explanation) or
+                            'repository does not exist' in str(explanation)):
             cls = ImageNotFound
         else:
             cls = NotFound
-    raise cls(e, response=response, explanation=explanation) from e
+    raise cls(e, response=response, explanation=explanation)
 
 
 class APIError(requests.exceptions.HTTPError, DockerException):
@@ -54,16 +46,14 @@ class APIError(requests.exceptions.HTTPError, DockerException):
         message = super().__str__()
 
         if self.is_client_error():
-            message = (
+            message = '{} Client Error for {}: {}'.format(
-                f'{self.response.status_code} Client Error for '
+                self.response.status_code, self.response.url,
-                f'{self.response.url}: {self.response.reason}'
+                self.response.reason)
-            )
 
         elif self.is_server_error():
-            message = (
+            message = '{} Server Error for {}: {}'.format(
-                f'{self.response.status_code} Server Error for '
+                self.response.status_code, self.response.url,
-                f'{self.response.url}: {self.response.reason}'
+                self.response.reason)
-            )
 
         if self.explanation:
             message = f'{message} ("{self.explanation}")'
@@ -144,10 +134,10 @@ class ContainerError(DockerException):
         self.stderr = stderr
 
         err = f": {stderr}" if stderr is not None else ""
-        super().__init__(
+        msg = ("Command '{}' in image '{}' returned non-zero exit "
-            f"Command '{command}' in image '{image}' "
+               "status {}{}").format(command, image, exit_status, err)
-            f"returned non-zero exit status {exit_status}{err}"
+
-        )
+        super().__init__(msg)
 
 
 class StreamParseError(RuntimeError):

docker/models/configs.py

@@ -1,5 +1,5 @@
 from ..api import APIClient
-from .resource import Collection, Model
+from .resource import Model, Collection
 
 
 class Config(Model):
@@ -30,7 +30,6 @@ class ConfigCollection(Collection):
 
     def create(self, **kwargs):
         obj = self.client.api.create_config(**kwargs)
-        obj.setdefault("Spec", {})["Name"] = kwargs.get("name")
         return self.prepare_model(obj)
     create.__doc__ = APIClient.create_config.__doc__
 

docker/models/containers.py

@@ -5,13 +5,10 @@ from collections import namedtuple
 from ..api import APIClient
 from ..constants import DEFAULT_DATA_CHUNK_SIZE
 from ..errors import (
-    ContainerError,
+    ContainerError, DockerException, ImageNotFound,
-    DockerException,
+    NotFound, create_unexpected_kwargs_error
-    ImageNotFound,
-    NotFound,
-    create_unexpected_kwargs_error,
 )
-from ..types import HostConfig, NetworkingConfig
+from ..types import HostConfig
 from ..utils import version_gte
 from .images import Image
 from .resource import Collection, Model
@@ -24,7 +21,6 @@ class Container(Model):
         query the Docker daemon for the current properties, causing
         :py:attr:`attrs` to be refreshed.
     """
-
     @property
     def name(self):
         """
@@ -51,11 +47,11 @@ class Container(Model):
         try:
             result = self.attrs['Config'].get('Labels')
             return result or {}
-        except KeyError as ke:
+        except KeyError:
             raise DockerException(
                 'Label data is not available for sparse objects. Call reload()'
                 ' to retrieve all information'
-            ) from ke
+            )
 
     @property
     def status(self):
@@ -66,15 +62,6 @@ class Container(Model):
             return self.attrs['State']['Status']
         return self.attrs['State']
 
-    @property
-    def health(self):
-        """
-        The healthcheck status of the container.
-
-        For example, ``healthy`, or ``unhealthy`.
-        """
-        return self.attrs.get('State', {}).get('Health', {}).get('Status', 'unknown')
-
     @property
     def ports(self):
         """
@@ -134,7 +121,6 @@ class Container(Model):
             tag (str): The tag to push
             message (str): A commit message
             author (str): The name of the author
-            pause (bool): Whether to pause the container before committing
             changes (str): Dockerfile instructions to apply while committing
             conf (dict): The configuration for the container. See the
                 `Engine API documentation
@@ -155,8 +141,7 @@ class Container(Model):
         Inspect changes on a container's filesystem.
 
         Returns:
-            (list) A list of dictionaries containing the attributes `Path`
+            (str)
-                and `Kind`.
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -181,8 +166,7 @@ class Container(Model):
             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. Ignored if ``detach`` is true.
+            stream (bool): Stream response data. Default: False
-                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
@@ -306,15 +290,14 @@ class Container(Model):
             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, int, or float): Show logs since a given datetime,
+            since (datetime or int): Show logs since a given datetime or
-                integer epoch (in seconds) or float (in nanoseconds)
+                integer epoch (in seconds)
             follow (bool): Follow log output. Default ``False``
-            until (datetime, int, or float): Show logs that occurred before
+            until (datetime or int): Show logs that occurred before the given
-                the given datetime, integer epoch (in seconds), or
+                datetime or integer epoch (in seconds)
-                float (in nanoseconds)
 
         Returns:
-            (generator of bytes or bytes): Logs from the container.
+            (generator or str): Logs from the container.
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -340,7 +323,7 @@ class Container(Model):
         Args:
             path (str): Path inside the container where the file(s) will be
                 extracted. Must exist.
-            data (bytes or stream): tar data to be extracted
+            data (bytes): tar data to be extracted
 
         Returns:
             (bool): True if the call succeeds.
@@ -570,11 +553,6 @@ class ContainerCollection(Collection):
                 ``["SYS_ADMIN", "MKNOD"]``.
             cap_drop (list of str): Drop kernel capabilities.
             cgroup_parent (str): Override the default parent cgroup.
-            cgroupns (str): Override the default cgroup namespace mode for the
-                container. One of:
-                - ``private`` the container runs in its own private cgroup
-                  namespace.
-                - ``host`` use the host system's cgroup namespace.
             cpu_count (int): Number of usable CPUs (Windows only).
             cpu_percent (int): Usable percentage of the available CPUs
                 (Windows only).
@@ -622,28 +600,7 @@ class ContainerCollection(Collection):
             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. The dict takes the following keys:
+                container is healthy.
-
-                - test (:py:class:`list` or str): Test to perform to determine
-                    container health. Possible values:
-
-                    - Empty list: Inherit healthcheck from parent image
-                    - ``["NONE"]``: Disable healthcheck
-                    - ``["CMD", args...]``: exec arguments directly.
-                    - ``["CMD-SHELL", command]``: Run command in the system's
-                      default shell.
-
-                    If a string is provided, it will be used as a ``CMD-SHELL``
-                    command.
-                - interval (int): The time to wait between checks in
-                  nanoseconds. It should be 0 or at least 1000000 (1 ms).
-                - timeout (int): The time to wait before considering the check
-                  to have hung. It should be 0 or at least 1000000 (1 ms).
-                - retries (int): The number of consecutive failures needed to
-                    consider a container as unhealthy.
-                - start_period (int): Start period for the container to
-                    initialize before starting health-retries countdown in
-                    nanoseconds. It should be 0 or at least 1000000 (1 ms).
             hostname (str): Optional hostname for the container.
             init (bool): Run an init inside the container that forwards
                 signals and reaps processes
@@ -687,7 +644,7 @@ class ContainerCollection(Collection):
             network_mode (str): One of:
 
                 - ``bridge`` Create a new network stack for the container on
-                  the bridge network.
+                  on the bridge network.
                 - ``none`` No networking for this container.
                 - ``container:<name|id>`` Reuse another container's network
                   stack.
@@ -695,14 +652,6 @@ class ContainerCollection(Collection):
                   This mode is incompatible with ``ports``.
 
                 Incompatible with ``network``.
-            networking_config (Dict[str, EndpointConfig]):
-                Dictionary of EndpointConfig objects for each container network.
-                The key is the name of the network.
-                Defaults to ``None``.
-
-                Used in conjuction with ``network``.
-
-                Incompatible with ``network_mode``.
             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.
@@ -812,8 +761,7 @@ class ContainerCollection(Collection):
                     {'/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
+                Or a list of strings which each one of its elements specifies a mount volume.
-                mount volume.
 
                 For example:
 
@@ -852,7 +800,7 @@ class ContainerCollection(Collection):
             image = image.id
         stream = kwargs.pop('stream', False)
         detach = kwargs.pop('detach', False)
-        platform = kwargs.get('platform', None)
+        platform = kwargs.pop('platform', None)
 
         if detach and remove:
             if version_gte(self.client.api._version, '1.25'):
@@ -867,12 +815,6 @@ class ContainerCollection(Collection):
                 'together.'
             )
 
-        if kwargs.get('networking_config') and not kwargs.get('network'):
-            raise RuntimeError(
-                'The option "networking_config" can not be used '
-                'without "network".'
-            )
-
         try:
             container = self.create(image=image, command=command,
                                     detach=detach, **kwargs)
@@ -907,9 +849,9 @@ class ContainerCollection(Collection):
                 container, exit_status, command, image, out
             )
 
-        if stream or out is None:
+        return out if stream or out is None else b''.join(
-            return out
+            [line for line in out]
-        return b''.join(out)
+        )
 
     def create(self, image, command=None, **kwargs):
         """
@@ -1025,7 +967,6 @@ class ContainerCollection(Collection):
 
     def prune(self, filters=None):
         return self.client.api.prune_containers(filters=filters)
-
     prune.__doc__ = APIClient.prune_containers.__doc__
 
 
@@ -1043,7 +984,6 @@ RUN_CREATE_KWARGS = [
     'mac_address',
     'name',
     'network_disabled',
-    'platform',
     'stdin_open',
     'stop_signal',
     'tty',
@@ -1060,7 +1000,6 @@ RUN_HOST_CONFIG_KWARGS = [
     'cap_add',
     'cap_drop',
     'cgroup_parent',
-    'cgroupns',
     'cpu_count',
     'cpu_percent',
     'cpu_period',
@@ -1144,17 +1083,8 @@ def _create_container_args(kwargs):
         host_config_kwargs['binds'] = volumes
 
     network = kwargs.pop('network', None)
-    networking_config = kwargs.pop('networking_config', None)
     if network:
-        if networking_config:
+        create_kwargs['networking_config'] = {network: None}
-            # Sanity check: check if the network is defined in the
-            # networking config dict, otherwise switch to None
-            if network not in networking_config:
-                networking_config = None
-
-        create_kwargs['networking_config'] = NetworkingConfig(
-            networking_config
-        ) if networking_config else {network: None}
         host_config_kwargs['network_mode'] = network
 
     # All kwargs should have been consumed by this point, so raise
@@ -1187,10 +1117,8 @@ def _host_volume_from_bind(bind):
     bits = rest.split(':', 1)
     if len(bits) == 1 or bits[1] in ('ro', 'rw'):
         return drive + bits[0]
-    elif bits[1].endswith(':ro') or bits[1].endswith(':rw'):
-        return bits[1][:-3]
     else:
-        return bits[1]
+        return bits[1].rstrip(':ro').rstrip(':rw')
 
 
 ExecResult = namedtuple('ExecResult', 'exit_code,output')

docker/models/images.py

@@ -15,8 +15,7 @@ class Image(Model):
     An image on the server.
     """
     def __repr__(self):
-        tag_str = "', '".join(self.tags)
+        return "<{}: '{}'>".format(self.__class__.__name__, "', '".join(self.tags))
-        return f"<{self.__class__.__name__}: '{tag_str}'>"
 
     @property
     def labels(self):
@@ -29,12 +28,12 @@ class Image(Model):
     @property
     def short_id(self):
         """
-        The ID of the image truncated to 12 characters, plus the ``sha256:``
+        The ID of the image truncated to 10 characters, plus the ``sha256:``
         prefix.
         """
         if self.id.startswith('sha256:'):
-            return self.id[:19]
+            return self.id[:17]
-        return self.id[:12]
+        return self.id[:10]
 
     @property
     def tags(self):
@@ -51,7 +50,7 @@ class Image(Model):
         Show the history of an image.
 
         Returns:
-            (list): The history of the image.
+            (str): The history of the image.
 
         Raises:
             :py:class:`docker.errors.APIError`
@@ -59,24 +58,6 @@ class Image(Model):
         """
         return self.client.api.history(self.id)
 
-    def remove(self, force=False, noprune=False):
-        """
-        Remove this image.
-
-        Args:
-            force (bool): Force removal of the image
-            noprune (bool): Do not delete untagged parents
-
-        Raises:
-            :py:class:`docker.errors.APIError`
-                If the server returns an error.
-        """
-        return self.client.api.remove_image(
-            self.id,
-            force=force,
-            noprune=noprune,
-        )
-
     def save(self, chunk_size=DEFAULT_DATA_CHUNK_SIZE, named=False):
         """
         Get a tarball of an image. Similar to the ``docker save`` command.
@@ -157,10 +138,10 @@ class RegistryData(Model):
     @property
     def short_id(self):
         """
-        The ID of the image truncated to 12 characters, plus the ``sha256:``
+        The ID of the image truncated to 10 characters, plus the ``sha256:``
         prefix.
         """
-        return self.id[:19]
+        return self.id[:17]
 
     def pull(self, platform=None):
         """
@@ -222,10 +203,10 @@ class ImageCollection(Collection):
         Build an image and return it. Similar to the ``docker build``
         command. Either ``path`` or ``fileobj`` must be set.
 
-        If you already have a tar file for the Docker build context (including
+        If you have a tar file for the Docker build context (including a
-        a Dockerfile), pass a readable file-like object to ``fileobj``
+        Dockerfile) already, pass a readable file-like object to ``fileobj``
-        and also pass ``custom_context=True``. If the stream is also
+        and also pass ``custom_context=True``. If the stream is compressed
-        compressed, set ``encoding`` to the correct value (e.g ``gzip``).
+        also, set ``encoding`` to the correct value (e.g ``gzip``).
 
         If you want to get the raw output of the build, use the
         :py:meth:`~docker.api.build.BuildApiMixin.build` method in the
@@ -282,7 +263,7 @@ class ImageCollection(Collection):
 
         Returns:
             (tuple): The first item is the :py:class:`Image` object for the
-                image that was built. The second item is a generator of the
+                image that was build. The second item is a generator of the
                 build logs as JSON-decoded objects.
 
         Raises:
@@ -407,8 +388,8 @@ class ImageCollection(Collection):
                 if match:
                     image_id = match.group(2)
                     images.append(image_id)
-            if 'errorDetail' in chunk:
+            if 'error' in chunk:
-                raise ImageLoadError(chunk['errorDetail']['message'])
+                raise ImageLoadError(chunk['error'])
 
         return [self.get(i) for i in images]
 
@@ -456,8 +437,7 @@ class ImageCollection(Collection):
         if 'stream' in kwargs:
             warnings.warn(
                 '`stream` is not a valid parameter for this method'
-                ' and will be overridden',
+                ' and will be overridden'
-                stacklevel=1,
             )
             del kwargs['stream']
 
@@ -470,8 +450,9 @@ class ImageCollection(Collection):
             # to be pulled.
             pass
         if not all_tags:
-            sep = '@' if tag.startswith('sha256:') else ':'
+            return self.get('{0}{2}{1}'.format(
-            return self.get(f'{repository}{sep}{tag}')
+                repository, tag, '@' if tag.startswith('sha256:') else ':'
+            ))
         return self.list(repository)
 
     def push(self, repository, tag=None, **kwargs):

docker/models/networks.py

@@ -1,7 +1,7 @@
 from ..api import APIClient
 from ..utils import version_gte
 from .containers import Container
-from .resource import Collection, Model
+from .resource import Model, Collection
 
 
 class Network(Model):
@@ -184,7 +184,7 @@ class NetworkCollection(Collection):
 
     def list(self, *args, **kwargs):
         """
-        List networks. Similar to the ``docker network ls`` command.
+        List networks. Similar to the ``docker networks ls`` command.
 
         Args:
             names (:py:class:`list`): List of names to filter by.

docker/models/nodes.py

@@ -1,4 +1,4 @@
-from .resource import Collection, Model
+from .resource import Model, Collection
 
 
 class Node(Model):

docker/models/plugins.py

@@ -44,19 +44,16 @@ class Plugin(Model):
         self.client.api.configure_plugin(self.name, options)
         self.reload()
 
-    def disable(self, force=False):
+    def disable(self):
         """
             Disable the plugin.
 
-            Args:
-                force (bool): Force disable. Default: False
-
             Raises:
                 :py:class:`docker.errors.APIError`
                     If the server returns an error.
         """
 
-        self.client.api.disable_plugin(self.name, force)
+        self.client.api.disable_plugin(self.name)
         self.reload()
 
     def enable(self, timeout=0):
@@ -120,11 +117,7 @@ class Plugin(Model):
         if remote is None:
             remote = self.name
         privileges = self.client.api.plugin_privileges(remote)
-        yield from self.client.api.upgrade_plugin(
+        yield from self.client.api.upgrade_plugin(self.name, remote, privileges)
-            self.name,
-            remote,
-            privileges,
-        )
         self.reload()
 
 
@@ -187,7 +180,7 @@ class PluginCollection(Collection):
         """
         privileges = self.client.api.plugin_privileges(remote_name)
         it = self.client.api.pull_plugin(remote_name, privileges, local_name)
-        for _data in it:
+        for data in it:
             pass
         return self.get(local_name or remote_name)
 

docker/models/resource.py

@@ -35,9 +35,9 @@ class Model:
     @property
     def short_id(self):
         """
-        The ID of the object, truncated to 12 characters.
+        The ID of the object, truncated to 10 characters.
         """
-        return self.id[:12]
+        return self.id[:10]
 
     def reload(self):
         """
@@ -64,10 +64,9 @@ class Collection:
 
     def __call__(self, *args, **kwargs):
         raise TypeError(
-            f"'{self.__class__.__name__}' object is not callable. "
+            "'{}' object is not callable. You might be trying to use the old "
-            "You might be trying to use the old (pre-2.0) API - "
+            "(pre-2.0) API - use docker.APIClient if so."
-            "use docker.APIClient if so."
+            .format(self.__class__.__name__))
-        )
 
     def list(self):
         raise NotImplementedError
@@ -89,4 +88,5 @@ class Collection:
         elif isinstance(attrs, dict):
             return self.model(attrs=attrs, client=self.client, collection=self)
         else:
-            raise Exception(f"Can't create {self.model.__name__} from {attrs}")
+            raise Exception("Can't create %s from %s" %
+                            (self.model.__name__, attrs))

docker/models/secrets.py

@@ -1,5 +1,5 @@
 from ..api import APIClient
-from .resource import Collection, Model
+from .resource import Model, Collection
 
 
 class Secret(Model):

docker/models/services.py

@@ -1,9 +1,7 @@
 import copy
-
+from docker.errors import create_unexpected_kwargs_error, InvalidArgument
-from docker.errors import InvalidArgument, create_unexpected_kwargs_error
+from docker.types import TaskTemplate, ContainerSpec, Placement, ServiceMode
-from docker.types import ContainerSpec, Placement, ServiceMode, TaskTemplate
+from .resource import Model, Collection
-
-from .resource import Collection, Model
 
 
 class Service(Model):
@@ -219,8 +217,6 @@ class ServiceCollection(Collection):
                 the default set for the container.
             cap_drop (:py:class:`list`): A list of kernel capabilities to drop
                 from the default set for the container.
-            sysctls (:py:class:`dict`): A dict of sysctl values to add to the
-                container
 
         Returns:
             :py:class:`Service`: The created service.
@@ -268,8 +264,6 @@ class ServiceCollection(Collection):
             filters (dict): Filters to process on the nodes list. Valid
                 filters: ``id``, ``name`` , ``label`` and ``mode``.
                 Default: ``None``.
-            status (bool): Include the service task count of running and
-                desired tasks. Default: ``None``.
 
         Returns:
             list of :py:class:`Service`: The services.
@@ -311,7 +305,6 @@ CONTAINER_SPEC_KWARGS = [
     'tty',
     'user',
     'workdir',
-    'sysctls',
 ]
 
 # kwargs to copy straight over to TaskTemplate
@@ -327,7 +320,6 @@ CREATE_SERVICE_KWARGS = [
     'labels',
     'mode',
     'update_config',
-    'rollback_config',
     'endpoint_spec',
 ]
 

docker/models/swarm.py

@@ -1,6 +1,5 @@
 from docker.api import APIClient
 from docker.errors import APIError
-
 from .resource import Model
 
 
@@ -36,8 +35,7 @@ class Swarm(Model):
 
     def init(self, advertise_addr=None, listen_addr='0.0.0.0:2377',
              force_new_cluster=False, default_addr_pool=None,
-             subnet_size=None, data_path_addr=None, data_path_port=None,
+             subnet_size=None, data_path_addr=None, **kwargs):
-             **kwargs):
         """
         Initialize a new swarm on this Engine.
 
@@ -67,9 +65,6 @@ class Swarm(Model):
                 networks created from the default subnet pool. Default: None
             data_path_addr (string): Address or interface to use for data path
                 traffic. For example, 192.168.1.1, or an interface, like eth0.
-            data_path_port (int): Port number to use for data path traffic.
-                Acceptable port range is 1024 to 49151. If set to ``None`` or
-                0, the default port 4789 will be used. Default: None
             task_history_retention_limit (int): Maximum number of tasks
                 history stored.
             snapshot_interval (int): Number of logs entries between snapshot.
@@ -126,7 +121,6 @@ class Swarm(Model):
             'default_addr_pool': default_addr_pool,
             'subnet_size': subnet_size,
             'data_path_addr': data_path_addr,
-            'data_path_port': data_path_port,
         }
         init_kwargs['swarm_spec'] = self.client.api.create_swarm_spec(**kwargs)
         node_id = self.client.api.init_swarm(**init_kwargs)

docker/models/volumes.py

@@ -1,5 +1,5 @@
 from ..api import APIClient
-from .resource import Collection, Model
+from .resource import Model, Collection
 
 
 class Volume(Model):

docker/tls.py

@@ -1,6 +1,8 @@
 import os
+import ssl
 
 from . import errors
+from .transport import SSLHTTPAdapter
 
 
 class TLSConfig:
@@ -10,21 +12,56 @@ class TLSConfig:
     Args:
         client_cert (tuple of str): Path to client cert, path to client key.
         ca_cert (str): Path to CA cert file.
-        verify (bool or str): This can be a bool or a path to a CA cert
+        verify (bool or str): This can be ``False`` or a path to a CA cert
-            file to verify against. If ``True``, verify using ca_cert;
+            file.
-            if ``False`` or not specified, do not verify.
+        ssl_version (int): A valid `SSL version`_.
+        assert_hostname (bool): Verify the hostname of the server.
+
+    .. _`SSL version`:
+        https://docs.python.org/3.5/library/ssl.html#ssl.PROTOCOL_TLSv1
     """
     cert = None
     ca_cert = None
     verify = None
+    ssl_version = None
 
-    def __init__(self, client_cert=None, ca_cert=None, verify=None):
+    def __init__(self, client_cert=None, ca_cert=None, verify=None,
+                 ssl_version=None, assert_hostname=None,
+                 assert_fingerprint=None):
         # Argument compatibility/mapping with
         # https://docs.docker.com/engine/articles/https/
         # This diverges from the Docker CLI in that users can specify 'tls'
         # here, but also disable any public/default CA pool verification by
         # leaving verify=False
 
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+
+        # TODO(dperny): according to the python docs, PROTOCOL_TLSvWhatever is
+        # depcreated, and it's recommended to use OPT_NO_TLSvWhatever instead
+        # to exclude versions. But I think that might require a bigger
+        # architectural change, so I've opted not to pursue it at this time
+
+        # If the user provides an SSL version, we should use their preference
+        if ssl_version:
+            self.ssl_version = ssl_version
+        else:
+            # If the user provides no ssl version, we should default to
+            # TLSv1_2.  This option is the most secure, and will work for the
+            # majority of users with reasonably up-to-date software. However,
+            # before doing so, detect openssl version to ensure we can support
+            # it.
+            if ssl.OPENSSL_VERSION_INFO[:3] >= (1, 0, 1) and hasattr(
+                    ssl, 'PROTOCOL_TLSv1_2'):
+                # If the OpenSSL version is high enough to support TLSv1_2,
+                # then we should use it.
+                self.ssl_version = getattr(ssl, 'PROTOCOL_TLSv1_2')
+            else:
+                # Otherwise, TLS v1.0 seems to be the safest default;
+                # SSLv23 fails in mysterious ways:
+                # https://github.com/docker/docker-py/issues/963
+                self.ssl_version = ssl.PROTOCOL_TLSv1
+
         # "client_cert" must have both or neither cert/key files. In
         # either case, Alert the user when both are expected, but any are
         # missing.
@@ -36,7 +73,7 @@ class TLSConfig:
                 raise errors.TLSParameterError(
                     'client_cert must be a tuple of'
                     ' (client certificate, key file)'
-                ) from None
+                )
 
             if not (tls_cert and tls_key) or (not os.path.isfile(tls_cert) or
                                               not os.path.isfile(tls_key)):
@@ -58,6 +95,8 @@ class TLSConfig:
         """
         Configure a client with these TLS options.
         """
+        client.ssl_version = self.ssl_version
+
         if self.verify and self.ca_cert:
             client.verify = self.ca_cert
         else:
@@ -65,3 +104,9 @@ class TLSConfig:
 
         if self.cert:
             client.cert = self.cert
+
+        client.mount('https://', SSLHTTPAdapter(
+            ssl_version=self.ssl_version,
+            assert_hostname=self.assert_hostname,
+            assert_fingerprint=self.assert_fingerprint,
+        ))

docker/transport/__init__.py

@@ -1,5 +1,6 @@
+# flake8: noqa
 from .unixconn import UnixHTTPAdapter
-
+from .ssladapter import SSLHTTPAdapter
 try:
     from .npipeconn import NpipeHTTPAdapter
     from .npipesocket import NpipeSocket

docker/transport/basehttpadapter.py

@@ -6,8 +6,3 @@ class BaseHTTPAdapter(requests.adapters.HTTPAdapter):
         super().close()
         if hasattr(self, 'pools'):
             self.pools.clear()
-
-    # Fix for requests 2.32.2+:
-    # https://github.com/psf/requests/commit/c98e4d133ef29c46a9b68cd783087218a8075e05
-    def get_connection_with_tls_context(self, request, verify, proxies=None, cert=None):
-        return self.get_connection(request.url, proxies)

docker/transport/npipeconn.py

@@ -1,17 +1,21 @@
 import queue
-
 import requests.adapters
-import urllib3
-import urllib3.connection
 
+from docker.transport.basehttpadapter import BaseHTTPAdapter
 from .. import constants
-from .basehttpadapter import BaseHTTPAdapter
 from .npipesocket import NpipeSocket
 
+import http.client as httplib
+
+try:
+    import requests.packages.urllib3 as urllib3
+except ImportError:
+    import urllib3
+
 RecentlyUsedContainer = urllib3._collections.RecentlyUsedContainer
 
 
-class NpipeHTTPConnection(urllib3.connection.HTTPConnection):
+class NpipeHTTPConnection(httplib.HTTPConnection):
     def __init__(self, npipe_path, timeout=60):
         super().__init__(
             'localhost', timeout=timeout
@@ -46,8 +50,9 @@ class NpipeHTTPConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
         conn = None
         try:
             conn = self.pool.get(block=self.block, timeout=timeout)
-        except AttributeError as ae:  # self.pool is None
+
-            raise urllib3.exceptions.ClosedPoolError(self, "Pool is closed.") from ae
+        except AttributeError:  # self.pool is None
+            raise urllib3.exceptions.ClosedPoolError(self, "Pool is closed.")
 
         except queue.Empty:
             if self.block:
@@ -55,8 +60,8 @@ class NpipeHTTPConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
                     self,
                     "Pool reached maximum size and no more "
                     "connections are allowed."
-                ) from None
+                )
-            # Oh well, we'll create a new connection then
+            pass  # Oh well, we'll create a new connection then
 
         return conn or self._new_conn()
 

docker/transport/npipesocket.py

@@ -1,10 +1,7 @@
 import functools
-import io
 import time
+import io
 
-import pywintypes
-import win32api
-import win32event
 import win32file
 import win32pipe
 
@@ -57,9 +54,7 @@ class NpipeSocket:
                 0,
                 None,
                 win32file.OPEN_EXISTING,
-                (cSECURITY_ANONYMOUS
+                cSECURITY_ANONYMOUS | cSECURITY_SQOS_PRESENT,
-                    | cSECURITY_SQOS_PRESENT
-                    | win32file.FILE_FLAG_OVERLAPPED),
                 0
             )
         except win32pipe.error as e:
@@ -136,37 +131,22 @@ class NpipeSocket:
         if not isinstance(buf, memoryview):
             readbuf = memoryview(buf)
 
-        event = win32event.CreateEvent(None, True, True, None)
-        try:
-            overlapped = pywintypes.OVERLAPPED()
-            overlapped.hEvent = event
         err, data = win32file.ReadFile(
             self._handle,
-                readbuf[:nbytes] if nbytes else readbuf,
+            readbuf[:nbytes] if nbytes else readbuf
-                overlapped
         )
-            wait_result = win32event.WaitForSingleObject(event, self._timeout)
+        return len(data)
-            if wait_result == win32event.WAIT_TIMEOUT:
+
-                win32file.CancelIo(self._handle)
+    def _recv_into_py2(self, buf, nbytes):
-                raise TimeoutError
+        err, data = win32file.ReadFile(self._handle, nbytes or len(buf))
-            return win32file.GetOverlappedResult(self._handle, overlapped, 0)
+        n = len(data)
-        finally:
+        buf[:n] = data
-            win32api.CloseHandle(event)
+        return n
 
     @check_closed
     def send(self, string, flags=0):
-        event = win32event.CreateEvent(None, True, True, None)
+        err, nbytes = win32file.WriteFile(self._handle, string)
-        try:
+        return nbytes
-            overlapped = pywintypes.OVERLAPPED()
-            overlapped.hEvent = event
-            win32file.WriteFile(self._handle, string, overlapped)
-            wait_result = win32event.WaitForSingleObject(event, self._timeout)
-            if wait_result == win32event.WAIT_TIMEOUT:
-                win32file.CancelIo(self._handle)
-                raise TimeoutError
-            return win32file.GetOverlappedResult(self._handle, overlapped, 0)
-        finally:
-            win32api.CloseHandle(event)
 
     @check_closed
     def sendall(self, string, flags=0):
@@ -185,12 +165,15 @@ class NpipeSocket:
     def settimeout(self, value):
         if value is None:
             # Blocking mode
-            self._timeout = win32event.INFINITE
+            self._timeout = win32pipe.NMPWAIT_WAIT_FOREVER
         elif not isinstance(value, (float, int)) or value < 0:
             raise ValueError('Timeout value out of range')
+        elif value == 0:
+            # Non-blocking mode
+            self._timeout = win32pipe.NMPWAIT_NO_WAIT
         else:
             # Timeout mode - Value converted to milliseconds
-            self._timeout = int(value * 1000)
+            self._timeout = value * 1000
 
     def gettimeout(self):
         return self._timeout

docker/transport/sshconn.py

@@ -1,18 +1,22 @@
+import paramiko
+import queue
+import urllib.parse
+import requests.adapters
 import logging
 import os
-import queue
 import signal
 import socket
 import subprocess
-import urllib.parse
-
-import paramiko
-import requests.adapters
-import urllib3
-import urllib3.connection
 
+from docker.transport.basehttpadapter import BaseHTTPAdapter
 from .. import constants
-from .basehttpadapter import BaseHTTPAdapter
+
+import http.client as httplib
+
+try:
+    import requests.packages.urllib3 as urllib3
+except ImportError:
+    import urllib3
 
 RecentlyUsedContainer = urllib3._collections.RecentlyUsedContainer
 
@@ -54,11 +58,12 @@ class SSHSocket(socket.socket):
         env.pop('SSL_CERT_FILE', None)
 
         self.proc = subprocess.Popen(
-            args,
+            ' '.join(args),
             env=env,
+            shell=True,
             stdout=subprocess.PIPE,
             stdin=subprocess.PIPE,
-            preexec_fn=preexec_func)
+            preexec_fn=None if constants.IS_WINDOWS_PLATFORM else preexec_func)
 
     def _write(self, data):
         if not self.proc or self.proc.stdin.closed:
@@ -95,7 +100,7 @@ class SSHSocket(socket.socket):
         self.proc.terminate()
 
 
-class SSHConnection(urllib3.connection.HTTPConnection):
+class SSHConnection(httplib.HTTPConnection):
     def __init__(self, ssh_transport=None, timeout=60, host=None):
         super().__init__(
             'localhost', timeout=timeout
@@ -141,8 +146,8 @@ class SSHConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
         try:
             conn = self.pool.get(block=self.block, timeout=timeout)
 
-        except AttributeError as ae:  # self.pool is None
+        except AttributeError:  # self.pool is None
-            raise urllib3.exceptions.ClosedPoolError(self, "Pool is closed.") from ae
+            raise urllib3.exceptions.ClosedPoolError(self, "Pool is closed.")
 
         except queue.Empty:
             if self.block:
@@ -150,8 +155,8 @@ class SSHConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
                     self,
                     "Pool reached maximum size and no more "
                     "connections are allowed."
-                ) from None
+                )
-            # Oh well, we'll create a new connection then
+            pass  # Oh well, we'll create a new connection then
 
         return conn or self._new_conn()
 
@@ -199,7 +204,7 @@ class SSHHTTPAdapter(BaseHTTPAdapter):
             host_config = conf.lookup(base_url.hostname)
             if 'proxycommand' in host_config:
                 self.ssh_params["sock"] = paramiko.ProxyCommand(
-                    host_config['proxycommand']
+                    self.ssh_conf['proxycommand']
                 )
             if 'hostname' in host_config:
                 self.ssh_params['hostname'] = host_config['hostname']
@@ -211,7 +216,7 @@ class SSHHTTPAdapter(BaseHTTPAdapter):
                 self.ssh_params['key_filename'] = host_config['identityfile']
 
         self.ssh_client.load_system_host_keys()
-        self.ssh_client.set_missing_host_key_policy(paramiko.RejectPolicy())
+        self.ssh_client.set_missing_host_key_policy(paramiko.WarningPolicy())
 
     def _connect(self):
         if self.ssh_client:

docker/transport/ssladapter.py

@@ -0,0 +1,73 @@
+""" Resolves OpenSSL issues in some servers:
+      https://lukasa.co.uk/2013/01/Choosing_SSL_Version_In_Requests/
+      https://github.com/kennethreitz/requests/pull/799
+"""
+import sys
+
+from distutils.version import StrictVersion
+from requests.adapters import HTTPAdapter
+
+from docker.transport.basehttpadapter import BaseHTTPAdapter
+
+try:
+    import requests.packages.urllib3 as urllib3
+except ImportError:
+    import urllib3
+
+
+PoolManager = urllib3.poolmanager.PoolManager
+
+# Monkey-patching match_hostname with a version that supports
+# IP-address checking. Not necessary for Python 3.5 and above
+if sys.version_info[0] < 3 or sys.version_info[1] < 5:
+    from backports.ssl_match_hostname import match_hostname
+    urllib3.connection.match_hostname = match_hostname
+
+
+class SSLHTTPAdapter(BaseHTTPAdapter):
+    '''An HTTPS Transport Adapter that uses an arbitrary SSL version.'''
+
+    __attrs__ = HTTPAdapter.__attrs__ + ['assert_fingerprint',
+                                         'assert_hostname',
+                                         'ssl_version']
+
+    def __init__(self, ssl_version=None, assert_hostname=None,
+                 assert_fingerprint=None, **kwargs):
+        self.ssl_version = ssl_version
+        self.assert_hostname = assert_hostname
+        self.assert_fingerprint = assert_fingerprint
+        super().__init__(**kwargs)
+
+    def init_poolmanager(self, connections, maxsize, block=False):
+        kwargs = {
+            'num_pools': connections,
+            'maxsize': maxsize,
+            'block': block,
+            'assert_hostname': self.assert_hostname,
+            'assert_fingerprint': self.assert_fingerprint,
+        }
+        if self.ssl_version and self.can_override_ssl_version():
+            kwargs['ssl_version'] = self.ssl_version
+
+        self.poolmanager = PoolManager(**kwargs)
+
+    def get_connection(self, *args, **kwargs):
+        """
+        Ensure assert_hostname is set correctly on our pool
+
+        We already take care of a normal poolmanager via init_poolmanager
+
+        But we still need to take care of when there is a proxy poolmanager
+        """
+        conn = super().get_connection(*args, **kwargs)
+        if conn.assert_hostname != self.assert_hostname:
+            conn.assert_hostname = self.assert_hostname
+        return conn
+
+    def can_override_ssl_version(self):
+        urllib_ver = urllib3.__version__.split('-')[0]
+        if urllib_ver is None:
+            return False
+        if urllib_ver == 'dev':
+            return True
+        return StrictVersion(urllib_ver) > StrictVersion('1.5')

docker/transport/unixconn.py

@@ -1,16 +1,20 @@
-import socket
-
 import requests.adapters
-import urllib3
+import socket
-import urllib3.connection
+import http.client as httplib
 
+from docker.transport.basehttpadapter import BaseHTTPAdapter
 from .. import constants
-from .basehttpadapter import BaseHTTPAdapter
+
+try:
+    import requests.packages.urllib3 as urllib3
+except ImportError:
+    import urllib3
+
 
 RecentlyUsedContainer = urllib3._collections.RecentlyUsedContainer
 
 
-class UnixHTTPConnection(urllib3.connection.HTTPConnection):
+class UnixHTTPConnection(httplib.HTTPConnection):
 
     def __init__(self, base_url, unix_socket, timeout=60):
         super().__init__(
@@ -26,6 +30,12 @@ class UnixHTTPConnection(urllib3.connection.HTTPConnection):
         sock.connect(self.unix_socket)
         self.sock = sock
 
+    def putheader(self, header, *values):
+        super().putheader(header, *values)
+
+    def response_class(self, sock, *args, **kwargs):
+        return httplib.HTTPResponse(sock, *args, **kwargs)
+
 
 class UnixHTTPConnectionPool(urllib3.connectionpool.HTTPConnectionPool):
     def __init__(self, base_url, socket_path, timeout=60, maxsize=10):
@@ -54,7 +64,7 @@ class UnixHTTPAdapter(BaseHTTPAdapter):
                  max_pool_size=constants.DEFAULT_MAX_POOL_SIZE):
         socket_path = socket_url.replace('http+unix://', '')
         if not socket_path.startswith('/'):
-            socket_path = f"/{socket_path}"
+            socket_path = '/' + socket_path
         self.socket_path = socket_path
         self.timeout = timeout
         self.max_pool_size = max_pool_size

docker/types/__init__.py

@@ -1,24 +1,14 @@
-from .containers import ContainerConfig, DeviceRequest, HostConfig, LogConfig, Ulimit
+# flake8: noqa
+from .containers import (
+    ContainerConfig, HostConfig, LogConfig, Ulimit, DeviceRequest
+)
 from .daemon import CancellableStream
 from .healthcheck import Healthcheck
 from .networks import EndpointConfig, IPAMConfig, IPAMPool, NetworkingConfig
 from .services import (
-    ConfigReference,
+    ConfigReference, ContainerSpec, DNSConfig, DriverConfig, EndpointSpec,
-    ContainerSpec,
+    Mount, Placement, PlacementPreference, Privileges, Resources,
-    DNSConfig,
+    RestartPolicy, RollbackConfig, SecretReference, ServiceMode, TaskTemplate,
-    DriverConfig,
+    UpdateConfig, NetworkAttachmentConfig
-    EndpointSpec,
-    Mount,
-    NetworkAttachmentConfig,
-    Placement,
-    PlacementPreference,
-    Privileges,
-    Resources,
-    RestartPolicy,
-    RollbackConfig,
-    SecretReference,
-    ServiceMode,
-    TaskTemplate,
-    UpdateConfig,
 )
-from .swarm import SwarmExternalCA, SwarmSpec
+from .swarm import SwarmSpec, SwarmExternalCA

docker/types/containers.py

@@ -1,16 +1,8 @@
 from .. import errors
 from ..utils.utils import (
-    convert_port_bindings,
+    convert_port_bindings, convert_tmpfs_mounts, convert_volume_binds,
-    convert_tmpfs_mounts,
+    format_environment, format_extra_hosts, normalize_links, parse_bytes,
-    convert_volume_binds,
+    parse_devices, split_command, version_gte, version_lt,
-    format_environment,
-    format_extra_hosts,
-    normalize_links,
-    parse_bytes,
-    parse_devices,
-    split_command,
-    version_gte,
-    version_lt,
 )
 from .base import DictType
 from .healthcheck import Healthcheck
@@ -56,11 +48,8 @@ class LogConfig(DictType):
         >>> container = client.create_container('busybox', 'true',
         ...    host_config=hc)
         >>> client.inspect_container(container)['HostConfig']['LogConfig']
-        {
+        {'Type': 'json-file', 'Config': {'labels': 'production_status,geo', 'max-size': '1g'}}
-            'Type': 'json-file',
+    """  # noqa: E501
-            'Config': {'labels': 'production_status,geo', 'max-size': '1g'}
-        }
-    """
     types = LogConfigTypesEnum
 
     def __init__(self, **kwargs):
@@ -283,8 +272,7 @@ class HostConfig(dict):
                  volume_driver=None, cpu_count=None, cpu_percent=None,
                  nano_cpus=None, cpuset_mems=None, runtime=None, mounts=None,
                  cpu_rt_period=None, cpu_rt_runtime=None,
-                 device_cgroup_rules=None, device_requests=None,
+                 device_cgroup_rules=None, device_requests=None):
-                 cgroupns=None):
 
         if mem_limit is not None:
             self['Memory'] = parse_bytes(mem_limit)
@@ -658,30 +646,27 @@ class HostConfig(dict):
                     req = DeviceRequest(**req)
                 self['DeviceRequests'].append(req)
 
-        if cgroupns:
-            self['CgroupnsMode'] = cgroupns
-
 
 def host_config_type_error(param, param_value, expected):
-    return TypeError(
+    error_msg = 'Invalid type for {0} param: expected {1} but found {2}'
-        f'Invalid type for {param} param: expected {expected} '
+    return TypeError(error_msg.format(param, expected, type(param_value)))
-        f'but found {type(param_value)}'
-    )
 
 
 def host_config_version_error(param, version, less_than=True):
     operator = '<' if less_than else '>'
-    return errors.InvalidVersion(
+    error_msg = '{0} param is not supported in API versions {1} {2}'
-        f'{param} param is not supported in API versions {operator} {version}',
+    return errors.InvalidVersion(error_msg.format(param, operator, version))
-    )
+
 
 def host_config_value_error(param, param_value):
-    return ValueError(f'Invalid value for {param} param: {param_value}')
+    error_msg = 'Invalid value for {0} param: {1}'
+    return ValueError(error_msg.format(param, param_value))
 
 
 def host_config_incompatible_error(param, param_value, incompatible_param):
+    error_msg = '\"{1}\" {0} is incompatible with {2}'
     return errors.InvalidArgument(
-        f'\"{param_value}\" {param} is incompatible with {incompatible_param}'
+        error_msg.format(param, param_value, incompatible_param)
     )
 
 

docker/types/daemon.py

@@ -1,6 +1,9 @@
 import socket
 
-import urllib3
+try:
+    import requests.packages.urllib3 as urllib3
+except ImportError:
+    import urllib3
 
 from ..errors import DockerException
 
@@ -28,9 +31,9 @@ class CancellableStream:
         try:
             return next(self._stream)
         except urllib3.exceptions.ProtocolError:
-            raise StopIteration from None
+            raise StopIteration
         except OSError:
-            raise StopIteration from None
+            raise StopIteration
 
     next = __next__
 

docker/types/networks.py

@@ -4,8 +4,7 @@ from ..utils import normalize_links, version_lt
 
 class EndpointConfig(dict):
     def __init__(self, version, aliases=None, links=None, ipv4_address=None,
-                 ipv6_address=None, link_local_ips=None, driver_opt=None,
+                 ipv6_address=None, link_local_ips=None, driver_opt=None):
-                 mac_address=None):
         if version_lt(version, '1.22'):
             raise errors.InvalidVersion(
                 'Endpoint config is not supported for API version < 1.22'
@@ -24,13 +23,6 @@ class EndpointConfig(dict):
         if ipv6_address:
             ipam_config['IPv6Address'] = ipv6_address
 
-        if mac_address:
-            if version_lt(version, '1.25'):
-                raise errors.InvalidVersion(
-                    'mac_address is not supported for API version < 1.25'
-                )
-            self['MacAddress'] = mac_address
-
         if link_local_ips is not None:
             if version_lt(version, '1.24'):
                 raise errors.InvalidVersion(

docker/types/services.py

@@ -1,12 +1,8 @@
 from .. import errors
 from ..constants import IS_WINDOWS_PLATFORM
 from ..utils import (
-    check_resource,
+    check_resource, format_environment, format_extra_hosts, parse_bytes,
-    convert_service_networks,
+    split_command, convert_service_networks,
-    format_environment,
-    format_extra_hosts,
-    parse_bytes,
-    split_command,
 )
 
 
@@ -33,7 +29,6 @@ class TaskTemplate(dict):
         force_update (int): A counter that triggers an update even if no
             relevant parameters have been changed.
     """
-
     def __init__(self, container_spec, resources=None, restart_policy=None,
                  placement=None, log_driver=None, networks=None,
                  force_update=None):
@@ -119,17 +114,14 @@ class ContainerSpec(dict):
             default set for the container.
         cap_drop (:py:class:`list`): A list of kernel capabilities to drop from
             the default set for the container.
-        sysctls (:py:class:`dict`): A dict of sysctl values to add to
-            the container
     """
-
     def __init__(self, image, command=None, args=None, hostname=None, env=None,
                  workdir=None, user=None, labels=None, mounts=None,
                  stop_grace_period=None, secrets=None, tty=None, groups=None,
                  open_stdin=None, read_only=None, stop_signal=None,
                  healthcheck=None, hosts=None, dns_config=None, configs=None,
                  privileges=None, isolation=None, init=None, cap_add=None,
-                 cap_drop=None, sysctls=None):
+                 cap_drop=None):
         self['Image'] = image
 
         if isinstance(command, str):
@@ -211,12 +203,6 @@ class ContainerSpec(dict):
 
             self['CapabilityDrop'] = cap_drop
 
-        if sysctls is not None:
-            if not isinstance(sysctls, dict):
-                raise TypeError('sysctls must be a dict')
-
-            self['Sysctls'] = sysctls
-
 
 class Mount(dict):
     """
@@ -242,15 +228,13 @@ class Mount(dict):
           for the ``volume`` type.
         driver_config (DriverConfig): Volume driver configuration. Only valid
           for the ``volume`` type.
-        subpath (str): Path inside a volume to mount instead of the volume root.
         tmpfs_size (int or string): The size for the tmpfs mount in bytes.
         tmpfs_mode (int): The permission mode for the tmpfs mount.
     """
-
     def __init__(self, target, source, type='volume', read_only=False,
                  consistency=None, propagation=None, no_copy=False,
                  labels=None, driver_config=None, tmpfs_size=None,
-                 tmpfs_mode=None, subpath=None):
+                 tmpfs_mode=None):
         self['Target'] = target
         self['Source'] = source
         if type not in ('bind', 'volume', 'tmpfs', 'npipe'):
@@ -268,7 +252,7 @@ class Mount(dict):
                 self['BindOptions'] = {
                     'Propagation': propagation
                 }
-            if any([labels, driver_config, no_copy, tmpfs_size, tmpfs_mode, subpath]):
+            if any([labels, driver_config, no_copy, tmpfs_size, tmpfs_mode]):
                 raise errors.InvalidArgument(
                     'Incompatible options have been provided for the bind '
                     'type mount.'
@@ -281,8 +265,6 @@ class Mount(dict):
                 volume_opts['Labels'] = labels
             if driver_config:
                 volume_opts['DriverConfig'] = driver_config
-            if subpath:
-                volume_opts['Subpath'] = subpath
             if volume_opts:
                 self['VolumeOptions'] = volume_opts
             if any([propagation, tmpfs_size, tmpfs_mode]):
@@ -349,7 +331,6 @@ class Resources(dict):
           ``{ resource_name: resource_value }``. Alternatively, a list of
           of resource specifications as defined by the Engine API.
     """
-
     def __init__(self, cpu_limit=None, mem_limit=None, cpu_reservation=None,
                  mem_reservation=None, generic_resources=None):
         limits = {}
@@ -377,8 +358,8 @@ def _convert_generic_resources_dict(generic_resources):
         return generic_resources
     if not isinstance(generic_resources, dict):
         raise errors.InvalidArgument(
-            'generic_resources must be a dict or a list '
+            'generic_resources must be a dict or a list'
-            f'(found {type(generic_resources)})'
+            ' (found {})'.format(type(generic_resources))
         )
     resources = []
     for kind, value in generic_resources.items():
@@ -388,9 +369,9 @@ def _convert_generic_resources_dict(generic_resources):
         elif isinstance(value, str):
             resource_type = 'NamedResourceSpec'
         else:
-            kv = {kind: value}
             raise errors.InvalidArgument(
-                f'Unsupported generic resource reservation type: {kv}'
+                'Unsupported generic resource reservation '
+                'type: {}'.format({kind: value})
             )
         resources.append({
             resource_type: {'Kind': kind, 'Value': value}
@@ -418,9 +399,8 @@ class UpdateConfig(dict):
           an update before the failure action is invoked, specified as a
           floating point number between 0 and 1. Default: 0
         order (string): Specifies the order of operations when rolling out an
-          updated task. Either ``start-first`` or ``stop-first`` are accepted.
+          updated task. Either ``start_first`` or ``stop_first`` are accepted.
     """
-
     def __init__(self, parallelism=0, delay=None, failure_action='continue',
                  monitor=None, max_failure_ratio=None, order=None):
         self['Parallelism'] = parallelism
@@ -456,8 +436,7 @@ class UpdateConfig(dict):
 
 class RollbackConfig(UpdateConfig):
     """
-    Used to specify the way container rollbacks should be performed by a
+    Used to specify the way containe rollbacks should be performed by a service
-    service
 
     Args:
         parallelism (int): Maximum number of tasks to be rolled back in one
@@ -473,7 +452,7 @@ class RollbackConfig(UpdateConfig):
           a rollback before the failure action is invoked, specified as a
           floating point number between 0 and 1. Default: 0
         order (string): Specifies the order of operations when rolling out a
-          rolled back task. Either ``start-first`` or ``stop-first`` are
+          rolled back task. Either ``start_first`` or ``stop_first`` are
           accepted.
     """
     pass
@@ -532,7 +511,6 @@ class DriverConfig(dict):
         name (string): Name of the driver to use.
         options (dict): Driver-specific options. Default: ``None``.
     """
-
     def __init__(self, name, options=None):
         self['Name'] = name
         if options:
@@ -554,7 +532,6 @@ class EndpointSpec(dict):
           is ``(target_port [, protocol [, publish_mode]])``.
           Ports can only be provided if the ``vip`` resolution mode is used.
     """
-
     def __init__(self, mode=None, ports=None):
         if ports:
             self['Ports'] = convert_service_ports(ports)
@@ -597,70 +574,37 @@ def convert_service_ports(ports):
 
 class ServiceMode(dict):
     """
-        Indicate whether a service or a job should be deployed as a replicated
+        Indicate whether a service should be deployed as a replicated or global
-        or global service, and associated parameters
+        service, and associated parameters
 
         Args:
-            mode (string): Can be either ``replicated``, ``global``,
+            mode (string): Can be either ``replicated`` or ``global``
-              ``replicated-job`` or ``global-job``
             replicas (int): Number of replicas. For replicated services only.
-            concurrency (int): Number of concurrent jobs. For replicated job
-              services only.
     """
-
+    def __init__(self, mode, replicas=None):
-    def __init__(self, mode, replicas=None, concurrency=None):
+        if mode not in ('replicated', 'global'):
-        replicated_modes = ('replicated', 'replicated-job')
-        supported_modes = replicated_modes + ('global', 'global-job')
-
-        if mode not in supported_modes:
             raise errors.InvalidArgument(
-                'mode must be either "replicated", "global", "replicated-job"'
+                'mode must be either "replicated" or "global"'
-                ' or "global-job"'
             )
-
+        if mode != 'replicated' and replicas is not None:
-        if mode not in replicated_modes:
+            raise errors.InvalidArgument(
+                'replicas can only be used for replicated mode'
+            )
+        self[mode] = {}
         if replicas is not None:
-                raise errors.InvalidArgument(
+            self[mode]['Replicas'] = replicas
-                    'replicas can only be used for "replicated" or'
-                    ' "replicated-job" mode'
-                )
 
-            if concurrency is not None:
+    @property
-                raise errors.InvalidArgument(
+    def mode(self):
-                    'concurrency can only be used for "replicated-job" mode'
+        if 'global' in self:
-                )
+            return 'global'
-
+        return 'replicated'
-        service_mode = self._convert_mode(mode)
-        self.mode = service_mode
-        self[service_mode] = {}
-
-        if replicas is not None:
-            if mode == 'replicated':
-                self[service_mode]['Replicas'] = replicas
-
-            if mode == 'replicated-job':
-                self[service_mode]['MaxConcurrent'] = concurrency or 1
-                self[service_mode]['TotalCompletions'] = replicas
-
-    @staticmethod
-    def _convert_mode(original_mode):
-        if original_mode == 'global-job':
-            return 'GlobalJob'
-
-        if original_mode == 'replicated-job':
-            return 'ReplicatedJob'
-
-        return original_mode
 
     @property
     def replicas(self):
-        if 'replicated' in self:
+        if self.mode != 'replicated':
-            return self['replicated'].get('Replicas')
-
-        if 'ReplicatedJob' in self:
-            return self['ReplicatedJob'].get('TotalCompletions')
-
             return None
+        return self['replicated'].get('Replicas')
 
 
 class SecretReference(dict):
@@ -734,7 +678,6 @@ class Placement(dict):
             platforms (:py:class:`list` of tuple): A list of platforms
                 expressed as ``(arch, os)`` tuples
     """
-
     def __init__(self, constraints=None, preferences=None, platforms=None,
                  maxreplicas=None):
         if constraints is not None:
@@ -767,12 +710,11 @@ class PlacementPreference(dict):
                 the scheduler will try to spread tasks evenly over groups of
                 nodes identified by this label.
     """
-
     def __init__(self, strategy, descriptor):
         if strategy != 'spread':
             raise errors.InvalidArgument(
-                f'PlacementPreference strategy value is invalid ({strategy}): '
+                'PlacementPreference strategy value is invalid ({}):'
-                'must be "spread".'
+                ' must be "spread".'.format(strategy)
             )
         self['Spread'] = {'SpreadDescriptor': descriptor}
 
@@ -789,7 +731,6 @@ class DNSConfig(dict):
             options (:py:class:`list`): A list of internal resolver variables
                 to be modified (e.g., ``debug``, ``ndots:3``, etc.).
     """
-
     def __init__(self, nameservers=None, search=None, options=None):
         self['Nameservers'] = nameservers
         self['Search'] = search
@@ -820,7 +761,6 @@ class Privileges(dict):
             selinux_type (string): SELinux type label
             selinux_level (string): SELinux level label
     """
-
     def __init__(self, credentialspec_file=None, credentialspec_registry=None,
                  selinux_disable=None, selinux_user=None, selinux_role=None,
                  selinux_type=None, selinux_level=None):
@@ -863,7 +803,6 @@ class NetworkAttachmentConfig(dict):
             options (:py:class:`dict`): Driver attachment options for the
                 network target.
     """
-
     def __init__(self, target, aliases=None, options=None):
         self['Target'] = target
         self['Aliases'] = aliases

docker/utils/__init__.py

@@ -1,28 +1,13 @@
-
+# flake8: noqa
-from .build import create_archive, exclude_paths, match_tag, mkbuildcontext, tar
+from .build import create_archive, exclude_paths, mkbuildcontext, tar
 from .decorators import check_resource, minimum_version, update_headers
 from .utils import (
-    compare_version,
+    compare_version, convert_port_bindings, convert_volume_binds,
-    convert_filters,
+    parse_repository_tag, parse_host,
-    convert_port_bindings,
+    kwargs_from_env, convert_filters, datetime_to_timestamp,
-    convert_service_networks,
+    create_host_config, parse_bytes, parse_env_file, version_lt,
-    convert_volume_binds,
+    version_gte, decode_json_header, split_command, create_ipam_config,
-    create_host_config,
+    create_ipam_pool, parse_devices, normalize_links, convert_service_networks,
-    create_ipam_config,
+    format_environment, format_extra_hosts
-    create_ipam_pool,
-    datetime_to_timestamp,
-    decode_json_header,
-    format_environment,
-    format_extra_hosts,
-    kwargs_from_env,
-    normalize_links,
-    parse_bytes,
-    parse_devices,
-    parse_env_file,
-    parse_host,
-    parse_repository_tag,
-    split_command,
-    version_gte,
-    version_lt,
 )
 

docker/utils/build.py

@@ -4,19 +4,11 @@ import re
 import tarfile
 import tempfile
 
-from ..constants import IS_WINDOWS_PLATFORM
 from .fnmatch import fnmatch
+from ..constants import IS_WINDOWS_PLATFORM
+
 
 _SEP = re.compile('/|\\\\') if IS_WINDOWS_PLATFORM else re.compile('/')
-_TAG = re.compile(
-    r"^[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*"
-    r"(?::[0-9]+)?(/[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*)*"
-    r"(:[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127})?$"
-)
-
-
-def match_tag(tag: str) -> bool:
-    return bool(_TAG.match(tag))
 
 
 def tar(path, exclude=None, dockerfile=None, fileobj=None, gzip=False):
@@ -50,7 +42,7 @@ def exclude_paths(root, patterns, dockerfile=None):
     if dockerfile is None:
         dockerfile = 'Dockerfile'
 
-    patterns.append(f"!{dockerfile}")
+    patterns.append('!' + dockerfile)
     pm = PatternMatcher(patterns)
     return set(pm.walk(root))
 
@@ -101,10 +93,10 @@ def create_archive(root, files=None, fileobj=None, gzip=False,
             try:
                 with open(full_path, 'rb') as f:
                     t.addfile(i, f)
-            except OSError as oe:
+            except OSError:
                 raise OSError(
                     f'Can not read file in context: {full_path}'
-                ) from oe
+                )
         else:
             # Directories, FIFOs, symlinks... don't need to be read.
             t.addfile(i, None)
@@ -188,7 +180,7 @@ class PatternMatcher:
                 fpath = os.path.join(
                     os.path.relpath(current_dir, root), f
                 )
-                if fpath.startswith(f".{os.path.sep}"):
+                if fpath.startswith('.' + os.path.sep):
                     fpath = fpath[2:]
                 match = self.matches(fpath)
                 if not match:
@@ -232,9 +224,6 @@ class Pattern:
     @classmethod
     def normalize(cls, p):
 
-        # Remove trailing spaces
-        p = p.strip()
-
         # Leading and trailing slashes are not relevant. Yes,
         # "foo.py/" must exclude the "foo.py" regular file. "."
         # components are not relevant either, even if the whole

docker/utils/decorators.py

@@ -27,7 +27,9 @@ def minimum_version(version):
         def wrapper(self, *args, **kwargs):
             if utils.version_lt(self._version, version):
                 raise errors.InvalidVersion(
-                    f'{f.__name__} is not available for version < {version}',
+                    '{} is not available for version < {}'.format(
+                        f.__name__, version
+                    )
                 )
             return f(self, *args, **kwargs)
         return wrapper

docker/utils/fnmatch.py

@@ -79,18 +79,18 @@ def translate(pat):
                     i = i + 1
                 if i >= n:
                     # is "**EOF" - to align with .gitignore just accept all
-                    res = f"{res}.*"
+                    res = res + '.*'
                 else:
                     # is "**"
                     # Note that this allows for any # of /'s (even 0) because
                     # the .* will eat everything, even /'s
-                    res = f"{res}(.*/)?"
+                    res = res + '(.*/)?'
             else:
                 # is "*" so map it to anything but "/"
-                res = f"{res}[^/]*"
+                res = res + '[^/]*'
         elif c == '?':
             # "?" is any char except "/"
-            res = f"{res}[^/]"
+            res = res + '[^/]'
         elif c == '[':
             j = i
             if j < n and pat[j] == '!':
@@ -100,16 +100,16 @@ def translate(pat):
             while j < n and pat[j] != ']':
                 j = j + 1
             if j >= n:
-                res = f"{res}\\["
+                res = res + '\\['
             else:
                 stuff = pat[i:j].replace('\\', '\\\\')
                 i = j + 1
                 if stuff[0] == '!':
-                    stuff = f"^{stuff[1:]}"
+                    stuff = '^' + stuff[1:]
                 elif stuff[0] == '^':
-                    stuff = f"\\{stuff}"
+                    stuff = '\\' + stuff
                 res = f'{res}[{stuff}]'
         else:
             res = res + re.escape(c)
 
-    return f"{res}$"
+    return res + '$'

docker/utils/json_stream.py

@@ -3,6 +3,7 @@ import json.decoder
 
 from ..errors import StreamParseError
 
+
 json_decoder = json.JSONDecoder()
 
 
@@ -71,4 +72,4 @@ def split_buffer(stream, splitter=None, decoder=lambda a: a):
         try:
             yield decoder(buffered)
         except Exception as e:
-            raise StreamParseError(e) from e
+            raise StreamParseError(e)

docker/utils/ports.py

@@ -49,7 +49,7 @@ def port_range(start, end, proto, randomly_available_port=False):
     if not end:
         return [start + proto]
     if randomly_available_port:
-        return [f"{start}-{end}{proto}"]
+        return [f'{start}-{end}' + proto]
     return [str(port) + proto for port in range(int(start), int(end) + 1)]
 
 

docker/utils/proxy.py

@@ -69,9 +69,5 @@ class ProxyConfig(dict):
         return proxy_env + environment
 
     def __str__(self):
-        return (
+        return 'ProxyConfig(http={}, https={}, ftp={}, no_proxy={})'.format(
-            'ProxyConfig('
+            self.http, self.https, self.ftp, self.no_proxy)
-            f'http={self.http}, https={self.https}, '
-            f'ftp={self.ftp}, no_proxy={self.no_proxy}'
-            ')'
-        )

docker/utils/socket.py

@@ -18,11 +18,6 @@ class SocketError(Exception):
     pass
 
 
-# NpipeSockets have their own error types
-# pywintypes.error: (109, 'ReadFile', 'The pipe has been ended.')
-NPIPE_ENDED = 109
-
-
 def read(socket, n=4096):
     """
     Reads at most n bytes from socket
@@ -31,32 +26,17 @@ def read(socket, n=4096):
     recoverable_errors = (errno.EINTR, errno.EDEADLK, errno.EWOULDBLOCK)
 
     if not isinstance(socket, NpipeSocket):
-        if not hasattr(select, "poll"):
-            # Limited to 1024
         select.select([socket], [], [])
-        else:
-            poll = select.poll()
-            poll.register(socket, select.POLLIN | select.POLLPRI)
-            poll.poll()
 
     try:
         if hasattr(socket, 'recv'):
             return socket.recv(n)
-        if isinstance(socket, pysocket.SocketIO):
+        if isinstance(socket, getattr(pysocket, 'SocketIO')):
             return socket.read(n)
         return os.read(socket.fileno(), n)
     except OSError as e:
         if e.errno not in recoverable_errors:
             raise
-    except Exception as e:
-        is_pipe_ended = (isinstance(socket, NpipeSocket) and
-                         len(e.args) > 0 and
-                         e.args[0] == NPIPE_ENDED)
-        if is_pipe_ended:
-            # npipes don't support duplex sockets, so we interpret
-            # a PIPE_ENDED error as a close operation (0-length read).
-            return ''
-        raise
 
 
 def read_exactly(socket, n):
@@ -64,7 +44,7 @@ def read_exactly(socket, n):
     Reads exactly n bytes from socket
     Raises SocketError if there isn't enough data
     """
-    data = b""
+    data = bytes()
     while len(data) < n:
         next_data = read(socket, n - len(data))
         if not next_data:
@@ -152,7 +132,7 @@ def consume_socket_output(frames, demux=False):
     if demux is False:
         # If the streams are multiplexed, the generator returns strings, that
         # we just need to concatenate.
-        return b"".join(frames)
+        return bytes().join(frames)
 
     # If the streams are demultiplexed, the generator yields tuples
     # (stdout, stderr)

docker/utils/utils.py

@@ -1,28 +1,20 @@
 import base64
-import collections
 import json
 import os
 import os.path
 import shlex
 import string
-from datetime import datetime, timezone
+from datetime import datetime
-from functools import lru_cache
+from distutils.version import StrictVersion
-from itertools import zip_longest
-from urllib.parse import urlparse, urlunparse
 
 from .. import errors
-from ..constants import (
+from .. import tls
-    BYTE_UNITS,
+from ..constants import DEFAULT_HTTP_HOST
-    DEFAULT_HTTP_HOST,
+from ..constants import DEFAULT_UNIX_SOCKET
-    DEFAULT_NPIPE,
+from ..constants import DEFAULT_NPIPE
-    DEFAULT_UNIX_SOCKET,
+from ..constants import BYTE_UNITS
-)
-from ..tls import TLSConfig
 
-URLComponents = collections.namedtuple(
+from urllib.parse import splitnport, urlparse
-    'URLComponents',
-    'scheme netloc url params query fragment',
-)
 
 
 def create_ipam_pool(*args, **kwargs):
@@ -45,7 +37,6 @@ def decode_json_header(header):
     return json.loads(data)
 
 
-@lru_cache(maxsize=None)
 def compare_version(v1, v2):
     """Compare docker versions
 
@@ -58,20 +49,14 @@ def compare_version(v1, v2):
     >>> compare_version(v2, v2)
     0
     """
-    if v1 == v2:
+    s1 = StrictVersion(v1)
+    s2 = StrictVersion(v2)
+    if s1 == s2:
         return 0
-    # Split into `sys.version_info` like tuples.
+    elif s1 > s2:
-    s1 = tuple(int(p) for p in v1.split('.'))
-    s2 = tuple(int(p) for p in v2.split('.'))
-    # Compare each component, padding with 0 if necessary.
-    for c1, c2 in zip_longest(s1, s2, fillvalue=0):
-        if c1 == c2:
-            continue
-        elif c1 > c2:
         return -1
     else:
         return 1
-    return 0
 
 
 def version_lt(v1, v2):
@@ -135,7 +120,8 @@ def convert_volume_binds(binds):
         if isinstance(v, dict):
             if 'ro' in v and 'mode' in v:
                 raise ValueError(
-                    f'Binding cannot contain both "ro" and "mode": {v!r}'
+                    'Binding cannot contain both "ro" and "mode": {}'
+                    .format(repr(v))
                 )
 
             bind = v['bind']
@@ -149,22 +135,6 @@ def convert_volume_binds(binds):
             else:
                 mode = 'rw'
 
-            # NOTE: this is only relevant for Linux hosts
-            # (doesn't apply in Docker Desktop)
-            propagation_modes = [
-                'rshared',
-                'shared',
-                'rslave',
-                'slave',
-                'rprivate',
-                'private',
-            ]
-            if 'propagation' in v and v['propagation'] in propagation_modes:
-                if mode:
-                    mode = f"{mode},{v['propagation']}"
-                else:
-                    mode = v['propagation']
-
             result.append(
                 f'{k}:{bind}:{mode}'
             )
@@ -183,8 +153,8 @@ def convert_tmpfs_mounts(tmpfs):
 
     if not isinstance(tmpfs, list):
         raise ValueError(
-            'Expected tmpfs value to be either a list or a dict, '
+            'Expected tmpfs value to be either a list or a dict, found: {}'
-            f'found: {type(tmpfs).__name__}'
+            .format(type(tmpfs).__name__)
         )
 
     result = {}
@@ -198,8 +168,8 @@ def convert_tmpfs_mounts(tmpfs):
 
         else:
             raise ValueError(
-                "Expected item in tmpfs list to be a string, "
+                "Expected item in tmpfs list to be a string, found: {}"
-                f"found: {type(mount).__name__}"
+                .format(type(mount).__name__)
             )
 
         result[name] = options
@@ -231,6 +201,10 @@ def parse_repository_tag(repo_name):
 
 
 def parse_host(addr, is_win32=False, tls=False):
+    path = ''
+    port = None
+    host = None
+
     # Sensible defaults
     if not addr and is_win32:
         return DEFAULT_NPIPE
@@ -241,9 +215,9 @@ def parse_host(addr, is_win32=False, tls=False):
 
     parsed_url = urlparse(addr)
     proto = parsed_url.scheme
-    if not proto or any(x not in f"{string.ascii_letters}+" for x in proto):
+    if not proto or any([x not in string.ascii_letters + '+' for x in proto]):
         # https://bugs.python.org/issue754016
-        parsed_url = urlparse(f"//{addr}", 'tcp')
+        parsed_url = urlparse('//' + addr, 'tcp')
         proto = 'tcp'
 
     if proto == 'fd':
@@ -279,46 +253,40 @@ def parse_host(addr, is_win32=False, tls=False):
 
     if parsed_url.path and proto == 'ssh':
         raise errors.DockerException(
-            f'Invalid bind address format: no path allowed for this protocol: {addr}'
+            'Invalid bind address format: no path allowed for this protocol:'
+            ' {}'.format(addr)
         )
     else:
         path = parsed_url.path
         if proto == 'unix' and parsed_url.hostname is not None:
             # For legacy reasons, we consider unix://path
             # to be valid and equivalent to unix:///path
-            path = f"{parsed_url.hostname}/{path}"
+            path = '/'.join((parsed_url.hostname, path))
 
-    netloc = parsed_url.netloc
     if proto in ('tcp', 'ssh'):
-        port = parsed_url.port or 0
+        # parsed_url.hostname strips brackets from IPv6 addresses,
-        if port <= 0:
+        # which can be problematic hence our use of splitnport() instead.
+        host, port = splitnport(parsed_url.netloc)
+        if port is None or port < 0:
             if proto != 'ssh':
                 raise errors.DockerException(
-                    f'Invalid bind address format: port is required: {addr}'
+                    'Invalid bind address format: port is required:'
+                    ' {}'.format(addr)
                 )
             port = 22
-            netloc = f'{parsed_url.netloc}:{port}'
 
-        if not parsed_url.hostname:
+        if not host:
-            netloc = f'{DEFAULT_HTTP_HOST}:{port}'
+            host = DEFAULT_HTTP_HOST
 
     # Rewrite schemes to fit library internals (requests adapters)
     if proto == 'tcp':
-        proto = f"http{'s' if tls else ''}"
+        proto = 'http{}'.format('s' if tls else '')
     elif proto == 'unix':
         proto = 'http+unix'
 
     if proto in ('http+unix', 'npipe'):
         return f"{proto}://{path}".rstrip('/')
-
+    return f'{proto}://{host}:{port}{path}'.rstrip('/')
-    return urlunparse(URLComponents(
-        scheme=proto,
-        netloc=netloc,
-        url=path,
-        params='',
-        query='',
-        fragment='',
-    )).rstrip('/')
 
 
 def parse_devices(devices):
@@ -350,7 +318,7 @@ def parse_devices(devices):
     return device_list
 
 
-def kwargs_from_env(environment=None):
+def kwargs_from_env(ssl_version=None, assert_hostname=None, environment=None):
     if not environment:
         environment = os.environ
     host = environment.get('DOCKER_HOST')
@@ -378,11 +346,18 @@ def kwargs_from_env(environment=None):
     if not cert_path:
         cert_path = os.path.join(os.path.expanduser('~'), '.docker')
 
-    params['tls'] = TLSConfig(
+    if not tls_verify and assert_hostname is None:
+        # assert_hostname is a subset of TLS verification,
+        # so if it's not set already then set it to false.
+        assert_hostname = False
+
+    params['tls'] = tls.TLSConfig(
         client_cert=(os.path.join(cert_path, 'cert.pem'),
                      os.path.join(cert_path, 'key.pem')),
         ca_cert=os.path.join(cert_path, 'ca.pem'),
         verify=tls_verify,
+        ssl_version=ssl_version,
+        assert_hostname=assert_hostname,
     )
 
     return params
@@ -403,8 +378,8 @@ def convert_filters(filters):
 
 
 def datetime_to_timestamp(dt):
-    """Convert a datetime to a Unix timestamp"""
+    """Convert a UTC datetime to a Unix timestamp"""
-    delta = dt.astimezone(timezone.utc) - datetime(1970, 1, 1, tzinfo=timezone.utc)
+    delta = dt - datetime.utcfromtimestamp(0)
     return delta.seconds + delta.days * 24 * 3600
 
 
@@ -431,18 +406,19 @@ def parse_bytes(s):
     if suffix in units.keys() or suffix.isdigit():
         try:
             digits = float(digits_part)
-        except ValueError as ve:
+        except ValueError:
             raise errors.DockerException(
-                'Failed converting the string value for memory '
+                'Failed converting the string value for memory ({}) to'
-                f'({digits_part}) to an integer.'
+                ' an integer.'.format(digits_part)
-            ) from ve
+            )
 
         # Reconvert to long for the final result
         s = int(digits * units[suffix])
     else:
         raise errors.DockerException(
-            f'The specified value for memory ({s}) should specify the units. '
+            'The specified value for memory ({}) should specify the'
-            'The postfix should be one of the `b` `k` `m` `g` characters'
+            ' units. The postfix should be one of the `b` `k` `m` `g`'
+            ' characters'.format(s)
         )
 
     return s
@@ -478,7 +454,8 @@ def parse_env_file(env_file):
                 environment[k] = v
             else:
                 raise errors.DockerException(
-                    f'Invalid line in environment file {env_file}:\n{line}')
+                    'Invalid line in environment file {}:\n{}'.format(
+                        env_file, line))
 
     return environment
 

docker/version.py

@@ -1,8 +1,2 @@
-try:
+version = "5.0.3"
-    from ._version import __version__
+version_info = tuple(int(d) for d in version.split("-")[0].split("."))
-except ImportError:
-    from importlib.metadata import PackageNotFoundError, version
-    try:
-        __version__ = version('docker')
-    except PackageNotFoundError:
-        __version__ = '0.0.0'

docs-requirements.txt

@@ -0,0 +1,2 @@
+recommonmark==0.4.0
+Sphinx==1.4.6

docs/_static/custom.css

@@ -1,12 +1,3 @@
 dl.hide-signature > dt {
   display: none;
 }
-
-dl.field-list > dt {
-    /* prevent code blocks from forcing wrapping on the "Parameters" header */
-    word-break: initial;
-}
-
-code.literal{
-  hyphens: none;
-}

docs/change-log.md

@@ -1,142 +1,6 @@
-Changelog
+Change log
 ==========
 
-7.1.0
------
-### Upgrade Notes
-- Bumped minimum engine API version to 1.24
-- Bumped default engine API version to 1.44 (Moby 25.0)
-
-### Bugfixes
-- Fixed issue with tag parsing when the registry address includes ports that resulted in `invalid tag format` errors
-- Fixed issue preventing creating new configs (`ConfigCollection`), which failed with a `KeyError` due to the `name` field
-- Fixed an issue due to an update in the [requests](https://github.com/psf/requests) package breaking `docker-py` by applying the [suggested fix](https://github.com/psf/requests/pull/6710)
-
-### Miscellaneous
-- Documentation improvements
-- Updated Ruff (linter) and fixed minor linting issues
-- Packaging/CI updates
-  - Started using hatch for packaging (https://github.com/pypa/hatch)
-  - Updated `setup-python` github action
-- Updated tests
-  - Stopped checking for deprecated container and image related fields (`Container` and `ContainerConfig`)
-  - Updated tests that check `NetworkSettings.Networks.<network>.Aliases` due to engine changes
-
-7.0.0
------
-### Upgrade Notes
-- Removed SSL version (`ssl_version`) and explicit hostname check (`assert_hostname`) options
-  - `assert_hostname` has not been used since Python 3.6 and was removed in 3.12
-  - Python 3.7+ supports TLSv1.3 by default
-- Websocket support is no longer included by default
-  - Use `pip install docker[websockets]` to include `websocket-client` dependency
-  - By default, `docker-py` hijacks the TCP connection and does not use Websockets
-  - Websocket client is only required to use `attach_socket(container, ws=True)`
-- Python 3.7 no longer officially supported (reached end-of-life June 2023)
-
-### Features
-- Python 3.12 support
-- Full `networking_config` support for `containers.create()`
-    - Replaces `network_driver_opt` (added in 6.1.0)
-- Add `health()` property to container that returns status (e.g. `unhealthy`)
-- Add `pause` option to `container.commit()`
-- Add support for bind mount propagation (e.g. `rshared`, `private`)
-- Add `filters`, `keep_storage`, and `all` parameters to `prune_builds()` (requires API v1.39+)
-
-### Bugfixes
-- Consistently return `docker.errors.NotFound` on 404 responses
-- Validate tag format before image push
-
-### Miscellaneous
-- Upgraded urllib3 version in `requirements.txt` (used for development/tests)
-- Documentation typo fixes & formatting improvements
-- Fixed integration test compatibility for newer Moby engine versions
-- Switch to [ruff](https://github.com/astral-sh/ruff) for linting
-
-6.1.3
------
-#### Bugfixes
-- Fix compatibility with [`eventlet/eventlet`](https://github.com/eventlet/eventlet)
-
-6.1.2
------
-
-#### Bugfixes
-- Fix for socket timeouts on long `docker exec` calls 
-
-6.1.1
------
-
-#### Bugfixes
-- Fix `containers.stats()` hanging with `stream=True`
-- Correct return type in docs for `containers.diff()` method
-
-
-6.1.0
------
-
-### Upgrade Notes
-- Errors are no longer returned during client initialization if the credential helper cannot be found. A warning will be emitted instead, and an error is returned if the credential helper is used.
-
-### Features
-- Python 3.11 support
-- Use `poll()` instead of `select()` on non-Windows platforms
-- New API fields
-  - `network_driver_opt` on container run / create
-  - `one-shot` on container stats
-  - `status` on services list
-
-### Bugfixes
-- Support for requests 2.29.0+ and urllib3 2.x
-- Do not strip characters from volume names
-- Fix connection leak on container.exec_* operations
-- Fix errors closing named pipes on Windows
-
-6.0.1
------
-
-### Bugfixes
-- Fix for `The pipe has been ended errors` on Windows
-- Support floats for container log filtering by timestamp (`since` / `until`)
-
-6.0.0
------
-
-### Upgrade Notes
-- Minimum supported Python version is 3.7+
-- When installing with pip, the `docker[tls]` extra is deprecated and a no-op,
-  use `docker` for same functionality (TLS support is always available now)
-- Native Python SSH client (used by default / `use_ssh_client=False`) will now
-  reject unknown host keys with `paramiko.ssh_exception.SSHException`
-- Short IDs are now 12 characters instead of 10 characters (same as Docker CLI)
-
-### Features
-- Python 3.10 support
-- Automatically negotiate most secure TLS version
-- Add `platform` (e.g. `linux/amd64`, `darwin/arm64`) to container create & run
-- Add support for `GlobalJob` and `ReplicatedJobs` for Swarm
-- Add `remove()` method on `Image`
-- Add `force` param to `disable()` on `Plugin`
-
-### Bugfixes
-- Fix install issues on Windows related to `pywin32`
-- Do not accept unknown SSH host keys in native Python SSH mode
-- Use 12 character short IDs for consistency with Docker CLI
-- Ignore trailing whitespace in `.dockerignore` files
-- Fix IPv6 host parsing when explicit port specified
-- Fix `ProxyCommand` option for SSH connections
-- Do not spawn extra subshell when launching external SSH client
-- Improve exception semantics to preserve context
-- Documentation improvements (formatting, examples, typos, missing params)
-
-### Miscellaneous
-- Upgrade dependencies in `requirements.txt` to latest versions
-- Remove extraneous transitive dependencies
-- Eliminate usages of deprecated functions/methods
-- Test suite reliability improvements
-- GitHub Actions workflows for linting, unit tests, integration tests, and
-  publishing releases
-
 5.0.3
 -----
 

docs/conf.py

@@ -18,8 +18,6 @@
 import datetime
 import os
 import sys
-from importlib.metadata import version
-
 sys.path.insert(0, os.path.abspath('..'))
 
 
@@ -35,19 +33,24 @@ sys.path.insert(0, os.path.abspath('..'))
 extensions = [
     'sphinx.ext.autodoc',
     'sphinx.ext.napoleon',
-    'myst_parser'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 
 
-source_suffix = {
+from recommonmark.parser import CommonMarkParser
-    '.rst': 'restructuredtext',
+
-    '.txt': 'markdown',
+source_parsers = {
-    '.md': 'markdown',
+    '.md': CommonMarkParser,
 }
 
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = ['.rst', '.md']
+# source_suffix = '.md'
+
 # The encoding of source files.
 #
 # source_encoding = 'utf-8-sig'
@@ -58,24 +61,26 @@ master_doc = 'index'
 # General information about the project.
 project = 'Docker SDK for Python'
 year = datetime.datetime.now().year
-copyright = f'{year} Docker Inc'
+copyright = '%d Docker Inc' % year
 author = 'Docker Inc'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
-# see https://github.com/pypa/setuptools_scm#usage-from-sphinx
+with open('../docker/version.py') as vfile:
-release = version('docker')
+    exec(vfile.read())
-# for example take major/minor
+# The full version, including alpha/beta/rc tags.
-version = '.'.join(release.split('.')[:2])
+release = version
+# The short X.Y version.
+version = f'{version_info[0]}.{version_info[1]}'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = 'en'
+language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

docs/tls.rst

@@ -15,7 +15,7 @@ For example, to check the server against a specific CA certificate:
 
 .. code-block:: python
 
-  tls_config = docker.tls.TLSConfig(ca_cert='/path/to/ca.pem', verify=True)
+  tls_config = docker.tls.TLSConfig(ca_cert='/path/to/ca.pem')
   client = docker.DockerClient(base_url='<https_url>', tls=tls_config)
 
 This is the equivalent of ``docker --tlsverify --tlscacert /path/to/ca.pem ...``.

docs/user_guides/multiplex.rst

@@ -16,13 +16,10 @@ Prepare the command we are going to use. It prints "hello stdout"
 in `stdout`, followed by "hello stderr" in `stderr`:
 
 >>> cmd = '/bin/sh -c "echo hello stdout ; echo hello stderr >&2"'
-
 We'll run this command with all four the combinations of ``stream``
 and ``demux``.
-
 With ``stream=False`` and ``demux=False``, the output is a string
 that contains both the `stdout` and the `stderr` output:
-
 >>> res = container.exec_run(cmd, stream=False, demux=False)
 >>> res.output
 b'hello stderr\nhello stdout\n'
@@ -55,8 +52,15 @@ Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 StopIteration
 
-Finally, with ``stream=False`` and ``demux=True``, the output is a tuple ``(stdout, stderr)``:
+Finally, with ``stream=False`` and ``demux=True``, the whole output
+is returned, but the streams are still separated:
 
->>> res = container.exec_run(cmd, stream=False, demux=True)
+>>> res = container.exec_run(cmd, stream=True, demux=True)
->>> res.output
+>>> next(res.output)
-(b'hello stdout\n', b'hello stderr\n')
+(b'hello stdout\n', None)
+>>> next(res.output)
+(None, b'hello stderr\n')
+>>> next(res.output)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+StopIteration

pyproject.toml

@@ -1,102 +0,0 @@
-[build-system]
-requires = ["hatchling", "hatch-vcs"]
-build-backend = "hatchling.build"
-
-[project]
-name = "docker"
-dynamic = ["version"]
-description = "A Python library for the Docker Engine API."
-readme = "README.md"
-license = "Apache-2.0"
-requires-python = ">=3.8"
-maintainers = [
-    { name = "Docker Inc.", email = "no-reply@docker.com" },
-]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Other Environment",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development",
-    "Topic :: Utilities",
-]
-
-dependencies = [
-    "requests >= 2.26.0",
-    "urllib3 >= 1.26.0",
-    "pywin32>=304; sys_platform == \"win32\"",
-]
-
-[project.optional-dependencies]
-# ssh feature allows DOCKER_HOST=ssh://... style connections
-ssh = [
-    "paramiko>=2.4.3",
-]
-# tls is always supported, the feature is a no-op for backwards compatibility
-tls = []
-# websockets can be used as an alternate container attach mechanism but
-# by default docker-py hijacks the TCP connection and does not use Websockets
-# unless attach_socket(container, ws=True) is called
-websockets = [
-    "websocket-client >= 1.3.0",
-]
-# docs are dependencies required to build the ReadTheDocs site
-# this is only needed for CI / working on the docs!
-docs = [
-    "myst-parser==0.18.0",
-    "Sphinx==5.1.1",
-
-]
-# dev are dependencies required to test & lint this project
-# this is only needed if you are making code changes to docker-py!
-dev = [
-    "coverage==7.2.7",
-    "pytest==7.4.2",
-    "pytest-cov==4.1.0",
-    "pytest-timeout==2.1.0",
-    "ruff==0.1.8",
-]
-
-[project.urls]
-Changelog = "https://docker-py.readthedocs.io/en/stable/change-log.html"
-Documentation = "https://docker-py.readthedocs.io"
-Homepage = "https://github.com/docker/docker-py"
-Source = "https://github.com/docker/docker-py"
-Tracker = "https://github.com/docker/docker-py/issues"
-
-[tool.hatch.version]
-source = "vcs"
-
-[tool.hatch.build.hooks.vcs]
-version-file = "docker/_version.py"
-
-[tool.hatch.build.targets.sdist]
-include = [
-    "/docker",
-]
-
-[tool.ruff]
-target-version = "py38"
-extend-select = [
-    "B",
-    "C",
-    "F",
-    "I",
-    "UP",
-    "W",
-]
-ignore = [
-    "UP012",  # unnecessary `UTF-8` argument (we want to be explicit)
-    "C901",  # too complex (there's a whole bunch of these)
-]
-
-[tool.ruff.per-file-ignores]
-"**/__init__.py" = ["F401"]

requirements.txt

@@ -0,0 +1,17 @@
+appdirs==1.4.3
+asn1crypto==0.22.0
+backports.ssl-match-hostname==3.5.0.1
+cffi==1.14.4
+cryptography==3.4.7
+enum34==1.1.6
+idna==2.5
+ipaddress==1.0.18
+packaging==16.8
+paramiko==2.4.2
+pycparser==2.17
+pyOpenSSL==18.0.0
+pyparsing==2.2.0
+pywin32==301; sys_platform == 'win32'
+requests==2.26.0
+urllib3==1.26.5
+websocket-client==0.56.0

setup.cfg

@@ -0,0 +1,6 @@
+[bdist_wheel]
+universal = 1
+
+[metadata]
+description_file = README.rst
+license = Apache License 2.0

setup.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+import codecs
+import os
+
+from setuptools import find_packages
+from setuptools import setup
+
+ROOT_DIR = os.path.dirname(__file__)
+SOURCE_DIR = os.path.join(ROOT_DIR)
+
+requirements = [
+    'websocket-client >= 0.32.0',
+    'requests >= 2.14.2, != 2.18.0',
+]
+
+extras_require = {
+    # win32 APIs if on Windows (required for npipe support)
+    ':sys_platform == "win32"': 'pywin32==227',
+
+    # If using docker-py over TLS, highly recommend this option is
+    # pip-installed or pinned.
+
+    # TODO: if pip installing both "requests" and "requests[security]", the
+    # extra package from the "security" option are not installed (see
+    # https://github.com/pypa/pip/issues/4391).  Once that's fixed, instead of
+    # installing the extra dependencies, install the following instead:
+    # 'requests[security] >= 2.5.2, != 2.11.0, != 2.12.2'
+    'tls': ['pyOpenSSL>=17.5.0', 'cryptography>=3.4.7', 'idna>=2.0.0'],
+
+    # Only required when connecting using the ssh:// protocol
+    'ssh': ['paramiko>=2.4.2'],
+
+}
+
+version = None
+exec(open('docker/version.py').read())
+
+with open('./test-requirements.txt') as test_reqs_txt:
+    test_requirements = [line for line in test_reqs_txt]
+
+
+long_description = ''
+with codecs.open('./README.md', encoding='utf-8') as readme_md:
+    long_description = readme_md.read()
+
+setup(
+    name="docker",
+    version=version,
+    description="A Python library for the Docker Engine API.",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/docker/docker-py',
+    project_urls={
+        'Documentation': 'https://docker-py.readthedocs.io',
+        'Changelog': 'https://docker-py.readthedocs.io/en/stable/change-log.html',  # noqa: E501
+        'Source': 'https://github.com/docker/docker-py',
+        'Tracker': 'https://github.com/docker/docker-py/issues',
+    },
+    packages=find_packages(exclude=["tests.*", "tests"]),
+    install_requires=requirements,
+    tests_require=test_requirements,
+    extras_require=extras_require,
+    python_requires='>=3.6',
+    zip_safe=False,
+    test_suite='tests',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Other Environment',
+        'Intended Audience :: Developers',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Topic :: Software Development',
+        'Topic :: Utilities',
+        'License :: OSI Approved :: Apache Software License',
+    ],
+    maintainer='Ulysses Souza',
+    maintainer_email='ulysses.souza@docker.com',
+)

test-requirements.txt

@@ -0,0 +1,7 @@
+setuptools==54.1.1
+coverage==4.5.2
+flake8==3.6.0
+mock==1.0.1
+pytest==4.3.1
+pytest-cov==2.6.1
+pytest-timeout==1.3.3

tests/Dockerfile

@@ -1,16 +1,17 @@
-# syntax=docker/dockerfile:1
+ARG PYTHON_VERSION=3.7
 
-ARG PYTHON_VERSION=3.12
 FROM python:${PYTHON_VERSION}
 
+ARG APT_MIRROR
+RUN sed -ri "s/(httpredir|deb).debian.org/${APT_MIRROR:-deb.debian.org}/g" /etc/apt/sources.list \
+    && sed -ri "s/(security).debian.org/${APT_MIRROR:-security.debian.org}/g" /etc/apt/sources.list
+
 RUN apt-get update && apt-get -y install --no-install-recommends \
     gnupg2 \
     pass
 
 # Add SSH keys and set permissions
-COPY tests/ssh/config/client /root/.ssh
+COPY tests/ssh-keys /root/.ssh
-COPY tests/ssh/config/server/known_ed25519.pub /root/.ssh/known_hosts
-RUN sed -i '1s;^;dpy-dind-ssh ;' /root/.ssh/known_hosts
 RUN chmod -R 600 /root/.ssh
 
 COPY ./tests/gpg-keys /gpg-keys
@@ -26,10 +27,11 @@ RUN curl -sSL -o /opt/docker-credential-pass.tar.gz \
     chmod +x /usr/local/bin/docker-credential-pass
 
 WORKDIR /src
-COPY . .
+COPY requirements.txt /src/requirements.txt
+RUN pip install -r requirements.txt
 
-ARG VERSION=0.0.0.dev0
+COPY test-requirements.txt /src/test-requirements.txt
-RUN --mount=type=cache,target=/cache/pip \
+RUN pip install -r test-requirements.txt
-    PIP_CACHE_DIR=/cache/pip \
+
-    SETUPTOOLS_SCM_PRETEND_VERSION=${VERSION} \
+COPY . /src
-    pip install .[dev,ssh,websockets]
+RUN pip install .

tests/Dockerfile-dind-certs

@@ -1,6 +1,4 @@
-# syntax=docker/dockerfile:1
+ARG PYTHON_VERSION=3.6
-
-ARG PYTHON_VERSION=3.12
 
 FROM python:${PYTHON_VERSION}
 RUN mkdir /tmp/certs

tests/Dockerfile-ssh-dind

@@ -1,20 +1,23 @@
-# syntax=docker/dockerfile:1
+ARG API_VERSION=1.39
-
+ARG ENGINE_VERSION=19.03.12
-ARG API_VERSION=1.45
-ARG ENGINE_VERSION=26.1
 
 FROM docker:${ENGINE_VERSION}-dind
 
-RUN apk add --no-cache --upgrade \
+RUN apk add --no-cache \
 		openssh
 
-COPY tests/ssh/config/server /etc/ssh/
+# Add the keys and set permissions
+RUN ssh-keygen -A
+
+# copy the test SSH config
+RUN echo "IgnoreUserKnownHosts yes" > /etc/ssh/sshd_config && \
+  echo "PubkeyAuthentication yes" >> /etc/ssh/sshd_config && \
+  echo "PermitRootLogin yes" >> /etc/ssh/sshd_config
 
 # set authorized keys for client paswordless connection
-COPY tests/ssh/config/client/id_rsa.pub /root/.ssh/authorized_keys
+COPY tests/ssh-keys/authorized_keys /root/.ssh/authorized_keys
+RUN chmod 600 /root/.ssh/authorized_keys
 
-# RUN echo "root:root" | chpasswd
+RUN echo "root:root" | chpasswd
-RUN chmod -R 600 /etc/ssh \
+RUN ln -s /usr/local/bin/docker /usr/bin/docker
- && chmod -R 600 /root/.ssh \
- && ln -s /usr/local/bin/docker /usr/bin/docker
 EXPOSE 22

tests/helpers.py

@@ -8,11 +8,10 @@ import tarfile
 import tempfile
 import time
 
+import docker
 import paramiko
 import pytest
 
-import docker
-
 
 def make_tree(dirs, files):
     base = tempfile.mkdtemp()
@@ -47,19 +46,6 @@ def untar_file(tardata, filename):
     return result
 
 
-def skip_if_desktop():
-    def fn(f):
-        @functools.wraps(f)
-        def wrapped(self, *args, **kwargs):
-            info = self.client.info()
-            if info['Name'] == 'docker-desktop':
-                pytest.skip('Test does not support Docker Desktop')
-            return f(self, *args, **kwargs)
-
-        return wrapped
-
-    return fn
-
 def requires_api_version(version):
     test_version = os.environ.get(
         'DOCKER_TEST_API_VERSION', docker.constants.DEFAULT_DOCKER_API_VERSION
@@ -94,7 +80,7 @@ def wait_on_condition(condition, delay=0.1, timeout=40):
     start_time = time.time()
     while not condition():
         if time.time() - start_time > timeout:
-            raise AssertionError(f"Timeout: {condition}")
+            raise AssertionError("Timeout: %s" % condition)
         time.sleep(delay)
 
 
@@ -157,4 +143,4 @@ def ctrl_with(char):
     if re.match('[a-z]', char):
         return chr(ord(char) - ord('a') + 1).encode('ascii')
     else:
-        raise Exception('char must be [a-z]')
+        raise(Exception('char must be [a-z]'))

tests/integration/api_build_test.py

@@ -3,13 +3,13 @@ import os
 import shutil
 import tempfile
 
-import pytest
-
 from docker import errors
 from docker.utils.proxy import ProxyConfig
 
+import pytest
+
+from .base import BaseAPIIntegrationTest, TEST_IMG
 from ..helpers import random_name, requires_api_version, requires_experimental
-from .base import TEST_IMG, BaseAPIIntegrationTest
 
 
 class BuildTest(BaseAPIIntegrationTest):
@@ -100,9 +100,7 @@ class BuildTest(BaseAPIIntegrationTest):
                 'ignored',
                 'Dockerfile',
                 '.dockerignore',
-                ' ignored-with-spaces ',  # check that spaces are trimmed
                 '!ignored/subdir/excepted-file',
-                '! ignored/subdir/excepted-with-spaces  '
                 '',  # empty line,
                 '#*',  # comment line
             ]))
@@ -113,9 +111,6 @@ class BuildTest(BaseAPIIntegrationTest):
         with open(os.path.join(base_dir, '#file.txt'), 'w') as f:
             f.write('this file should not be ignored')
 
-        with open(os.path.join(base_dir, 'ignored-with-spaces'), 'w') as f:
-            f.write("this file should be ignored")
-
         subdir = os.path.join(base_dir, 'ignored', 'subdir')
         os.makedirs(subdir)
         with open(os.path.join(subdir, 'file'), 'w') as f:
@@ -124,15 +119,12 @@ class BuildTest(BaseAPIIntegrationTest):
         with open(os.path.join(subdir, 'excepted-file'), 'w') as f:
             f.write("this file should not be ignored")
 
-        with open(os.path.join(subdir, 'excepted-with-spaces'), 'w') as f:
-            f.write("this file should not be ignored")
-
         tag = 'docker-py-test-build-with-dockerignore'
         stream = self.client.build(
             path=base_dir,
             tag=tag,
         )
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         c = self.client.create_container(tag, ['find', '/test', '-type', 'f'])
@@ -142,9 +134,8 @@ class BuildTest(BaseAPIIntegrationTest):
 
         logs = logs.decode('utf-8')
 
-        assert sorted(filter(None, logs.split('\n'))) == sorted([
+        assert sorted(list(filter(None, logs.split('\n')))) == sorted([
             '/test/#file.txt',
-            '/test/ignored/subdir/excepted-with-spaces',
             '/test/ignored/subdir/excepted-file',
             '/test/not-ignored'
         ])
@@ -160,7 +151,7 @@ class BuildTest(BaseAPIIntegrationTest):
             fileobj=script, tag='buildargs', buildargs={'test': 'OK'}
         )
         self.tmp_imgs.append('buildargs')
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         info = self.client.inspect_image('buildargs')
@@ -180,7 +171,7 @@ class BuildTest(BaseAPIIntegrationTest):
             fileobj=script, tag=tag, shmsize=shmsize
         )
         self.tmp_imgs.append(tag)
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         # There is currently no way to get the shmsize
@@ -198,7 +189,7 @@ class BuildTest(BaseAPIIntegrationTest):
             isolation='default'
         )
 
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
     @requires_api_version('1.23')
@@ -213,7 +204,7 @@ class BuildTest(BaseAPIIntegrationTest):
             fileobj=script, tag='labels', labels=labels
         )
         self.tmp_imgs.append('labels')
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         info = self.client.inspect_image('labels')
@@ -230,7 +221,7 @@ class BuildTest(BaseAPIIntegrationTest):
 
         stream = self.client.build(fileobj=script, tag='build1')
         self.tmp_imgs.append('build1')
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         stream = self.client.build(
@@ -271,11 +262,11 @@ class BuildTest(BaseAPIIntegrationTest):
             fileobj=script, target='first', tag='build1'
         )
         self.tmp_imgs.append('build1')
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         info = self.client.inspect_image('build1')
-        assert 'OnBuild' not in info['Config'] or not info['Config']['OnBuild']
+        assert not info['Config']['OnBuild']
 
     @requires_api_version('1.25')
     def test_build_with_network_mode(self):
@@ -300,7 +291,7 @@ class BuildTest(BaseAPIIntegrationTest):
         )
 
         self.tmp_imgs.append('dockerpytest_customnetbuild')
-        for _chunk in stream:
+        for chunk in stream:
             pass
 
         assert self.client.inspect_image('dockerpytest_customnetbuild')
@@ -312,7 +303,7 @@ class BuildTest(BaseAPIIntegrationTest):
         )
 
         self.tmp_imgs.append('dockerpytest_nonebuild')
-        logs = list(stream)
+        logs = [chunk for chunk in stream]
         assert 'errorDetail' in logs[-1]
         assert logs[-1]['errorDetail']['code'] == 1
 
@@ -365,7 +356,7 @@ class BuildTest(BaseAPIIntegrationTest):
                 fileobj=script, tag=tag, squash=squash
             )
             self.tmp_imgs.append(tag)
-            for _chunk in stream:
+            for chunk in stream:
                 pass
 
             return self.client.inspect_image(tag)
@@ -389,8 +380,10 @@ class BuildTest(BaseAPIIntegrationTest):
         lines = []
         for chunk in stream:
             lines.append(chunk.get('stream'))
-        expected = f'{control_chars[0]}{snippet}\n{control_chars[1]}'
+        expected = '{0}{2}\n{1}'.format(
-        assert any(line == expected for line in lines)
+            control_chars[0], control_chars[1], snippet
+        )
+        assert any([line == expected for line in lines])
 
     def test_build_gzip_encoding(self):
         base_dir = tempfile.mkdtemp()

tests/integration/api_client_test.py

@@ -47,7 +47,7 @@ class ConnectionTimeoutTest(unittest.TestCase):
         # This call isn't supposed to complete, and it should fail fast.
         try:
             res = self.client.inspect_container('id')
-        except Exception:
+        except:  # noqa: E722
             pass
         end = time.time()
         assert res is None
@@ -72,4 +72,6 @@ class UnixconnTest(unittest.TestCase):
             client.close()
             del client
 
-            assert len(w) == 0, f"No warnings produced: {w[0].message}"
+            assert len(w) == 0, "No warnings produced: {}".format(
+                w[0].message
+            )

tests/integration/api_config_test.py

@@ -1,6 +1,5 @@
-import pytest
-
 import docker
+import pytest
 
 from ..helpers import force_leave_swarm, requires_api_version
 from .base import BaseAPIIntegrationTest
@@ -74,7 +73,7 @@ class ConfigAPITest(BaseAPIIntegrationTest):
     def test_create_config_with_templating(self):
         config_id = self.client.create_config(
             'favorite_character', 'sakuya izayoi',
-            templating={'name': 'golang'}
+            templating={ 'name': 'golang'}
         )
         self.tmp_configs.append(config_id)
         assert 'ID' in config_id

tests/integration/api_container_test.py

@@ -9,17 +9,15 @@ import pytest
 import requests
 
 import docker
-from docker.constants import IS_WINDOWS_PLATFORM
-from docker.utils.socket import next_frame_header, read_exactly
-
 from .. import helpers
-from ..helpers import (
+from ..helpers import assert_cat_socket_detached_with_keys
-    assert_cat_socket_detached_with_keys,
+from ..helpers import ctrl_with
-    ctrl_with,
+from ..helpers import requires_api_version
-    requires_api_version,
+from .base import BaseAPIIntegrationTest
-    skip_if_desktop,
+from .base import TEST_IMG
-)
+from docker.constants import IS_WINDOWS_PLATFORM
-from .base import TEST_IMG, BaseAPIIntegrationTest
+from docker.utils.socket import next_frame_header
+from docker.utils.socket import read_exactly
 
 
 class ListContainersTest(BaseAPIIntegrationTest):
@@ -124,8 +122,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         self.client.wait(id)
         with pytest.raises(docker.errors.APIError) as exc:
             self.client.remove_container(id)
-        err = exc.value.explanation.lower()
+        err = exc.value.explanation
-        assert 'stop the container before' in err
+        assert 'You cannot remove ' in err
         self.client.remove_container(id, force=True)
 
     def test_create_container_with_volumes_from(self):
@@ -217,20 +215,6 @@ class CreateContainerTest(BaseAPIIntegrationTest):
 
         self.client.kill(id)
 
-    @requires_api_version('1.41')
-    def test_create_with_cgroupns(self):
-        host_config = self.client.create_host_config(cgroupns='private')
-
-        container = self.client.create_container(
-            image=TEST_IMG,
-            command=['sleep', '60'],
-            host_config=host_config,
-        )
-        self.tmp_containers.append(container)
-
-        res = self.client.inspect_container(container)
-        assert 'private' == res['HostConfig']['CgroupnsMode']
-
     def test_group_id_ints(self):
         container = self.client.create_container(
             TEST_IMG, 'id -G',
@@ -476,13 +460,16 @@ class CreateContainerTest(BaseAPIIntegrationTest):
     def test_create_with_device_cgroup_rules(self):
         rule = 'c 7:128 rwm'
         ctnr = self.client.create_container(
-            TEST_IMG, 'true', host_config=self.client.create_host_config(
+            TEST_IMG, 'cat /sys/fs/cgroup/devices/devices.list',
+            host_config=self.client.create_host_config(
                 device_cgroup_rules=[rule]
             )
         )
         self.tmp_containers.append(ctnr)
         config = self.client.inspect_container(ctnr)
         assert config['HostConfig']['DeviceCgroupRules'] == [rule]
+        self.client.start(ctnr)
+        assert rule in self.client.logs(ctnr).decode('utf-8')
 
     def test_create_with_uts_mode(self):
         container = self.client.create_container(
@@ -544,27 +531,6 @@ class VolumeBindTest(BaseAPIIntegrationTest):
         inspect_data = self.client.inspect_container(container)
         self.check_container_data(inspect_data, False)
 
-    @skip_if_desktop()
-    def test_create_with_binds_rw_rshared(self):
-        container = self.run_with_volume_propagation(
-            False,
-            'rshared',
-            TEST_IMG,
-            ['touch', os.path.join(self.mount_dest, self.filename)],
-        )
-        inspect_data = self.client.inspect_container(container)
-        self.check_container_data(inspect_data, True, 'rshared')
-        container = self.run_with_volume_propagation(
-            True,
-            'rshared',
-            TEST_IMG,
-            ['ls', self.mount_dest],
-        )
-        logs = self.client.logs(container).decode('utf-8')
-        assert self.filename in logs
-        inspect_data = self.client.inspect_container(container)
-        self.check_container_data(inspect_data, False, 'rshared')
-
     @requires_api_version('1.30')
     def test_create_with_mounts(self):
         mount = docker.types.Mount(
@@ -620,57 +586,7 @@ class VolumeBindTest(BaseAPIIntegrationTest):
         assert mount['Source'] == mount_data['Name']
         assert mount_data['RW'] is True
 
-    @requires_api_version('1.45')
+    def check_container_data(self, inspect_data, rw):
-    def test_create_with_subpath_volume_mount(self):
-        source_volume = helpers.random_name()
-        self.client.create_volume(name=source_volume)
-
-        setup_container = None
-        test_container = None
-
-
-        # Create a file structure in the volume to test with
-        setup_container = self.client.create_container(
-            TEST_IMG,
-            [
-                "sh",
-                "-c",
-                'mkdir -p /vol/subdir && echo "test content" > /vol/subdir/testfile.txt',
-            ],
-            host_config=self.client.create_host_config(
-                binds=[f"{source_volume}:/vol"]
-            ),
-        )
-        self.client.start(setup_container)
-        self.client.wait(setup_container)
-
-        # Now test with subpath
-        mount = docker.types.Mount(
-            type="volume",
-            source=source_volume,
-            target=self.mount_dest,
-            read_only=True,
-            subpath="subdir",
-        )
-
-
-        host_config = self.client.create_host_config(mounts=[mount])
-        test_container = self.client.create_container(
-            TEST_IMG,
-            ["cat", os.path.join(self.mount_dest, "testfile.txt")],
-            host_config=host_config,
-        )
-
-        self.client.start(test_container)
-        self.client.wait(test_container)  # Wait for container to finish
-        output = self.client.logs(test_container).decode("utf-8").strip()
-
-        # If the subpath feature is working, we should be able to see the content
-        # of the file in the subdir
-        assert output == "test content"
-
-
-    def check_container_data(self, inspect_data, rw, propagation='rprivate'):
         assert 'Mounts' in inspect_data
         filtered = list(filter(
             lambda x: x['Destination'] == self.mount_dest,
@@ -680,7 +596,6 @@ class VolumeBindTest(BaseAPIIntegrationTest):
         mount_data = filtered[0]
         assert mount_data['Source'] == self.mount_origin
         assert mount_data['RW'] == rw
-        assert mount_data['Propagation'] == propagation
 
     def run_with_volume(self, ro, *args, **kwargs):
         return self.run_container(
@@ -698,23 +613,6 @@ class VolumeBindTest(BaseAPIIntegrationTest):
             **kwargs
         )
 
-    def run_with_volume_propagation(self, ro, propagation, *args, **kwargs):
-        return self.run_container(
-            *args,
-            volumes={self.mount_dest: {}},
-            host_config=self.client.create_host_config(
-                binds={
-                    self.mount_origin: {
-                        'bind': self.mount_dest,
-                        'ro': ro,
-                        'propagation': propagation
-                    },
-                },
-                network_mode='none'
-            ),
-            **kwargs
-        )
-
 
 class ArchiveTest(BaseAPIIntegrationTest):
     def test_get_file_archive_from_container(self):
@@ -757,7 +655,9 @@ class ArchiveTest(BaseAPIIntegrationTest):
             test_file.seek(0)
             ctnr = self.client.create_container(
                 TEST_IMG,
-                f"cat {os.path.join('/vol1/', os.path.basename(test_file.name))}",
+                'cat {}'.format(
+                    os.path.join('/vol1/', os.path.basename(test_file.name))
+                ),
                 volumes=['/vol1']
             )
             self.tmp_containers.append(ctnr)
@@ -915,7 +815,7 @@ class LogsTest(BaseAPIIntegrationTest):
         exitcode = self.client.wait(id)['StatusCode']
         assert exitcode == 0
         logs = self.client.logs(id)
-        assert logs == f"{snippet}\n".encode(encoding='ascii')
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_tail_option(self):
         snippet = '''Line1
@@ -946,7 +846,7 @@ Line2'''
         exitcode = self.client.wait(id)['StatusCode']
         assert exitcode == 0
 
-        assert logs == f"{snippet}\n".encode(encoding='ascii')
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     @pytest.mark.timeout(5)
     @pytest.mark.skipif(os.environ.get('DOCKER_HOST', '').startswith('ssh://'),
@@ -967,7 +867,7 @@ Line2'''
         for chunk in generator:
             logs += chunk
 
-        assert logs == f"{snippet}\n".encode(encoding='ascii')
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_dict_instead_of_id(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -980,7 +880,7 @@ Line2'''
         exitcode = self.client.wait(id)['StatusCode']
         assert exitcode == 0
         logs = self.client.logs(container)
-        assert logs == f"{snippet}\n".encode(encoding='ascii')
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_tail_0(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -1009,7 +909,7 @@ Line2'''
         logs_until_1 = self.client.logs(container, until=1)
         assert logs_until_1 == b''
         logs_until_now = self.client.logs(container, datetime.now())
-        assert logs_until_now == f"{snippet}\n".encode(encoding='ascii')
+        assert logs_until_now == (snippet + '\n').encode(encoding='ascii')
 
 
 class DiffTest(BaseAPIIntegrationTest):
@@ -1175,7 +1075,7 @@ class PortTest(BaseAPIIntegrationTest):
 
             ip, host_port = port_binding['HostIp'], port_binding['HostPort']
 
-            port_binding = port if not protocol else f"{port}/{protocol}"
+            port_binding = port if not protocol else port + "/" + protocol
             assert ip == port_bindings[port_binding][0]
             assert host_port == port_bindings[port_binding][1]
 
@@ -1300,7 +1200,7 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         sock = self.client.attach_socket(container, ws=False)
         assert sock.fileno() > -1
 
-    def test_run_container_reading_socket_http(self):
+    def test_run_container_reading_socket(self):
         line = 'hi there and stuff and things, words!'
         # `echo` appends CRLF, `printf` doesn't
         command = f"printf '{line}'"
@@ -1320,33 +1220,12 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         data = read_exactly(pty_stdout, next_size)
         assert data.decode('utf-8') == line
 
-    @pytest.mark.xfail(condition=bool(os.environ.get('DOCKER_CERT_PATH', '')),
-                       reason='DOCKER_CERT_PATH not respected for websockets')
-    def test_run_container_reading_socket_ws(self):
-        line = 'hi there and stuff and things, words!'
-        # `echo` appends CRLF, `printf` doesn't
-        command = f"printf '{line}'"
-        container = self.client.create_container(TEST_IMG, command,
-                                                 detach=True, tty=False)
-        self.tmp_containers.append(container)
-
-        opts = {"stdout": 1, "stream": 1, "logs": 1}
-        pty_stdout = self.client.attach_socket(container, opts, ws=True)
-        self.addCleanup(pty_stdout.close)
-
-        self.client.start(container)
-
-        data = pty_stdout.recv()
-        assert data.decode('utf-8') == line
-
-    @pytest.mark.timeout(10)
     def test_attach_no_stream(self):
         container = self.client.create_container(
             TEST_IMG, 'echo hello'
         )
         self.tmp_containers.append(container)
         self.client.start(container)
-        self.client.wait(container, condition='not-running')
         output = self.client.attach(container, stream=False, logs=True)
         assert output == 'hello\n'.encode(encoding='ascii')
 
@@ -1481,7 +1360,7 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
         response = self.client.stats(container, stream=0)
         self.client.kill(container)
 
-        assert isinstance(response, dict)
+        assert type(response) == dict
         for key in ['read', 'networks', 'precpu_stats', 'cpu_stats',
                     'memory_stats', 'blkio_stats']:
             assert key in response
@@ -1494,7 +1373,7 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
             self.client.start(container)
             stream = self.client.stats(container)
             for chunk in stream:
-                assert isinstance(chunk, dict)
+                assert type(chunk) == dict
                 for key in ['read', 'network', 'precpu_stats', 'cpu_stats',
                             'memory_stats', 'blkio_stats']:
                     assert key in chunk

tests/integration/api_exec_test.py

@@ -1,12 +1,11 @@
+from ..helpers import assert_cat_socket_detached_with_keys
+from ..helpers import ctrl_with
+from ..helpers import requires_api_version
+from .base import BaseAPIIntegrationTest
+from .base import TEST_IMG
 from docker.utils.proxy import ProxyConfig
-from docker.utils.socket import next_frame_header, read_exactly
+from docker.utils.socket import next_frame_header
-
+from docker.utils.socket import read_exactly
-from ..helpers import (
-    assert_cat_socket_detached_with_keys,
-    ctrl_with,
-    requires_api_version,
-)
-from .base import TEST_IMG, BaseAPIIntegrationTest
 
 
 class ExecTest(BaseAPIIntegrationTest):

tests/integration/api_healthcheck_test.py

@@ -1,5 +1,5 @@
+from .base import BaseAPIIntegrationTest, TEST_IMG
 from .. import helpers
-from .base import TEST_IMG, BaseAPIIntegrationTest
 
 SECOND = 1000000000
 
@@ -16,7 +16,7 @@ class HealthcheckTest(BaseAPIIntegrationTest):
     @helpers.requires_api_version('1.24')
     def test_healthcheck_shell_command(self):
         container = self.client.create_container(
-            TEST_IMG, 'top', healthcheck={'test': 'echo "hello world"'})
+            TEST_IMG, 'top', healthcheck=dict(test='echo "hello world"'))
         self.tmp_containers.append(container)
 
         res = self.client.inspect_container(container)
@@ -27,12 +27,12 @@ class HealthcheckTest(BaseAPIIntegrationTest):
     @helpers.requires_api_version('1.24')
     def test_healthcheck_passes(self):
         container = self.client.create_container(
-            TEST_IMG, 'top', healthcheck={
+            TEST_IMG, 'top', healthcheck=dict(
-                'test': "true",
+                test="true",
-                'interval': 1 * SECOND,
+                interval=1 * SECOND,
-                'timeout': 1 * SECOND,
+                timeout=1 * SECOND,
-                'retries': 1,
+                retries=1,
-            })
+            ))
         self.tmp_containers.append(container)
         self.client.start(container)
         wait_on_health_status(self.client, container, "healthy")
@@ -40,12 +40,12 @@ class HealthcheckTest(BaseAPIIntegrationTest):
     @helpers.requires_api_version('1.24')
     def test_healthcheck_fails(self):
         container = self.client.create_container(
-            TEST_IMG, 'top', healthcheck={
+            TEST_IMG, 'top', healthcheck=dict(
-                'test': "false",
+                test="false",
-                'interval': 1 * SECOND,
+                interval=1 * SECOND,
-                'timeout': 1 * SECOND,
+                timeout=1 * SECOND,
-                'retries': 1,
+                retries=1,
-            })
+            ))
         self.tmp_containers.append(container)
         self.client.start(container)
         wait_on_health_status(self.client, container, "unhealthy")
@@ -53,14 +53,14 @@ class HealthcheckTest(BaseAPIIntegrationTest):
     @helpers.requires_api_version('1.29')
     def test_healthcheck_start_period(self):
         container = self.client.create_container(
-            TEST_IMG, 'top', healthcheck={
+            TEST_IMG, 'top', healthcheck=dict(
-                'test': "echo 'x' >> /counter.txt && "
+                test="echo 'x' >> /counter.txt && "
                      "test `cat /counter.txt | wc -l` -ge 3",
-                'interval': 1 * SECOND,
+                interval=1 * SECOND,
-                'timeout': 1 * SECOND,
+                timeout=1 * SECOND,
-                'retries': 1,
+                retries=1,
-                'start_period': 3 * SECOND
+                start_period=3 * SECOND
-            }
+            )
         )
 
         self.tmp_containers.append(container)

tests/integration/api_image_test.py

@@ -2,18 +2,19 @@ import contextlib
 import json
 import shutil
 import socket
-import socketserver
 import tarfile
 import tempfile
 import threading
-from http.server import SimpleHTTPRequestHandler
 
 import pytest
+from http.server import SimpleHTTPRequestHandler
+import socketserver
+
 
 import docker
 
 from ..helpers import requires_api_version, requires_experimental
-from .base import TEST_IMG, BaseAPIIntegrationTest
+from .base import BaseAPIIntegrationTest, TEST_IMG
 
 
 class ListImagesTest(BaseAPIIntegrationTest):
@@ -31,7 +32,7 @@ class ListImagesTest(BaseAPIIntegrationTest):
 
     def test_images_quiet(self):
         res1 = self.client.images(quiet=True)
-        assert isinstance(res1[0], str)
+        assert type(res1[0]) == str
 
 
 class PullImageTest(BaseAPIIntegrationTest):
@@ -42,7 +43,7 @@ class PullImageTest(BaseAPIIntegrationTest):
             pass
         res = self.client.pull('hello-world')
         self.tmp_imgs.append('hello-world')
-        assert isinstance(res, str)
+        assert type(res) == str
         assert len(self.client.images('hello-world')) >= 1
         img_info = self.client.inspect_image('hello-world')
         assert 'Id' in img_info
@@ -84,8 +85,13 @@ class CommitTest(BaseAPIIntegrationTest):
         img_id = res['Id']
         self.tmp_imgs.append(img_id)
         img = self.client.inspect_image(img_id)
-        assert 'Parent' in img
+        assert 'Container' in img
+        assert img['Container'].startswith(id)
+        assert 'ContainerConfig' in img
+        assert 'Image' in img['ContainerConfig']
+        assert TEST_IMG == img['ContainerConfig']['Image']
         busybox_id = self.client.inspect_image(TEST_IMG)['Id']
+        assert 'Parent' in img
         assert img['Parent'] == busybox_id
 
     def test_commit_with_changes(self):
@@ -97,6 +103,8 @@ class CommitTest(BaseAPIIntegrationTest):
         )
         self.tmp_imgs.append(img_id)
         img = self.client.inspect_image(img_id)
+        assert 'Container' in img
+        assert img['Container'].startswith(cid['Id'])
         assert '8000/tcp' in img['Config']['ExposedPorts']
         assert img['Config']['Cmd'] == ['bash']
 
@@ -255,8 +263,10 @@ class ImportImageTest(BaseAPIIntegrationTest):
         data = self.client.get_image(test_img)
         assert data
         output = self.client.load_image(data)
-        assert any(line for line in output
+        assert any([
-            if f'Loaded image: {test_img}' in line.get('stream', ''))
+            line for line in output
+            if f'Loaded image: {test_img}' in line.get('stream', '')
+        ])
 
     @contextlib.contextmanager
     def temporary_http_file_server(self, stream):
@@ -271,7 +281,7 @@ class ImportImageTest(BaseAPIIntegrationTest):
 
         server = socketserver.TCPServer(('', 0), Handler)
         thread = threading.Thread(target=server.serve_forever)
-        thread.daemon = True
+        thread.setDaemon(True)
         thread.start()
 
         yield f'http://{socket.gethostname()}:{server.server_address[1]}'

tests/integration/api_network_test.py

@@ -1,10 +1,9 @@
-import pytest
-
 import docker
 from docker.types import IPAMConfig, IPAMPool
+import pytest
 
 from ..helpers import random_name, requires_api_version
-from .base import TEST_IMG, BaseAPIIntegrationTest
+from .base import BaseAPIIntegrationTest, TEST_IMG
 
 
 class TestNetworks(BaseAPIIntegrationTest):
@@ -234,7 +233,7 @@ class TestNetworks(BaseAPIIntegrationTest):
         net_name, net_id = self.create_network(
             ipam=IPAMConfig(
                 driver='default',
-                pool_configs=[IPAMPool(subnet="2001:389::/64")],
+                pool_configs=[IPAMPool(subnet="2001:389::1/64")],
             ),
         )
         container = self.client.create_container(
@@ -328,6 +327,8 @@ class TestNetworks(BaseAPIIntegrationTest):
         net_name, net_id = self.create_network()
         with pytest.raises(docker.errors.APIError):
             self.client.create_network(net_name, check_duplicate=True)
+        net_id = self.client.create_network(net_name, check_duplicate=False)
+        self.tmp_networks.append(net_id['Id'])
 
     @requires_api_version('1.22')
     def test_connect_with_links(self):
@@ -388,7 +389,7 @@ class TestNetworks(BaseAPIIntegrationTest):
                 driver='default',
                 pool_configs=[
                     IPAMPool(
-                        subnet="2001:389::/64", iprange="2001:389::0/96",
+                        subnet="2001:389::1/64", iprange="2001:389::0/96",
                         gateway="2001:389::ffff"
                     )
                 ]
@@ -407,22 +408,6 @@ class TestNetworks(BaseAPIIntegrationTest):
         net_data = container_data['NetworkSettings']['Networks'][net_name]
         assert net_data['IPAMConfig']['IPv6Address'] == '2001:389::f00d'
 
-    @requires_api_version('1.25')
-    def test_connect_with_mac_address(self):
-        net_name, net_id = self.create_network()
-
-        container = self.client.create_container(TEST_IMG, 'top')
-        self.tmp_containers.append(container)
-
-        self.client.connect_container_to_network(
-            container, net_name, mac_address='02:42:ac:11:00:02'
-        )
-
-        container_data = self.client.inspect_container(container)
-
-        net_data = container_data['NetworkSettings']['Networks'][net_name]
-        assert net_data['MacAddress'] == '02:42:ac:11:00:02'
-
     @requires_api_version('1.23')
     def test_create_internal_networks(self):
         _, net_id = self.create_network(internal=True)
@@ -454,7 +439,7 @@ class TestNetworks(BaseAPIIntegrationTest):
                 driver='default',
                 pool_configs=[
                     IPAMPool(
-                        subnet="2001:389::/64", iprange="2001:389::0/96",
+                        subnet="2001:389::1/64", iprange="2001:389::0/96",
                         gateway="2001:389::ffff"
                     )
                 ]

tests/integration/api_plugin_test.py

@@ -1,11 +1,10 @@
 import os
 
+import docker
 import pytest
 
-import docker
-
-from ..helpers import requires_api_version
 from .base import BaseAPIIntegrationTest
+from ..helpers import requires_api_version
 
 SSHFS = 'vieux/sshfs:latest'
 
@@ -23,13 +22,13 @@ class PluginTest(BaseAPIIntegrationTest):
     def teardown_method(self, method):
         client = self.get_client_instance()
         try:
-            client.disable_plugin(SSHFS, True)
+            client.disable_plugin(SSHFS)
         except docker.errors.APIError:
             pass
 
         for p in self.tmp_plugins:
             try:
-                client.remove_plugin(p)
+                client.remove_plugin(p, force=True)
             except docker.errors.APIError:
                 pass
 
@@ -40,7 +39,7 @@ class PluginTest(BaseAPIIntegrationTest):
             return self.client.inspect_plugin(plugin_name)
         except docker.errors.NotFound:
             prv = self.client.plugin_privileges(plugin_name)
-            for _d in self.client.pull_plugin(plugin_name, prv):
+            for d in self.client.pull_plugin(plugin_name, prv):
                 pass
         return self.client.inspect_plugin(plugin_name)
 
@@ -119,7 +118,7 @@ class PluginTest(BaseAPIIntegrationTest):
             pass
 
         prv = self.client.plugin_privileges(SSHFS)
-        logs = list(self.client.pull_plugin(SSHFS, prv))
+        logs = [d for d in self.client.pull_plugin(SSHFS, prv)]
         assert filter(lambda x: x['status'] == 'Download complete', logs)
         assert self.client.inspect_plugin(SSHFS)
         assert self.client.enable_plugin(SSHFS)
@@ -129,7 +128,7 @@ class PluginTest(BaseAPIIntegrationTest):
         pl_data = self.ensure_plugin_installed(SSHFS)
         assert pl_data['Enabled'] is False
         prv = self.client.plugin_privileges(SSHFS)
-        logs = list(self.client.upgrade_plugin(SSHFS, SSHFS, prv))
+        logs = [d for d in self.client.upgrade_plugin(SSHFS, SSHFS, prv)]
         assert filter(lambda x: x['status'] == 'Download complete', logs)
         assert self.client.inspect_plugin(SSHFS)
         assert self.client.enable_plugin(SSHFS)

tests/integration/api_secret_test.py

@@ -1,6 +1,5 @@
-import pytest
-
 import docker
+import pytest
 
 from ..helpers import force_leave_swarm, requires_api_version
 from .base import BaseAPIIntegrationTest

tests/integration/api_service_test.py

@@ -1,12 +1,13 @@
 import random
 import time
 
+import docker
 import pytest
 
-import docker
+from ..helpers import (
-
+    force_leave_swarm, requires_api_version, requires_experimental
-from ..helpers import force_leave_swarm, requires_api_version
+)
-from .base import TEST_IMG, BaseAPIIntegrationTest
+from .base import BaseAPIIntegrationTest, TEST_IMG
 
 
 class ServiceTest(BaseAPIIntegrationTest):
@@ -84,20 +85,6 @@ class ServiceTest(BaseAPIIntegrationTest):
         assert len(test_services) == 1
         assert test_services[0]['Spec']['Labels']['test_label'] == 'testing'
 
-    @requires_api_version('1.41')
-    def test_list_services_with_status(self):
-        test_services = self.client.services()
-        assert len(test_services) == 0
-        self.create_simple_service()
-        test_services = self.client.services(
-            filters={'name': 'dockerpytest_'}, status=False
-        )
-        assert 'ServiceStatus' not in test_services[0]
-        test_services = self.client.services(
-            filters={'name': 'dockerpytest_'}, status=True
-        )
-        assert 'ServiceStatus' in test_services[0]
-
     def test_inspect_service_by_id(self):
         svc_name, svc_id = self.create_simple_service()
         svc_info = self.client.inspect_service(svc_id)
@@ -140,7 +127,8 @@ class ServiceTest(BaseAPIIntegrationTest):
         assert len(services) == 1
         assert services[0]['ID'] == svc_id['ID']
 
-    @requires_api_version('1.29')
+    @requires_api_version('1.25')
+    @requires_experimental(until='1.29')
     def test_service_logs(self):
         name, svc_id = self.create_simple_service()
         assert self.get_service_container(name, include_stopped=True)
@@ -638,39 +626,6 @@ class ServiceTest(BaseAPIIntegrationTest):
         assert 'Replicated' in svc_info['Spec']['Mode']
         assert svc_info['Spec']['Mode']['Replicated'] == {'Replicas': 5}
 
-    @requires_api_version('1.41')
-    def test_create_service_global_job_mode(self):
-        container_spec = docker.types.ContainerSpec(
-            TEST_IMG, ['echo', 'hello']
-        )
-        task_tmpl = docker.types.TaskTemplate(container_spec)
-        name = self.get_service_name()
-        svc_id = self.client.create_service(
-            task_tmpl, name=name, mode='global-job'
-        )
-        svc_info = self.client.inspect_service(svc_id)
-        assert 'Mode' in svc_info['Spec']
-        assert 'GlobalJob' in svc_info['Spec']['Mode']
-
-    @requires_api_version('1.41')
-    def test_create_service_replicated_job_mode(self):
-        container_spec = docker.types.ContainerSpec(
-            TEST_IMG, ['echo', 'hello']
-        )
-        task_tmpl = docker.types.TaskTemplate(container_spec)
-        name = self.get_service_name()
-        svc_id = self.client.create_service(
-            task_tmpl, name=name,
-            mode=docker.types.ServiceMode('replicated-job', 5)
-        )
-        svc_info = self.client.inspect_service(svc_id)
-        assert 'Mode' in svc_info['Spec']
-        assert 'ReplicatedJob' in svc_info['Spec']['Mode']
-        assert svc_info['Spec']['Mode']['ReplicatedJob'] == {
-            'MaxConcurrent': 1,
-            'TotalCompletions': 5
-        }
-
     @requires_api_version('1.25')
     def test_update_service_force_update(self):
         container_spec = docker.types.ContainerSpec(
@@ -1431,23 +1386,3 @@ class ServiceTest(BaseAPIIntegrationTest):
         assert services[0]['ID'] == svc_id['ID']
         spec = services[0]['Spec']['TaskTemplate']['ContainerSpec']
         assert 'CAP_SYSLOG' in spec['CapabilityDrop']
-
-    @requires_api_version('1.40')
-    def test_create_service_with_sysctl(self):
-        name = self.get_service_name()
-        sysctls = {
-            'net.core.somaxconn': '1024',
-            'net.ipv4.tcp_syncookies': '0',
-        }
-        container_spec = docker.types.ContainerSpec(
-            TEST_IMG, ['echo', 'hello'], sysctls=sysctls
-        )
-        task_tmpl = docker.types.TaskTemplate(container_spec)
-        svc_id = self.client.create_service(task_tmpl, name=name)
-        assert self.client.inspect_service(svc_id)
-        services = self.client.services(filters={'name': name})
-        assert len(services) == 1
-        assert services[0]['ID'] == svc_id['ID']
-        spec = services[0]['Spec']['TaskTemplate']['ContainerSpec']
-        assert spec['Sysctls']['net.core.somaxconn'] == '1024'
-        assert spec['Sysctls']['net.ipv4.tcp_syncookies'] == '0'