diff --git a/api/app/models/bookings/exam.py b/api/app/models/bookings/exam.py
index bc903a55e..bdfda45a7 100644
--- a/api/app/models/bookings/exam.py
+++ b/api/app/models/bookings/exam.py
@@ -49,6 +49,8 @@ class Exam(Base):
     payee_email = db.Column(db.String(50), nullable=True)
     payee_name = db.Column(db.String(50), nullable=True)
     payee_phone = db.Column(db.String(50), nullable=True)
+    candidates_list = db.Column(db.JSON, nullable=True)
+    is_pesticide = db.Column(db.Integer, nullable=True, default=0)
 
     booking = db.relationship("Booking")
     exam_type = db.relationship("ExamType")
diff --git a/api/app/resources/bookings/booking/booking_post.py b/api/app/resources/bookings/booking/booking_post.py
index 73e129344..919f177f7 100644
--- a/api/app/resources/bookings/booking/booking_post.py
+++ b/api/app/resources/bookings/booking/booking_post.py
@@ -55,11 +55,23 @@ def post(self):
                 db.session.add(booking)
                 db.session.commit()
 
-            else:
+            elif type(i_id) == int:
 
                 booking.invigilators.append(Invigilator.query.filter_by(invigilator_id=i_id).first_or_404())
                 db.session.add(booking)
                 db.session.commit()
+            
+            elif type(i_id) == list:
+
+                if len(i_id) == 0:
+                    db.session.add(booking)
+                    db.session.commit()
+
+                else:
+                    for value in i_id:
+                        booking.invigilators.append(Invigilator.query.filter_by(invigilator_id=value).first_or_404())
+                        db.session.add(booking)
+                        db.session.commit()
 
             result = self.booking_schema.dump(booking)
 
diff --git a/api/app/resources/bookings/exam/exam_bcmp.py b/api/app/resources/bookings/exam/exam_bcmp.py
new file mode 100644
index 000000000..dfa9ed7a5
--- /dev/null
+++ b/api/app/resources/bookings/exam/exam_bcmp.py
@@ -0,0 +1,80 @@
+'''Copyright 2018 Province of British Columbia
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.'''
+
+import logging
+import copy
+import json
+from flask import request, g
+from flask_restx import Resource
+from app.models.theq import CSR, Office
+from app.models.bookings import ExamType, Invigilator
+from app.schemas.bookings import ExamSchema, CandidateSchema
+from qsystem import api, api_call_with_retry, db, oidc
+from app.utilities.bcmp_service import BCMPService
+
+from app.resources.bookings.exam.exam_post import ExamPost
+
+@api.route("/exams/bcmp/", methods=["POST"])
+class ExamBcmpPost(Resource):
+
+    exam_schema = ExamSchema()
+    bcmp_service = BCMPService()
+
+    @oidc.accept_token(require_token=True)
+    @api_call_with_retry
+    def post(self):
+
+        csr = CSR.find_by_username(g.oidc_token_info['username'])
+
+        json_data = request.get_json()
+
+        exam, warning = self.exam_schema.load(json_data)
+
+        print("json_data: ")
+        print(json_data)
+
+        if warning:
+            logging.warning("WARNING: %s", warning)
+            return {"message": warning}, 422
+        
+        if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
+            return {"The Exam Office ID and CSR Office ID do not match!"}, 403   
+            
+        formatted_data = ExamPost.format_data(self, json_data, exam)
+        exam = formatted_data["exam"]
+
+        invigilator = None
+        if exam.invigilator_id:
+            invigilator = Invigilator.query.filter_by(invigilator_id=exam.invigilator_id).first()
+
+        bcmp_response = None
+        if json_data["ind_or_group"] == "individual":
+            
+            exam_fees = json_data["fees"]
+            
+            logging.info("Creating individual pesticide exam")
+            bcmp_response = self.bcmp_service.create_individual_exam(exam, exam_fees, invigilator, formatted_data["pesticide_office"], g.oidc_token_info)
+
+        else:
+
+            logging.info("Creating Group pesticide exam")
+            bcmp_response = self.bcmp_service.create_group_exam_bcmp(exam, formatted_data["candidates_list_bcmp"], invigilator, formatted_data["pesticide_office"], g.oidc_token_info)
+            
+            
+        if bcmp_response:
+            return {"bcmp_job_id": bcmp_response['jobId'],
+                "errors": {}}, 201
+        else:
+            return {"message": "create_group_exam_bcmp failed",
+                "error": bcmp_response}, 403
diff --git a/api/app/resources/bookings/exam/exam_bulk_status.py b/api/app/resources/bookings/exam/exam_bulk_status.py
index 0687cadfb..292fe5214 100644
--- a/api/app/resources/bookings/exam/exam_bulk_status.py
+++ b/api/app/resources/bookings/exam/exam_bulk_status.py
@@ -13,18 +13,21 @@
 limitations under the License.'''
 
 import logging
+import json
 from flask import g
-from flask_restplus import Resource
+from flask_restx import Resource
 from sqlalchemy import exc
 from app.models.bookings import Exam
+from app.schemas.bookings import ExamSchema
 from app.models.theq import CSR
 from app.utilities.bcmp_service import BCMPService
-from qsystem import api, oidc
+from qsystem import api, oidc, db
 
 
 @api.route("/exams/bcmp_status/", methods=["POST"])
 class ExamList(Resource):
     bcmp_service = BCMPService()
+    exam_schema = ExamSchema()
 
     @oidc.accept_token(require_token=True)
     def post(self):
@@ -32,9 +35,32 @@ def post(self):
 
         try:
             exams = Exam.query.filter_by(upload_received_ind=0).filter(Exam.bcmp_job_id.isnot(None))
-            self.bcmp_service.bulk_check_exam_status(exams)
+            bcmp_response = self.bcmp_service.bulk_check_exam_status(exams)
 
-            return {}, 200
+            job_ids = []
+            for job in bcmp_response["jobs"]:
+                if job["jobStatus"] == "RESPONSE_UPLOADED":
+                    job_ids.append(job["jobId"])
+
+            print("job_ids to update: ")
+            print(job_ids)
+
+            exams_tobe_updated = None
+
+            if len(job_ids) != 0:
+                exams_tobe_updated = Exam.query.filter(Exam.bcmp_job_id.in_(job_ids))
+
+                for exam in exams_tobe_updated:
+                    exam_upd, warn = self.exam_schema.load({'upload_received_ind': 1}, instance=exam, partial=True)
+                    db.session.add(exam_upd)
+
+                try:
+                    db.session.commit()
+                except:
+                    db.session.rollback()
+                    raise
+
+            return {"exams_updated": exams_tobe_updated}, 200
 
         except exc.SQLAlchemyError as error:
             logging.error(error, exc_info=True)
diff --git a/api/app/resources/bookings/exam/exam_download.py b/api/app/resources/bookings/exam/exam_download.py
index 0aed9a52d..3bd875cbf 100644
--- a/api/app/resources/bookings/exam/exam_download.py
+++ b/api/app/resources/bookings/exam/exam_download.py
@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g, Response
-from flask_restplus import Resource
+from flask_restx import Resource
 import io
 import logging
 import urllib
@@ -40,11 +40,11 @@ def get(self, exam_id):
             if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
                 return {"The Exam Office ID and CSR Office ID do not match!"}, 403
 
-            status = self.bcmp_service.check_exam_status(exam)
-            print(status)
+            job = self.bcmp_service.check_exam_status(exam)
+            print(job)
 
-            if status == 'PACKAGE_GENERATED':
-                package_url = status["jobProperties"]["EXAM_PACKAGE_URL"]
+            if job['jobStatus'] == 'PACKAGE_GENERATED':
+                package_url = job["jobProperties"]["EXAM_PACKAGE_URL"]
                 req = urllib.request.Request(package_url)
                 response = urllib.request.urlopen(req).read()
                 exam_file = io.BytesIO(response)
@@ -58,7 +58,7 @@ def get(self, exam_id):
                                     "Content-Type": "application/pdf"
                                 })
             else:
-                return {'message': 'API is down'}, 400
+                return {'message': 'Package not yet generated', 'status': job['jobStatus']}, 400
                 # test_url = 'http://www.pdf995.com/samples/pdf.pdf'
                 # req = urllib.request.Request(test_url)
                 # response = urllib.request.urlopen(req).read()
diff --git a/api/app/resources/bookings/exam/exam_email_invigilator.py b/api/app/resources/bookings/exam/exam_email_invigilator.py
index 793608036..b9defb438 100644
--- a/api/app/resources/bookings/exam/exam_email_invigilator.py
+++ b/api/app/resources/bookings/exam/exam_email_invigilator.py
@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g, request
-from flask_restplus import Resource
+from flask_restx import Resource
 import logging
 from sqlalchemy import exc
 from app.models.theq import CSR
diff --git a/api/app/resources/bookings/exam/exam_post.py b/api/app/resources/bookings/exam/exam_post.py
index fe5793c63..358cbe16d 100644
--- a/api/app/resources/bookings/exam/exam_post.py
+++ b/api/app/resources/bookings/exam/exam_post.py
@@ -13,16 +13,17 @@
 limitations under the License.'''
 
 import logging
+import copy
+import json
 from flask import request, g
 from flask_restx import Resource
 from app.models.theq import CSR, Office
-from flask_restplus import Resource
-from app.models.bookings import ExamType
-from app.schemas.bookings import ExamSchema
+from flask_restx import Resource
+from app.models.bookings import ExamType, Invigilator
+from app.schemas.bookings import ExamSchema, CandidateSchema
 from qsystem import api, api_call_with_retry, db, oidc
 from app.utilities.bcmp_service import BCMPService
 
-
 @api.route("/exams/", methods=["POST"])
 class ExamPost(Resource):
 
@@ -33,46 +34,34 @@ class ExamPost(Resource):
     @api_call_with_retry
     def post(self):
 
+        is_bcmp_req = True if request.args.get('bcmp_pesticide') else False
+
+        print("is_bcmp_req: ")
+        print(is_bcmp_req)
+
         csr = CSR.find_by_username(g.oidc_token_info['username'])
 
         json_data = request.get_json()
 
         exam, warning = self.exam_schema.load(json_data)
 
+        print("json_data: ")
+        print(json_data)
+
         if warning:
             logging.warning("WARNING: %s", warning)
             return {"message": warning}, 422
-        print("+=+=+=+= NAME: %s +=+=+=+=" % exam.examinee_name)
-
-        exam_type = ExamType.query.filter_by(exam_type_id=exam.exam_type_id).first()
-
-        if not exam_type:
-            exam_type = ExamType.query.filter_by(pesticide_exam_ind=1, group_exam_ind=1).first()
-            exam.exam_type = exam_type
-
-        if exam_type.pesticide_exam_ind:
-            if not exam_type.group_exam_ind:
-                logging.info("Create BCMP exam since this is a pesticide exam")
-
-                if json_data["sbc_managed"] != "sbc":
-                    print("Setting non-SBC shit")
-                    pesticide_office = Office.query.filter_by(office_name="Pesticide Offsite").first()
-                    exam.office_id = pesticide_office.office_id
-
-                if exam_type.group_exam_ind:
-                    logging.info("Creating group pesticide exam")
-                    bcmp_response = self.bcmp_service.create_group_exam(exam)
-                else:
-                    logging.info("Creating individual pesticide exam")
-                    bcmp_response = self.bcmp_service.create_individual_exam(exam, exam_type)
-
-                if bcmp_response:
-                    exam.bcmp_job_id = bcmp_response['jobId']
-            else:
-                print("Do the group exam shit here")
-        else:
-            if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
-                return {"The Exam Office ID and CSR Office ID do not match!"}, 403
+        
+        if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
+            return {"The Exam Office ID and CSR Office ID do not match!"}, 403   
+        
+        if exam.is_pesticide:
+            formatted_data = self.format_data(json_data, exam)
+            exam = formatted_data["exam"]
+            job = self.bcmp_service.check_exam_status(exam)
+            print(job)
+            if job and job['jobProperties'] and job['jobProperties']['JOB_ID']:
+                exam.event_id = job['jobProperties']['JOB_ID']
 
         db.session.add(exam)
         db.session.commit()
@@ -81,3 +70,64 @@ def post(self):
 
         return {"exam": result.data,
                 "errors": result.errors}, 201
+
+
+
+    ## formating data to save on bcmp
+    def format_data(self, json_data, exam):
+
+        candidates_list_bcmp = []
+
+        pesticide_office = None
+        if json_data["sbc_managed"] == "sbc":
+            pesticide_office = Office.query.filter_by(office_id=exam.office_id).first()
+        else:
+            pesticide_office = Office.query.filter_by(office_name="Pesticide Offsite").first()
+            exam.office_id = pesticide_office.office_id
+
+        if json_data["ind_or_group"] == "individual":
+        
+            exam_type = ExamType.query.filter_by(exam_type_id=exam.exam_type_id).first()
+
+            if not exam_type:
+                exam_type = ExamType.query.filter_by(pesticide_exam_ind=1, group_exam_ind=1).first()
+            exam.exam_type = exam_type
+
+        else:
+            logging.info("For Group Exams")
+
+            exam_type = ExamType.query.filter_by(exam_type_name="Group Pesticide Exam").first()
+            if exam_type:
+                exam.exam_type_id = exam_type.exam_type_id
+                exam.exam_type = exam_type
+
+            if json_data["candidates"]:
+                candidates = json_data["candidates"]
+                candidates_list = []
+                for candidate in candidates:
+                    candidate_temp = {}
+                    candidate_temp["examinee_name"] = candidate["name"]
+                    candidate_temp["examinee_email"] = candidate["email"]
+                    candidate_temp["exam_type_id"] = candidate["exam_type_id"]
+                    candidate_temp["fees"] = candidate["fees"]
+                    candidate_temp["payee_ind"] = 1 if (candidate["billTo"] == "candidate") else 0
+                    candidate_temp["receipt"] = candidate["receipt"]
+                    candidate_temp["receipt_number"] = candidate["receipt"]
+                    candidate_temp["payee_name"] = candidate["payeeName"]
+                    candidate_temp["payee_email"] = candidate["payeeEmail"]
+                    candidates_list.append(candidate_temp)
+                    # for bcmp service
+                    candidates_bcmp = copy.deepcopy(candidate_temp)
+                    exam_type = ExamType.query.filter_by(exam_type_id=candidate["exam_type_id"]).first()
+                    if exam_type.exam_type_name:
+                        candidates_bcmp["exam_type"] = exam_type.exam_type_name
+                    candidates_list_bcmp.append(candidates_bcmp)
+
+                exam.candidates_list = candidates_list
+        
+        return { 
+            'exam': exam, 
+            'candidates_list_bcmp': candidates_list_bcmp, 
+            'pesticide_office': pesticide_office,
+        }
+
diff --git a/api/app/resources/bookings/exam/exam_transfer.py b/api/app/resources/bookings/exam/exam_transfer.py
index c03ab3d16..18ee2b6d1 100644
--- a/api/app/resources/bookings/exam/exam_transfer.py
+++ b/api/app/resources/bookings/exam/exam_transfer.py
@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g
-from flask_restplus import Resource
+from flask_restx import Resource
 import logging
 from sqlalchemy import exc
 from app.models.theq import CSR
@@ -37,8 +37,14 @@ def post(self, exam_id):
             if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
                 return {"The Exam Office ID and CSR Office ID do not match!"}, 403
 
-            self.bcmp_service.send_exam_to_bcmp(exam)
-            return {}
+            bcmp_response = self.bcmp_service.send_exam_to_bcmp(exam)
+
+            if bcmp_response:
+                return {"bcmp": bcmp_response,
+                "errors": {}}, 202
+            else:
+                return {"message": "create_group_exam_bcmp failed",
+                    "error": bcmp_response}, 403
 
         except exc.SQLAlchemyError as error:
             logging.error(error, exc_info=True)
diff --git a/api/app/resources/bookings/exam/exam_upload.py b/api/app/resources/bookings/exam/exam_upload.py
index 70b0deb41..9ea15710a 100644
--- a/api/app/resources/bookings/exam/exam_upload.py
+++ b/api/app/resources/bookings/exam/exam_upload.py
@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g, request
-from flask_restplus import Resource
+from flask_restx import Resource
 import logging
 from sqlalchemy import exc
 from app.models.theq import CSR
diff --git a/api/app/resources/bookings/invigilator/invigilator_list.py b/api/app/resources/bookings/invigilator/invigilator_list.py
index ddc362312..66cadb3ae 100644
--- a/api/app/resources/bookings/invigilator/invigilator_list.py
+++ b/api/app/resources/bookings/invigilator/invigilator_list.py
@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 import logging
-from flask import g
+from flask import request, g
 from flask_restx import Resource
 from sqlalchemy import exc
 from app.models.bookings import Invigilator
@@ -44,24 +44,3 @@ def get(self):
             logging.error(error, exc_info=True)
             return {"message": "api is down"}, 500
 
-@api.route("/pesticide_invigilators/", methods=["GET"])
-class InvigilatorList(Resource):
-
-    invigilator_schema = InvigilatorSchema(many=True)
-
-    @oidc.accept_token(require_token=True)
-    def get(self):
-
-        csr = CSR.find_by_username(g.oidc_token_info['username'])
-
-        try:
-            invigilators = Invigilator.query.filter_by(office_id=csr.office_id)\
-                                            .filter(Invigilator.deleted.is_(None))
-
-            result = self.invigilator_schema.dump(invigilators)
-            return {'invigilators': result.data,
-                    'errors': result.errors}, 200
-
-        except exc.SQLAlchemyError as error:
-            logging.error(error, exc_info=True)
-            return {"message": "api is down"}, 500
diff --git a/api/app/resources/bookings/invigilator/invigilator_list_offsite.py b/api/app/resources/bookings/invigilator/invigilator_list_offsite.py
new file mode 100644
index 000000000..74d241390
--- /dev/null
+++ b/api/app/resources/bookings/invigilator/invigilator_list_offsite.py
@@ -0,0 +1,48 @@
+'''Copyright 2018 Province of British Columbia
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.'''
+
+import logging
+from flask import request, g
+from flask_restx import Resource
+from sqlalchemy import exc
+from app.models.bookings import Invigilator
+from app.models.theq import CSR, Office
+from app.schemas.bookings import InvigilatorSchema
+from qsystem import api, oidc
+
+
+@api.route("/invigilators/offsite/", methods=["GET"])
+class InvigilatorListOffsiteGet(Resource):
+
+    invigilator_schema = InvigilatorSchema(many=True)
+
+    @oidc.accept_token(require_token=True)
+    def get(self):
+
+        csr = CSR.find_by_username(g.oidc_token_info['username'])
+
+        pesticide_office = Office.query.filter_by(office_name="Pesticide Offsite").first()
+
+        try:
+            invigilators = Invigilator.query.filter_by(office_id=pesticide_office.office_id)\
+                                            .filter(Invigilator.deleted.is_(None))
+
+            result = self.invigilator_schema.dump(invigilators)
+            return {'invigilators': result.data,
+                    'errors': result.errors}, 200
+
+        except exc.SQLAlchemyError as error:
+            logging.error(error, exc_info=True)
+            return {"message": "api is down"}, 500
+
diff --git a/api/app/resources/theq/citizen/citizen_generic_invite.py b/api/app/resources/theq/citizen/citizen_generic_invite.py
index d5911cde0..60d7b996e 100644
--- a/api/app/resources/theq/citizen/citizen_generic_invite.py
+++ b/api/app/resources/theq/citizen/citizen_generic_invite.py
@@ -15,9 +15,85 @@
 from filelock import FileLock
 from flask import g, request
 from flask_restx import Resource
-from qsystem import api, api_call_with_retry, db, oidc, socketio, my_print
+from qsystem import api, api_call_with_retry, db, oidc, socketio, my_print, get_key
 from app.models.theq import Citizen, CSR, CitizenState, Period, PeriodState, ServiceReq, SRState
 from app.schemas.theq import CitizenSchema
+from datetime import datetime
+from pprint import pprint
+
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def csr_find_by_user():
+    csr = CSR.find_by_username(g.oidc_token_info['username'])
+    return csr
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_active():
+    active_citizen_state = CitizenState.query.filter_by(cs_state_name='Active').first()
+    return active_citizen_state
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_wait():
+    waiting_period_state = PeriodState.get_state_by_name("Waiting")
+    return waiting_period_state
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_citizen(counter_id, active_citizen_state, csr, waiting_period_state):
+    citizen = Citizen.query \
+        .filter_by(counter_id=counter_id, cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
+        .join(Citizen.service_reqs) \
+        .join(ServiceReq.periods) \
+        .filter_by(ps_id=waiting_period_state.ps_id) \
+        .filter(Period.time_end.is_(None)) \
+        .order_by(Citizen.priority, Citizen.citizen_id) \
+        .first()
+    return citizen
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_citizen2(active_citizen_state, csr, waiting_period_state):
+    citizen = Citizen.query \
+        .filter_by(cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
+        .join(Citizen.service_reqs) \
+        .join(ServiceReq.periods) \
+        .filter_by(ps_id=waiting_period_state.ps_id) \
+        .filter(Period.time_end.is_(None)) \
+        .order_by(Citizen.priority, Citizen.citizen_id) \
+        .first()
+    return citizen
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_active_sr(citizen):
+    active_service_request = citizen.get_active_service_request()
+    return active_service_request
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def invite_active_sr(active_service_request,csr,citizen):
+    active_service_request.invite(csr, invite_type="generic", sr_count=len(citizen.service_reqs))
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_active_ss():
+    active_service_state = SRState.get_state_by_name("Active")
+    return active_service_state
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_active_sr(citizen):
+    active_service_request = citizen.get_active_service_request()
+    return active_service_request
+
+@oidc.accept_token(require_token=True)
+@api_call_with_retry
+def find_active_sr(citizen):
+    active_service_request = citizen.get_active_service_request()
+    return active_service_request
 
 @api.route("/citizens/invite/", methods=['POST'])
 class CitizenGenericInvite(Resource):
@@ -26,16 +102,26 @@ class CitizenGenericInvite(Resource):
     citizens_schema = CitizenSchema(many=True)
 
     @oidc.accept_token(require_token=True)
-    @api_call_with_retry
+    #@api_call_with_retry
     def post(self):
-
-        csr = CSR.find_by_username(g.oidc_token_info['username'])
+        #print("==> In Python /citizens/invitetest")
+        y = 0
+        #for x in range(0, 25):
+        key = "DR->" + get_key()
+        #print("")
+        y = y + 1
+        #print("DATETIME:", datetime.now(), "starting loop:", y, "==>Key : ", key)
+        csr = csr_find_by_user()
+        #print("DATETIME:", datetime.now(), "==>Key : ", key,"===>AFTER CALL TO csr_find_by_user:", csr)
         lock = FileLock("lock/invite_citizen_{}.lock".format(csr.office_id))
-
         with lock:
 
-            active_citizen_state = CitizenState.query.filter_by(cs_state_name='Active').first()
-            waiting_period_state = PeriodState.get_state_by_name("Waiting")
+            #active_citizen_state = find_active()
+            active_citizen_state = citizen_state
+            #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_Active:", active_citizen_state)
+
+            waiting_period_state = find_wait()
+            #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_wait:", waiting_period_state)
             citizen = None
             json_data = request.get_json()
 
@@ -44,25 +130,13 @@ def post(self):
             else:
                 counter_id = int(csr.counter_id)
 
-            citizen = Citizen.query \
-                .filter_by(counter_id=counter_id, cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
-                .join(Citizen.service_reqs) \
-                .join(ServiceReq.periods) \
-                .filter_by(ps_id=waiting_period_state.ps_id) \
-                .filter(Period.time_end.is_(None)) \
-                .order_by(Citizen.priority, Citizen.citizen_id) \
-                .first()
+            citizen = find_citizen(counter_id,active_citizen_state, csr, waiting_period_state)
+            #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_citizen:", citizen)
 
             # If no matching citizen with the same counter type, get next one
             if citizen is None:
-                citizen = Citizen.query \
-                    .filter_by(cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
-                    .join(Citizen.service_reqs) \
-                    .join(ServiceReq.periods) \
-                    .filter_by(ps_id=waiting_period_state.ps_id) \
-                    .filter(Period.time_end.is_(None)) \
-                    .order_by(Citizen.priority, Citizen.citizen_id) \
-                    .first()
+                citizen = find_citizen2(active_citizen_state, csr, waiting_period_state)
+                #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_citizen2:", citizen)
 
             if citizen is None:
                 return {"message": "There is no citizen to invite"}, 400
@@ -70,16 +144,21 @@ def post(self):
             my_print("==> POST /citizens/invite/ Citizen: " + str(citizen.citizen_id) + ', Ticket: ' + citizen.ticket_number)
 
             db.session.refresh(citizen)
-            active_service_request = citizen.get_active_service_request()
+
+            active_service_request = find_active_sr(citizen)
+            #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_active_sr:", citizen)
 
             try:
-                active_service_request.invite(csr, invite_type="generic", sr_count = len(citizen.service_reqs))
+                invite_active_sr(active_service_request,csr,citizen)
+                #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO invite_active_sr:")
+
             except TypeError:
                 return {"message": "Error inviting citizen. Please try again."}, 400
 
-            active_service_state = SRState.get_state_by_name("Active")
-            active_service_request.sr_state_id = active_service_state.sr_state_id
 
+            active_service_state = find_active_ss()
+            #print("DATETIME:", datetime.now(), "==>Key : ", key, "===>AFTER CALL TO find_active_ss:", active_service_state)
+            active_service_request.sr_state_id = active_service_state.sr_state_id
             db.session.add(citizen)
             db.session.commit()
 
@@ -88,5 +167,15 @@ def post(self):
             result = self.citizen_schema.dump(citizen)
             socketio.emit('update_active_citizen', result.data, room=csr.office_id)
 
+            #print("DATETIME:", datetime.now(), "end loop:     ", y , "==>Key : ", key)
+
         return {'citizen': result.data,
                 'errors': result.errors}, 200
+
+try:
+    citizen_state = CitizenState.query.filter_by(cs_state_name="Active").first()
+    active_id = citizen_state.cs_id
+except:
+    active_id = 1
+    print("==> In citizen_generic_invite.py")
+    print("    --> NOTE!!  You should only see this if doing a 'python3 manage.py db upgrade'")
diff --git a/api/app/resources/theq/citizen/citizen_generic_invite_original.py b/api/app/resources/theq/citizen/citizen_generic_invite_original.py
new file mode 100644
index 000000000..7cb06f1dc
--- /dev/null
+++ b/api/app/resources/theq/citizen/citizen_generic_invite_original.py
@@ -0,0 +1,142 @@
+'''Copyright 2018 Province of British Columbia
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.'''
+
+from filelock import FileLock
+from flask import g, request
+from flask_restx import Resource
+from qsystem import api, api_call_with_retry, db, oidc, socketio, my_print
+from app.models.theq import Citizen, CSR, CitizenState, Period, PeriodState, ServiceReq, SRState
+from app.schemas.theq import CitizenSchema
+
+@api.route("/citizens/invite/", methods=['POST'])
+class CitizenGenericInvite(Resource):
+
+    citizen_schema = CitizenSchema()
+    citizens_schema = CitizenSchema(many=True)
+
+    @oidc.accept_token(require_token=True)
+    @api_call_with_retry
+    def post(self):
+
+        line = 0
+        print("==> In Python /citizens/invite")
+        line = line + 1
+        print("    --> Line: " + str(line))
+        csr = CSR.find_by_username(g.oidc_token_info['username'])
+        line = line + 1
+        print("    --> Line: " + str(line))
+        lock = FileLock("lock/invite_citizen_{}.lock".format(csr.office_id))
+        line = line + 1
+        print("    --> Line: " + str(line))
+
+        with lock:
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            active_citizen_state = CitizenState.query.filter_by(cs_state_name='Active').first()
+            line = line + 1
+            print("    --> Line: " + str(line))
+            waiting_period_state = PeriodState.get_state_by_name("Waiting")
+            line = line + 1
+            print("    --> Line: " + str(line))
+            citizen = None
+            line = line + 1
+            print("    --> Line: " + str(line))
+            json_data = request.get_json()
+            line = line + 1
+            print("    --> Line: " + str(line))
+
+            if json_data and 'counter_id' in json_data:
+                counter_id = int(json_data.get('counter_id'))
+            else:
+                counter_id = int(csr.counter_id)
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            citizen = Citizen.query \
+                .filter_by(counter_id=counter_id, cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
+                .join(Citizen.service_reqs) \
+                .join(ServiceReq.periods) \
+                .filter_by(ps_id=waiting_period_state.ps_id) \
+                .filter(Period.time_end.is_(None)) \
+                .order_by(Citizen.priority, Citizen.citizen_id) \
+                .first()
+
+            # If no matching citizen with the same counter type, get next one
+            line = line + 1
+            print("    --> Line: " + str(line))
+            if citizen is None:
+                citizen = Citizen.query \
+                    .filter_by(cs_id=active_citizen_state.cs_id, office_id=csr.office_id) \
+                    .join(Citizen.service_reqs) \
+                    .join(ServiceReq.periods) \
+                    .filter_by(ps_id=waiting_period_state.ps_id) \
+                    .filter(Period.time_end.is_(None)) \
+                    .order_by(Citizen.priority, Citizen.citizen_id) \
+                    .first()
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            if citizen is None:
+                return {"message": "There is no citizen to invite"}, 400
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            my_print("==> POST /citizens/invite/ Citizen: " + str(citizen.citizen_id) + ', Ticket: ' + citizen.ticket_number)
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            db.session.refresh(citizen)
+            line = line + 1
+            print("    --> Line: " + str(line))
+            active_service_request = citizen.get_active_service_request()
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            try:
+                active_service_request.invite(csr, invite_type="generic", sr_count = len(citizen.service_reqs))
+            except TypeError:
+                return {"message": "Error inviting citizen. Please try again."}, 400
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            active_service_state = SRState.get_state_by_name("Active")
+            line = line + 1
+            print("    --> Line: " + str(line))
+            active_service_request.sr_state_id = active_service_state.sr_state_id
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            db.session.add(citizen)
+            line = line + 1
+            print("    --> Line: " + str(line))
+            db.session.commit()
+
+            line = line + 1
+            print("    --> Line: " + str(line))
+            socketio.emit('update_customer_list', {}, room=csr.office_id)
+            line = line + 1
+            print("    --> Line: " + str(line))
+            socketio.emit('citizen_invited', {}, room='sb-%s' % csr.office.office_number)
+            line = line + 1
+            print("    --> Line: " + str(line))
+            result = self.citizen_schema.dump(citizen)
+            line = line + 1
+            print("    --> Line: " + str(line))
+            socketio.emit('update_active_citizen', result.data, room=csr.office_id)
+
+        line = line + 1
+        print("    --> Line: " + str(line))
+        return {'citizen': result.data,
+                'errors': result.errors}, 200
diff --git a/api/app/resources/theq/csrs.py b/api/app/resources/theq/csrs.py
index 9a85d2930..3fbd39f9c 100644
--- a/api/app/resources/theq/csrs.py
+++ b/api/app/resources/theq/csrs.py
@@ -101,7 +101,7 @@ def get(self):
                     if exam.booking is not None:
                         attention_needed = attention_needed or exam.booking.start_time < start_date
                     if exam.expiry_date is not None:
-                        attention_needed = attention_needed or exam.expiry_date < start_date
+                        attention_needed = attention_needed or self.timezone.localize(exam.expiry_date) < start_date
                     if exam.exam_returned_date is not None:
                         attention_needed = False
                     if attention_needed:
@@ -113,9 +113,12 @@ def get(self):
             if not attention_needed:
                 for exam in office_exams:
                     if exam.exam_type.group_exam_ind == 1:
-                        attention_needed = attention_needed or exam.booking.start_time < start_date
+                        if exam.booking is not None:
+                            attention_needed = attention_needed or exam.booking.start_time < start_date
+                        else:
+                            attention_needed = True
                         if exam.expiry_date is not None:
-                            attention_needed = attention_needed or exam.expiry_date < start_date
+                            attention_needed = attention_needed or self.timezone.localize(exam.expiry_date) < start_date
                         if exam.booking is not None and exam.number_of_students is not None:
                             attention_needed = attention_needed or exam.booking.start_time < start_date
                             attention_needed = attention_needed or (len(exam.booking.invigilators) < 1
diff --git a/api/app/resources/theq/websocket.py b/api/app/resources/theq/websocket.py
index f6ceea605..2bbc6f0fe 100644
--- a/api/app/resources/theq/websocket.py
+++ b/api/app/resources/theq/websocket.py
@@ -37,6 +37,7 @@ def on_join(message):
         csr = CSR.find_by_username(claims["preferred_username"])
         if csr:
             join_room(csr.office_id)
+            print("==> In websocket.py, CSR joinroom, CSR: " + csr.username + "; request sid: " + str(request.sid))
             emit('joinRoomSuccess', {"sucess": True})
             emit('get_Csr_State_IDs', {"success": True})
             emit('update_customer_list', {"success": True})
@@ -56,6 +57,7 @@ def on_join_smartboard(message):
         my_print("Joining room: %s" % room)
 
         join_room(room)
+        print("==> In websocket.py, Smartboard joinroom, Office id: " + str(office_id) + "; request sid: " + str(request.sid))
         emit('joinSmartboardRoomSuccess')
     except KeyError as e:
         print(e)
diff --git a/api/app/schemas/bookings/__init__.py b/api/app/schemas/bookings/__init__.py
index 0c4d93d49..92f28d0bb 100644
--- a/api/app/schemas/bookings/__init__.py
+++ b/api/app/schemas/bookings/__init__.py
@@ -16,7 +16,7 @@
 from app.schemas.bookings.exam_type_schema import ExamTypeSchema
 from app.schemas.bookings.room_schema import RoomSchema
 from app.schemas.bookings.booking_schema import BookingSchema
-from app.schemas.bookings.exam_schema import ExamSchema
+from app.schemas.bookings.exam_schema import ExamSchema, CandidateSchema
 from app.schemas.bookings.appointment_schema import AppointmentSchema
 
 
diff --git a/api/app/schemas/bookings/exam_schema.py b/api/app/schemas/bookings/exam_schema.py
index 1c6fd6e82..20ac55fe4 100644
--- a/api/app/schemas/bookings/exam_schema.py
+++ b/api/app/schemas/bookings/exam_schema.py
@@ -15,11 +15,23 @@
 from marshmallow import fields
 import toastedmarshmallow
 from app.models.bookings import Exam
-from app.schemas.bookings import BookingSchema, ExamTypeSchema
+from app.schemas.bookings import BookingSchema, ExamTypeSchema, InvigilatorSchema
 from app.schemas.theq import OfficeSchema
 from qsystem import ma
 
 
+class CandidateSchema(ma.Schema):
+    examinee_name = fields.String()
+    examinee_email = fields.String()
+    exam_type_id = fields.String()
+    fees = fields.String()
+    payee_ind = fields.String()
+    receipt = fields.String()
+    receipt_number = fields.String()
+    payee_name = fields.String()
+    payee_email = fields.String()
+
+
 class ExamSchema(ma.ModelSchema):
 
     class Meta:
@@ -36,25 +48,36 @@ class Meta:
     exam_received_date = fields.DateTime(allow_none=True)
     exam_type_id = fields.Int()
     examinee_name = fields.Str()
+    examinee_phone = fields.Str()
+    examinee_email = fields.Str()
     expiry_date = fields.DateTime()
     notes = fields.Str(allow_none=True)
     number_of_students = fields.Int()
     office_id = fields.Int()
+    invigilator_id = fields.Int()
     session_number = fields.Int()
+    exam_returned_ind = fields.Int()
     exam_returned_date = fields.Str(allow_none=True)
-    exam_returned_tracking_number = fields.String(allow_none=True)
+    exam_returned_tracking_number = fields.Str(allow_none=True)
     exam_written_ind = fields.Int()
-    offsite_location = fields.String()
+    upload_received_ind = fields.Int()
+    offsite_location = fields.Str()
     sbc_managed_ind = fields.Int()
-    receipt = fields.String()
+    receipt = fields.Str()
+    receipt_number = fields.Str()
+    fees = fields.Str()
     payee_ind = fields.Int()
     receipt_sent_ind = fields.Int()
-    payee_name = fields.String()
-    payee_email = fields.String()
-    payee_phone = fields.String()
+    payee_name = fields.Str()
+    payee_email = fields.Str()
+    payee_phone = fields.Str()
+    bcmp_job_id = fields.Str(allow_none=True)
+    is_pesticide = fields.Int(allow_none=True)
+    candidates_list = fields.Nested(CandidateSchema)
 
     booking = fields.Nested(BookingSchema())
     exam_type = fields.Nested(ExamTypeSchema())
+    invigilator = fields.Nested(InvigilatorSchema())
     office = fields.Nested(OfficeSchema(only=('appointments_enabled_ind', 'exams_enabled_ind', 'office_id',
                                               'office_name', 'office_number', 'timezone')))
 
diff --git a/api/app/utilities/bcmp_service.py b/api/app/utilities/bcmp_service.py
index 683d6fc66..85cbb8e8d 100644
--- a/api/app/utilities/bcmp_service.py
+++ b/api/app/utilities/bcmp_service.py
@@ -3,6 +3,7 @@
 import urllib
 from qsystem import application
 from app.utilities.document_service import DocumentService
+from datetime import datetime
 
 
 class BCMPService:
@@ -11,6 +12,9 @@ class BCMPService:
 
     def __init__(self):
         return
+    
+    def __exam_time_format(self, date_value):
+        return date_value.strftime("%a %b %d, %Y at %-I:%M %p")
 
     def send_request(self, path, method, data):
         if method == 'POST':
@@ -28,15 +32,13 @@ def send_request(self, path, method, data):
         print(req)
 
         response = urllib.request.urlopen(req)
+        
 
-        print('response')
-        print(response.status)
-
-        response_data = response.read().decode('utf-8')
+        response_data = response.read().decode('utf8')
         print(response_data)
 
         try:
-            return json.loads(response.read().decode('utf-8'))
+            return json.loads(response_data)
         except json.decoder.JSONDecodeError:
             logging.warning("Error decoding JSON response data. Response data: %s" % response_data)
             return False
@@ -49,13 +51,12 @@ def check_exam_status(self, exam):
             ]
         }
         response = self.send_request(url, 'POST', data)
-        print(response)
 
-        if response:
+        if response and response['jobs']:
             for job in response['jobs']:
                 print(job)
                 if job['jobId'] == exam.bcmp_job_id:
-                    return job['jobStatus']
+                    return job
 
         return False
 
@@ -73,18 +74,91 @@ def bulk_check_exam_status(self, exams):
 
         return response
 
-    def create_individual_exam(self, exam, exam_type):
+    def create_individual_exam(self, exam, exam_fees, invigilator, pesticide_office, oidc_token_info):
         url = "%s/auth=env_exam;%s/JSON/create:ENV-IPM-EXAM" % (self.base_url, self.auth_token)
+
+        office_name = None
+        if pesticide_office:
+            office_name = pesticide_office.office_name
+
+        receipt_number = "%s fees" % exam_fees
+        if exam.receipt:
+            receipt_number = exam.receipt
+        
+        exam_type_name = None
+        if exam.exam_type:
+            exam_type_name = exam.exam_type.exam_type_name
+
+        invigilator_name = None
+        if invigilator:
+            invigilator_name = invigilator.invigilator_name
+
         bcmp_exam = {
-            "category": exam_type.exam_type_name,
+            "EXAM_SESSION_LOCATION" : office_name,
+            "SESSION_DATE_TIME" : self.__exam_time_format(exam.expiry_date),
+            "REGISTRAR_name" : oidc_token_info['preferred_username'],
+            "RECIPIENT_EMAIL_ADDRESS" : oidc_token_info['email'],
+            "REGISTRAR_phoneNumber" : "",
             "students": [
-                {"name": exam.examinee_name}
+                {
+                    "REGISTRAR_name": invigilator_name,
+                    "EXAM_CATEGORY": exam_type_name,
+                    "STUDENT_LEGAL_NAME_first": exam.examinee_name,
+                    "STUDENT_LEGAL_NAME_last": exam.examinee_name,
+                    "STUDENT_emailAddress": exam.examinee_email,
+                    "STUDENT_phoneNumber": exam.examinee_phone,
+                    "REGISTRATION_NOTES": exam.notes,
+                    "RECEIPT_RMS_NUMBER": receipt_number
+                }
             ]
         }
 
         response = self.send_request(url, 'POST', bcmp_exam)
         return response
 
+    def create_group_exam_bcmp(self, exam, candiate_list, invigilator, pesticide_office, oidc_token_info):
+        url = "%s/auth=env_exam;%s/JSON/create:ENV-IPM-EXAM-GROUP" % (self.base_url, self.auth_token)
+
+        invigilator_name = None
+        if invigilator:
+            invigilator_name = invigilator.invigilator_name
+
+        office_name = None
+        if pesticide_office:
+            office_name = pesticide_office.office_name
+
+        print(exam.expiry_date.strftime("%a %b %d, %Y at %-I:%M %p"))
+        
+        bcmp_exam = {
+            "EXAM_SESSION_LOCATION": office_name,
+            "SESSION_DATE_TIME" : self.__exam_time_format(exam.expiry_date),
+            "REGISTRAR_name" : oidc_token_info['preferred_username'],
+            "RECIPIENT_EMAIL_ADDRESS" : oidc_token_info['email'],
+            "REGISTRAR_phoneNumber": "",
+            "students": []
+        }
+
+        for candiate in candiate_list:
+            bcmp_exam["students"].append({
+                "EXAM_CATEGORY": candiate["exam_type"],
+                "STUDENT_LEGAL_NAME_first": candiate["examinee_name"],
+                "STUDENT_LEGAL_NAME_last": candiate["examinee_name"],
+                "STUDENT_emailAddress": candiate["examinee_email"],
+                "STUDENT_phoneNumber": "",
+                "STUDENT_ADDRESS_line1": "",
+                "STUDENT_ADDRESS_line2": "",
+                "STUDENT_ADDRESS_city": "",
+                "STUDENT_ADDRESS_province": "",
+                "STUDENT_ADDRESS_postalCode": "",
+                "REGISTRATION_NOTES": "",
+                "RECEIPT_RMS_NUMBER": candiate["receipt"],
+                "PAYMENT_METHOD": candiate["fees"],
+                "FEE_PAYMENT_NOTES": ""
+            })
+
+        response = self.send_request(url, 'POST', bcmp_exam)
+        return response
+
     def create_group_exam(self, exam):
         url = "%s/auth=env_exam;%s/JSON/create:ENV-IPM-EXAM" % (self.base_url, self.auth_token)
 
@@ -120,7 +194,8 @@ def send_exam_to_bcmp(self, exam):
             }
         }
 
-        self.send_request(url, "POST", json_data)
+        response = self.send_request(url, 'POST', json_data)
+        return response
 
     def email_exam_invigilator(self, exam, invigilator_name, invigilator_email, invigilator_phone):
         url = "%s/auth=env_exam;%s/JSON/create:ENV-IPM-EXAM-API-ACTION" % (self.base_url, self.auth_token)
diff --git a/api/app/utilities/document_service.py b/api/app/utilities/document_service.py
index e2e9064d6..c885741b2 100644
--- a/api/app/utilities/document_service.py
+++ b/api/app/utilities/document_service.py
@@ -47,12 +47,12 @@ def __init__(self, host, bucket, access_key, secret_key, use_secure):
 
     def get_presigned_put_url(self, object_name):
         """Retrieves the a presigned URL for putting objects into an S3 source"""
-        url = self.client.presigned_put_object(self.bucket, object_name, expires=timedelta(minutes=30))
+        url = self.client.presigned_put_object(self.bucket, object_name, expires=timedelta(days=7))
 
         return url
 
     def get_presigned_get_url(self, object_name):
         """Retrieves the presigned URL for GETting objects out of an S3 source"""
-        url = self.client.presigned_get_object(self.bucket, object_name, expires=timedelta(minutes=30))
+        url = self.client.presigned_get_object(self.bucket, object_name, expires=timedelta(days=7))
 
         return url
diff --git a/api/config.py b/api/config.py
index 3a567e2ab..d2a37540b 100644
--- a/api/config.py
+++ b/api/config.py
@@ -1,6 +1,7 @@
 import logging
 import os
 import dotenv
+from pprint import pprint
 
 # Load all the environment variables from a .env file located in some directory above.
 dotenv.load_dotenv(dotenv.find_dotenv())
@@ -64,37 +65,87 @@ class BaseConfig(object):
     DB_NAME = os.getenv('DATABASE_NAME','')
     DB_HOST = os.getenv('DATABASE_HOST','')
     DB_PORT = os.getenv('DATABASE_PORT','')
-    DB_TIMEOUT_STRING = os.getenv('DATABASE_TIMEOUT_STRING', '')
-    SQLALCHEMY_DATABASE_URI = '{engine}://{user}:{password}@{host}:{port}/{name}{timeout}'.format(
+    DB_POOL_TIMEOUT = os.getenv('DATABASE_TIMEOUT_STRING', '')
+    DB_CONNECT_TIMEOUT = os.getenv('DATABASE_CONNECT_TIMEOUT_STRING', '')
+
+    SQLALCHEMY_DATABASE_URI = '{engine}://{user}:{password}@{host}:{port}/{name}'.format(
         engine=DB_ENGINE,
         user=DB_USER,
         password=DB_PASSWORD,
         host=DB_HOST,
         port=DB_PORT,
         name=DB_NAME,
-        timeout=DB_TIMEOUT_STRING
     )
 
-    SQLALCHEMY_DATABASE_URI_DISPLAY = '{engine}://{user}:<password>@{host}:{port}/{name}{timeout}'.format(
+    SQLALCHEMY_DATABASE_URI_DISPLAY = '{engine}://{user}:<password>@{host}:{port}/{name}'.format(
         engine=DB_ENGINE,
         user=DB_USER,
         host=DB_HOST,
         port=DB_PORT,
         name=DB_NAME,
-        timeout=DB_TIMEOUT_STRING
     )
 
     #  Get SQLAlchemy environment variables.
     pool_size = int(os.getenv('SQLALCHEMY_POOL_SIZE', '9'))
     max_overflow = int(os.getenv('SQLALCHEMY_MAX_OVERFLOW', '18'))
+    # db_timeout = int(os.getenv('SQLALCHEMY_TIMEOUT', '10'))
+
+    # Karims settings
+    # SQLALCHEMY_ENGINE_OPTIONS = {
+    #     'pool_size': pool_size,
+    #     'max_overflow': max_overflow,
+    #     'pool_pre_ping': True,
+    #     'pool_timeout': 5,
+    #     'pool_recycle': 3600,
+    #     'connect_args': {
+    #         'connect_timeout': 3
+    #     }
+    # }
+
+    #  Try to set some options to avoid long delays.
+    # SQLALCHEMY_ENGINE_OPTIONS  = {
+    #     'pool_size' : pool_size,
+    #     'max_overflow' : max_overflow,
+    #     'pool_pre_ping' : True,
+    #     'pool_timeout': DB_POOL_TIMEOUT,
+    #     'pool_recycle': 3600,
+    #     'connect_args': {
+    #         'connect_timeout': DB_CONNECT_TIMEOUT,
+    #         'options' : '-c statement_timeout=1000'
+    #     }
+    # }
+
+    #  Get SQLAlchemy environment variables.
+    pool_size = int(os.getenv('SQLALCHEMY_POOL_SIZE', '9'))
+    pool_timeout = os.getenv('SQLALCHEMY_POOL_TIMEOUT', '')
+    connect_timeout_string = os.getenv('SQLALCHEMY_CONNECT_TIMEOUT', '')
+    max_overflow = int(os.getenv('SQLALCHEMY_MAX_OVERFLOW', '18'))
+    pool_pre_ping = (os.getenv('SQLALCHEMY_POOL_PRE_PING', 'False')).upper() == "TRUE"
 
     #  Try to set some options to avoid long delays.
     SQLALCHEMY_ENGINE_OPTIONS = {
-        'pool_size' : pool_size,
-        'max_overflow' : max_overflow,
-        'pool_pre_ping' : False
+        'pool_size': pool_size,
+        'max_overflow': max_overflow,
+        'pool_pre_ping': pool_pre_ping
     }
 
+    if pool_timeout != "":
+        SQLALCHEMY_ENGINE_OPTIONS['pool_timeout'] = pool_timeout
+
+    if connect_timeout_string != "":
+        connect_timeout = int(connect_timeout_string)
+
+        #   Determine which database engine being used, to use correct syntax.
+        if "PG8000" in DB_ENGINE.upper():
+            SQLALCHEMY_ENGINE_OPTIONS['connect_args'] = {'timeout': connect_timeout}
+            # SQLALCHEMY_ENGINE_OPTIONS['connect_args'] = {'timeout': connect_timeout, 'tcp_user_timeout': 500 }
+        else:
+            # SQLALCHEMY_ENGINE_OPTIONS['connect_args'] = { 'connect_timeout': connect_timeout, 'tcp_user_timeout': 500 }
+            SQLALCHEMY_ENGINE_OPTIONS['connect_args'] = {'connect_timeout': connect_timeout}
+
+    print("==> SQLALCHEMY_ENGINE_OPTIONS (Engine: " + DB_ENGINE)
+    pprint(SQLALCHEMY_ENGINE_OPTIONS)
+
     #  Set echo appropriately.
     if (os.getenv('SQLALCHEMY_ECHO', "False")).upper() == "TRUE":
         SQLALCHEMY_ECHO=True
@@ -115,6 +166,17 @@ class BaseConfig(object):
     BACK_OFFICE_DISPLAY = os.getenv("BACK_OFFICE_DISPLAY", "BackOffice")
     RECURRING_FEATURE_FLAG = os.getenv("RECURRING_FEATURE_FLAG", "On")
 
+    MINIO_HOST = os.getenv('MINIO_HOST', 'localhost:9000')
+    MINIO_BUCKET = os.getenv('MINIO_BUCKET', 'exams')
+    MINIO_ACCESS_KEY = os.getenv('MINIO_ACCESS_KEY', 'minio')
+    MINIO_SECRET_KEY = os.getenv('MINIO_SECRET_KEY', 'minio1234')
+    MINIO_USE_SECURE = os.getenv('MINIO_USE_SECURE', 0)
+
+    #print(parse_dsn(("postgresql://localhost:5000?connect_timeout=10")))
+    #quote_ident("connect_timeout", scope)
+
+
+
 class LocalConfig(BaseConfig):
     DEBUG = True
     TESTING = False
@@ -147,13 +209,14 @@ class LocalConfig(BaseConfig):
         port=DB_PORT,
         name=DB_NAME
     )
-    BCMP_BASE_URL = 'https://bcmaildirect.gov.bc.ca/JOB_TEST'
-    BCMP_AUTH_TOKEN = 'f697697a090c4f349545a09d21b3eb08'
-    MINIO_HOST = 'localhost:9000'
-    MINIO_BUCKET = 'exams'
-    MINIO_ACCESS_KEY = 'minio'
-    MINIO_SECRET_KEY = 'minio1234'
-    MINIO_USE_SECURE = 0
+    BCMP_BASE_URL = os.getenv('BCMP_BASE_URL')
+    BCMP_AUTH_TOKEN = os.getenv('BCMP_AUTH_TOKEN')
+
+    MINIO_HOST = os.getenv('MINIO_HOST', 'localhost:9000')
+    MINIO_BUCKET = os.getenv('MINIO_BUCKET', 'exams')
+    MINIO_ACCESS_KEY = os.getenv('MINIO_ACCESS_KEY', 'minio')
+    MINIO_SECRET_KEY = os.getenv('MINIO_SECRET_KEY', 'minio1234')
+    MINIO_USE_SECURE = os.getenv('MINIO_USE_SECURE', 0)
 
 
 class DevelopmentConfig(BaseConfig):
@@ -164,8 +227,8 @@ class DevelopmentConfig(BaseConfig):
 
     USE_HTTPS = True
     PREFERRED_URL_SCHEME = 'https'
-    BCMP_BASE_URL = 'https://bcmaildirect.gov.bc.ca/JOB_TEST'
-    BCMP_AUTH_TOKEN = 'f697697a090c4f349545a09d21b3eb08'
+    BCMP_BASE_URL = os.getenv('BCMP_BASE_URL')
+    BCMP_AUTH_TOKEN = os.getenv('BCMP_AUTH_TOKEN')
 
 
 class TestConfig(BaseConfig):
@@ -176,8 +239,8 @@ class TestConfig(BaseConfig):
 
     USE_HTTPS = True
     PREFERRED_URL_SCHEME = 'https'
-    BCMP_BASE_URL = 'https://bcmaildirect.gov.bc.ca/JOB_TEST'
-    BCMP_AUTH_TOKEN = 'f697697a090c4f349545a09d21b3eb08'
+    BCMP_BASE_URL = os.getenv('BCMP_BASE_URL')
+    BCMP_AUTH_TOKEN = os.getenv('BCMP_AUTH_TOKEN')
 
 
 class ProductionConfig(BaseConfig):
@@ -188,8 +251,8 @@ class ProductionConfig(BaseConfig):
 
     USE_HTTPS = True
     PREFERRED_URL_SCHEME = 'https'
-    BCMP_BASE_URL = 'https://bcmaildirect.gov.bc.ca/JOB'
-    BCMP_AUTH_TOKEN = 'f697697a090c4f349545a09d21b3eb08'
+    BCMP_BASE_URL = os.getenv('BCMP_BASE_URL')
+    BCMP_AUTH_TOKEN = os.getenv('BCMP_AUTH_TOKEN')
 
 
 def configure_app(app):
diff --git a/api/gunicorn_config.py b/api/gunicorn_config.py
index c69f54257..1535f858c 100644
--- a/api/gunicorn_config.py
+++ b/api/gunicorn_config.py
@@ -16,7 +16,7 @@
 
 worker_class = 'eventlet'
 worker_connections = 500
-timeout = 60
+timeout = 10
 keepalive = 20
 
 def profiler_enable(worker, req):
diff --git a/api/manage.py b/api/manage.py
index d1714b79d..1186adf68 100644
--- a/api/manage.py
+++ b/api/manage.py
@@ -847,6 +847,16 @@ def run(self):
             group_exam_ind=0,
             pesticide_exam_ind=1,
         )
+        
+        exam_type_twenty_four = bookings.ExamType(
+            exam_type_name="Group Pesticide Exam",
+            exam_color="#FFFFFF",
+            number_of_hours=0,
+            method_type="written",
+            ita_ind=0,
+            group_exam_ind=1,
+            pesticide_exam_ind=0,
+        )
 
         db.session.add(exam_type_one)
         db.session.add(exam_type_two)
@@ -869,6 +879,7 @@ def run(self):
         db.session.add(exam_type_twenty_one)
         db.session.add(exam_type_twenty_two)
         db.session.add(exam_type_twenty_three)
+        db.session.add(exam_type_twenty_four)
         db.session.commit()
 
         print("--> Bookings: Exam - No exams added")
diff --git a/api/migrations/versions/89294ac623e8_.py b/api/migrations/versions/89294ac623e8_.py
new file mode 100644
index 000000000..b330631d4
--- /dev/null
+++ b/api/migrations/versions/89294ac623e8_.py
@@ -0,0 +1,27 @@
+"""empty message
+
+Revision ID: 89294ac623e8
+Revises: 05301cda7812
+Create Date: 2020-04-01 19:42:56.383186
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlalchemy_utc
+
+
+# revision identifiers, used by Alembic.
+revision = '89294ac623e8'
+down_revision = '05301cda7812'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column('exam', sa.Column('candidates_list', sa.JSON(), nullable=True))
+    op.add_column('exam', sa.Column('is_pesticide', sa.Integer(), nullable=True, default=0))
+
+
+def downgrade():
+    op.drop_column('exam', 'candidates_list')
+    op.drop_column('exam', 'is_pesticide')
diff --git a/api/qsystem.py b/api/qsystem.py
index 725550d87..2023e3191 100644
--- a/api/qsystem.py
+++ b/api/qsystem.py
@@ -22,10 +22,15 @@
 from sqlalchemy import event
 from sqlalchemy.engine import Engine
 
-
 def my_print(string):
     if print_flag:
-        print(string)
+        print(time_string() + string)
+
+def time_string():
+    now = datetime.datetime.now()
+    ms = now.strftime("%f")[:3]
+    now_string = now.strftime("%Y-%m-%d %H:%M:%S,")
+    return "[" + now_string + ms + "] "
 
 application = Flask(__name__, instance_relative_config=True)
 
@@ -49,7 +54,7 @@ def my_print(string):
 ma = Marshmallow(application)
 
 #   Set up socket io and rabbit mq.
-socketio = SocketIO(logger=socket_flag, engineio_logger=engine_flag,
+socketio = SocketIO(logger=socket_flag, engineio_logger=engine_flag,ping_timeout=6,ping_interval=3,
                     cors_allowed_origins=application.config['CORS_ALLOWED_ORIGINS'])
 
 if application.config['ACTIVE_MQ_URL'] is not None:
@@ -102,13 +107,14 @@ def my_print(string):
 #  Code to determine all db.engine properties and sub-properties, as necessary.
 if False:
     print("==> All DB Engine options")
-    for attr in dir(db.engine):
-        print("    --> db.engine." + attr + " = " + str(getattr(db.engine, attr)))
+    for attr in dir(db._engine_options.keys):
+        print("    --> db._engine_options.keys." + attr + " = " + str(getattr(db._engine_options.keys, attr)))
         # print("db.engine.%s = %s") % (attr, getattr(db.engine, attr))
 
 #  See whether options took.
 if print_flag:
      print("==> DB Engine options")
+     print("    --> db options:    " + str(db.engine))
      print("    --> pool size:    " + str(db.engine.pool.size()))
      print("    --> max overflow: " + str(db.engine.pool._max_overflow))
      print("    --> echo:         " + str(db.engine.echo))
@@ -135,7 +141,8 @@ def my_print(string):
             if h.__class__.__name__ != "NullHandler":
                 print("        --> name: " + name + "; handler type: " + h.__class__.__name__)
 
-def api_call_with_retry(f, max_time=15000, max_tries=12, delay_first=100, delay_start=200, delay_mult=1.5):
+# def api_call_with_retry(f, max_time=15000, max_tries=12, delay_first=100, delay_start=200, delay_mult=1.5):
+def api_call_with_retry(f, max_time=15000, max_tries=12, delay_first=175, delay_start=175, delay_mult=1.0):
 
     @wraps(f)
     def decorated_function(*args, **kwargs):
@@ -190,13 +197,13 @@ def print_retry_info(print_debug, parameters, f, kwargs):
     if print_debug:
         msg = "==> RT K:" + parameters['key'] + "; T:" + str(parameters['current_try']) \
             + "; F:" + str(f) + "; KW:" + str(kwargs) if kwargs is not None else "None"
-        print(msg)
+        print(time_string() + msg)
 
 def print_error_info(print_debug, parameters, err):
     if print_debug:
         msg = "==> AE K:" + parameters['key'] + "; T:" + str(parameters['current_try']) \
             + "; E:" + str(err).replace("\n", ">").replace("\r", ">")
-        print(msg)
+        print(time_string() + msg)
 
         #  Print more info, if the builtins.dict error.
         # if "builtins.dict" in str(err):
@@ -266,6 +273,7 @@ def get_key():
 import app.resources.bookings.booking.booking_put
 import app.resources.bookings.booking.booking_recurring_delete
 import app.resources.bookings.booking.booking_recurring_put
+import app.resources.bookings.exam.exam_bcmp
 import app.resources.bookings.exam.exam_bulk_status
 import app.resources.bookings.exam.exam_delete
 import app.resources.bookings.exam.exam_detail
@@ -279,6 +287,7 @@ def get_key():
 import app.resources.bookings.exam.exam_transfer
 import app.resources.bookings.exam.exam_upload
 import app.resources.bookings.invigilator.invigilator_list
+import app.resources.bookings.invigilator.invigilator_list_offsite
 import app.resources.bookings.invigilator.invigilator_put
 import app.resources.bookings.room.room_list
 import app.resources.bookings.exam_type.exam_type_list
diff --git a/api/requirements.txt b/api/requirements.txt
index e158d0d78..00bb36d97 100755
--- a/api/requirements.txt
+++ b/api/requirements.txt
@@ -1,6 +1,5 @@
 # Moved to the top of the requirements as another package uses the latest Werkzeug.  Werkzeug==0.16.1 is required for flask-restx until later release  flask-restx 0.2.0.
 flask-restx
-flask-restplus==0.12.1
 
 #  SQLAlchemy needs to point to version 1.3.12 because there is a bug with
 #  with inviting Citizens expected to be fixed with Release 1.3.14
@@ -22,7 +21,7 @@ filelock
 flask-caching
 flask-compress
 flask-cors
-flask_marshmallow
+flask_marshmallow==0.11.0
 flask-socketio
 gunicorn
 marshmallow-sqlalchemy
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 737695d00..f207f1624 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -13461,4 +13461,4 @@
       "integrity": "sha1-AI4G2AlDIMNy28L47XagymyKxBk="
     }
   }
-}
+}
\ No newline at end of file
diff --git a/frontend/src/Socket.vue b/frontend/src/Socket.vue
index 8e7495647..0aac5f53e 100644
--- a/frontend/src/Socket.vue
+++ b/frontend/src/Socket.vue
@@ -48,6 +48,8 @@ limitations under the License.*/
 
       connect() {
         socket = io(process.env.SOCKET_URL, {
+          timeout: '3000',
+          reconnectionDelayMax: '100',
           path: '/api/v1/socket.io',
           transports: ['websocket']
         })
@@ -58,10 +60,13 @@ limitations under the License.*/
       },
 
       addListeners() {
+        console.log("Begin Add Listener");
         socket.on('reconnecting',()=>{this.onReconnecting()})
         socket.on('joinRoomSuccess',()=>{this.onJoinRoom(true)})
         socket.on('joinRoomFail',()=>{this.onJoinRoom(false)})
+        console.log("Call get csr State IDS");
         socket.on('get_Csr_State_IDs',()=>{this.getCsrStateIDs()})
+        console.log("DO WE SEE THIS MESSAGE BEFORE POP UP")
         socket.on('update_customer_list',()=>{this.onUpdateCustomerList()})
         socket.on('update_active_citizen', (citizen) => { this.onUpdateActiveCitizen(citizen) } )
         socket.on('csr_update', (data)=>{this.onCSRUpdate(data)})
@@ -69,6 +74,7 @@ limitations under the License.*/
       },
 
       join() {
+        console.log("==> In Socket.vue.join, socket.io.engine.id is: " + socket.io.engine.id.toString())
         socket.emit('joinRoom',{count:0}, ()=>{console.log('socket emit: "joinRoom"')}
         )
       },
diff --git a/frontend/src/add-citizen/add-citizen.vue b/frontend/src/add-citizen/add-citizen.vue
index b5f295773..8ba2c0233 100644
--- a/frontend/src/add-citizen/add-citizen.vue
+++ b/frontend/src/add-citizen/add-citizen.vue
@@ -27,7 +27,7 @@
              @dismiss-count-down="countDownChanged">{{this.$store.state.alertMessage}}</b-alert>
     <div v-if="!minimizeWindow">
       <div v-if="!this.addModalForm.citizen && !this.addModalForm.setup === 'add_mode'">
-        <div class="q-loader" />
+        <div class="q-loader2" />
       </div>
       <div v-else>
         <AddCitizenForm />
@@ -230,6 +230,19 @@ export default {
 </script>
 
 <style>
+  .q-loader2 {
+    position: absolute;
+    text-align: center;
+    margin: 50px auto auto 300px;
+    width: 50px;
+    height: 50px;
+    border: 10px solid LightGrey;
+    opacity:0.9;
+    border-radius: 50%;
+    border-top-color: DodgerBlue;
+    animation: spin 1s ease-in-out infinite;
+    -webkit-animation: spin 1s ease-in-out infinite;
+}
 .modal_header {
   display: flex;
   flex-direction: row;
diff --git a/frontend/src/appointments/appt-booking-modal/appt-booking-modal.vue b/frontend/src/appointments/appt-booking-modal/appt-booking-modal.vue
index 2d388352d..013138991 100644
--- a/frontend/src/appointments/appt-booking-modal/appt-booking-modal.vue
+++ b/frontend/src/appointments/appt-booking-modal/appt-booking-modal.vue
@@ -1,4 +1,5 @@
 <template>
+
   <b-modal v-model="modalVisible"
            @shown="show"
            size="md"
@@ -7,6 +8,11 @@
            no-close-on-backdrop
            no-close-on-esc
            hide-header>
+    <div id="navi">
+      <template v-if="this.$store.state.showServeCitizenSpinner">
+        <div class="q-loader2" ></div>
+      </template>
+    </div>
       <template slot="modal-footer">
         <div class="d-flex flex-row-reverse">
           <b-button class="disabled btn-primary ml-2"
@@ -196,6 +202,7 @@
         'showApptBookingModal',
         'selectedService',
         'editDeleteSeries',
+        'submitClicked'
       ]),
       appointments() {
         if (this.clickedAppt) {
@@ -320,6 +327,7 @@
         'setRescheduling',
         'toggleApptBookingModal',
         'toggleEditDeleteSeries',
+        'toggleSubmitClicked'
       ]),
       addService() {
         this.selectingService = true
@@ -348,13 +356,17 @@
         this.resetAddModalForm()
       },
       deleteAppt() {
+        this.$store.commit('toggleServeCitizenSpinner', true)
         this.deleteAppointment(this.clickedAppt.appointment_id).then( () => {
           this.cancel()
+          this.$store.commit('toggleServeCitizenSpinner', false)
         })
       },
       deleteRecurringAppts() {
+        this.$store.commit('toggleServeCitizenSpinner', true)
         this.deleteRecurringAppointments(this.clickedAppt.recurring_uuid).then( () => {
           this.cancel()
+          this.$store.commit('toggleServeCitizenSpinner', false)
         })
       },
       reschedule() {
@@ -415,64 +427,95 @@
         }
       },
       submit() {
-        this.clearMessage()
-        let service_id = this.selectedService
-        let start = moment(this.start).clone()
-        let end = moment(this.end).clone()
-        let e = {
-          start_time: moment.utc(start).format(),
-          end_time: moment.utc(end).format(),
-          service_id,
-          citizen_name: this.citizen_name,
-          contact_information: this.contact_information,
-        }
-        if (this.comments) {
-          e.comments = this.comments
-        }
-        let finish = () => {
-          this.cancel()
-          this.$root.$emit('clear-clicked-appt')
-          this.$root.$emit('clear-clicked-time')
-        }
-        if (this.clickedAppt) {
-          let payload = {
-            id: this.clickedAppt.appointment_id,
-            data: e
+        if (!this.submitClicked) {
+          this.toggleSubmitClicked(true)
+          this.$store.commit('toggleServeCitizenSpinner', true)
+          this.clearMessage()
+          let service_id = this.selectedService
+          let start = moment(this.start).clone()
+          let end = moment(this.end).clone()
+          let e = {
+            start_time: moment.utc(start).format(),
+            end_time: moment.utc(end).format(),
+            service_id,
+            citizen_name: this.citizen_name,
+            contact_information: this.contact_information,
           }
-          if(this.editDeleteSeries === true){
-            // IFF further fields are added to the appointment model that are intended to be edited,
-            // and they belong to blackouts, and them to the following object below. Ensure that dates are
-            // not included as all events in this series will be under the start/end time of the event
-            // that is clicked in the calendar
-            this.toggleEditDeleteSeries(false)
-            let re_e = {
-              comments: this.comments
-            }
-            let re_payload = {
+          if (this.comments) {
+            e.comments = this.comments
+          }
+          let finish = () => {
+            this.cancel()
+            this.$root.$emit('clear-clicked-appt')
+            this.$root.$emit('clear-clicked-time')
+          }
+          if (this.clickedAppt) {
+            let payload = {
               id: this.clickedAppt.appointment_id,
-              data: re_e,
-              recurring_uuid: this.clickedAppt.recurring_uuid
+              data: e
             }
-            this.putRecurringAppointment(re_payload).then(() => {
-              this.getAppointments().then( () => {
-                finish()
+            if (this.editDeleteSeries === true) {
+              // IFF further fields are added to the appointment model that are intended to be edited,
+              // and they belong to blackouts, and them to the following object below. Ensure that dates are
+              // not included as all events in this series will be under the start/end time of the event
+              // that is clicked in the calendar
+              this.toggleEditDeleteSeries(false)
+              let re_e = {
+                comments: this.comments
+              }
+              let re_payload = {
+                id: this.clickedAppt.appointment_id,
+                data: re_e,
+                recurring_uuid: this.clickedAppt.recurring_uuid
+              }
+              this.putRecurringAppointment(re_payload).then(() => {
+                this.getAppointments().then(() => {
+                  finish()
+                  this.$store.commit('toggleServeCitizenSpinner', false)
+                })
               })
-            })
-          }else {
-            this.putAppointment(payload).then( () => {
-              this.getAppointments().then( () => {
-                finish()
+            } else {
+              this.putAppointment(payload).then(() => {
+                this.getAppointments().then(() => {
+                  finish()
+                  this.$store.commit('toggleServeCitizenSpinner', false)
+                  setTimeout(()=>{ this.toggleSubmitClicked(false) }, 2000);
+                })
               })
-            })
+            }
+            return
           }
-          return
-        }
-        this.postAppointment(e).then( () => {
-          this.getAppointments().then( () => {
-            finish()
+          this.postAppointment(e).then(() => {
+            this.getAppointments().then(() => {
+              finish()
+              this.$store.commit('toggleServeCitizenSpinner', false)
+              setTimeout(()=>{ this.toggleSubmitClicked(false) }, 2000);
+            })
           })
-        })
+        }
       },
     },
   }
 </script>
+
+
+<style scoped>
+  #navi {
+    position: relative;
+  }
+  .q-loader2 {
+    position: absolute;
+    z-index: 1100;
+    text-align: center;
+    margin: 250px auto auto 175px;
+    width: 50px;
+    height: 50px;
+    border: 10px solid LightGrey;
+    opacity:0.9;
+    border-radius: 50%;
+    border-top-color: DodgerBlue;
+    animation: spin 1s ease-in-out infinite;
+    -webkit-animation: spin 1s ease-in-out infinite;
+}
+</style>
+
diff --git a/frontend/src/appointments/checkin-modal.vue b/frontend/src/appointments/checkin-modal.vue
index d4872c28a..b4d05e8dd 100644
--- a/frontend/src/appointments/checkin-modal.vue
+++ b/frontend/src/appointments/checkin-modal.vue
@@ -7,6 +7,11 @@
            no-close-on-esc
            hide-header
            size="sm">
+     <div id="navi">
+        <template v-if="this.$store.state.showServeCitizenSpinner">
+          <div class="q-loader2" ></div>
+        </template>
+     </div>
     <template slot="modal-footer">
       <b-button class="btn-secondary"
                 @click="hide">Close</b-button>
@@ -58,8 +63,13 @@
   export default {
     name: "CheckInModal",
     props: ['clickedAppt'],
+    data() {
+      return {
+        showcheckInSpinner: false
+      }
+    },
     computed: {
-      ...mapState(['showCheckInModal']),
+      ...mapState(['showCheckInModal','showServeCitizenSpinner', 'checkInClicked'],),
       modalVisible: {
         get() { return this.showCheckInModal },
         set(e) { this.toggleCheckInModal(e) }
@@ -90,11 +100,17 @@
         'toggleCheckInModal',
         'toggleApptBookingModal',
         'toggleEditDeleteSeries',
+        'toggleCheckInClicked'
       ]),
       checkIn() {
-        this.postCheckIn(this.clickedAppt).then( () => {
-          this.hide()
-        })
+        if (!this.checkInClicked) {
+          this.toggleCheckInClicked(true)
+          this.$store.commit('toggleServeCitizenSpinner', true)
+          this.postCheckIn(this.clickedAppt).then(() => {
+            this.hide()
+            this.$store.commit('toggleServeCitizenSpinner', false)
+          })
+        }
       },
       clearTime() {
         this.$root.$emit('cleardate')
@@ -121,5 +137,21 @@
 </script>
 
 <style scoped>
-
+  #navi {
+    position: relative;
+  }
+  .q-loader2 {
+    position: absolute;
+    z-index: 1100;
+    text-align: center;
+    margin: 50px auto auto 100px;
+    width: 50px;
+    height: 50px;
+    border: 10px solid LightGrey;
+    opacity:0.9;
+    border-radius: 50%;
+    border-top-color: DodgerBlue;
+    animation: spin 1s ease-in-out infinite;
+    -webkit-animation: spin 1s ease-in-out infinite;
+}
 </style>
diff --git a/frontend/src/booking/edit-booking-modal.vue b/frontend/src/booking/edit-booking-modal.vue
index d6446abce..8432c2d95 100644
--- a/frontend/src/booking/edit-booking-modal.vue
+++ b/frontend/src/booking/edit-booking-modal.vue
@@ -196,7 +196,7 @@
                 </b-col>
               </b-row>
             </template>
-            <template v-else>
+            <template v-else-if="!this.event.exam.is_pesticide">
               <b-button v-if="examAssociated"
                         v-b-toggle.collapse-1
                         variant="primary"
diff --git a/frontend/src/exams/add-exam-final-step.vue b/frontend/src/exams/add-exam-final-step.vue
index ff98d7eb9..e307ec3f4 100644
--- a/frontend/src/exams/add-exam-final-step.vue
+++ b/frontend/src/exams/add-exam-final-step.vue
@@ -177,7 +177,7 @@
         <span class="confirm-item">{{ formatDate(exam.expiry_date) }}</span>
       </b-col>
     </b-row>
-    <b-row no-gutters align-h="between" align-v="end"">
+    <b-row no-gutters align-h="between" align-v="end">
       <b-col cols="1" />
       <b-col cols="3">
         <span class="confirm-header">Exam Time
diff --git a/frontend/src/exams/add-exam-form-components.js b/frontend/src/exams/add-exam-form-components.js
index a811ab4e6..994d73ba9 100644
--- a/frontend/src/exams/add-exam-form-components.js
+++ b/frontend/src/exams/add-exam-form-components.js
@@ -72,12 +72,6 @@ export const AddExamCounter = Vue.component('add-exam-counter', {
           <span style="color: red">Number of selected exams does not equal the number of candidates</span>
         </b-col>
       </b-row>
-      <b-row no-gutters>
-        <b-col cols="12" class="text-right">
-          <b-btn class="btn-warning">Save Draft</b-btn>
-         </b-col>
-        <checkmark :validated="validationObj[q.key].valid" />
-      </b-row>
     </fragment>
   `
 })
@@ -93,6 +87,11 @@ export const DateQuestion = Vue.component('date-question', {
   computed: {
     ...mapState(['user', 'addExamModal', 'capturedExam']),
   },
+  beforeMount() {
+    if (this.exam.ind_or_group === "group") {
+      this.exam.expiry_date = null
+    }
+  },
   methods: {
     selectDate(e) {
       this.handleInput({
@@ -108,7 +107,7 @@ export const DateQuestion = Vue.component('date-question', {
       <b-col cols="11">
         <b-form-group>
           <label>
-            {{ addExamModal.setup == 'group' || addExamModal.setup == 'challenger' ? 'Exam Date' : 'Expiry Date' }}
+            {{ addExamModal.setup == 'group' || addExamModal.setup == 'challenger' || addExamModal.setup == 'pesticide' ? 'Exam Date' : 'Expiry Date' }}
             <span v-if="error" style="color: red">{{ validationObj[q.key].message }}</span>
           </label><br>
           <DatePicker :value="exam[q.key]"
@@ -528,7 +527,7 @@ export const LocationInput = Vue.component('location-input-question', {
   },
   template: `
     <fragment>
-      <template v-if="capturedExam.on_or_off === 'off' || setup === 'pesticide' ">
+      <template v-if="capturedExam.on_or_off === 'off' || setup === 'pesticide' || setup === 'group' ">
         <b-row no-gutters>
           <b-col cols="11">
             <b-form-group>
@@ -565,7 +564,7 @@ export const LocationInput = Vue.component('location-input-question', {
                             disabled />
             </b-form-group>
           </b-col>
-          
+
         </b-row>
         <b-row no-gutters v-if="invigilator.show">
           <b-col cols="12">
diff --git a/frontend/src/exams/add-exam-modal.vue b/frontend/src/exams/add-exam-modal.vue
index 44b5017d6..b5ed8044f 100644
--- a/frontend/src/exams/add-exam-modal.vue
+++ b/frontend/src/exams/add-exam-modal.vue
@@ -42,8 +42,8 @@
                     @click="logAnother">Start Again</b-button>
           </div>
           <div style="display: flex">
-            <b-button v-if="errors.length > 0"
-                      @click="submitMsg='You have an error on a previous step.  Click on the red tab.'"
+            <b-button v-if="errors.length > 0 || (addExamModal.setup=='pesticide' && !examBcmpJobId)"
+                      @click="showErrorMsg"
                       class="btn-primary disabled"
                       id="add_exam_submit">Submit</b-button>
             <b-button v-else
@@ -88,7 +88,7 @@
                  align-h="center"
                  align-content="center">
             <b-col>
-              <p><h5>Success.  Exam Details Added.</h5></p>
+              <div><h5>Success.  Exam Details Added.</h5></div>
               <p><b-button @click="logAnother" class="btn-primary">Log Another Exam</b-button></p>
             </b-col>
           </b-row>
@@ -106,6 +106,18 @@
           </b-row>
         </b-container>
       </div>
+      <div v-if="status==='EMAIL_FAILED'">
+        <b-container>
+          <b-row align-v="center"
+                 align-h="center"
+                 align-content="center">
+            <b-col>
+              <h5>Exam Details Added, <strong>Email to invigilator Failed.</strong></h5>
+              <p class="message-text">Please notify the invigilator manually</p>
+            </b-col>
+          </b-row>
+        </b-container>
+      </div>
     </template>
   </b-modal>
 </template>
@@ -140,6 +152,7 @@
         tab: 'captureITAExamTabSetup',
         user: 'user',
         module: 'addExamModule',
+        examBcmpJobId: 'examBcmpJobId',
       }),
       lastStep() {
         if (this.addExamModal.setup === 'challenger') {
@@ -148,6 +161,7 @@
         return 4
       },
       errors() {
+        console.log(this.exam)
         if (this.tab.errors) {
           return this.tab.errors
         } else {
@@ -342,8 +356,12 @@
           this.clickAddExamSubmit('individual').then(resp => {
             this.status = resp
             this.getExams()
+          }, err => {
+            this.status = err
+            console.log(this.status)
           }).catch(error => {
             this.status = error
+            console.log(this.status)
             this.getExams()
           })
         }
@@ -383,6 +401,10 @@
         }
         return []
       },
+      showErrorMsg() {
+        this.submitMsg = (this.addExamModal.setup=='pesticide' && !this.exam.bcmp_job_id) ? 'Please click on the Request Exam button to generate BCMP Job Id' : 'You have an error on a previous step.  Click on the red tab.'
+        
+      }
     }
   }
 </script>
diff --git a/frontend/src/exams/add-pesticide-final-step.vue b/frontend/src/exams/add-pesticide-final-step.vue
index d6b6d183d..becada386 100644
--- a/frontend/src/exams/add-pesticide-final-step.vue
+++ b/frontend/src/exams/add-pesticide-final-step.vue
@@ -10,21 +10,74 @@
         <span style="font-size:1rem; color: red">{{ submitMsg }}</span>
       </b-col>
     </b-row>
-    <b-row no-gutters class="mt-2" align-v="end" v-for="(item, i) of displayData" :key="i+'sumary'">
-      <b-col cols="1" />
-      <b-col cols="3">
-        <span class="confirm-header">{{ item.heading }}</span>
-      </b-col>
-      <b-col>
-          {{ item.text }}
+    <b-row no-gutters class="summary-box my-3" align-v="end">
+      <template v-if="isGroupExam" >
+        <b-col cols="12" class="summary-box-col group-exam" v-for="(candidate, i) of candidateTableData" :key="i+'groupsumary'">
+          <div class="summary-heading" v-if="candidate.exam_type_name">{{ candidate.exam_type_name }}
+            <span class="qty">candidates: {{candidate.qty}}</span>
+          </div>
+          <div class="summary-text" v-if="candidate.name"> - {{ candidate.name }}</div>
+        </b-col>
+      </template>
+      <b-col cols="6" class="summary-box-col" v-for="(item, i) of displayData" :key="i+'sumary'">
+        <div class="summary-heading">{{ item.heading }}:</div>
+        <div class="summary-text">{{ item.text }}</div>
       </b-col>
     </b-row>
+    <!-- for SBC Based exam flow -->
+    <template>
+      <b-row class="mt-2" align-v="end">
+        <b-col cols="12">
+          <b-button
+            variant="primary"
+            @click="requestExam()"
+            :disabled="isRequestExamBtnLoading || !!examBcmpJobId"
+          >
+            <span v-if="isRequestExamBtnLoading">
+              <b-spinner small></b-spinner>
+              Please Wait...
+            </span>
+            <span v-else>
+              Request Exam
+            </span>
+          </b-button>
+        </b-col>
+        <b-col cols="12" class="mt-4" v-if="examBcmpJobId">
+          <b-alert variant="success" show>
+            Job Id generated from BCMP: {{examBcmpJobId}}
+            <br><br>
+            <strong>Click on the "Submit" button to finish adding the pesticide exam</strong>
+          </b-alert>
+        </b-col>
+      </b-row>
+      <b-row class="mt-4" align-v="end" v-if="isExamReqFailed">
+        <b-col cols="12">
+          <b-alert variant="warning" show>
+            Failed to request exam from BCMP, please follow the manual steps and enter the generated job id in the input below, then
+            <br>
+            <strong>Click on the "Submit" button to finish adding the pesticide exam</strong>
+          </b-alert>
+          <label for="bcmp-job-id">BCMP Job Id:</label>
+          <b-form-input
+            id="bcmp-job-id"
+            v-model="bcmpJobId"
+            type="text"
+            aria-describedby="generated-bcmp-jobid"
+            placeholder="Enter generated BCMP job id"
+            trim
+            @blur="addBCMPJobId()"
+          ></b-form-input>
+        </b-col>
+        <b-col>
+        </b-col>
+      </b-row>
+    </template>
 
   </b-form>
 </template>
 
 <script>
-  import { mapState, mapGetters } from 'vuex'
+  import { mapState, mapGetters, mapActions, mapMutations } from 'vuex'
   import moment from 'moment'
 
   export default {
@@ -33,8 +86,8 @@
     data() {
       return {
         headings: {
-          pesticide_type: "Pesticide Exam Type",
-          fees: "Fees",
+          exam_type_name: "Exam Type",
+          fees: "Exam Fees",
           examinee_name: "Candidate",
           examinee_phone: "Candidate's Phone",
           examinee_email: "Candidate's Email",
@@ -42,8 +95,15 @@
           payee_name: "Payee Name",
           payee_email: "Payee Email",
           payee_phone: "Payee Phone",
-          offsite_location: "Location"
-        }
+          offsite_location: "Location",
+          exam_time_str: "Exam Date",
+          notes: "Notes"
+        },
+        bcmpJobId: '',
+        isExamReqFailed: false,
+        generatedJobId: '',
+        isGroupExam: false,
+        isRequestExamBtnLoading: false,
       }
     },
     computed: {
@@ -54,17 +114,28 @@
         user: state => state.user,
         addExamModal: state => state.addExamModal,
         offices: state => state.offices,
+        candidateTableData: state => state.addExamModule.candidateTableData,
+        examBcmpJobId: state => state.examBcmpJobId
       }),
       displayData() {
-        let keys = Object.keys(this.exam)
+        this.isGroupExam = (this.exam.ind_or_group == "group")
+        let examObj = this.exam
+        if(this.exam.exam_type_id) {
+          const examType = this.examTypes.find(examType => (examType.exam_type_id == this.exam.exam_type_id))
+          examObj.exam_type_name = (examType) ? examType.exam_type_name : ''
+        }
+        if(this.exam.exam_time) {
+          examObj.exam_time_str = `${moment(this.exam.expiry_date).format('YYYY-MMM-DD')} ${moment(this.exam.exam_time).format('hh:mm A')}`;
+        }
+        let keys = Object.keys(examObj)
         let headings = Object.keys(this.headings)
         let output = []
         keys.forEach(key => {
           if (headings.includes(key)) {
-            if (this.exam[key]) {
+            if (examObj[key]) {
               output.push({
                 heading: this.headings[key],
-                text: this.exam[key]
+                text: examObj[key]
               })
             }
           }
@@ -91,8 +162,33 @@
 
     },
     methods: {
+      ...mapActions([
+        'clickPesticideRequestExam',
+      ]),
+      ...mapMutations([
+        'setBCMPJobId',
+      ]),
       formatDate(d) {
         return new moment(d).format('MMM D, YYYY')
+      },
+
+      requestExam() {
+        this.isRequestExamBtnLoading = true
+        this.clickPesticideRequestExam().then(bcmp_job_id => {
+          console.log("bcmp_job_id: ", bcmp_job_id)
+          this.setBCMPJobId(bcmp_job_id);
+          this.generatedJobId = bcmp_job_id;
+          this.isRequestExamBtnLoading = false
+        }).catch(error => {
+          console.log(error)
+          this.isExamReqFailed = true;
+          this.isRequestExamBtnLoading = false
+        })
+      },
+
+      addBCMPJobId() {
+        console.log(this.bcmpJobId)
+        this.setBCMPJobId(this.bcmpJobId)
       }
     }
   }
@@ -103,4 +199,30 @@
     font-weight: 500; font-size: 1.05rem;
   }
 
+  .summary-box {
+    padding: 10px 20px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+  }
+  .summary-box-col{
+    padding-bottom: 8px;
+  }
+  .summary-heading {
+    font-weight: 700
+  }
+  .summary-text {
+    padding-left: 12px;
+  }
+  .group-exam .summary-heading {
+    background: #ddd;
+    padding: 3px 6px;
+    border-radius: 4px;
+  }
+  .group-exam .summary-heading .qty{
+    float: right;
+  }
+  .group-exam .summary-box-col {
+    padding-bottom: 4px;
+  }
+
 </style>
diff --git a/frontend/src/exams/buttons-exams.vue b/frontend/src/exams/buttons-exams.vue
index b051cc3b7..90b10e41c 100644
--- a/frontend/src/exams/buttons-exams.vue
+++ b/frontend/src/exams/buttons-exams.vue
@@ -59,6 +59,8 @@
         this.setAddExamModalSetting(true)
         if (type === 'pesticide') {
           this.$store.dispatch('getPesticideExamTypes')
+          this.$store.dispatch('getPesticideOfficeInvigilators')
+          this.$store.dispatch('getPesticideOffsiteInvigilators')
         }
       },
       clickGenFinReport() {
diff --git a/frontend/src/exams/edit-exam-form-modal.vue b/frontend/src/exams/edit-exam-form-modal.vue
index 6b55b9769..b09ebe82b 100644
--- a/frontend/src/exams/edit-exam-form-modal.vue
+++ b/frontend/src/exams/edit-exam-form-modal.vue
@@ -83,7 +83,7 @@
             </b-col>
           </b-form-row>
           <b-form-row>
-            <b-col cols="6">
+            <b-col>
               <b-form-group>
                 <label class="my-0">Telephone</label><br>
                 <b-form-input id="examinee_phone"
@@ -92,6 +92,17 @@
                               v-model="fields.examinee_phone" />
               </b-form-group>
             </b-col>
+          </b-form-row>
+          <b-form-row>
+            <b-col cols="6">
+              <b-form-group>
+                <label class="my-0">Event ID</label>
+                <b-form-input id="event_id"
+                              type="text"
+                              class="less-10-mb"
+                              v-model="fields.event_id" />
+              </b-form-group>
+            </b-col>
             <b-col cols="6">
               <b-form-group>
                 <label class="my-0">Expiry Date</label><br>
@@ -115,7 +126,7 @@
             <b-col :cols="feesOptions === 'collect' ? 12 : 5">
               <b-form-group><label class="my-0">Fees</label>
                 <b-form-select v-model="feesOptions" :disabled="feesOptions === 'liaison'">
-                  <option value="liaison">Collected By Liason</option>
+                  <option value="liaison" disabled>Collected By Liason</option>
                   <option value="paid">Collect Now</option>
                   <option value="collect">Collect at Exam Time</option>
                 </b-form-select>
@@ -123,11 +134,23 @@
             </b-col>
             <b-col cols="7" v-if="feesOptions !== 'collect'">
               <b-form-group><label class="my-0">Receipt</label>
-                <b-input :disabled="feesOptions === 'liaison'" />
+                <b-input :disabled="feesOptions === 'liaison'" v-model="fields.receipt" />
+              </b-form-group>
+            </b-col>
+            <b-col cols="12" v-if="feesOptions !== 'collect'">
+              <b-form-group>
+                <b-form-checkbox
+                  id="receipt-sent"
+                  v-model="fields.receipt_sent_ind"
+                  name="receipt-sent"
+                  value="1"
+                  unchecked-value="0"
+                >
+                  Receipt Sent?
+                </b-form-checkbox>
               </b-form-group>
             </b-col>
           </b-form-row>
-
         </b-form>
       </template>
 
@@ -414,15 +437,13 @@
         examNotReady: false,
         feesOptions: 'collect',
         clickedMenu: false,
-        examReceivedOptions: [
-          { value: false, text: 'No' },
-          { value: true, text: 'Yes' },
-        ],
         fields: {
           exam_received_date: null,
           notes: null,
           event_id: null,
           exam_name: null,
+          receipt: null,
+          receipt_sent_ind: null,
         },
         lengthError: false,
         message: '',
@@ -501,6 +522,10 @@
       },
       exam() {
         if (Object.keys(this.actionedExam).length > 0) {
+          console.log("this.actionedExam ", this.actionedExam)
+          this.feesOptions = (this.actionedExam.receipt) ? 'liaison' : 'collect'
+          this.fields.receipt = this.actionedExam.receipt
+          this.fields.receipt_sent_ind = this.actionedExam.receipt_sent_ind
           return this.actionedExam
         }
         return false
@@ -569,6 +594,14 @@
         }
         return []
       },
+      examReceivedOptions() {
+        this.exam_received = this.actionedExam.exam_received_date !== null ? true : false;
+        this.fields.exam_received_date = this.actionedExam.exam_received_date
+        return [
+          { value: false, text: 'No' },
+          { value: true, text: 'Yes' },
+        ];
+      },
       showAllFields() {
         if (this.role_code === 'GA' || this.is_liaison_designate || this.is_ita_designate) {
           return true
@@ -583,6 +616,7 @@
           return this.showEditExamModal
         },
         set(e) {
+          this.examNotReady = false
           this.toggleEditExamModal(e)
         }
       },
@@ -609,17 +643,17 @@
         return ex.exam_type.ita_ind ? true : false
       },
       checkAndDownloadExam() {
-        console.log("blah")
         this.downloadExam(this.exam)
           .then((resp) => {
-            console.log(resp)
+            console.log(resp.statusText)
             let filename = `${this.exam.exam_id}.pdf`
             FileDownload(resp.data, filename, "application/pdf")
+            this.updateExamReceived(new Event('exam-downloaded'))
           })
           .catch((error) => {
             console.error(error)
             this.examNotReady = true
-            setTimeout(() => { this.examNotReady = false }, 5000)
+            setTimeout(() => { this.examNotReady = false }, 15000)
           })
       },
       checkInputLength(e) {
@@ -749,6 +783,9 @@
       },
       updateExamReceived(e) {
         let { exam_received_date } = this.fields
+        if(e.type == 'exam-downloaded') {
+          this.exam_received = true
+        }
         if (e && !exam_received_date) {
           this.fields.exam_received_date = new moment().format('YYYY-MM-DD')
           return
diff --git a/frontend/src/exams/edit-group-exam-modal.vue b/frontend/src/exams/edit-group-exam-modal.vue
index 3d34f5647..768e96966 100644
--- a/frontend/src/exams/edit-group-exam-modal.vue
+++ b/frontend/src/exams/edit-group-exam-modal.vue
@@ -90,307 +90,382 @@
           </b-col>
         </b-form-row>
       </b-form>
-      <template>
-        <b-button v-if="this.currentInvigilatorList.length == 0 && this.groupInvigilatorBoolean"
-                  v-b-toggle.collapse-invigilators
-                  variant="primary"
-                  style="width: 95%; margin-left: 10px;"
-                  class="mb-0"
-                  @click="setShadowInvigilatorBoolean">
-          Add Invigilators
-        </b-button>
-      </template>
-      <template>
-        <b-row style="display: inline-flex;" class="w-100 ml-0 mb-1">
-          <b-col class="w-50">
-            <b-button v-if="this.currentInvigilatorList.length > 0 && this.changeInvigilatorState "
-                      v-b-toggle.collapse-invigilators
-                      variant="primary"
-                      style="padding-left: 40px; padding-right: 25px; margin-left: -4px; white-space: nowrap;"
-                      @click="setRemoveShadowInvigilatorBoolean">
-              <span>Change Invigilator(s)</span>
-            </b-button>
-            <b-button v-if="this.currentInvigilatorList.length > 0 && !this.groupInvigilatorBoolean && !this.changeInvigilatorState"
-                      style="padding-left: 40px; padding-right: 25px; margin-left: -4px; white-space: nowrap;"
-                      variant="primary"
-                      disabled>
-              <span>Change Invigilator(s)</span>
-            </b-button>
+      <template v-if="actionedExam.is_pesticide">
+        <b-form-row>
+          <b-col>
+            <b-form-group>
+              <label>Event ID</label><br>
+              <b-form-input v-model="eventId"
+                          :disabled="fieldDisabled"
+                          type="text"
+                          class="less-10-mb"
+                          @input.native="checkInput"
+                          name="event_id" />
+            </b-form-group>
           </b-col>
-          <b-col class="w-50">
-            <b-button v-if="this.currentInvigilatorList.length > 0 && this.removeInvigilatorState"
-                      v-b-toggle.collapse-remove-invigilators
-                      variant="danger"
-                      style="padding-left: 40px; padding-right: 28px; margin-left: -11px; white-space: nowrap;"
-                      @click="setChangeShadowInvigilatorBoolean">
-              Remove Invigilator(s)
-            </b-button>
-            <b-button v-if="this.currentInvigilatorList.length > 0 && !this.groupInvigilatorBoolean && !this.removeInvigilatorState"
-                      style="padding-left: 40px; padding-right: 28px; margin-left: -11px; white-space: nowrap;"
-                      variant="danger"
-                      disabled>
-              <span>Remove Invigilator(s)</span>
-            </b-button>
+        </b-form-row>
+        <b-form-row>
+          <b-col :col="!this.fields.exam_received_date" :cols="this.exam_received ? '' : 3 ">
+            <b-form-group>
+              <label class="my-0">Exam Printed?</label>
+              <b-select id="exam_received"
+                        v-model="exam_received"
+                        @input="updateExamReceived"
+                        class="less-10-mb"
+                        :options="examReceivedOptions" />
+            </b-form-group>
           </b-col>
-        </b-row>
-      </template>
-      <b-collapse id="collapse-remove-invigilators"
-                      class="mt-2 w-100">
-            <b-form-group class="q-info-display-grid-container">
-              <b-row class="ml-1">
-                <span style="font-weight: bold;">Current Invigilator(s): </span>
-              </b-row>
-              <b-row v-for="current in this.currentInvigilatorList"
-                       style="justify-content: center"
-                       class="mb-1">
-                  {{ current.name }}
-                </b-row>
-              <b-row class="ml-1">
-                <span style="font-weight: bold;">Would you like to remove invigilator(s)?</span>
-              </b-row>
-              <template>
-                <b-row style="display: flex; justify-content: center;"
-                       class="w-100 mb-0">
-                  <b-button class="mr-2 mt-1"
-                            variant="danger"
-                            @click="setSelectedInvigilator">
-                    Yes
-                  </b-button>
-                  <b-button class="ml-2 mt-1"
-                            variant="primary"
-                            @click="closeRemoveInvigilator">
-                    No
-                  </b-button>
-                </b-row>
-              </template>
+          <b-col>
+            <label class="my-0">Retrieve Exam and Print</label>
+            <b-btn class="btn-success w-100" @click="checkAndDownloadExam()">Print</b-btn>
+          </b-col>
+          <b-col v-if="exam_received">
+            <b-form-group>
+              <label class="my-0">Printed Date</label><br>
+              <DatePicker :value="fields.exam_received_date"
+                          @input="handleDate"
+                          format="YYYY-MM-DD"
+                          value-type="format"
+                          lang="en"
+                          id="exam_received_date"
+                          input-class="form-control"
+                          class="w-100 my-0 less-10-mb">
+              </DatePicker>
             </b-form-group>
-          </b-collapse>
-      <b-collapse id="collapse-invigilators"
-                  class="mt-2 mb-1 w-100">
-        <label class="mb-1">Add Invigilators</label>
-        <b-form class="q-info-display-grid-container">
-          <b-row>
-            <b-col cols="7">
-              <b-table selectable
-                       select-mode="multi"
-                       :fields="fields"
-                       :items="invigilator_multi_select"
-                       responsive
-                       selected-variant="success"
-                       style="height: 110px; width: 250px;"
-                       @row-selected="rowSelected"
-                       bordered
-                       striped>
-                <template slot="selected" slot-scope="{ rowSelected }">
-                  <span v-if="rowSelected">✔</span>
-                </template>
-              </b-table>
+          </b-col>
+        </b-form-row>
+        <b-form-row v-if="examNotReady">
+          <b-col cols="12" style="color: red">
+            This exam is not yet ready for retrieval.  Please try again in no less than 15 minutes.
+          </b-col>
+        </b-form-row>
+        <b-form-row>
+          <b-col cols="12">
+            <b-form-group>
+              <label class="my-0">Invigilator</label>
+              <b-form-select 
+                v-model="invigilator_id"
+                :options="invigilatorList"
+                @change="invigilatorChanged"
+              >
+              </b-form-select>
+            </b-form-group>
+          </b-col>
+        </b-form-row>
+      </template>
+      <template v-else>
+        <!-- Invigilator Start -->
+        <template>
+          <b-button v-if="this.currentInvigilatorList.length == 0 && this.groupInvigilatorBoolean"
+                    v-b-toggle.collapse-invigilators
+                    variant="primary"
+                    style="width: 95%; margin-left: 10px;"
+                    class="mb-0"
+                    @click="setShadowInvigilatorBoolean">
+            Add Invigilators
+          </b-button>
+        </template>
+        <template>
+          <b-row style="display: inline-flex;" class="w-100 ml-0 mb-1">
+            <b-col class="w-50">
+              <b-button v-if="this.currentInvigilatorList.length > 0 && this.changeInvigilatorState "
+                        v-b-toggle.collapse-invigilators
+                        variant="primary"
+                        style="padding-left: 40px; padding-right: 25px; margin-left: -4px; white-space: nowrap;"
+                        @click="setRemoveShadowInvigilatorBoolean">
+                <span>Change Invigilator(s)</span>
+              </b-button>
+              <b-button v-if="this.currentInvigilatorList.length > 0 && !this.groupInvigilatorBoolean && !this.changeInvigilatorState"
+                        style="padding-left: 40px; padding-right: 25px; margin-left: -4px; white-space: nowrap;"
+                        variant="primary"
+                        disabled>
+                <span>Change Invigilator(s)</span>
+              </b-button>
             </b-col>
-            <b-col cols="4">
-              <b-row class="mb-2"
-                     style="font-weight: bold;">
-                Required Invigilators: {{ Math.ceil(actionedExam.number_of_students / 24) }}
-              </b-row>
-              <template v-if="checkCurrentLength">
-                <b-row class="mb-2"
-                       style="font-weight: bold;">
-                  Current Invigilators:
-                </b-row >
-                <b-row v-for="current in this.currentInvigilatorList"
-                       style="justify-content: center"
-                       class="mb-1">
-                  {{ current.name }}
-                </b-row>
-              </template>
-              <b-row style="font-weight: bold;" class="mb-2">
-                Selected Invigilators
-              </b-row>
-              <b-row v-for="select in selected"
-                     style="justify-content: center;">
-                {{ select.name }}
-              </b-row>
-              <b-row style="justify-content: center;"
-                     v-if="this.currentInvigilatorList.length == 0 && this.selected.length == 0"
-                     class="mt-2">
-                <font-awesome-icon icon="life-ring"
-                                   style="font-size: 3.0rem; color: red;"
-                                   class="p-1"/>
-              </b-row>
-              <b-row style="justify-content: center;"
-                     v-else-if="(selected.length > 0 && selected.length < Math.ceil(actionedExam.number_of_students / 24)) ||
-                            (selected.length > Math.ceil(actionedExam.number_of_students / 24))"
-                     class="mt-2">
-                <font-awesome-icon icon="exclamation-triangle"
-                                   style="font-size: 3.0rem; color: #FFC32B;"
-                                   class="p-1"/>
-
-              </b-row>
-              <b-row style="justify-content: center;"
-                     v-else-if="(selected.length == 0 && this.currentInvigilatorList.length < Math.ceil(actionedExam.number_of_students / 24))"
-                     class="mt-2">
-                <font-awesome-icon icon="exclamation-triangle"
-                                   style="font-size: 3.0rem; color: #FFC32B;"
-                                   class="p-1"/>
-
-              </b-row>
-              <b-row style="justify-content: center;"
-                     v-else-if="(selected.length > 0 && selected.length == Math.ceil(actionedExam.number_of_students / 24))"
-                     class="mt-2">
-                <font-awesome-icon icon="check"
-                                   style="font-size: 3.0rem; color: green;"
-                                   class="p-1"/>
-              </b-row>
-              <b-row style="justify-content: center;"
-                     v-else-if="(this.currentInvigilatorList.length == Math.ceil(actionedExam.number_of_students / 24))"
-                     class="mt-2">
-                <font-awesome-icon icon="check"
-                                   style="font-size: 3.0rem; color: green;"
-                                   class="p-1"/>
-              </b-row>
+            <b-col class="w-50">
+              <b-button v-if="this.currentInvigilatorList.length > 0 && this.removeInvigilatorState"
+                        v-b-toggle.collapse-remove-invigilators
+                        variant="danger"
+                        style="padding-left: 40px; padding-right: 28px; margin-left: -11px; white-space: nowrap;"
+                        @click="setChangeShadowInvigilatorBoolean">
+                Remove Invigilator(s)
+              </b-button>
+              <b-button v-if="this.currentInvigilatorList.length > 0 && !this.groupInvigilatorBoolean && !this.removeInvigilatorState"
+                        style="padding-left: 40px; padding-right: 28px; margin-left: -11px; white-space: nowrap;"
+                        variant="danger"
+                        disabled>
+                <span>Remove Invigilator(s)</span>
+              </b-button>
             </b-col>
           </b-row>
-        </b-form>
-      </b-collapse>
-      <b-form-group>
-        <b-form-row>
-          <template v-if="this.currentShadowInvigilator != null">
-          <b-row style="display: flex;" class="w-100 ml-0 mb-2">
-              <b-col class="w-50 ml-0 mr-0 pr-1">
-                <b-button v-if="this.changeState && this.shadowInvigilatorBoolean"
-                          v-b-toggle.collapse-1
-                          variant="primary"
-                          @click="setRemove"
-                          class="mt-1 ml-0">
-                  Change Shadow Invigilator
+        </template>
+        <b-collapse id="collapse-remove-invigilators"
+                    class="mt-2 w-100">
+          <b-form-group class="q-info-display-grid-container">
+            <b-row class="ml-1">
+              <span style="font-weight: bold;">Current Invigilator(s): </span>
+            </b-row>
+            <b-row v-for="current in this.currentInvigilatorList"
+                      style="justify-content: center"
+                      class="mb-1"
+                      v-bind:key="current">
+                {{ current.name }}
+              </b-row>
+            <b-row class="ml-1">
+              <span style="font-weight: bold;">Would you like to remove invigilator(s)?</span>
+            </b-row>
+            <template>
+              <b-row style="display: flex; justify-content: center;"
+                      class="w-100 mb-0">
+                <b-button class="mr-2 mt-1"
+                          variant="danger"
+                          @click="setSelectedInvigilator">
+                  Yes
                 </b-button>
-                <b-button v-else-if="!this.changeState || !this.shadowInvigilatorBoolean"
-                          disabled
+                <b-button class="ml-2 mt-1"
                           variant="primary"
-                          class="mt-1 ml-0">
-                  Change Shadow Invigilator
+                          @click="closeRemoveInvigilator">
+                  No
                 </b-button>
+              </b-row>
+            </template>
+          </b-form-group>
+        </b-collapse>
+        <b-collapse id="collapse-invigilators"
+                    class="mt-2 mb-1 w-100">
+          <label class="mb-1">Add Invigilators</label>
+          <b-form class="q-info-display-grid-container">
+            <b-row>
+              <b-col cols="7">
+                <b-table selectable
+                        select-mode="multi"
+                        :fields="invigilatorFields"
+                        :items="invigilator_multi_select"
+                        responsive
+                        selected-variant="success"
+                        style="height: 110px; width: 250px;"
+                        @row-selected="rowSelected"
+                        bordered
+                        striped>
+                  <template slot="selected" slot-scope="{ rowSelected }">
+                    <span v-if="rowSelected">✔</span>
+                  </template>
+                </b-table>
               </b-col>
-              <b-col class="w-50 ml-1 mr-1 pl-1">
-                <b-button v-if="this.removeState && this.shadowInvigilatorBoolean"
-                          v-b-toggle.collapse-2
-                          variant="danger"
-                          @click="setChange"
-                          class="mt-1 mr-0">
-                  Remove Shadow Invigilator
-                </b-button>
-                <b-button v-else-if="!this.removeState || !this.shadowInvigilatorBoolean"
-                          disabled
-                          variant="danger"
-                          class="mt-1 mr-0">
-                  Remove Shadow Invigilator
-                </b-button>
+              <b-col cols="4">
+                <b-row class="mb-2"
+                      style="font-weight: bold;">
+                  Required Invigilators: {{ Math.ceil(actionedExam.number_of_students / 24) }}
+                </b-row>
+                <template v-if="checkCurrentLength">
+                  <b-row class="mb-2"
+                        style="font-weight: bold;">
+                    Current Invigilators:
+                  </b-row >
+                  <b-row v-for="current in this.currentInvigilatorList"
+                        style="justify-content: center"
+                        class="mb-1"
+                        v-bind:key="current">
+                    {{ current.name }}
+                  </b-row>
+                </template>
+                <b-row style="font-weight: bold;" class="mb-2">
+                  Selected Invigilators
+                </b-row>
+                <b-row v-for="select in selected"
+                      style="justify-content: center;"
+                      v-bind:key="select">
+                  {{ select.name }}
+                </b-row>
+                <b-row style="justify-content: center;"
+                      v-if="this.currentInvigilatorList.length == 0 && this.selected.length == 0"
+                      class="mt-2">
+                  <font-awesome-icon icon="life-ring"
+                                    style="font-size: 3.0rem; color: red;"
+                                    class="p-1"/>
+                </b-row>
+                <b-row style="justify-content: center;"
+                      v-else-if="(selected.length > 0 && selected.length < Math.ceil(actionedExam.number_of_students / 24)) ||
+                              (selected.length > Math.ceil(actionedExam.number_of_students / 24))"
+                      class="mt-2">
+                  <font-awesome-icon icon="exclamation-triangle"
+                                    style="font-size: 3.0rem; color: #FFC32B;"
+                                    class="p-1"/>
+
+                </b-row>
+                <b-row style="justify-content: center;"
+                      v-else-if="(selected.length == 0 && this.currentInvigilatorList.length < Math.ceil(actionedExam.number_of_students / 24))"
+                      class="mt-2">
+                  <font-awesome-icon icon="exclamation-triangle"
+                                    style="font-size: 3.0rem; color: #FFC32B;"
+                                    class="p-1"/>
+
+                </b-row>
+                <b-row style="justify-content: center;"
+                      v-else-if="(selected.length > 0 && selected.length == Math.ceil(actionedExam.number_of_students / 24))"
+                      class="mt-2">
+                  <font-awesome-icon icon="check"
+                                    style="font-size: 3.0rem; color: green;"
+                                    class="p-1"/>
+                </b-row>
+                <b-row style="justify-content: center;"
+                      v-else-if="(this.currentInvigilatorList.length == Math.ceil(actionedExam.number_of_students / 24))"
+                      class="mt-2">
+                  <font-awesome-icon icon="check"
+                                    style="font-size: 3.0rem; color: green;"
+                                    class="p-1"/>
+                </b-row>
               </b-col>
             </b-row>
-          </template>
-          <template v-else>
-            <b-button v-b-toggle.collapse-1
-                      variant="primary"
-                      class="mt-2"
-                      style="width: 93%; margin-left: 15px;"
-                      @click="setInvigilatorBoolean">
-              Add Shadow Invigilator
-            </b-button>
-          </template>
-          <b-collapse id="collapse-1"
-                      class="mt-2 mb-2 w-100">
-            <b-form-group class="q-info-display-grid-container">
-              <label>Shadow Invigilators</label>
-              <b-form>
-                <b-row>
-                  <b-col cols="7">
-                    <b-table selectable
-                             select-mode="single"
-                             :fields="shadowFields"
-                             :items="shadow_invigilator_options"
-                             @row-selected="rowSelectedShadow"
-                             responsive
-                             selected-variant="success"
-                             style="height: 150px; width: 250px;"
-                             bordered
-                             striped
-                             class="pl-2">
-                      <template slot="selected" slot-scope=" { rowSelected } ">
-                        <span v-if="rowSelected">✔</span>
-                      </template>
-                    </b-table>
-                  </b-col>
-                  <b-col cols="4">
-                    <b-row>
-                      Shadow Invigilator Limit: 1
-                    </b-row>
-                    <b-row v-if="this.currentShadowInvigilator != null"
-                           class="mb-1">
-                      Current Invigilator
-                    </b-row>
-                    <b-row v-if="this.currentShadowInvigilator != null"
-                           style="justify-content: center;"
-                           class="mb-1">
-                      {{ this.currentShadowInvigilatorName }}
-                    </b-row>
-                    <b-row style="font-weight: bold;"
-                           class="mb-0">
-                      Selected Invigilators
-                    </b-row>
-                    <b-row v-for="select in selectedShadow"
-                           style="justify-content: center;"
-                           class="mb-0">
-                      {{ select.name }}
-                    </b-row>
-                    <b-row style="justify-content: center;"
-                           v-if="this.selectedShadow"
-                           class="mt-2">
-                      <font-awesome-icon icon="check"
-                                         style="font-size: 3.0rem; color: green;"
-                                         class="p-1"/>
-                    </b-row>
-                  </b-col>
-                </b-row>
-              </b-form>
-            </b-form-group>
-          </b-collapse>
-          <b-collapse id="collapse-2"
-                      class="mt-2 w-100">
-            <b-form-group class="q-info-display-grid-container">
-              <b-row class="ml-1">
-                <span style="font-weight: bold;">Current Shadow Invigilator: </span>
-              </b-row>
-              <b-row class="mb-2"
-                     style="justify-content: center;">
-                <span>{{ this.currentShadowInvigilatorName}}</span>
-              </b-row>
-              <b-row class="ml-1">
-                <span style="font-weight: bold;">Would you like to remove this shadow invigilator?</span>
-              </b-row>
-              <template>
-                <b-row style="display: flex; justify-content: center;"
-                       class="w-100 mb-0">
-                  <b-button class="mr-2 mt-1"
-                            variant="danger"
-                            @click="setSelectedShadowNull">
-                    Yes
+          </b-form>
+        </b-collapse>
+        <!-- Invigilator End -->
+
+        <!-- Shadow Invigilator Start -->
+        <b-form-group>
+          <b-form-row>
+            <template v-if="this.currentShadowInvigilator != null">
+            <b-row style="display: flex;" class="w-100 ml-0 mb-2">
+                <b-col class="w-50 ml-0 mr-0 pr-1">
+                  <b-button v-if="this.changeState && this.shadowInvigilatorBoolean"
+                            v-b-toggle.collapse-1
+                            variant="primary"
+                            @click="setRemove"
+                            class="mt-1 ml-0">
+                    Change Shadow Invigilator
                   </b-button>
-                  <b-button class="ml-2 mt-1"
+                  <b-button v-else-if="!this.changeState || !this.shadowInvigilatorBoolean"
+                            disabled
                             variant="primary"
+                            class="mt-1 ml-0">
+                    Change Shadow Invigilator
+                  </b-button>
+                </b-col>
+                <b-col class="w-50 ml-1 mr-1 pl-1">
+                  <b-button v-if="this.removeState && this.shadowInvigilatorBoolean"
                             v-b-toggle.collapse-2
-                            @click="setChange">
-                    No
+                            variant="danger"
+                            @click="setChange"
+                            class="mt-1 mr-0">
+                    Remove Shadow Invigilator
                   </b-button>
+                  <b-button v-else-if="!this.removeState || !this.shadowInvigilatorBoolean"
+                            disabled
+                            variant="danger"
+                            class="mt-1 mr-0">
+                    Remove Shadow Invigilator
+                  </b-button>
+                </b-col>
+              </b-row>
+            </template>
+            <template v-else>
+              <b-button v-b-toggle.collapse-1
+                        variant="primary"
+                        class="mt-2"
+                        style="width: 93%; margin-left: 15px;"
+                        @click="setInvigilatorBoolean">
+                Add Shadow Invigilator
+              </b-button>
+            </template>
+            <b-collapse id="collapse-1"
+                        class="mt-2 mb-2 w-100">
+              <b-form-group class="q-info-display-grid-container">
+                <label>Shadow Invigilators</label>
+                <b-form>
+                  <b-row>
+                    <b-col cols="7">
+                      <b-table selectable
+                              select-mode="single"
+                              :fields="shadowFields"
+                              :items="shadow_invigilator_options"
+                              @row-selected="rowSelectedShadow"
+                              responsive
+                              selected-variant="success"
+                              style="height: 150px; width: 250px;"
+                              bordered
+                              striped
+                              class="pl-2">
+                        <template slot="selected" slot-scope=" { rowSelected } ">
+                          <span v-if="rowSelected">✔</span>
+                        </template>
+                      </b-table>
+                    </b-col>
+                    <b-col cols="4">
+                      <b-row>
+                        Shadow Invigilator Limit: 1
+                      </b-row>
+                      <b-row v-if="this.currentShadowInvigilator != null"
+                            class="mb-1">
+                        Current Invigilator
+                      </b-row>
+                      <b-row v-if="this.currentShadowInvigilator != null"
+                            style="justify-content: center;"
+                            class="mb-1">
+                        {{ this.currentShadowInvigilatorName }}
+                      </b-row>
+                      <b-row style="font-weight: bold;"
+                            class="mb-0">
+                        Selected Invigilators
+                      </b-row>
+                      <b-row v-for="select in selectedShadow"
+                            style="justify-content: center;"
+                            class="mb-0"
+                            v-bind:key="select">
+                        {{ select.name }}
+                      </b-row>
+                      <b-row style="justify-content: center;"
+                            v-if="this.selectedShadow"
+                            class="mt-2">
+                        <font-awesome-icon icon="check"
+                                          style="font-size: 3.0rem; color: green;"
+                                          class="p-1"/>
+                      </b-row>
+                    </b-col>
+                  </b-row>
+                </b-form>
+              </b-form-group>
+            </b-collapse>
+            <b-collapse id="collapse-2"
+                        class="mt-2 w-100">
+              <b-form-group class="q-info-display-grid-container">
+                <b-row class="ml-1">
+                  <span style="font-weight: bold;">Current Shadow Invigilator: </span>
                 </b-row>
-              </template>
-            </b-form-group>
-          </b-collapse>
-        </b-form-row>
-      </b-form-group>
+                <b-row class="mb-2"
+                      style="justify-content: center;">
+                  <span>{{ this.currentShadowInvigilatorName}}</span>
+                </b-row>
+                <b-row class="ml-1">
+                  <span style="font-weight: bold;">Would you like to remove this shadow invigilator?</span>
+                </b-row>
+                <template>
+                  <b-row style="display: flex; justify-content: center;"
+                        class="w-100 mb-0">
+                    <b-button class="mr-2 mt-1"
+                              variant="danger"
+                              @click="setSelectedShadowNull">
+                      Yes
+                    </b-button>
+                    <b-button class="ml-2 mt-1"
+                              variant="primary"
+                              v-b-toggle.collapse-2
+                              @click="setChange">
+                      No
+                    </b-button>
+                  </b-row>
+                </template>
+              </b-form-group>
+            </b-collapse>
+          </b-form-row>
+        </b-form-group>
+        <!-- Shadow Invigilator End -->
+      </template>
 
       <div v-if="showMessage"
             class="mb-3"
             style="color: red;">Nothing has changed.  All fields contain their initial values.</div>
       <div style="display: flex; justify-content: flex-end; width: 100%">
+        <b-btn class="w-12 mr-2 btn-warning" @click="show">Reset</b-btn>
         <b-btn class="btn-secondary mr-2" @click="cancel">Cancel</b-btn>
         <b-btn v-if="!allowSubmit"
                class="btn-primary disabled"
@@ -398,7 +473,6 @@
         <b-btn v-else-if="allowSubmit"
                class="btn-primary"
                @click="submit">Submit</b-btn>
-        <b-btn class="w-12 ml-2 btn-warning" @click="show">Reset</b-btn>
       </div>
     </div>
   </b-modal>
@@ -409,6 +483,8 @@
   import moment from 'moment'
   import zone from 'moment-timezone'
   import DatePicker from 'vue2-datepicker'
+  import Vue from 'vue'
+  const FileDownload = require('js-file-download')
 
   export default {
     name: "EditGroupExamBookingModal",
@@ -420,6 +496,7 @@
         date: '',
         time: '',
         offsite_location: '',
+        eventId: '',
         editedFields: [],
         showMessage: false,
         itemCopy: {},
@@ -434,13 +511,21 @@
         removeInvigilatorState: true,
         removeFlag: false,
         removeCurrentInvigilatorFlag: false,
-        fields: ['selected', 'name',],
+        invigilatorFields: ['selected', 'name',],
+        fields: {
+          exam_received_date: null,
+          notes: null,
+          event_id: null,
+          exam_name: null,
+        },
         numberOfInvigilators: 0,
         selected: [],
         currentInvigilatorList: [],
         invigilatorBoolean: true,
         shadowInvigilatorBoolean: true,
         groupInvigilatorBoolean: true,
+        exam_received: false,
+        examNotReady: false,
       }
     },
     computed: {
@@ -456,6 +541,8 @@
       ...mapState({
         showModal: state => state.showEditGroupBookingModal,
         invigilators: 'invigilators',
+        pesticide_invigilators: 'pesticide_invigilators',
+        pesticide_offsite_invigilators: 'pesticide_offsite_invigilators',
         user: 'user',
         shadowInvigilators: state => state.shadowInvigilators,
       }),
@@ -507,6 +594,26 @@
         }
         return ''
       },
+      exam() {
+        console.log(this.actionedExam)
+        if (Object.keys(this.actionedExam).length > 0) {
+          return this.actionedExam
+        }
+        return false
+      },
+      invigilatorList() {
+        console.log(this.invigilator_id)
+        let invigilators = (this.actionedExam.office && this.actionedExam.office.office_name == 'Pesticide Offsite') ? this.pesticide_offsite_invigilators : this.pesticide_invigilators;
+        return invigilators.map(invigilator => ({ text: invigilator.invigilator_name, value: parseInt(invigilator.invigilator_id) }))
+      },
+      examReceivedOptions() {
+        this.exam_received = this.actionedExam.exam_received_date !== null ? true : false;
+        this.fields.exam_received_date = this.actionedExam.exam_received_date
+        return [
+          { value: false, text: 'No' },
+          { value: true, text: 'Yes' },
+        ];
+      },
       fieldDisabled() {
         if ((this.role_code !== 'GA' && !this.is_liaison_designate) && this.examType != 'other') {
           return true
@@ -518,6 +625,7 @@
           return this.showModal
         },
         set(e) {
+          this.examNotReady = false
           this.toggleEditGroupBookingModal(e)
         }
       },
@@ -527,7 +635,8 @@
         'getBookings',
         'getExams',
         'postBooking',
-        'putRequest'
+        'putRequest',
+        'downloadExam',
       ]),
       ...mapMutations([
         'toggleEditGroupBookingModal'
@@ -635,6 +744,21 @@
             return
           }
         }
+        if (name === 'event_id') {
+          if (value !== this.itemCopy[name]) {
+            if (!this.editedFields.includes(e.target.name)) {
+              this.editedFields.push(e.target.name)
+            }
+            return
+          }
+          if (value === this.itemCopy[name]) {
+            if (this.editedFields.includes(e.target.name)) {
+              let i = this.editedFields.indexOf(e.target.name)
+              this.editedFields.splice(i, 1)
+            }
+            return
+          }
+        }
         if (name === 'invigilator_id') {
           if (!this.itemCopy.booking) {
             if (!this.editedFields.includes(name)) {
@@ -706,7 +830,8 @@
           }
 
           let examPut = {
-            offsite_location: this.offsite_location
+            offsite_location: this.offsite_location,
+            event_id: this.eventId
           }
           this.postBooking(bookingPost).then( booking_id => {
             examPut.booking_id = booking_id
@@ -764,18 +889,23 @@
             bookingChanges['shadow_invigilator_id'] = this.currentShadowInvigilator
           }
 
-          if(current_invigilator_id_list.length === 0){
-            bookingChanges['invigilator_id'] = invigilator_id_list
-          }
-          else if(invigilator_id_list.length >= current_invigilator_id_list.length){
-            bookingChanges['invigilator_id'] = invigilator_id_list
-          }
-          else if(invigilator_id_list.length < current_invigilator_id_list.length){
-            bookingChanges['invigilator_id'] = invigilator_id_list
-          }
-          else {
-            bookingChanges['invigilator_id'] = current_invigilator_id_list
+          if(this.actionedExam.is_pesticide) {
+            bookingChanges['invigilator_id'] = [this.invigilator_id]
+          } else {
+            if(current_invigilator_id_list.length === 0){
+              bookingChanges['invigilator_id'] = invigilator_id_list
+            }
+            else if(invigilator_id_list.length >= current_invigilator_id_list.length){
+              bookingChanges['invigilator_id'] = invigilator_id_list
+            }
+            else if(invigilator_id_list.length < current_invigilator_id_list.length){
+              bookingChanges['invigilator_id'] = invigilator_id_list
+            }
+            else {
+              bookingChanges['invigilator_id'] = current_invigilator_id_list
+            }
           }
+          
 
           if (this.removeCurrentInvigilatorFlag) {
             bookingChanges.invigilator_id = null
@@ -799,8 +929,13 @@
           }
         }
         let examChanges = {}
-        if (edits.includes('offsite_location')) {
+        console.log(edits)
+        console.log(this.itemCopy)
+        if (edits.includes('offsite_location') || edits.includes('invigilator_id') || edits.includes('exam_received') || edits.includes('event_id')) {
           examChanges['offsite_location'] = this.offsite_location
+          examChanges['event_id'] = this.eventId
+          examChanges['invigilator_id'] = this.invigilator_id
+          examChanges['exam_received_date'] = this.fields.exam_received_date
           putRequests.push({url:`/exams/${this.itemCopy.exam_id}/`, data: examChanges})
         }
 
@@ -840,13 +975,15 @@
         this.changeState = true
         this.selectedShadow = null
         this.removeFlag = false
-        this.actionedExam.booking.invigilators.forEach(function(invigilator) {
-          let indexOfInvigilator = self.invigilators.findIndex(x => x.invigilator_id == invigilator)
-          let index_invigilator_id = self.invigilators[indexOfInvigilator].invigilator_id
-          let index_invigilator_name = self.invigilators[indexOfInvigilator].invigilator_name
-          let invigilator_json = {name: index_invigilator_name, value: index_invigilator_id}
-          self.currentInvigilatorList.push(invigilator_json)
-        })
+        if(this.actionedExam.booking && this.actionedExam.booking.invigilators && !this.actionedExam.is_pesticide && !this.actionedExam.sbc_managed_ind) {
+          this.actionedExam.booking.invigilators.forEach(function(invigilator) {
+            let indexOfInvigilator = self.invigilators.findIndex(x => x.invigilator_id == invigilator)
+            let index_invigilator_id = self.invigilators[indexOfInvigilator].invigilator_id
+            let index_invigilator_name = self.invigilators[indexOfInvigilator].invigilator_name
+            let invigilator_json = {name: index_invigilator_name, value: index_invigilator_id}
+            self.currentInvigilatorList.push(invigilator_json)
+          })
+        }
         let tempItem = Object.assign({}, this.actionedExam)
         if (tempItem.booking && tempItem.booking.start_time) {
           let { start_time } = tempItem.booking
@@ -869,6 +1006,11 @@
           this.currentShadowInvigilatorName = currentName
         }
         this.offsite_location = tempItem.offsite_location === '_offsite' ? null : tempItem.offsite_location
+        this.eventId = tempItem.event_id
+        if(tempItem.is_pesticide && tempItem.invigilator_id) {
+          this.invigilator_id = parseInt(tempItem.invigilator_id)
+        }
+        console.log('invigilator_id: ', this.invigilator_id)
         this.editedFields = []
         this.itemCopy = tempItem
       },
@@ -876,9 +1018,11 @@
         this.time = null
         this.date = null
         this.offsite_location = null
+        this.eventId = null
         this.invigilator_id = null
         this.itemCopy = {}
         this.editedFields = []
+        this.exam_received = false
       },
       rowSelected(invigilator_multi_select){
         this.selected = invigilator_multi_select
@@ -981,6 +1125,49 @@
         this.changeInvigilatorState = !this.changeInvigilatorState
         this.groupInvigilatorBoolean = !this.groupInvigilatorBoolean
       },
+      updateExamReceived(e) {
+        let { exam_received_date } = this.fields
+        this.editedFields.push('exam_received')
+        if(e.type == 'exam-downloaded') {
+          this.exam_received = true
+        }
+        if (e && !exam_received_date) {
+          this.fields.exam_received_date = new moment().format('YYYY-MM-DD')
+          return
+        }
+        if (!e) {
+          this.fields.exam_received_date = null
+        }
+      },
+      checkAndDownloadExam() {
+        this.downloadExam(this.exam)
+          .then((resp) => {
+            console.log(resp.statusText)
+            let filename = `${this.exam.exam_id}.pdf`
+            FileDownload(resp.data, filename, "application/pdf")
+            this.updateExamReceived(new Event('exam-downloaded'))
+          })
+          .catch((error) => {
+            console.error(error)
+            this.examNotReady = true
+            setTimeout(() => { this.examNotReady = false }, 15000)
+          })
+      },
+      handleDate(date) {
+        console.log(date)
+        Vue.set(
+          this.fields,
+          'exam_received_date',
+          date
+        )
+      },
+      invigilatorChanged(value) {
+        console.log(value)
+        this.invigilator_id = value
+        if (!this.editedFields.includes('invigilator_id')) {
+          this.editedFields.push('invigilator_id')
+        }
+      }
     },
   }
 </script>
diff --git a/frontend/src/exams/exam-inventory-table.vue b/frontend/src/exams/exam-inventory-table.vue
index bd754653f..c45881114 100644
--- a/frontend/src/exams/exam-inventory-table.vue
+++ b/frontend/src/exams/exam-inventory-table.vue
@@ -48,23 +48,23 @@
             <b-input-group-prepend>
               <label class="mx-1 pt-3 mr-2 my-auto label-text">Filters</label>
             </b-input-group-prepend>
-            <b-btn-group v-if="is_liaison_designate" class="pt-2">
+            <!-- <b-btn-group v-if="is_liaison_designate" class="pt-2">
               <b-btn @click="officeFilterModal=true"
                      :variant="officeFilter === userOffice || officeFilter === 'default' ? 'primary' : 'warning'"
                      class="btn-sm mr-2">Office # {{ officeNumber }} - {{ officeName }}
               </b-btn>
-            </b-btn-group>
-              <b-dd v-if="is_ita_designate"
-                    split
-                    size="sm"
-                    :variant="officeFilter === userOffice || officeFilter === 'default' ? 'primary' : 'warning'"
-                    class="btn-sm mr-2 mt-2"
-                    :text="officeFilterText"
-                    @click="officeFilterModal=true">
-                <b-dd-item @click="viewAllOfficePesticideExams">
-                  {{ showAllPesticide ? 'Pesticide Office Only' : 'View All Offices' }}
-                </b-dd-item>
-              </b-dd>
+            </b-btn-group> -->
+            <b-dd v-if="is_ita_designate"
+                  split
+                  size="sm"
+                  :variant="officeFilter === userOffice || officeFilter === 'default' ? 'primary' : 'warning'"
+                  class="btn-sm mr-2 mt-2"
+                  :text="officeFilterText"
+                  @click="officeFilterModal=true">
+              <b-dd-item @click="viewAllOfficePesticideExams">
+                View All Offices
+              </b-dd-item>
+            </b-dd>
           </b-input-group>
 
           <!--  The Exam Type filter.  -->
@@ -78,7 +78,7 @@
                           v-model="selectedExamTypeFilter"
                           class="mt-2 mr-2">
                 <b-dropdown-item v-for="option in examTypeOptions"
-                                 @click="setExamTypeFilter(option)">
+                                 @click="setExamTypeFilter(option)" v-bind:key="option.value">
                   {{ option.text }}
                 </b-dropdown-item>
               </b-dropdown>
@@ -89,7 +89,7 @@
                           v-model="selectedExamTypeFilter"
                           class="mt-2 mr-2">
                 <b-dropdown-item v-for="option in examTypeOptions"
-                                 @click="setExamTypeFilter(option)">
+                                 @click="setExamTypeFilter(option)" v-bind:key="option.value">
                   {{ option.text }}
                 </b-dropdown-item>
               </b-dropdown>
@@ -103,7 +103,7 @@
                           v-model="selectedExamTypeFilter"
                           class="mt-2 mr-2">
                 <b-dropdown-item v-for="option in examTypeOptions"
-                                 @click="setExamTypeFilter(option)">
+                                 @click="setExamTypeFilter(option)" v-bind:key="option.value">
                   {{ option.text }}
                 </b-dropdown-item>
               </b-dropdown>
@@ -119,7 +119,7 @@
                             v-model="selectedQuickActionFilter"
                             class="mt-2 mr-2">
                   <b-dropdown-item v-for="option in newQuickActionOptions"
-                                   @click="setQuickActionFilter(option)">
+                                   @click="setQuickActionFilter(option)" v-bind:key="option.value">
                     <!--  The various Quick Action options. -->
                     <div style="display: flex; justify-content: space-between;">
                       <div class="mr-3">{{ option.text }}</div>
@@ -146,7 +146,7 @@
                             v-model="selectedQuickActionFilter"
                             class="mt-2 mr-2">
                   <b-dropdown-item v-for="option in newQuickActionOptions"
-                                   @click="setQuickActionFilter(option)">
+                                   @click="setQuickActionFilter(option)" v-bind:key="option.value">
                     <!--  The various Quick Action options. -->
                     <div style="display: flex; justify-content: space-between;">
                       <div class="mr-3">{{ option.text }}</div>
@@ -175,7 +175,7 @@
                             v-model="selectedQuickActionFilter"
                             class="mt-2 mr-2">
                   <b-dropdown-item v-for="option in newQuickActionOptionsNoOEM"
-                                   @click="setQuickActionFilter(option)">
+                                   @click="setQuickActionFilter(option)" v-bind:key="option.value">
                     <div style="display: flex; justify-content: space-between;">
                       <div class="mr-3">{{ option.text }}</div>
                       <div v-if="option.text === 'Ready'">
@@ -199,7 +199,7 @@
                             v-model="selectedQuickActionFilter"
                             class="mt-2 mr-2">
                   <b-dropdown-item v-for="option in newQuickActionOptionsNoOEM"
-                                   @click="setQuickActionFilter(option)">
+                                   @click="setQuickActionFilter(option)" v-bind:key="option.value">
                     <div style="display: flex; justify-content: space-between;">
                       <div class="mr-3">{{ option.text }}</div>
                       <div v-if="option.text === 'Ready'">
@@ -255,6 +255,7 @@
                :current-page="page"
                :per-page="10"
                :filter="searchTerm"
+               v-if="!isLoading"
                id="exam_inventory_table">
 
         <!--  Field 1 - Event id??? Don't see it.  -->
@@ -323,7 +324,7 @@
           <template v-if="stillRequires(row.item).length === 0">
             <div class="details-slot-div">
               <template v-for="(val, key) in readyDetailsMap(row.item)">
-                <div class="ml-3 mt-1" style="flex-grow: 1;"><b>{{ key }}: </b> {{ val }} </div>
+                <div class="ml-3 mt-1" style="flex-grow: 1;" v-bind:key="key"><b>{{ key }}: </b> {{ val }} </div>
               </template>
               <div style="flex-grow: 6"></div>
             </div>
@@ -341,7 +342,7 @@
               <!--  The Details info. -->
               <div style="flex-grow: 1; font-size: 1rem;">Details</div>
               <template v-for="(val, key) in readyDetailsMap(row.item)">
-                <div class="ml-3 mt-1" style="flex-grow: 1;"><b>{{ key }}: </b> {{ val }} </div>
+                <div class="ml-3 mt-1" style="flex-grow: 1;" :key="key"><b>{{ key }}: </b> {{ val }} </div>
               </template>
               <div style="flex-grow: 12" />
             </div>
@@ -379,7 +380,7 @@
                     </b-dropdown-item>
                   </template>
 
-                  <template v-if="!row.item.offsite_location || (row.item.exam_name === 'pesticide')">
+                  <template v-if="!row.item.offsite_location || row.item.is_pesticide">
                     <b-dropdown-item size="sm"
                                        v-if="row.item.booking && Object.keys(row.item.booking).length > 0"
                                      @click="updateCalendarBooking(row.item)">
@@ -392,9 +393,8 @@
 
                 <!--  Options for group exam ind (???).  -->
                 <template v-else-if="row.item.exam_type.group_exam_ind">
-                  <b-dropdown-item size="sm"> 444 </b-dropdown-item>
                   <b-dropdown-item size="sm"
-                                   v-if="row.item.offsite_location"
+                                   v-if="row.item.offsite_location || row.item.is_pesticide"
                                    @click="editGroupBooking(row.item)">
                     {{ checkInvigilator(row.item) ? 'Update Booking' : 'Add Invigilator' }}
                   </b-dropdown-item>
@@ -441,10 +441,11 @@
                 </template>
 
                   <b-dropdown-item size="sm"
-                                   @click="editExamDetails(row.item)">Edit Exam Details</b-dropdown-item>
+                      v-if="!(row.item.exam_type.group_exam_ind && row.item.is_pesticide)"
+                      @click="editExamDetails(row.item)">Edit Exam Details</b-dropdown-item>
                   <b-dropdown-item size="sm"
-                                   @click="returnExam(row.item)">
-                    {{ row.item.exam_type.pesticide_exam_ind ? 'Upload Exam' : 'Return Exam' }}
+                      @click="returnExam(row.item)">
+                    {{ row.item.is_pesticide ? 'Upload Exam' : 'Return Exam' }}
                   </b-dropdown-item>
               </template>
 
@@ -455,6 +456,9 @@
                                  @click="editGroupBooking(row.item)">Edit Booking</b-dropdown-item>
                 <b-dropdown-item size="sm"
                                  @click="editExamDetails(row.item)">Edit Exam Details</b-dropdown-item>
+                <b-dropdown-item size="sm" v-if="row.item.is_pesticide"
+                      @click="returnExam(row.item)">Upload Exam
+                </b-dropdown-item>
               </template>
             </template>
 
@@ -469,6 +473,9 @@
          {{ row.item.office.office_name }}
         </template>
       </b-table>
+      <div class="text-center" v-if="isLoading">
+        <b-spinner variant="primary" label="Loading"></b-spinner>
+      </div>
     </div>
     <!--  End of exam display.  -->
   </fragment>
@@ -504,6 +511,14 @@
       SelectInvigilatorModal
     },
     mounted() {
+      if(this.is_pesticide_designate) {
+        const pestFilterOptions = [
+          {text: 'Awaiting Upload', value: 'awaiting_upload'},
+          {text: 'Awaiting Receipt', value: 'awaiting_receipt'},
+          {text: 'All', value: 'all'},
+        ]
+        this.newQuickActionOptions = this.newQuickActionOptions.concat(pestFilterOptions)
+      }
       this.getExams().then( () => { this.getBookings() })
       this.getOffices()
       this.getInvigilators()
@@ -535,10 +550,6 @@
           {text: 'Office Exam Manager Action Items', value:'oemai'},
           {text: 'Expired', value: 'expired'},
           {text: 'Returned', value: 'returned'},
-          {text: 'Saved Drafts', value: 'saved_drafts'},
-          {text: 'Awaiting Upload', value: 'awaiting_upload'},
-          {text: 'Awaiting Receipt', value: 'awaiting_receipt'},
-          {text: 'All', value: 'all'},
         ],
         newQuickActionOptionsNoOEM: [
           {text: 'Ready', value: 'ready'},
@@ -547,6 +558,7 @@
           {text: 'Returned', value: 'returned'},
           {text: 'All', value: 'all'},
         ],
+        isLoading: false,
       }
     },
     computed: {
@@ -554,6 +566,7 @@
                      'exam_inventory',
                      'role_code',
                      'is_liaison_designate',
+                     'is_pesticide_designate',
                      'is_ita_designate']),
       ...mapState([
         'bookings',
@@ -662,7 +675,10 @@
       officeNumber() {
         if (this.inventoryFilters && this.inventoryFilters.office_number) {
           let { office_number } = this.inventoryFilters
-          if (office_number !== 'default') {
+          if (this.inventoryFilters.office_number === 'pesticide_offsite') {
+            let office = (this.offices.find(office => office.office_name == 'Pesticide Offsite'))
+            return office.office_number
+          } else if (office_number !== 'default') {
             return office_number
           }
         }
@@ -715,10 +731,7 @@
         this.toggleExamInventoryModal(false)
       },
       viewAllOfficePesticideExams() {
-        if (!this.showAllPesticide) {
-          this.$store.dispatch('getAllPesticideExams')
-          return
-        }
+        this.$store.dispatch('getAllPesticideExams')
         this.$store.commit('toggleShowAllPesticideExams', false)
       },
       checkChallenger(item) {
@@ -987,6 +1000,10 @@
         let examInventory = this.exam_inventory
         let office_number = this.inventoryFilters.office_number === 'default' ?
           this.user.office.office_number : this.inventoryFilters.office_number
+        if (this.inventoryFilters.office_number === 'pesticide_offsite') {
+          office_number = (this.offices.find(office => office.office_name == 'Pesticide Offsite')).office_number
+          this.inventoryFilters.office_number = office_number
+        }
         let filtered = []
         if (examInventory.length > 0) {
 
@@ -1065,19 +1082,35 @@
               evenMoreFiltered = moreFiltered
               break
           }
+          let uploadFiltered = []
+          switch(this.inventoryFilters.uploadFilter) {
+            case 'notuploaded':
+              uploadFiltered = evenMoreFiltered.filter(exam => !exam.upload_received_ind)
+              break
+            default:
+              uploadFiltered = evenMoreFiltered
+          } 
+          let receptSentFiltered = []
+          switch(this.inventoryFilters.receptSentFilter) {
+            case 'notsent':
+              receptSentFiltered = uploadFiltered.filter(exam => !exam.receipt_sent_ind)
+              break
+            default:
+              receptSentFiltered = uploadFiltered
+          } 
           let finalFiltered = []
           switch (this.inventoryFilters.returnedFilter) {
             case 'both':
-              finalFiltered = evenMoreFiltered
+              finalFiltered = receptSentFiltered
               break
             case 'returned':
-              finalFiltered = evenMoreFiltered.filter(ex => ex.exam_returned_date)
+              finalFiltered = receptSentFiltered.filter(ex => ex.exam_returned_date)
               break
             case 'unreturned':
-              finalFiltered = evenMoreFiltered.filter(ex => !ex.exam_returned_date)
+              finalFiltered = receptSentFiltered.filter(ex => !ex.exam_returned_date)
               break
             default:
-              finalFiltered = evenMoreFiltered
+              finalFiltered = receptSentFiltered
               break
           }
           return finalFiltered
@@ -1154,7 +1187,7 @@
       },
       returnExam(item) {
         this.actionedExam = item
-        if (item.exam_type.pesticide_exam_ind) {
+        if (item.is_pesticide) {
           this.toggleUploadExamModal(true)
         } else {
           this.toggleReturnExamModal(true)
@@ -1173,6 +1206,8 @@
           this.setInventoryFilters({type:'returnedFilter', value:'both'})
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+          this.setInventoryFilters({type:'uploadFilter', value:'default'})
         }else if (option.value === 'group'){
           this.setSelectedQuickAction('')
           this.setSelectedQuickActionFilter('')
@@ -1181,6 +1216,8 @@
           this.setInventoryFilters({type:'returnedFilter', value:'both'})
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+          this.setInventoryFilters({type:'uploadFilter', value:'default'})
         }else if (option.value === 'all'){
           this.setSelectedQuickAction('')
           this.setSelectedQuickActionFilter('')
@@ -1188,6 +1225,8 @@
           this.setInventoryFilters({type:'returnedFilter', value:'both'})
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+          this.setInventoryFilters({type:'uploadFilter', value:'default'})
           this.setInventoryFilters({type:'groupFilter', value:'both'})
         }
       },
@@ -1202,6 +1241,8 @@
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
           this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
+          this.setInventoryFilters({type:'uploadFilter', value: 'default'})
         }else if(option.value === 'require_attention') {
           if (this.selectedExamType === 'individual') {
             this.setInventoryFilters({type: 'returnedFilter', value: 'both'})
@@ -1209,15 +1250,21 @@
             this.setInventoryFilters({type: 'scheduledFilter', value: 'both'})
             this.setInventoryFilters({type: 'requireAttentionFilter', value: 'individual'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+            this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
+            this.setInventoryFilters({type:'uploadFilter', value: 'default'})
           } else if (this.selectedExamType === 'group') {
             this.setInventoryFilters({type: 'returnedFilter', value: 'unreturned'})
             this.setInventoryFilters({type: 'expiryFilter', value: 'all'})
             this.setInventoryFilters({type: 'scheduledFilter', value: 'unscheduled'})
             this.setInventoryFilters({type: 'requireAttentionFilter', value: 'group'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+            this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
+            this.setInventoryFilters({type:'uploadFilter', value: 'default'})
           } else if (this.selectedExamType === 'all') {
             this.setInventoryFilters({type: 'requireAttentionFilter', value: 'both'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+            this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
+            this.setInventoryFilters({type:'uploadFilter', value: 'default'})
             this.setInventoryFilters({type: 'expiryFilter', value: 'all'})
           }
         }
@@ -1227,12 +1274,16 @@
           this.setInventoryFilters({type:'scheduledFilter', value:'scheduled'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
           this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
+          this.setInventoryFilters({type:'uploadFilter', value: 'default'})
         }else if(option.value === 'expired'){
           this.setInventoryFilters({type:'expiryFilter', value:'expired'})
           this.setInventoryFilters({type:'returnedFilter', value:'unreturned'})
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
           this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+          this.setInventoryFilters({type:'uploadFilter', value:'default'})
         }else if(option.value === 'oemai'){
           if(this.selectedExamType === 'individual'){
             this.setInventoryFilters({type:'returnedFilter', value:'both'})
@@ -1240,36 +1291,65 @@
             this.setInventoryFilters({type:'scheduledFilter', value:'both'})
             this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'individual'})
+            this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+            this.setInventoryFilters({type:'uploadFilter', value:'default'})
           }else if(this.selectedExamType === 'group'){
             this.setInventoryFilters({type:'returnedFilter', value:'both'})
             this.setInventoryFilters({type:'expiryFilter', value:'all'})
             this.setInventoryFilters({type:'scheduledFilter', value:'both'})
             this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'group'})
+            this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+            this.setInventoryFilters({type:'uploadFilter', value:'default'})
           }else if(this.selectedExamType === 'all'){
             this.setInventoryFilters({type:'returnedFilter', value:'both'})
             this.setInventoryFilters({type:'expiryFilter', value:'all'})
             this.setInventoryFilters({type:'scheduledFilter', value:'both'})
             this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
             this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'both'})
+            this.setInventoryFilters({type:'receptSentFilter', value:'default'})
+            this.setInventoryFilters({type:'uploadFilter', value:'default'})
           }
-        }else if(option.value === 'saved_drafts'){
-          this.setInventoryFilters({type: 'expiryFilter', value: 'all'})
-        }else if(option.value === 'awaiting_upload'){
-          this.setInventoryFilters({type: 'expiryFilter', value: 'current'})
-          this.setInventoryFilters({type: 'groupFilter', value: 'both'})
-          this.setInventoryFilters({type: 'office_number', value: 'default'})
-          this.setInventoryFilters({type: 'returnedFilter', value: 'unreturned'})
-          this.setInventoryFilters({type: 'scheduledFilter', value: 'both'})
-          this.setInventoryFilters({type: 'uploaded', value: 'all'})
+        } else if(option.value === 'awaiting_upload'){
+          this.isLoading = true;
+          this.setInventoryFilters({type: 'office_number', value: 'pesticide_offsite'})
+          this.updateExamStatus().then(success => {
+            console.log(success)
+            this.$store.commit('toggleShowAllPesticideExams', false)
+            this.setInventoryFilters({type: 'expiryFilter', value: 'current'})
+            this.setInventoryFilters({type: 'groupFilter', value: 'both'})
+            this.setInventoryFilters({type: 'returnedFilter', value: 'unreturned'})
+            this.setInventoryFilters({type: 'scheduledFilter', value: 'both'})
+            this.setInventoryFilters({type: 'receptSentFilter', value: 'default'})
+            this.setInventoryFilters({type: 'uploadFilter', value: 'notuploaded'})
+            this.isLoading = false;
+          }, err => {
+            console.error(err)
+            this.isLoading = false;
+          }).catch(err => {
+            this.isLoading = false;
+          })
+        } else if(option.value === 'awaiting_receipt'){
+
+          // this.$store.commit('toggleShowAllPesticideExams', false)
+          this.viewAllOfficePesticideExams()
 
-          this.updateExamStatus()
-        }else if(option.value === 'all'){
+          this.setInventoryFilters({type: 'expiryFilter', value: 'current'})
+          this.setInventoryFilters({type:'scheduledFilter', value:'both'})
+          this.setInventoryFilters({type:'returnedFilter', value:'unreturned'})
+          this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
+          this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+          this.setInventoryFilters({type:'uploadFilter', value: 'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value: 'notsent'})
+        } else if(option.value === 'all'){
           this.setInventoryFilters({type: 'expiryFilter', value: 'all'})
           this.setInventoryFilters({type:'scheduledFilter', value:'both'})
+          this.setInventoryFilters({type:'groupFilter', value:'both'})
           this.setInventoryFilters({type:'returnedFilter', value:'both'})
           this.setInventoryFilters({type:'requireAttentionFilter', value:'default'})
           this.setInventoryFilters({type:'requireOEMAttentionFilter', value: 'default'})
+          this.setInventoryFilters({type:'uploadFilter', value: 'default'})
+          this.setInventoryFilters({type:'receptSentFilter', value: 'default'})
         }
       },
       setFilter(e) {
@@ -1312,7 +1392,7 @@
           if (!value) {
             return ''
           } else if (value instanceof Object) {
-            return keys(value)
+            return Object.keys(value)
             .sort()
             .map(key => toString(value[key]))
             .join(' ')
@@ -1349,6 +1429,11 @@
           rank: 1,
           style: {fontSize: '1rem', color: '#4e9de0'}
         }
+        let feePending = {
+          icon: 'dollar-sign',
+          rank: 2,
+          style: {fontSize: '1rem', color: 'green'}
+        }
         if (item.exam_returned_date) {
           return envelopeOpenText
         }
@@ -1421,6 +1506,9 @@
         if (!item.exam_received_date) {
             return exclamationTriangle
         }
+        if (item.is_pesticide && item.exam_received_date && !item.receipt) {
+          return feePending
+        }
         return clipboardCheck
       },
       stillRequires(item) {
@@ -1450,6 +1538,7 @@
             output.push('Event ID')
           }
         }
+        console.log(item)
         if (item.booking) {
           if(item.exam_type.group_exam_ind == 1){
             if(length_of_invigilator_array == 0 && number_of_invigilators == 1){
diff --git a/frontend/src/exams/form-components/group-pesticide-modal.vue b/frontend/src/exams/form-components/group-pesticide-modal.vue
index 3d0d3b62e..13f29aaf4 100644
--- a/frontend/src/exams/form-components/group-pesticide-modal.vue
+++ b/frontend/src/exams/form-components/group-pesticide-modal.vue
@@ -12,8 +12,7 @@
                        autocomplete="off"
                        class="my-0 pb-0"
                        size="sm"
-                       @click.prevent
-                       @input.prevent="clickSelectItem"
+                       @click="clickSelectItem"
                        :select-size="6" />
       </b-col>
     </b-row>
@@ -176,7 +175,7 @@
                                    class="mr-2"
                                    style="font-size: 1rem;" />
               </div>
-              <div>{{ row.item.name }}</div>
+              <div>{{ row.item.exam_type_name }}</div>
               <div v-show="false">
                 {{ currentlyEditing === 'exam' && row.item.exam_type_id === highlightedTableRow.exam_type_id ?
                 row.item._rowVariant = 'primary' : row.item._rowVariant = 'secondary' }}
@@ -348,6 +347,7 @@
             output.push(candidate)
           }
         }
+        this.$store.commit('setCandidateTableData', output)
         return output
       },
     },
diff --git a/frontend/src/exams/select-invigilator-modal.vue b/frontend/src/exams/select-invigilator-modal.vue
index 9739ab6e7..5d6890bfc 100644
--- a/frontend/src/exams/select-invigilator-modal.vue
+++ b/frontend/src/exams/select-invigilator-modal.vue
@@ -45,6 +45,7 @@
     components: { },
     mounted() {
       this.getPesticideOfficeInvigilators()
+      this.getPesticideOffsiteInvigilators()
     },
     props: [],
     data () {
@@ -61,6 +62,7 @@
       ...mapState({
         showSelectInvigilatorModal: state => state.showSelectInvigilatorModal,
         pesticide_invigilators: state => state.pesticide_invigilators,
+        selectedExam: 'selectedExam',
       }),
       modal: {
         get() {
@@ -76,7 +78,7 @@
       },
     },
     methods: {
-      ...mapActions(['emailInvigilator', 'getPesticideOfficeInvigilators']),
+      ...mapActions(['emailInvigilator', 'getPesticideOfficeInvigilators', 'getPesticideOffsiteInvigilators']),
       ...mapMutations([
         'setSelectedExam',
         'toggleSelectInvigilatorModal',
@@ -98,15 +100,18 @@
       },
       submit() {
         this.loading = true
-        this.emailInvigilator(this.selected_invigilator)
-          .then(() => {
-            this.toggleSelectInvigilatorModal(false);
-            this.loading = false
-          })
-          .catch(() => {
-            this.alertMessage = "An error occurred emailing the invigilator"
-            this.loading = false
-          })
+        this.emailInvigilator({
+          'invigilator': this.selected_invigilator,
+          'exam': selectedExam,
+        })
+        .then(() => {
+          this.toggleSelectInvigilatorModal(false);
+          this.loading = false
+        })
+        .catch(() => {
+          this.alertMessage = "An error occurred emailing the invigilator"
+          this.loading = false
+        })
       },
     },
   }
diff --git a/frontend/src/exams/upload-pesticide-exam.vue b/frontend/src/exams/upload-pesticide-exam.vue
index d8103ada1..862727953 100644
--- a/frontend/src/exams/upload-pesticide-exam.vue
+++ b/frontend/src/exams/upload-pesticide-exam.vue
@@ -1,18 +1,17 @@
 <template>
-  <b-modal v-model="modal"
+  <b-modal v-model="modalVisible"
            @shown="showModal"
            :no-close-on-backdrop="true"
            hide-header
            size="md"
-           @hidden="resetModal()">
+           @hidden="resetModal">
     <template slot="modal-footer">
       <div style="display: flex; justify-content: flex-end; width: 100%">
         <b-btn class="btn-secondary mr-2"
-               @click="resetModal()">{{ submitted ? 'Done' : 'Cancel' }}</b-btn>
+               @click="resetModal">{{ submitted ? 'Done' : 'Cancel' }}</b-btn>
         <b-btn class="btn-primary"
                v-if="!submitted"
-               @click.prevent="submitted = true"
-               @click="submit()">Submit</b-btn>
+               @click.once="submit">Submit</b-btn>
       </div>
     </template>
 
@@ -20,8 +19,8 @@
       <b-form-row>
         <b-col class="q-modal-header">Upload Completed Exam</b-col>
       </b-form-row>
-      <b-form-row>
-        <b-col v-if="submitted" class="text-center mt-2">
+      <b-form-row v-if="submitted">
+        <b-col class="text-center mt-2">
           <font-awesome-icon icon="check"
                              class="m-0 p-0"
                              style="font-size: 5rem; color: green" />
@@ -39,18 +38,27 @@
               </div>
               <div class="q-id-grid-col px-2">
                 <div>Upload Status:</div>
-                <div style="color: red">Not Received</div>
+                <div style="color: green" v-if="actionedExam.upload_received_ind">Received</div>
+                <div style="color: red" v-else>Not Received</div>
               </div>
             </div>
           </div>
         </b-col>
       </b-form-row>
-      <template v-if="!submitted">
+      <template v-if="!submitted && !isLoading">
+        <b-form-row v-if="actionedExam.upload_received_ind">
+          <b-col :cols="12">
+            <b-form-group class="mt-2 mb-0">
+              <label class="mb-0">Upload Again?</label><br>
+              <p>This exam appears to be received, however you can submit it again if needed.</p>
+            </b-form-group>
+          </b-col>
+        </b-form-row>
         <b-form-row>
           <b-col :cols="6">
             <b-form-group class="mb-0">
               <label class="mb-0">Exam Status</label><br>
-              <b-select id="exam-returned-select"
+              <b-select id="exam-status-select"
                         v-model="status"
                         :options="statusOptions" />
             </b-form-group>
@@ -62,9 +70,7 @@
               <label class="mb-0">Attach Scanned Exam</label><br>
               <b-form-file
                 v-model="file"
-                :state="file"
                 placeholder="Choose a file or drop it here..."
-                no-drop
               ></b-form-file>
             </b-form-group>
           </b-col>
@@ -89,7 +95,16 @@
             </b-form-group>
           </b-col>
         </b-form-row>
+        <b-alert
+          class="mt-2"
+          :show="uploadFailed"
+          variant="danger">
+          File upload failed, please try again.
+          </b-alert>
       </template>
+      <div class="text-center" v-if="isLoading && !submitted">
+        <b-spinner variant="primary" label="Loading"></b-spinner>
+      </div>
     </b-form>
 
   </b-modal>
@@ -105,7 +120,7 @@
       return {
         file: null,
         examNotes: this.actionedExam.notes,
-        status: this.actionedExam.exam_destroyed_date !== null ? 'noshow' : 'unwritten',
+        status: 'unwritten',
         destroyed: this.actionedExam.exam_destroyed_date !== null ? true : false,
         submitted: false,
         statusOptions: [
@@ -113,23 +128,22 @@
           { value: 'written', text: 'Written' },
           { value: 'noshow', text: 'No Show' }
         ],
+        uploadFailed: false,
+        isLoading: false,
       }
     },
     computed: {
       ...mapState({
         showModal: state => state.addExamModule.uploadPesticideModalVisible,
       }),
-      examNotes: {
-        get() { return this.feedbackMessage },
-        set(value) { this.examNotes = value }
-      },
       exam() {
         if (this.actionedExam) {
+          console.log("this.actionedExam ", this.actionedExam)
           return this.actionedExam
         }
         return {}
       },
-      modal: {
+      modalVisible: {
         get() {
           return this.showModal
         },
@@ -138,57 +152,66 @@
         },
       },
     },
+    mounted() {
+      this.uploadFailed = false
+      if(this.actionedExam.exam_destroyed_date !== null) {
+        this.status = 'noshow'
+      } else if(this.actionedExam.upload_received_ind && this.actionedExam.exam_written_ind) {
+        this.status = 'written'
+      } else {
+        this.status = 'unwritten'
+      }
+    },
     methods: {
-      ...mapActions(['putExamInfo', 'getExams', 'getBCMPlusExamStatus', 'submitExam', 'toggleUploadExamModal' ]),
+      ...mapActions(['putExamInfo', 'getExams', 'getBCMPlusExamStatus', 'submitExam' ]),
       ...mapMutations(['toggleUploadExamModal', 'setEditExamFailure' ]),
       resetModal() {
         this.resetExam()
         this.toggleUploadExamModal(false)
       },
       submit() {
+        this.uploadFailed = false
+        this.isLoading = true
         let putData = {
           exam_id: this.exam.exam_id,
-          exam_returned_tracking_number: this.exam_returned_tracking_number,
           notes: this.examNotes,
-          exam_written_ind: 0,
-          exam_destroyed_date: null
+          exam_written_ind: (this.status === 'written') ? 1 : 0,
+          exam_destroyed_date: (this.destroyed) ? new Date().toISOString() : null,
         }
 
-        if (this.statusOptions === 'written') {
-          putData.exam_written_ind = 1
-        }
-        if (this.destroyed) {
-          putData.exam_destroyed_date = new Date().toISOString()
-        }
+        console.log(this.exam)
+        console.log(this.status)
 
-        if (!this.written && this.modalUse === 'edit') {
-          putData = {
-            exam_id: this.exam.exam_id,
-            exam_returned_date: null,
-            exam_returned_tracking_number: null,
-            notes: ''
-          }
-        }
-        if (this.notes) {
-          putData.notes = this.notes
-        }
-        this.putExamInfo(putData).then( () => {
-          console.log(this.exam)
+        if (this.status === 'written' && this.file) {
           this.submitExam({file: this.file, exam: this.exam})
-            .then(() => {
-              this.getExams()
-                .then( () => {
-                  this.resetModal()
-                })
-                .catch((error) => {
-                  console.error(error)
-                })
+            .then((bcmpResponse) => {
+              this.isLoading = false
+              this.submitted = true
+              console.log(bcmpResponse)
+              putData['upload_received_ind'] = this.actionedExam.upload_received_ind = 1
+              putData['exam_returned_date'] = this.actionedExam.exam_returned_date = new Date().toISOString()
+              this.updateExam(putData)
             })
             .catch( (error) => {
+              this.uploadFailed = true
+              this.isLoading = false
               console.error(error)
             })
-        })
-      }
+        } else {
+          this.updateExam(putData)
+        }
+      },
+      updateExam(putData) {
+        this.putExamInfo(putData)
+          .then(() => {
+            // setTimeout(()=> {
+            //   this.resetModal()
+            // }, 3000)
+          })
+          .catch( (error) => {
+            console.error(error)
+          })
+      },
     },
   }
 </script>
diff --git a/frontend/src/layout/footer.vue b/frontend/src/layout/footer.vue
index 6b4a98993..2662b0bb8 100644
--- a/frontend/src/layout/footer.vue
+++ b/frontend/src/layout/footer.vue
@@ -24,7 +24,7 @@
           <a href="#" @click="keycloakLogin()" id="keycloak-login">Keycloak Login</a>
         </div>
         <div class="footer-anchor-item-last" style="display:inline-block; color: white; margin-right:15px;">
-          v1.0.87
+          v1.0.92
         </div>
       </div>
     </div>
diff --git a/frontend/src/serve-citizen/dash-buttons.vue b/frontend/src/serve-citizen/dash-buttons.vue
index 86331244c..3f5f03271 100644
--- a/frontend/src/serve-citizen/dash-buttons.vue
+++ b/frontend/src/serve-citizen/dash-buttons.vue
@@ -16,7 +16,10 @@
 
 <template>
   <div id="dash-flex-button-container">
-    <div>
+    <div id="navi">
+            <template v-if="showInviteCitizenSpinner">
+              <div class="q-loader2" ></div>
+            </template>
       <b-button class="btn-primary mr-1"
                 @click="invite"
                 :disabled="citizenInvited || showTimeTrackingIcon || performingAction || showAdmin"
@@ -86,6 +89,7 @@
         'showTimeTrackingIcon',
         'serveNowStyle',
         'user',
+        'showInviteCitizenSpinner'
       ]),
       queueLength() {
         return this.citizens_queue.length
@@ -155,11 +159,30 @@
 </script>
 
 <style scoped>
+  #navi {
+    position: relative;
+    z-index: 1000;
+  }
+  .q-loader2 {
+    position: absolute;
+    text-align: center;
+    margin: 50px auto auto 50px;
+    width: 50px;
+    height: 50px;
+    border: 10px solid LightGrey;
+    opacity:0.9;
+    border-radius: 50%;
+    border-top-color: DodgerBlue;
+    animation: spin 1s ease-in-out infinite;
+    -webkit-animation: spin 1s ease-in-out infinite;
+    z-index: 1500;
+}
   #dash-flex-button-container {
     display: flex;
     justify-content: space-between;
     width: 100%;
     height: 100% !important;
+    z-index: 1;
   }
   .btn-highlighted {
     color: black;
diff --git a/frontend/src/serve-citizen/serve-citizen.vue b/frontend/src/serve-citizen/serve-citizen.vue
index 249ef27c3..7591c055f 100644
--- a/frontend/src/serve-citizen/serve-citizen.vue
+++ b/frontend/src/serve-citizen/serve-citizen.vue
@@ -1,12 +1,11 @@
-
-
 <template>
   <div id="serveModal" class="serve-modal">
     <div class="serve-modal-content">
-      <template v-if="showServeCitizenSpinner">
-        <div class="q-loader" />
-      </template>
-      <template v-else>
+      <div id="navi">
+        <template v-if="showServeCitizenSpinner">
+          <div class="q-loader2" ></div>
+        </template>
+      </div>
         <b-alert :show="this.alertMessage != ''"
                   style="h-align: center"
                   variant="warning">{{this.alertMessage}}</b-alert>
@@ -155,7 +154,6 @@
             </b-row>
           </b-container>
         </template>
-      </template>
     </div>
   </div>
 </template>
@@ -408,6 +406,23 @@ export default {
 </script>
 
 <style scoped>
+   #navi {
+    position: relative;
+  }
+  .q-loader2 {
+    position: absolute;
+    z-index: 1100;
+    text-align: center;
+    margin: 250px auto auto 450px;
+    width: 50px;
+    height: 50px;
+    border: 10px solid LightGrey;
+    opacity:0.9;
+    border-radius: 50%;
+    border-top-color: DodgerBlue;
+    animation: spin 1s ease-in-out infinite;
+    -webkit-animation: spin 1s ease-in-out infinite;
+}
 .serve-modal {
   position: fixed;
   z-index: 1040;
diff --git a/frontend/src/smartboard/board-socket.vue b/frontend/src/smartboard/board-socket.vue
index ce804fdca..e21c5e44f 100644
--- a/frontend/src/smartboard/board-socket.vue
+++ b/frontend/src/smartboard/board-socket.vue
@@ -40,7 +40,10 @@ limitations under the License.*/
     methods: {
       connect(data) {
         socket = io(process.env.SOCKET_URL, {
-          path: '/api/v1/socket.io'
+          timeout: '3000',
+          reconnectionDelayMax: '100',
+          path: '/api/v1/socket.io',
+          transports: ['websocket']
         })
         socket.on('connect',()=>{this.onConnect()})
         socket.on('disconnect',()=>{this.onDisconnect()})
@@ -80,6 +83,7 @@ limitations under the License.*/
 //LISTENER METHODS
       onConnect() {
         console.log('boardSocket connected')
+        console.log("==> In board-socket.vue, onConnect, socket.io.engine.id is: " + socket.io.engine.id.toString())
         clearInterval(this.reconnectInterval)
         this.join()
       },
diff --git a/frontend/src/smartboard/call-by-name.vue b/frontend/src/smartboard/call-by-name.vue
index 9f744d4d8..24cc21349 100644
--- a/frontend/src/smartboard/call-by-name.vue
+++ b/frontend/src/smartboard/call-by-name.vue
@@ -14,8 +14,8 @@ limitations under the License.*/
 
 
 <template>
-  <div style="display: flex; height: 75%; width: 100%; justify-content: center">
-    <div class="board-85-video">
+  <div style="">
+    <div class="board-nameticket-video">
       <div class="board-video-div">
         <Video :office_number="smartboardData.office_number" />
       </div>
diff --git a/frontend/src/smartboard/call-by-ticket.vue b/frontend/src/smartboard/call-by-ticket.vue
index f9e362c53..85034f7e7 100644
--- a/frontend/src/smartboard/call-by-ticket.vue
+++ b/frontend/src/smartboard/call-by-ticket.vue
@@ -15,7 +15,7 @@ limitations under the License.*/
 <template>
 <div style="width: 100%; height: 100%;">
   <div style="display: flex; height: 75%; width: 100%;">
-    <div class="board-85-video">
+    <div class="board-nameticket-video">
       <div class="board-video-div">
         <Video :office_number="smartboardData.office_number" />
       </div>
diff --git a/frontend/src/smartboard/index.vue b/frontend/src/smartboard/index.vue
index dd707a22a..9f8525f62 100644
--- a/frontend/src/smartboard/index.vue
+++ b/frontend/src/smartboard/index.vue
@@ -143,7 +143,8 @@ export default {
   .flashing-ticket {color: red; font-size: 1rem }
   .board-content-div { background-color: white; box-shadow: 2px 3px 10px rgba(0, 0, 0, .5); text-align: center; }
   .board-table-style { width: 100%; background-color: white; text-align: center; }
-  .board-85-video { display: inline-block; width: 74%; padding-left: 1%; padding-right: 1%; margin: 8px auto 0 auto; }
+  .board-nameticket-video { display: inline-block; width: 74%; }
+  .board-noticket-video { display: inline-block; width: 85%; }
   .board-25-table { display: inline-block; width: 24%; max-height: 60vh; padding-left: 1%; padding-right: 1%; vertical-align: top; }
   .flex-title { font-size: 4.0rem; color: midnightblue; margin-top: -4px; }
   .video-js { background-color: white; }
diff --git a/frontend/src/smartboard/non-reception.vue b/frontend/src/smartboard/non-reception.vue
index 9aecbf65b..093562d6c 100644
--- a/frontend/src/smartboard/non-reception.vue
+++ b/frontend/src/smartboard/non-reception.vue
@@ -15,7 +15,7 @@ limitations under the License.*/
 
 <template>
   <div style="display: flex; height: 75%; width: 100%; justify-content: center">
-      <div class="board-85-video">
+      <div class="board-noticket-video">
         <div class="board-video-div">
           <Video :office_number="smartboardData.office_number" />
         </div>
diff --git a/frontend/src/store/add-exam-module.js b/frontend/src/store/add-exam-module.js
index 406c4e29d..0acdb9576 100644
--- a/frontend/src/store/add-exam-module.js
+++ b/frontend/src/store/add-exam-module.js
@@ -162,8 +162,8 @@ const pesticideFeesQ = {
   kind: 'pesticideFees',
   minLength: 0,
   options: [
-    { text: 'Collect', value: 'collect' },
-    { text: 'Paid', value: 'paid' }
+    { text: 'Collect at Exam Time', value: 'collect' },
+    { text: 'Paid with Liasion', value: 'paid' }
   ],
   text: 'Fees',
 }
@@ -237,7 +237,7 @@ export const addExamModule = {
 
         Axios(rootState.bearer).get(url)
           .then(resp => {
-            let pesticideExams = resp.data.exams.filter(exam => exam.exam_type.pesticide_exam_ind)
+            let pesticideExams = resp.data.exams.filter(exam => exam.is_pesticide)
             commit('setAllPesticideExams', pesticideExams)
             commit('toggleShowAllPesticideExams', true)
             resolve()
@@ -296,9 +296,9 @@ export const addExamModule = {
                 Axios(context.rootState.bearer).post(bcmpUrl)
                   .then((transferResponse) => {
                     console.log(transferResponse)
-                    resolve()
+                    resolve(transferResponse)
                   })
-                  .error((error) => {
+                  .catch((error) => {
                     console.error(error)
                   })
               })
@@ -306,7 +306,7 @@ export const addExamModule = {
                 console.error(error)
               })
           })
-          .error((error) => {
+          .catch((error) => {
             console.error(error)
             reject(error)
           })
@@ -338,15 +338,11 @@ export const addExamModule = {
         ...getters.pesticideStep1,
         ...getters.pesticideStep2,
         ...getters.pesticideStep3,
-        ...[{
-          step: 4,
-          title: 'Summary',
-          questions: [summaryQ]
-        }],
+        ...getters.pesticideStep4,
       ]
     },
     pesticideStep1(state, getters, rootState) {
-      let { capturedExam } = rootState
+      let { capturedExam, pesticide_invigilators, pesticide_offsite_invigilators } = rootState
       let pesticideTypeQ = {
         key: 'exam_type_id',
         text: 'Type of Pesticide Exam',
@@ -357,16 +353,29 @@ export const addExamModule = {
       }
 
       let step1 = { ...state.pesticideStep1 }
-      if ( capturedExam.sbc_managed === 'sbc' ) {
-        step1.questions = [...step1.questions, officeSelectQ]
-      }
 
       if ( capturedExam.ind_or_group === 'individual' ) {
         if ( step1.questions.findIndex(step => step.key === 'pesticide_type') === -1 ) {
           step1.questions = [...step1.questions, pesticideTypeQ]
-          return [step1]
         }
       }
+      if ( capturedExam.sbc_managed === 'sbc' ) {
+        step1.questions = [...step1.questions, officeSelectQ]
+        if( capturedExam.ind_or_group === 'group' ) {
+          step1.questions.push(offsiteQ)
+        }
+      }
+      if ( capturedExam.sbc_managed === 'non-sbc' ) {
+        let invigilatorQ = {
+          key: 'invigilator_id',
+          text: 'Invigilator',
+          kind: 'select',
+          options: pesticide_offsite_invigilators.map(invigilator => ({ text: invigilator.invigilator_name, value: parseInt(invigilator.invigilator_id) })),
+          minLength: 1,
+          digit: true,
+        }
+        step1.questions = [...step1.questions, offsiteQ, invigilatorQ]
+      }
       return [step1]
     },
     pesticideStep2(state, getters, rootState) {
@@ -403,6 +412,13 @@ export const addExamModule = {
       }
       return [ state.pesticideStep3 ]
     },
+    pesticideStep4(state, getters, rootState) {
+      let { capturedExam } = rootState
+
+      let step4 = { ...state.pesticideStep4_summary }
+      
+      return [ step4 ]
+    },
   },
   mutations: {
     clearChallengerBooking(state) {
@@ -425,6 +441,7 @@ export const addExamModule = {
     setAllPesticideExams: (state, payload) => state.allPesticideExams = payload,
     setPesticideExamTypes: (state, payload) => state.pesticideExamTypes = payload,
     setSelectedExams: (state, payload) => state.candidates = payload,
+    setCandidateTableData: (state, payload) => state.candidateTableData = payload,
     toggleShowAllPesticideExams: (state, payload) => state.showAllPesticideExams = payload,
     toggleUploadExamModal: (state, payload) => state.uploadPesticideModalVisible = payload,
   },
@@ -465,7 +482,7 @@ export const addExamModule = {
       {
         step: 3,
         title: 'Date, Time & Format',
-        questions: [ dateTimeQ, timeQ, examMethodQ, offsiteQ, notesQ ]
+        questions: [ dateTimeQ, timeQ, examMethodQ, offsiteQ, notesQ, ]
       },
       {
         step: 4,
@@ -519,8 +536,10 @@ export const addExamModule = {
     ],
     allPesticideExams: null,
     candidates: [],
+    candidateTableData: [],
     challengerBooking: {},
     pesticideExamTypes: [],
+    invigilators: [],
     pesticideGroupStep3: {
       step: 3,
       title: 'Notes',
@@ -549,12 +568,17 @@ export const addExamModule = {
     pesticideStep3_payee: {
       step: 3,
       title: 'Payee/Notes',
-      questions: [ payeeNameQ, payeeEmailQ, payeePhoneQ, offsiteQ, notesQ ]
+      questions: [ payeeNameQ, payeeEmailQ, payeePhoneQ, notesQ ]
     },
     pesticideStep3_group: {
       step: 3,
       title: 'Date, Time & Format',
-      questions: [ dateTimeQ, timeQ, offsiteQ, notesQ ]
+      questions: [ dateTimeQ, timeQ, notesQ ]
+    },
+    pesticideStep4_summary: {
+      step: 4,
+      title: 'Summary',
+      questions: [ summaryQ ]
     },
     showAllPesticideExams: false,
     uploadPesticideModalVisible: false,
diff --git a/frontend/src/store/appointments-module.js b/frontend/src/store/appointments-module.js
index f93365d4d..45e790e41 100644
--- a/frontend/src/store/appointments-module.js
+++ b/frontend/src/store/appointments-module.js
@@ -11,12 +11,14 @@ export default {
       title: null,
       name: null
     },
+    checkInClicked: false,
     editDeleteSeries: false,
     selectedService: null,
     showApptBookingModal: false,
     showAppointmentBlackoutModal: false,
     showCheckInModal: false,
     services: [],
+    submitClicked: false
   },
   getters: {
     service_name: (state, getters, rootState) => {
@@ -86,7 +88,7 @@ export default {
       commit('updateAddModalForm', { type: 'search', value: null}, {root: true})
       commit('setSelectedService', null)
     },
-  
+
     deleteAppointment({dispatch, rootState}, payload) {
       let state = rootState
       return new Promise((resolve, reject) => {
@@ -108,7 +110,7 @@ export default {
         })
       })
     },
-  
+
     getAppointments({commit, rootState}) {
       let state = rootState
       let output = []
@@ -123,17 +125,17 @@ export default {
         })
       })
     },
-    
+
     getChannels({dispatch}) {
       dispatch('getChannels', null, {root: true})
     },
-    
+
     getServices({dispatch, commit}) {
       dispatch('getServices', null, {root: true})
       dispatch('getCategories', null, {root: true})
       dispatch('getChannels', null, {root: true})
     },
-    
+
     postAddToQueue({rootState}, payload) {
       let state = rootState
       return new Promise((resolve, reject) => {
@@ -145,7 +147,7 @@ export default {
         })
       })
     },
-  
+
     postAppointment({rootState}, payload) {
       let state = rootState
       payload.office_id = rootState.user.office_id
@@ -155,8 +157,8 @@ export default {
         })
       })
     },
-    
-    postCheckIn({ dispatch, rootState }, payload) {
+
+    postCheckIn({ commit, dispatch, rootState }, payload) {
       let state = rootState
       let data = {
         checked_in_time: moment.utc().format(),
@@ -169,10 +171,11 @@ export default {
       return new Promise((resolve, reject) => {
         Axios({state}).put(`/appointments/${payload.appointment_id}/`, data).then( () => {
           dispatch('sendToQueue', payload)
+          setTimeout(()=>{ commit('toggleCheckInClicked', false) }, 2000);
         })
       })
     },
-    
+
     postServiceReq({rootState}, {citizen_id, payload}) {
       let state = rootState
       let { channel_id } = rootState.channels.find(ch => ch.channel_name.includes('Person'))
@@ -192,7 +195,7 @@ export default {
         })
       })
     },
-  
+
     putAppointment({dispatch, rootState}, payload) {
       let state = rootState
       let { id } = payload
@@ -215,7 +218,7 @@ export default {
         })
       })
     },
-    
+
     putCitizen({rootState}, {citizen_id, payload}) {
       let start = moment(payload.start).clone().format('h:mm')
       if (!payload.comments) {
@@ -231,7 +234,7 @@ export default {
         start_time: payload.start_time,
         snowplow_addcitizen: payload.snowplow_addcitizen
       }
-      
+
       return new Promise((resolve, reject) => {
         let state = rootState
         let url = `/citizens/${citizen_id}/`
@@ -242,7 +245,7 @@ export default {
         })
       })
     },
-    
+
     resetAddModalForm({commit}) {
       commit('resetAddModalForm', null, {root: true})
     },
@@ -276,8 +279,10 @@ export default {
       state.calendarSetup = { title, name }
     },
     toggleApptBookingModal: (state, payload) => state.showApptBookingModal = payload,
+    toggleCheckInClicked: (state, payload) => state.checkInClicked = payload,
     toggleCheckInModal: (state, payload) => state.showCheckInModal = payload,
     toggleEditDeleteSeries: (state, payload) => state.editDeleteSeries = payload,
+    toggleSubmitClicked: (state, payload) => state.submitClicked = payload,
     setSelectedService: (state, payload) => {
       state.selectedService = null
       state.selectedService = payload
diff --git a/frontend/src/store/index.js b/frontend/src/store/index.js
index e97dbbd2a..b449288f5 100644
--- a/frontend/src/store/index.js
+++ b/frontend/src/store/index.js
@@ -66,6 +66,7 @@ export const store = new Vuex.Store({
     bookings: [],
     calendarEvents: [],
     calendarSetup: null,
+    examBcmpJobId: null,
     capturedExam: {},
     captureITAExamTabSetup: {
       step: 1,
@@ -115,9 +116,12 @@ export const store = new Vuex.Store({
       office_number: 'default',
       requireAttentionFilter: 'default',
       requireOEMAttentionFilter: 'default',
+      receptSentFilter: 'default',
+      uploadFilter: 'default',
     },
     invigilators: [],
     pesticide_invigilators: [],
+    pesticide_offsite_invigilators: [],
     shadowInvigilators: [],
     isLoggedIn: false,
     isUploadingFile: false,
@@ -176,6 +180,7 @@ export const store = new Vuex.Store({
     showReturnExamModal: false,
     showSelectInvigilatorModal: false,
     showServeCitizenSpinner: false,
+    showInviteCitizenSpinner: false,
     showServiceModal: false,
     showTimeTrackingIcon: false,
     user: {
@@ -946,6 +951,20 @@ export const store = new Vuex.Store({
       })
     },
 
+    getPesticideOffsiteInvigilators(context) {
+      return new Promise ((resolve, reject) => {
+        Axios(context).get('/invigilators/offsite/')
+          .then(resp => {
+            context.commit('setPesticideOffsiteInvigilators', resp.data.invigilators)
+            resolve(resp)
+          })
+          .catch(error => {
+            console.log(error)
+            reject(error)
+          })
+      })
+    },
+
     getInvigilatorsWithShadowFlag(context) {
       return new Promise ((resolve, reject) => {
         Axios(context).get('/invigilators/')
@@ -962,13 +981,14 @@ export const store = new Vuex.Store({
 
     emailInvigilator(context, payload) {
       console.log(payload)
+      const invigilator = payload.invigilator
       const postData = {
-        invigilator_id: payload.invigilator_id,
-        invigilator_name: payload.invigilator_name,
-        invigilator_email: payload.contact_email,
-        invigilator_phone: payload.contact_phone,
+        invigilator_id: invigilator.invigilator_id,
+        invigilator_name: invigilator.invigilator_name,
+        invigilator_email: invigilator.contact_email,
+        invigilator_phone: invigilator.contact_phone,
       }
-      const exam = context.state.selectedExam
+      const exam = payload.exam
 
       return new Promise ((resolve, reject) => {
         Axios(context).post(`/exams/${exam.exam_id}/email_invigilator/`, postData)
@@ -1040,10 +1060,18 @@ export const store = new Vuex.Store({
     },
 
     updateExamStatus(context) {
-      Axios(context).post(`/exams/bcmp_status/`)
+      return new Promise((resolve, reject) => {
+        Axios(context).post(`/exams/bcmp_status/`)
         .then( resp => {
           context.dispatch('getExams')
+          resolve(resp.data)
+        }, err => {
+          reject(err)
         })
+        .catch(err => {
+          reject(err)
+        })
+      })
     },
 
     getUser(context) {
@@ -1102,6 +1130,7 @@ export const store = new Vuex.Store({
           error => {
             context.commit('toggleAddModal', false)
             context.commit('setMainAlert', 'An error occurred adding a citizen.')
+            context.commit('toggleServeCitizenSpinner', false)
           }).finally(() => {
             context.commit('setPerformingAction', false)
           })
@@ -1196,6 +1225,7 @@ export const store = new Vuex.Store({
           })
         }).catch(() => {
           context.commit('setPerformingAction', false)
+          context.commit('toggleServeCitizenSpinner', false)
         })
       }).catch(() => {
         context.commit('setPerformingAction', false)
@@ -1219,20 +1249,43 @@ export const store = new Vuex.Store({
         if (type === 'individual') {
           context.dispatch('postITAIndividualExam').then(() => {
             resolve('success')
-          }).catch(() => { reject('failed') })
+          }, (err) => {
+            reject(err)
+          }).catch((err) => { reject(err) })
         }
       })
     },
 
+    clickRequestExam(context, type) {
+      return new Promise((resolve, reject) => {
+        context.dispatch('postRequestExam').then(() => {
+          resolve('success')
+        }).catch(() => { reject('failed') })
+      })
+    },
+    
+    clickPesticideRequestExam(context) {
+      return new Promise((resolve, reject) => {
+        context.dispatch('postITAIndividualExam', true).then((resp) => {
+          if(resp && resp.data && resp.data.bcmp_job_id) {
+            resolve(resp.data.bcmp_job_id)
+          } else {
+            reject(resp)
+          }
+        }).catch((err) => { 
+          reject(err) 
+        })
+      })
+    },
+
     clickAdmin(context) {
       context.commit('toggleShowAdmin')
     },
 
     clickBeginService(context, payload) {
+      context.commit('setPerformingAction', true)
       context.commit('toggleServeCitizenSpinner', true)
       let { citizen_id } = context.getters.form_data.citizen
-      context.commit('setPerformingAction', true)
-
       context.dispatch('putCitizen').then( () => {
         context.dispatch('postServiceReq').then( () => {
           context.dispatch('postBeginService', citizen_id).then( () => {
@@ -1248,9 +1301,11 @@ export const store = new Vuex.Store({
           })
         }).catch(() => {
           context.commit('setPerformingAction', false)
+          context.commit('toggleServeCitizenSpinner', false)
         })
       }).catch(() => {
         context.commit('setPerformingAction', false)
+        context.commit('toggleServeCitizenSpinner', false)
       })
     },
 
@@ -1291,6 +1346,7 @@ export const store = new Vuex.Store({
         },
         error => {
           context.commit('setMainAlert', 'An error occurred adding a citizen.')
+          context.commit('toggleServeCitizenSpinner', false)
         })
 
       if (context.state.channels.length === 0) {
@@ -1521,16 +1577,18 @@ export const store = new Vuex.Store({
     },
 
     clickInvite(context) {
-      context.commit('toggleServeCitizenSpinner', true)
+      context.commit('toggleInviteCitizenSpinner', true)
       context.commit('setPerformingAction', true)
 
       context.dispatch('postInvite', 'next').then(() => {
         context.commit('toggleInvitedStatus', true)
         context.commit('toggleServiceModal', true)
       }).catch(() => {
-        context.commit('setMainAlert', 'There are no citizens waiting.')
+        // context.commit('setMainAlert', '(index) There are no citizens waiting.')
+        context.commit('toggleInviteCitizenSpinner', false)
       }).finally(() => {
         context.commit('setPerformingAction', false)
+        context.commit('toggleInviteCitizenSpinner', false)
       })
       context.dispatch('flashServeNow', 'stop')
     },
@@ -1655,8 +1713,10 @@ export const store = new Vuex.Store({
     },
 
     clickServiceBeginService(context) {
-      let { citizen_id } = context.state.serviceModalForm
       context.commit('setPerformingAction', true)
+      context.commit('toggleServeCitizenSpinner', true)
+      let { citizen_id } = context.state.serviceModalForm
+
 
       context.dispatch('putCitizen').then( () => {
         context.dispatch('putServiceRequest').then( () => {
@@ -1667,9 +1727,11 @@ export const store = new Vuex.Store({
           })
         }).catch(() => {
           context.commit('setPerformingAction', false)
+          context.commit('toggleServeCitizenSpinner', false)
         })
       }).catch(() => {
         context.commit('setPerformingAction', false)
+        context.commit('toggleServeCitizenSpinner', false)
       })
     },
 
@@ -1681,6 +1743,7 @@ export const store = new Vuex.Store({
         inaccurate_flag = 'false'
       }
       context.commit('setPerformingAction', true)
+      context.commit('toggleServeCitizenSpinner', true)
 
       context.dispatch('putCitizen').then( (resp) => {
         context.dispatch('putServiceRequest').then( () => {
@@ -1694,9 +1757,11 @@ export const store = new Vuex.Store({
           })
         }).catch(() => {
           context.commit('setPerformingAction', false)
+          context.commit('toggleServeCitizenSpinner', false)
         })
       }).catch(() => {
         context.commit('setPerformingAction', false)
+        context.commit('toggleServeCitizenSpinner', false)
       })
     },
 
@@ -1984,27 +2049,7 @@ export const store = new Vuex.Store({
 
     postITAGroupExam(context) {
       let responses = Object.assign( {}, context.state.capturedExam)
-      let timezone_name = context.state.user.office.timezone
-      let booking_office = context.state.offices.find(office => office.office_id == responses.office_id)
-      let booking_timezone_name = booking_office.timezone.timezone_name
-      let date = new moment(responses.expiry_date).format('YYYY-MM-DD')
-      let time = new moment(responses.exam_time).format('HH:mm:ss')
-      let datetime = date+'T'+time
-      let start
-      if (booking_timezone_name != timezone_name) {
-        start = new tZone.tz(datetime, booking_timezone_name)
-      } else {
-        start = new moment(datetime).local()
-      }
-      let length = context.state.examTypes.find(ex => ex.exam_type_id == responses.exam_type_id).number_of_hours
-      let end = start.clone().add(length, 'hours')
-      let booking = {
-        start_time: start.clone().utc().format('YYYY-MM-DD[T]HH:mm:ssZ'),
-        end_time: end.clone().utc().format('YYYY-MM-DD[T]HH:mm:ssZ'),
-        fees: 'false',
-        booking_name: responses.exam_name,
-        office_id: responses.office_id,
-      }
+      let booking = makeBookingReqObj(context, responses)
       let defaultValues = {
         exam_returned_ind: 0,
         examinee_name: 'group exam',
@@ -2033,7 +2078,8 @@ export const store = new Vuex.Store({
       })
     },
 
-    postITAIndividualExam(context) {
+    postITAIndividualExam(context, isRequestExam) {
+      let isRequestExamReq = isRequestExam || false 
       let responses = Object.assign( {}, context.state.capturedExam)
       console.log(responses)
       if (responses.on_or_off) {
@@ -2047,6 +2093,7 @@ export const store = new Vuex.Store({
         exam_returned_ind: 0,
         number_of_students: 1
       }
+      defaultValues.number_of_students = (responses['ind_or_group'] === 'group') ? responses.number_of_students : 1
       let exp = new moment(responses.expiry_date).format('YYYY-MM-DD').toString()
       responses.expiry_date = new moment(exp).utc().format('YYYY-MM-DD[T]HH:mm:ssZ')
       if (responses.exam_received_date) {
@@ -2061,8 +2108,9 @@ export const store = new Vuex.Store({
         }
       }
 
-      if (context.state.addExamModal.setup === 'pesticide' && !responses.exam_name) {
-        responses.exam_name = "pesticide"
+      if (context.state.addExamModal.setup === 'pesticide') {
+        responses.exam_name = responses.exam_name || "pesticide"
+        responses.is_pesticide = 1
       }
 
       responses.receipt = responses.receipt_number
@@ -2072,8 +2120,67 @@ export const store = new Vuex.Store({
 
       let postData = {...responses, ...defaultValues}
 
+      if(responses['ind_or_group'] === 'group') {
+        let examType = context.state.examTypes.find(type => (type.group_exam_ind && !type.ita_ind && !type.pesticide_exam_ind));
+        postData.exam_type_id = responses.exam_type_id = examType.exam_type_id
+        postData.candidates = (context.state.addExamModule && context.state.addExamModule.candidates) ? context.state.addExamModule.candidates : []
+      }
+
+      let booking = makeBookingReqObj(context, responses)
+
+      let apiUrl = (isRequestExamReq) ? '/exams/bcmp/' : '/exams/'
+
+      return new Promise((resolve, reject) => {
+        Axios(context).post(apiUrl, postData).then( examResp => {
+          console.log(examResp)
+          if ((responses['ind_or_group'] === 'group' || responses['sbc_managed'] === 'non-sbc') && !isRequestExamReq) {
+            let { exam_id } = examResp.data.exam
+            context.dispatch('postBooking', booking).then( bookingResp => {
+              let putObject = {
+                examId: exam_id,
+                bookingId: bookingResp,
+                officeId: responses.office_id
+              }
+              context.dispatch('putExam', putObject).then( (examResp) => {
+                if(responses['sbc_managed'] === 'non-sbc') {
+                  if(examResp.data && examResp.data.exam && examResp.data.exam.invigilator) {
+                    context.dispatch('emailInvigilator', {
+                      invigilator: examResp.data.exam.invigilator,
+                      exam: examResp.data.exam
+                    }).then( emailResp => {
+                      resolve(examResp)
+                    }).catch( () => { 
+                      console.log('EMAIL_FAILED')
+                      reject('EMAIL_FAILED') 
+                    })
+                  }
+                } else {
+                  resolve(examResp)
+                }
+              }).catch( () => { reject() })
+            }).catch( () => { reject() })
+          } else {
+            resolve(examResp)
+          }
+        }).catch( (err) => { 
+          console.log(err)
+          reject(err) 
+        })
+      })
+    },
+
+    postRequestExam(context) {
+      let responses = Object.assign( {}, context.state.requestExam)
+      console.log(responses)
+      let postData = {...responses}
+
       return new Promise((resolve, reject) => {
-        Axios(context).post('/exams/', postData).then( () => { resolve() }).catch( () => { reject() })
+        Axios(context).post('/exams/request', postData).then( examResp => { 
+          resolve() 
+        }).catch( (err) => { 
+          console.log(err)
+          reject() 
+        })
       })
     },
 
@@ -2192,7 +2299,6 @@ export const store = new Vuex.Store({
       context.commit('toggleAddModal', false)
       context.dispatch('toggleModalBack')
       context.commit('resetAddModalForm')
-      // console.log("====> resetAddCitizenModal set SPINNER to FALSE")
       context.commit('toggleServeCitizenSpinner', false)
     },
 
@@ -2595,6 +2701,10 @@ export const store = new Vuex.Store({
       state.pesticide_invigilators = payload
     },
 
+    setPesticideOffsiteInvigilators(state, payload) {
+      state.pesticide_offsite_invigilators = payload
+    },
+
     updateCitizen(state, payload) {
       Vue.set(state.citizens, payload.index, payload.citizen)
     },
@@ -2705,6 +2815,7 @@ export const store = new Vuex.Store({
         step1MenuOpen: false,
         office_number: null,
       }
+      state.addExamModule.candidates = []
     },
 
     resetLogAnotherExamModal: (state, setup) => {
@@ -2739,6 +2850,10 @@ export const store = new Vuex.Store({
 
     resetCaptureForm(state) {
       state.capturedExam = {}
+      state.addExamModule.candidates = []
+      state.captureITAExamTabSetup.capturePayee = false
+      state.captureITAExamTabSetup.payeeSentReceipt = false
+      state.examBcmpJobId = null
     },
 
     resetCaptureTab(state) {
@@ -2891,6 +3006,9 @@ export const store = new Vuex.Store({
     toggleServeCitizenSpinner(state, payload) {
       state.showServeCitizenSpinner = payload
     },
+    toggleInviteCitizenSpinner(state, payload) {
+      state.showInviteCitizenSpinner = payload
+    },
 
     setOffsiteOnly: (state, payload) => state.offsiteOnly = payload,
 
@@ -2901,6 +3019,39 @@ export const store = new Vuex.Store({
         state.capturedExam,
         payload
       )
-    }
+    },
+
+    setBCMPJobId: (state, payload) => {
+      state.capturedExam.bcmp_job_id = payload
+      state.examBcmpJobId = payload
+    },
   }
 })
+
+let makeBookingReqObj = (context, responses) => {
+    let timezone_name = context.state.user.office.timezone
+    let booking_office = context.state.offices.find(office => office.office_id == responses.office_id)
+    let booking_timezone_name = booking_office.timezone.timezone_name
+    let date = new moment(responses.expiry_date).format('YYYY-MM-DD')
+    let time = new moment(responses.exam_time).format('HH:mm:ss')
+    let datetime = date+'T'+time
+    let start
+    if (booking_timezone_name != timezone_name) {
+      start = new tZone.tz(datetime, booking_timezone_name)
+    } else {
+      start = new moment(datetime).local()
+    }
+    let length = context.state.examTypes.find(ex => ex.exam_type_id == responses.exam_type_id).number_of_hours
+    let end = start.clone().add(length, 'hours')
+    let booking = {
+      start_time: start.clone().utc().format('YYYY-MM-DD[T]HH:mm:ssZ'),
+      end_time: end.clone().utc().format('YYYY-MM-DD[T]HH:mm:ssZ'),
+      fees: 'false',
+      booking_name: responses.exam_name,
+      office_id: responses.office_id,
+    }
+    if(responses.is_pesticide && !responses.sbc_managed_ind && responses.invigilator_id) {
+      booking.invigilator_id = [responses.invigilator_id]
+    }
+    return booking;
+}
diff --git a/mender/image-tools/README.md b/mender/image-tools/README.md
index 45e44cfc3..1be2d03a4 100644
--- a/mender/image-tools/README.md
+++ b/mender/image-tools/README.md
@@ -55,7 +55,7 @@ Thus, it is this stage where the majority of updates will be produced.
 ## Building Images to Prepare for Mender Deployment
 ### Prerequisites
 
-- **Ubuntu 18.04**
+- **Ubuntu 19.04**
 - 10 gigabytes of storage
 - qemu
 - docker.io
@@ -81,14 +81,36 @@ sudo systemctl restart systemd-binfmt.service
 git clone https://www.github.com/bcgov/queue-management
 cd queue-management/mender/image-tools
 ```
-Download and unzip the latest [Raspbian Lite Image](https://downloads.raspberrypi.org/raspbian_lite_latest) and copy it into the `./mender/image-tools` directory.
+Download and unzip the latest [Raspbian Lite Image](https://downloads.raspberrypi.org/raspbian_lite_latest) and 
+You will need to resize the ext4 partition.
+
+Need to increase size of root filesystem of buster-lite
+https://www.codepool.biz/resize-raspbian-image-qemu-windows.html
+
+cp 2020-02-13-raspbian-buster-lite.img raspbian.img
+truncate -s +1G raspbian.img
+fdisk -l raspbian.img
+** Get partition start sector  and write it down (532480)
+fdisk raspbian.img
+--> d ,2 (partion 2 has need deleted)
+--> n, p, 2, 532480, enter for default end
+(Remove the signature?) Yes
+--> w (write)
+sudo losetup -f and write down output (/dev/loop2)
+sudo losetup -o $((532480*512)) /dev/loop2 raspbian.img
+sudo e2fsck -f /dev/loop2
+fix if errors
+sudo resize2fs /dev/loop2
+sudo losetup -d /dev/loop2
+
+copy it into the `./mender/image-tools` directory.
 
 **Note**: This step installs `chromium`. This will result in a large blue screen showing up and will require user input to continue. This is a good sign, do not be alarmed.
 
 Then, run:
 ```
-RASPI_IMG=<raspberry pi image filename>
-ENV_FILE=<config.env>
+export RASPI_IMG=<raspberry pi image filename>
+export ENV_FILE=<config.env>
 bootstrap-builder/generate-image.sh ${RASPI_IMG} ${ENV_FILE}
 ```
 
@@ -159,8 +181,8 @@ Shrunk Image:
 It is possible to run the bootstrapping stage without shrinking the image. The image produced by this step can be useful for debugging and quick prototyping since it takes less time to generate than a fully bootstrapped image. Image shrinking takes time and can sometimes interact adversely with other modifications to the image.
 
 ```
-RASPI_IMG=<raspberry pi image filename>
-ENV_FILE=<config.env>
+export RASPI_IMG=<raspberry pi image filename>
+export ENV_FILE=<config.env>
 bootstrap-builder/prepare-raspbian/prepare-raspbian ${RASPI_IMG} ${ENV_FILE}
 ```
 
@@ -173,39 +195,47 @@ First, download and build the `mender-convert` docker tool:
 ```
 git clone https://github.com/mendersoftware/mender-convert.git
 cd mender-convert
-git checkout 2743366
+git checkout 2.0.x
 
 ./docker-build
 ```
 
+Next create mender convert settings:
+
+1. Update the mender convert config to your needs: nano configs/mender_convert_config
+
+MENDER_COMPRESS_DISK_IMAGE=none
+MENDER_BOOT_PART_SIZE_MB="256"
+MENDER_DATA_PART_SIZE_MB="1000"
+IMAGE_ROOTFS_SIZE="-1"
+
+export server-url=<your mender server>
+
+And update config by running this script:
+./scripts/bootstrap-rootfs-overlay-production-server.sh \
+    --output-dir ${PWD}/rootfs_overlay_demo \
+    --server-url ${server-url}
+
 Next, to generate the **Menderized** image you will need to provide some information to the conversion tool:
 
 1. `raw-disk-image` - the base Image (Built in **Step #1**), which must be copied into the `./mender-convert/input` directory
-2. `artifact-name` - the name of the output image, also stored as metadata within the image itself to be read by Mender
-3. `server-url` - URL Which will be Hosting Mender - e.g. [https://mender.pathfinder.gov.bc.ca]
-4. `storage-total-size-mb` - total Image size (Mb) - The total store needs to be more than double the size of the base Image
-5. `data-part-size-mb` - total size of persistent data partition
 
 **Note**: copy the Raspberry PI Bootstrap image (from previous step) into `./mender-convert/input`.
 
 ```
-BOOTSTRAP_IMG=<bootstrapped image file>
-ARTIFACT_NAME=<artifact name>
-SERVER_URL=<https://your.mender.application.com>
-./docker-mender-convert from-raw-disk-image \
-    --raw-disk-image "${BOOTSTRAP_IMG}" \
-    --artifact-name "${ARTIFACT_NAME}" \
-    --device-type "raspberrypi3" \
-    --mender-client "/mender" \
-    --bootloader-toolchain "arm-linux-gnueabihf" \
-    --server-url "${SERVER_URL}" \
-    --storage-total-size-mb "5000" \
-    --data-part-size-mb "1000"
-```
+export INPUT_DISK_IMAGE=<bootstrapped image file> 
+export ARTIFACT_NAME=<artifact name>
+
+cp ~/git/queue-management/mender/image-tools/output/smartboard-bootstrap-image.img input/
+
+MENDER_ARTIFACT_NAME=SBCRPI3Base ./docker-mender-convert \
+   --disk-image input/$INPUT_DISK_IMAGE \
+   --config configs/raspberrypi3_config \
+   --overlay rootfs_overlay_demo/
 
 This step will produce 3 files:
 * `.ext4` - the filesystem of the Menderized image. This file is used later to produce deployment artifacts **(i.e. store it somewhere safe)**
-* `.sdimg` - the modified OS which can be flashed to an SD card and run directly on the PI. **(i.e. store it somewhere safe)**
+* `.img` - the modified OS which can be flashed to an SD card and run directly on the PI. **(i.e. store it somewhere safe)**
 * `.mender` - a deployment artifact, the one produced by this stage will not be used for anything.
 
 #### Example Output
@@ -275,19 +305,19 @@ Once we've menderized our base image the files system and mender configuration w
 Return to the `image-tools` directory and run:
 
 ```
-MENDER_SDIMG=<location of previously produced .sdimg>
+MENDER_SDIMG=<location of previously produced .img>
 mender-image-patcher/mender-image-patcher \
     ${MENDER_SDIMG}
 ```
 
-**Note**: The above step modifies the `.sdimg` in place. Store the output file somewhere reliable because it is now the core image for flashing SD cards to enable Mender updates on the PI.
+**Note**: The above step modifies the `.img` in place. Store the output file somewhere reliable because it is now the core image for flashing SD cards to enable Mender updates on the PI.
 
 ### Step 3b: Flashing the Base
-The patched `.sdimg` produced above can now be flashed onto SD cards and put into Raspberry PIs.   
+The patched `.img` produced above can now be flashed onto SD cards and put into Raspberry PIs.   
 
 You can do this with `dd` or your favorite flashing tool:
 ```
-MENDER_SDIMG=<location of previously produced .sdimg>
+MENDER_SDIMG=<location of previously produced .img>
 dd if=${MENDER_SDIMG} of=/dev/<your-sd-card-device> bs=1m
 ```
 
diff --git a/mender/image-tools/artifact-builder/Dockerfile b/mender/image-tools/artifact-builder/Dockerfile
index 5ac2b1d63..9f1348ca2 100644
--- a/mender/image-tools/artifact-builder/Dockerfile
+++ b/mender/image-tools/artifact-builder/Dockerfile
@@ -1,13 +1,12 @@
-FROM ubuntu:18.04
+FROM ubuntu:19.04
 
-ARG MENDER_ARTIFACT_VERSION=2.3.0
+ARG MENDER_ARTIFACT_VERSION=3.3.0
 
 RUN apt-get update && apt-get install -y \
     wget \
     qemu-user-static
 
-RUN wget -q -O /usr/bin/mender-artifact https://d1b0l86ne08fsf.cloudfront.net/mender-artifact/$MENDER_ARTIFACT_VERSION/mender-artifact \
-    && chmod +x /usr/bin/mender-artifact
+RUN wget -q -O /usr/bin/mender-artifact https://d1b0l86ne08fsf.cloudfront.net/mender-artifact/$MENDER_ARTIFACT_VERSION/linux/mender-artifact && chmod +x /usr/bin/mender-artifact
 
 COPY docker-entrypoint.sh /usr/local/bin/
 ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
diff --git a/mender/image-tools/artifact-builder/docker-entrypoint.sh b/mender/image-tools/artifact-builder/docker-entrypoint.sh
index 2afe9374c..90a406bcd 100755
--- a/mender/image-tools/artifact-builder/docker-entrypoint.sh
+++ b/mender/image-tools/artifact-builder/docker-entrypoint.sh
@@ -42,5 +42,6 @@ rm -rf /root_system/root/setup-scripts/
 umount /root_system
 
 echo "Creating Mender Artifact. This may take a few minutes..."
-mender-artifact write rootfs-image -t $DEVICE_TYPE -n $ARTIFACT_NAME -u /root_images/$ROOTFS_OUTPUT_FILE_NAME -o /root_images/$ARTIFACT_NAME.mender -s /setup-scripts/state-scripts
+mender-artifact write rootfs-image -t $DEVICE_TYPE -n $ARTIFACT_NAME -f /root_images/$ROOTFS_OUTPUT_FILE_NAME -o /root_images/$ARTIFACT_NAME.mender -s /setup-scripts/state-scripts
 sync
+echo "completed Creating Artificat"
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/Xwrapper.config b/mender/image-tools/artifact-builder/raspbian-setup/files/Xwrapper.config
index 94411bb7e..26e049438 100644
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/Xwrapper.config
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/Xwrapper.config
@@ -13,4 +13,4 @@
 # again, run the following command as root:
 #   dpkg-reconfigure xserver-xorg-legacy
 allowed_users=anybody
-
needs_root_rights=yes
+needs_root_rights=yes
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/autologin.conf b/mender/image-tools/artifact-builder/raspbian-setup/files/autologin.conf
new file mode 100644
index 000000000..4e9ec0efd
--- /dev/null
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/autologin.conf
@@ -0,0 +1,3 @@
+[Service]
+ExecStart=
+ExecStart=-/sbin/agetty --autologin ${username} --noclear %I \$TERM
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/crontab b/mender/image-tools/artifact-builder/raspbian-setup/files/crontab
new file mode 100644
index 000000000..0e01ff871
--- /dev/null
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/crontab
@@ -0,0 +1 @@
+0  0     * * *   root    reboot
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/deps_add.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/deps_add.txt
index bff2b3d99..5bba55386 100644
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/deps_add.txt
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/deps_add.txt
@@ -1,3 +1,4 @@
+chromium-browser
 python3
 avahi-daemon
 ufw
@@ -10,6 +11,7 @@ xinit
 unclutter
 matchbox-window-manager
 x11-xserver-utils
+xserver-xorg-video-fbturbo
 nginx
 supervisor
 python3-venv
@@ -17,10 +19,9 @@ fim
 fuse
 xloadimage
 jq
-
-rpi-chromium-mods
+xcompmgr
+gldriver-test
 libgl1-mesa-dri
 mesa-vdpau-drivers
-libgtk-3-0
-xcompmgr
 mesa-utils
+watchdog
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/deps_remove.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/deps_remove.txt
index 94b0e56e2..eb7b4e44a 100644
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/deps_remove.txt
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/deps_remove.txt
@@ -1,19 +1,10 @@
-build-essential
 samba-common
-alsa-utils
-binutils
 manpages
 manpages-dev
 man-db
-gcc-6
-firmware-atheros
-firmware-libertas
-firmware-misc-nonfree
-firmware-realtek
 gdb
 plymouth
 libplymouth4
 libraspberrypi-doc
-perl-modules-5.24
-iso-codes
-libc6-dev
+perl-modules-5.28
+iso-codes
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/first-boot.sh b/mender/image-tools/artifact-builder/raspbian-setup/files/first-boot.sh
index 3d3c4357a..e074278ba 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/first-boot.sh
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/first-boot.sh
@@ -16,6 +16,8 @@ mount / -o remount,rw
 
 ssh-keygen -A
 
+sed -i 's/IPV6=yes/IPV6=no/g' /etc/default/ufw
+systemctl daemon-reload
 ufw default deny incoming 
 ufw default allow outgoing
 ufw allow 443
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/launch-browser.sh b/mender/image-tools/artifact-builder/raspbian-setup/files/launch-browser.sh
index b0f1ab060..031e6b203 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/launch-browser.sh
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/launch-browser.sh
@@ -2,9 +2,14 @@
 
 sudo systemctl stop splashscreen
 
-xsetroot -solid white 
+xsetroot -solid white
 xsetbg -onroot -shrink -fullscreen -smooth -background white /var/flaskapp/web-service/static/splash.png
 
+until timedatectl status | grep -q "synchronized: yes";
+do
+  sleep 1;
+done
+
 # disable DPMS (Energy Star) features.
 xset -dpms
 # disable screen saver
@@ -24,14 +29,25 @@ while true ; do
 	# to try load the smart board. This ensures that the network is up
 	# before hitting the smartboard
 
-	chromium-browser --ignore-gpu-blacklist --force-gpu-rasterization --enable-zero-copy \
-		--enable-native-gpu-memory-buffers --disable-infobars --disable-session-crashed-bubble \
-		--noerrdialogs --incognito --kiosk \
-		"http://localhost/splash.html"
+		# --enable-fast-unload --enable-checker-imaging --enable-tcp-fast-open \
+		# -check-for-update-interval=0 --disable-background-networking \
+		# --enable-native-gpu-memory-buffers --enable-gpu-rasterization --enable-zero-copy \
+		# --use-gl=egl --gles --disable-quic \
+
+	chromium-browser \
+		--ignore-blacklist --ignore-gpu-blacklist \
+		--disable-translate --disable-features=TranslateUI \
+		--disable-infobars --disable-session-crashed-bubble \
+		--disable-logging --noerrdialogs --start-fullscreen \
+		--disk-cache-size=0  \
+		--check-for-update-interval=0 --disable-background-networking \
+		--kiosk "http://localhost/splash.html"
+
 
 	sleep 1
 	# Clean out any lingering processes if the browser has died
 
-	killall -HUP chromium-browser
+	pkill -f -- "chromium-browser"
 	sleep 2
-done 
+done
+
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/network/rfkill-unblock.service b/mender/image-tools/artifact-builder/raspbian-setup/files/network/rfkill-unblock.service
new file mode 100644
index 000000000..444acd6f8
--- /dev/null
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/network/rfkill-unblock.service
@@ -0,0 +1,11 @@
+[Unit]
+Description=RFKill-Unblock Wifi
+
+[Service]
+Type=oneshot
+ExecStart=/usr/sbin/rfkill unblock wifi
+ExecStop=
+RemainAfterExit=yes
+
+[Install]
+WantedBy=multi-user.target
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/venv.tar b/mender/image-tools/artifact-builder/raspbian-setup/files/venv.tar
new file mode 100644
index 000000000..5e1aedabc
Binary files /dev/null and b/mender/image-tools/artifact-builder/raspbian-setup/files/venv.tar differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/video-updater.sh b/mender/image-tools/artifact-builder/raspbian-setup/files/video-updater.sh
index 9b8809993..3dfc621b2 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/video-updater.sh
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/video-updater.sh
@@ -26,7 +26,7 @@ while true ; do
 		then
 			wget -O "/data/videos/video.mp4.tmp" "$BASE_URL$URL"
 			# Once a new video is downloaded the browser needs to be restarted
-			killall chromium-browser
+			pkill -f -- "chromium-browser"
 
 			mv /data/videos/video.mp4.tmp /data/videos/video.mp4
 			echo $UPDATED > /data/videos/updated
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/static/video.html b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/static/video.html
index 012bba0c7..34c53c37a 100644
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/static/video.html
+++ b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/static/video.html
@@ -33,7 +33,7 @@
         .main-container { position: fixed; top: 0; left: 0; height:100%; width: 100%; margin: 16px 0; align-items: center; }
         .top-flex-div { display: flex; height:6%; justify-content: center; align-items: center; width: 100% }
         .bottom-flex-div { display: flex; height:11%; justify-content: center; align-items: center; width: 100%; padding-top: 2%}
-        .flex-title { font-size: 7.2rem; color: darkblue; text-shadow: -1px 0 steelblue, 0 1px steelblue, 1px 0 steelblue, 0 -1px steelblue }
+        .flex-title { font-size: 4.0rem; color: darkblue; text-shadow: -1px 0 steelblue, 0 1px steelblue, 1px 0 steelblue, 0 -1px steelblue }
         .lg-boardtable-head { font-size: 2.3rem; text-align: center; height: 30px }
         .sm-boardtable-body { font-size: 1.8rem; text-align: center }
         .sm-boardtable-head { font-size: 1.8rem; text-align: center }
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate
deleted file mode 100644
index 260fbd162..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate
+++ /dev/null
@@ -1,76 +0,0 @@
-# This file must be used with "source bin/activate" *from bash*
-# you cannot run it directly
-
-deactivate () {
-    # reset old environment variables
-    if [ -n "$_OLD_VIRTUAL_PATH" ] ; then
-        PATH="$_OLD_VIRTUAL_PATH"
-        export PATH
-        unset _OLD_VIRTUAL_PATH
-    fi
-    if [ -n "$_OLD_VIRTUAL_PYTHONHOME" ] ; then
-        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
-        export PYTHONHOME
-        unset _OLD_VIRTUAL_PYTHONHOME
-    fi
-
-    # This should detect bash and zsh, which have a hash command that must
-    # be called to get it to forget past commands.  Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then
-        hash -r
-    fi
-
-    if [ -n "$_OLD_VIRTUAL_PS1" ] ; then
-        PS1="$_OLD_VIRTUAL_PS1"
-        export PS1
-        unset _OLD_VIRTUAL_PS1
-    fi
-
-    unset VIRTUAL_ENV
-    if [ ! "$1" = "nondestructive" ] ; then
-    # Self destruct!
-        unset -f deactivate
-    fi
-}
-
-# unset irrelevant variables
-deactivate nondestructive
-
-VIRTUAL_ENV="/var/flaskapp/web-service/venv"
-export VIRTUAL_ENV
-
-_OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/bin:$PATH"
-export PATH
-
-# unset PYTHONHOME if set
-# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
-# could use `if (set -u; : $PYTHONHOME) ;` in bash
-if [ -n "$PYTHONHOME" ] ; then
-    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
-    unset PYTHONHOME
-fi
-
-if [ -z "$VIRTUAL_ENV_DISABLE_PROMPT" ] ; then
-    _OLD_VIRTUAL_PS1="$PS1"
-    if [ "x(venv) " != x ] ; then
-	PS1="(venv) $PS1"
-    else
-    if [ "`basename \"$VIRTUAL_ENV\"`" = "__" ] ; then
-        # special case for Aspen magic directories
-        # see http://www.zetadev.com/software/aspen/
-        PS1="[`basename \`dirname \"$VIRTUAL_ENV\"\``] $PS1"
-    else
-        PS1="(`basename \"$VIRTUAL_ENV\"`)$PS1"
-    fi
-    fi
-    export PS1
-fi
-
-# This should detect bash and zsh, which have a hash command that must
-# be called to get it to forget past commands.  Without forgetting
-# past commands the $PATH changes we made may not be respected
-if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then
-    hash -r
-fi
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.csh b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.csh
deleted file mode 100644
index a65bbb5f4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.csh
+++ /dev/null
@@ -1,37 +0,0 @@
-# This file must be used with "source bin/activate.csh" *from csh*.
-# You cannot run it directly.
-# Created by Davide Di Blasi <davidedb@gmail.com>.
-# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
-
-alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
-
-# Unset irrelevant variables.
-deactivate nondestructive
-
-setenv VIRTUAL_ENV "/var/flaskapp/web-service/venv"
-
-set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/bin:$PATH"
-
-
-set _OLD_VIRTUAL_PROMPT="$prompt"
-
-if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    if ("venv" != "") then
-        set env_name = "venv"
-    else
-        if (`basename "VIRTUAL_ENV"` == "__") then
-            # special case for Aspen magic directories
-            # see http://www.zetadev.com/software/aspen/
-            set env_name = `basename \`dirname "$VIRTUAL_ENV"\``
-        else
-            set env_name = `basename "$VIRTUAL_ENV"`
-        endif
-    endif
-    set prompt = "[$env_name] $prompt"
-    unset env_name
-endif
-
-alias pydoc python -m pydoc
-
-rehash
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.fish b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.fish
deleted file mode 100644
index 65ba5611d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/activate.fish
+++ /dev/null
@@ -1,75 +0,0 @@
-# This file must be used with ". bin/activate.fish" *from fish* (http://fishshell.org)
-# you cannot run it directly
-
-function deactivate  -d "Exit virtualenv and return to normal shell environment"
-    # reset old environment variables
-    if test -n "$_OLD_VIRTUAL_PATH"
-        set -gx PATH $_OLD_VIRTUAL_PATH
-        set -e _OLD_VIRTUAL_PATH
-    end
-    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
-        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
-        set -e _OLD_VIRTUAL_PYTHONHOME
-    end
-
-    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        functions -e fish_prompt
-        set -e _OLD_FISH_PROMPT_OVERRIDE
-        functions -c _old_fish_prompt fish_prompt
-        functions -e _old_fish_prompt
-    end
-
-    set -e VIRTUAL_ENV
-    if test "$argv[1]" != "nondestructive"
-        # Self destruct!
-        functions -e deactivate
-    end
-end
-
-# unset irrelevant variables
-deactivate nondestructive
-
-set -gx VIRTUAL_ENV "/var/flaskapp/web-service/venv"
-
-set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/bin" $PATH
-
-# unset PYTHONHOME if set
-if set -q PYTHONHOME
-    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
-    set -e PYTHONHOME
-end
-
-if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
-    # fish uses a function instead of an env var to generate the prompt.
-
-    # save the current fish_prompt function as the function _old_fish_prompt
-    functions -c fish_prompt _old_fish_prompt
-
-    # with the original prompt function renamed, we can override with our own.
-    function fish_prompt
-        # Save the return status of the last command
-        set -l old_status $status
-
-        # Prompt override?
-        if test -n "(venv) "            
-            printf "%s%s" "(venv) " (set_color normal)
-        else
-            # ...Otherwise, prepend env
-            set -l _checkbase (basename "$VIRTUAL_ENV")
-            if test $_checkbase = "__"
-                # special case for Aspen magic directories
-                # see http://www.zetadev.com/software/aspen/
-                printf "%s[%s]%s " (set_color -b blue white) (basename (dirname "$VIRTUAL_ENV")) (set_color normal)
-            else
-                printf "%s(%s)%s" (set_color -b blue white) (basename "$VIRTUAL_ENV") (set_color normal)
-            end
-        end
-
-        # Restore the return status of the previous command.
-        echo "exit $old_status" | .
-        _old_fish_prompt
-    end
-
-    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-end
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install
deleted file mode 100755
index 691289b73..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from setuptools.command.easy_install import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install-3.5 b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install-3.5
deleted file mode 100755
index 691289b73..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/easy_install-3.5
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from setuptools.command.easy_install import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/flask b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/flask
deleted file mode 100755
index a4dfeebb2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/flask
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from flask.cli import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn
deleted file mode 100755
index e7497c1a1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from gunicorn.app.wsgiapp import run
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn_paster b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn_paster
deleted file mode 100755
index 29cdf6059..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/gunicorn_paster
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from gunicorn.app.pasterapp import run
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(run())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip
deleted file mode 100755
index 31f9968a3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from pip import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3 b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3
deleted file mode 100755
index 31f9968a3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from pip import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3.5 b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3.5
deleted file mode 100755
index 31f9968a3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/pip3.5
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/var/flaskapp/web-service/venv/bin/python3
-
-# -*- coding: utf-8 -*-
-import re
-import sys
-
-from pip import main
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python
deleted file mode 100755
index 84ce4669f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python3 b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python3
deleted file mode 100755
index 84ce4669f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/bin/python3 and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/LICENSE.txt
deleted file mode 100644
index 87ce152aa..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-Copyright © 2014 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the software as
-well as documentation, with or without modification, are permitted
-provided that the following conditions are met:
-
--   Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
--   Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
--   Neither the name of the copyright holder nor the names of its
-    contributors may be used to endorse or promote products derived from
-    this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-
-----
-
-Click uses parts of optparse written by Gregory P. Ward and maintained
-by the Python Software Foundation. This is limited to code in parser.py.
-
-Copyright © 2001-2006 Gregory P. Ward. All rights reserved.
-Copyright © 2002-2006 Python Software Foundation. All rights reserved.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/METADATA
deleted file mode 100644
index 625bdaddb..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/METADATA
+++ /dev/null
@@ -1,121 +0,0 @@
-Metadata-Version: 2.1
-Name: Click
-Version: 7.0
-Summary: Composable command line interface toolkit
-Home-page: https://palletsprojects.com/p/click/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets Team
-Maintainer-email: contact@palletsprojects.com
-License: BSD
-Project-URL: Documentation, https://click.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/click
-Project-URL: Issue tracker, https://github.com/pallets/click/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
-
-\$ click\_
-==========
-
-Click is a Python package for creating beautiful command line interfaces
-in a composable way with as little code as necessary. It's the "Command
-Line Interface Creation Kit". It's highly configurable but comes with
-sensible defaults out of the box.
-
-It aims to make the process of writing command line tools quick and fun
-while also preventing any frustration caused by the inability to
-implement an intended CLI API.
-
-Click in three points:
-
--   Arbitrary nesting of commands
--   Automatic help page generation
--   Supports lazy loading of subcommands at runtime
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    $ pip install click
-
-Click supports Python 3.4 and newer, Python 2.7, and PyPy.
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-A Simple Example
-----------------
-
-What does it look like? Here is an example of a simple Click program:
-
-.. code-block:: python
-
-    import click
-
-    @click.command()
-    @click.option("--count", default=1, help="Number of greetings.")
-    @click.option("--name", prompt="Your name",
-                  help="The person to greet.")
-    def hello(count, name):
-        """Simple program that greets NAME for a total of COUNT times."""
-        for _ in range(count):
-            click.echo("Hello, %s!" % name)
-
-    if __name__ == '__main__':
-        hello()
-
-And what it looks like when run:
-
-.. code-block:: text
-
-    $ python hello.py --count=3
-    Your name: Click
-    Hello, Click!
-    Hello, Click!
-    Hello, Click!
-
-
-Donate
-------
-
-The Pallets organization develops and supports Click and other popular
-packages. In order to grow the community of contributors and users, and
-allow the maintainers to devote more time to the projects, `please
-donate today`_.
-
-.. _please donate today: https://palletsprojects.com/donate
-
-
-Links
------
-
-*   Website: https://palletsprojects.com/p/click/
-*   Documentation: https://click.palletsprojects.com/
-*   License: `BSD <https://github.com/pallets/click/blob/master/LICENSE.rst>`_
-*   Releases: https://pypi.org/project/click/
-*   Code: https://github.com/pallets/click
-*   Issue tracker: https://github.com/pallets/click/issues
-*   Test status:
-
-    *   Linux, Mac: https://travis-ci.org/pallets/click
-    *   Windows: https://ci.appveyor.com/project/pallets/click
-
-*   Test coverage: https://codecov.io/gh/pallets/click
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/RECORD
deleted file mode 100644
index 657f38d08..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/RECORD
+++ /dev/null
@@ -1,40 +0,0 @@
-Click-7.0.dist-info/LICENSE.txt,sha256=4hIxn676T0Wcisk3_chVcECjyrivKTZsoqSNI5AlIlw,1876
-Click-7.0.dist-info/METADATA,sha256=-r8jeke3Zer4diRvT1MjFZuiJ6yTT_qFP39svLqdaLI,3516
-Click-7.0.dist-info/RECORD,,
-Click-7.0.dist-info/WHEEL,sha256=gduuPyBvFJQSQ0zdyxF7k0zynDXbIbvg5ZBHoXum5uk,110
-Click-7.0.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
-click/__init__.py,sha256=HjGThQ7tef9kkwCV371TBnrf0SAi6fKfU_jtEnbYTvQ,2789
-click/_bashcomplete.py,sha256=iaNUmtxag0YPfxba3TDYCNietiTMQIrvhRLj-H8okFU,11014
-click/_compat.py,sha256=vYmvoj4opPxo-c-2GMQQjYT_r_QkOKybkfGoeVrt0dA,23399
-click/_termui_impl.py,sha256=xHmLtOJhKUCVD6168yucJ9fknUJPAMs0eUTPgVUO-GQ,19611
-click/_textwrap.py,sha256=gwS4m7bdQiJnzaDG8osFcRb-5vn4t4l2qSCy-5csCEc,1198
-click/_unicodefun.py,sha256=QHy2_5jYlX-36O-JVrTHNnHOqg8tquUR0HmQFev7Ics,4364
-click/_winconsole.py,sha256=PPWVak8Iikm_gAPsxMrzwsVFCvHgaW3jPaDWZ1JBl3U,8965
-click/core.py,sha256=q8FLcDZsagBGSRe5Y9Hi_FGvAeZvusNfoO5EkhkSQ8Y,75305
-click/decorators.py,sha256=idKt6duLUUfAFftrHoREi8MJSd39XW36pUVHthdglwk,11226
-click/exceptions.py,sha256=CNpAjBAE7qjaV4WChxQeak95e5yUOau8AsvT-8m6wss,7663
-click/formatting.py,sha256=eh-cypTUAhpI3HD-K4ZpR3vCiURIO62xXvKkR3tNUTM,8889
-click/globals.py,sha256=oQkou3ZQ5DgrbVM6BwIBirwiqozbjfirzsLGAlLRRdg,1514
-click/parser.py,sha256=m-nGZz4VwprM42_qtFlWFGo7yRJQxkBlRcZodoH593Y,15510
-click/termui.py,sha256=o_ZXB2jyvL2Rce7P_bFGq452iyBq9ykJyRApIPMCZO0,23207
-click/testing.py,sha256=aYGqY_iWLu2p4k7lkuJ6t3fqpf6aPGqTsyLzNY_ngKg,13062
-click/types.py,sha256=2Q929p-aBP_ZYuMFJqJR-Ipucofv3fmDc5JzBDPmzJU,23287
-click/utils.py,sha256=6-D0WkAxvv9FkgHXSHwDIv0l9Gdx9Mm6Z5vuKNLIfZI,15763
-Click-7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-click/__pycache__/_unicodefun.cpython-35.pyc,,
-click/__pycache__/formatting.cpython-35.pyc,,
-click/__pycache__/_compat.cpython-35.pyc,,
-click/__pycache__/_textwrap.cpython-35.pyc,,
-click/__pycache__/_winconsole.cpython-35.pyc,,
-click/__pycache__/utils.cpython-35.pyc,,
-click/__pycache__/core.cpython-35.pyc,,
-click/__pycache__/parser.cpython-35.pyc,,
-click/__pycache__/globals.cpython-35.pyc,,
-click/__pycache__/_termui_impl.cpython-35.pyc,,
-click/__pycache__/termui.cpython-35.pyc,,
-click/__pycache__/decorators.cpython-35.pyc,,
-click/__pycache__/exceptions.cpython-35.pyc,,
-click/__pycache__/_bashcomplete.cpython-35.pyc,,
-click/__pycache__/testing.cpython-35.pyc,,
-click/__pycache__/__init__.cpython-35.pyc,,
-click/__pycache__/types.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/WHEEL
deleted file mode 100644
index 1316c41d0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.31.1)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/top_level.txt
deleted file mode 100644
index dca9a9096..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Click-7.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-click
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/LICENSE.txt
deleted file mode 100644
index 8f9252f45..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-Copyright © 2010 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the software as
-well as documentation, with or without modification, are permitted
-provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/METADATA
deleted file mode 100644
index c600e730a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/METADATA
+++ /dev/null
@@ -1,130 +0,0 @@
-Metadata-Version: 2.1
-Name: Flask
-Version: 1.0.2
-Summary: A simple framework for building complex web applications.
-Home-page: https://www.palletsprojects.com/p/flask/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets team
-Maintainer-email: contact@palletsprojects.com
-License: BSD
-Project-URL: Documentation, http://flask.pocoo.org/docs/
-Project-URL: Code, https://github.com/pallets/flask
-Project-URL: Issue tracker, https://github.com/pallets/flask/issues
-Platform: any
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Flask
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Provides-Extra: dev
-Provides-Extra: docs
-Provides-Extra: dotenv
-Requires-Dist: Werkzeug (>=0.14)
-Requires-Dist: Jinja2 (>=2.10)
-Requires-Dist: itsdangerous (>=0.24)
-Requires-Dist: click (>=5.1)
-Provides-Extra: dev
-Requires-Dist: pytest (>=3); extra == 'dev'
-Requires-Dist: coverage; extra == 'dev'
-Requires-Dist: tox; extra == 'dev'
-Requires-Dist: sphinx; extra == 'dev'
-Requires-Dist: pallets-sphinx-themes; extra == 'dev'
-Requires-Dist: sphinxcontrib-log-cabinet; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: sphinx; extra == 'docs'
-Requires-Dist: pallets-sphinx-themes; extra == 'docs'
-Requires-Dist: sphinxcontrib-log-cabinet; extra == 'docs'
-Provides-Extra: dotenv
-Requires-Dist: python-dotenv; extra == 'dotenv'
-
-Flask
-=====
-
-Flask is a lightweight `WSGI`_ web application framework. It is designed
-to make getting started quick and easy, with the ability to scale up to
-complex applications. It began as a simple wrapper around `Werkzeug`_
-and `Jinja`_ and has become one of the most popular Python web
-application frameworks.
-
-Flask offers suggestions, but doesn't enforce any dependencies or
-project layout. It is up to the developer to choose the tools and
-libraries they want to use. There are many extensions provided by the
-community that make adding new functionality easy.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Flask
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from flask import Flask
-
-    app = Flask(__name__)
-
-    @app.route('/')
-    def hello():
-        return 'Hello, World!'
-
-.. code-block:: text
-
-    $ FLASK_APP=hello.py flask run
-     * Serving Flask app "hello"
-     * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
-
-
-Donate
-------
-
-The Pallets organization develops and supports Flask and the libraries
-it uses. In order to grow the community of contributors and users, and
-allow the maintainers to devote more time to the projects, `please
-donate today`_.
-
-.. _please donate today: https://psfmember.org/civicrm/contribute/transact?reset=1&id=20
-
-
-Links
------
-
-* Website: https://www.palletsprojects.com/p/flask/
-* Documentation: http://flask.pocoo.org/docs/
-* License: `BSD <https://github.com/pallets/flask/blob/master/LICENSE>`_
-* Releases: https://pypi.org/project/Flask/
-* Code: https://github.com/pallets/flask
-* Issue tracker: https://github.com/pallets/flask/issues
-* Test status:
-
-  * Linux, Mac: https://travis-ci.org/pallets/flask
-  * Windows: https://ci.appveyor.com/project/pallets/flask
-
-* Test coverage: https://codecov.io/gh/pallets/flask
-
-.. _WSGI: https://wsgi.readthedocs.io
-.. _Werkzeug: https://www.palletsprojects.com/p/werkzeug/
-.. _Jinja: https://www.palletsprojects.com/p/jinja/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/RECORD
deleted file mode 100644
index dc0dab8cc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/RECORD
+++ /dev/null
@@ -1,48 +0,0 @@
-Flask-1.0.2.dist-info/LICENSE.txt,sha256=ziEXA3AIuaiUn1qe4cd1XxCESWTYrk4TjN7Qb06J3l8,1575
-Flask-1.0.2.dist-info/METADATA,sha256=iA5tiNWzTtgCVe80aTZGNWsckj853fJyfvHs9U-WZRk,4182
-Flask-1.0.2.dist-info/RECORD,,
-Flask-1.0.2.dist-info/WHEEL,sha256=J3CsTk7Mf2JNUyhImI-mjX-fmI4oDjyiXgWT4qgZiCE,110
-Flask-1.0.2.dist-info/entry_points.txt,sha256=gBLA1aKg0OYR8AhbAfg8lnburHtKcgJLDU52BBctN0k,42
-Flask-1.0.2.dist-info/top_level.txt,sha256=dvi65F6AeGWVU0TBpYiC04yM60-FX1gJFkK31IKQr5c,6
-flask/__init__.py,sha256=qq8lK6QQbxJALf1igz7qsvUwOTAoKvFGfdLm7jPNsso,1673
-flask/__main__.py,sha256=pgIXrHhxM5MAMvgzAqWpw_t6AXZ1zG38us4JRgJKtxk,291
-flask/_compat.py,sha256=UDFGhosh6mOdNB-4evKPuneHum1OpcAlwTNJCRm0irQ,2892
-flask/app.py,sha256=ahpe3T8w98rQd_Er5d7uDxK57S1nnqGQx3V3hirBovU,94147
-flask/blueprints.py,sha256=Cyhl_x99tgwqEZPtNDJUFneAfVJxWfEU4bQA7zWS6VU,18331
-flask/cli.py,sha256=30QYAO10Do9LbZYCLgfI_xhKjASdLopL8wKKVUGS2oA,29442
-flask/config.py,sha256=kznUhj4DLYxsTF_4kfDG8GEHto1oZG_kqblyrLFtpqQ,9951
-flask/ctx.py,sha256=leFzS9fzmo0uaLCdxpHc5_iiJZ1H0X_Ig4yPCOvT--g,16224
-flask/debughelpers.py,sha256=1ceC-UyqZTd4KsJkf0OObHPsVt5R3T6vnmYhiWBjV-w,6479
-flask/globals.py,sha256=pGg72QW_-4xUfsI33I5L_y76c21AeqfSqXDcbd8wvXU,1649
-flask/helpers.py,sha256=YCl8D1plTO1evEYP4KIgaY3H8Izww5j4EdgRJ89oHTw,40106
-flask/logging.py,sha256=qV9h0vt7NIRkKM9OHDWndzO61E5CeBMlqPJyTt-W2Wc,2231
-flask/sessions.py,sha256=2XHV4ASREhSEZ8bsPQW6pNVNuFtbR-04BzfKg0AfvHo,14452
-flask/signals.py,sha256=BGQbVyCYXnzKK2DVCzppKFyWN1qmrtW1QMAYUs-1Nr8,2211
-flask/templating.py,sha256=FDfWMbpgpC3qObW8GGXRAVrkHFF8K4CHOJymB1wvULI,4914
-flask/testing.py,sha256=XD3gWNvLUV8dqVHwKd9tZzsj81fSHtjOphQ1wTNtlMs,9379
-flask/views.py,sha256=Wy-_WkUVtCfE2zCXYeJehNgHuEtviE4v3HYfJ--MpbY,5733
-flask/wrappers.py,sha256=1Z9hF5-hXQajn_58XITQFRY8efv3Vy3uZ0avBfZu6XI,7511
-flask/json/__init__.py,sha256=Ns1Hj805XIxuBMh2z0dYnMVfb_KUgLzDmP3WoUYaPhw,10729
-flask/json/tag.py,sha256=9ehzrmt5k7hxf7ZEK0NOs3swvQyU9fWNe-pnYe69N60,8223
-../../../bin/flask,sha256=n5Vl75_JzHj1TQ3-xgtLQEgzVUAygtOXG1BuVyY-T_Y,249
-Flask-1.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-flask/__pycache__/globals.cpython-35.pyc,,
-flask/__pycache__/sessions.cpython-35.pyc,,
-flask/__pycache__/helpers.cpython-35.pyc,,
-flask/__pycache__/testing.cpython-35.pyc,,
-flask/__pycache__/_compat.cpython-35.pyc,,
-flask/__pycache__/app.cpython-35.pyc,,
-flask/__pycache__/config.cpython-35.pyc,,
-flask/__pycache__/signals.cpython-35.pyc,,
-flask/__pycache__/debughelpers.cpython-35.pyc,,
-flask/__pycache__/wrappers.cpython-35.pyc,,
-flask/__pycache__/ctx.cpython-35.pyc,,
-flask/__pycache__/templating.cpython-35.pyc,,
-flask/__pycache__/blueprints.cpython-35.pyc,,
-flask/json/__pycache__/tag.cpython-35.pyc,,
-flask/json/__pycache__/__init__.cpython-35.pyc,,
-flask/__pycache__/logging.cpython-35.pyc,,
-flask/__pycache__/cli.cpython-35.pyc,,
-flask/__pycache__/views.cpython-35.pyc,,
-flask/__pycache__/__init__.cpython-35.pyc,,
-flask/__pycache__/__main__.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/WHEEL
deleted file mode 100644
index f21b51cd8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.31.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/entry_points.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/entry_points.txt
deleted file mode 100644
index 1eb025200..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/entry_points.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-[console_scripts]
-flask = flask.cli:main
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/top_level.txt
deleted file mode 100644
index 7e1060246..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Flask-1.0.2.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-flask
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/DESCRIPTION.rst
deleted file mode 100644
index 1594da5ce..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,37 +0,0 @@
-
-Jinja2
-~~~~~~
-
-Jinja2 is a template engine written in pure Python.  It provides a
-`Django`_ inspired non-XML syntax but supports inline expressions and
-an optional `sandboxed`_ environment.
-
-Nutshell
---------
-
-Here a small example of a Jinja template::
-
-    {% extends 'base.html' %}
-    {% block title %}Memberlist{% endblock %}
-    {% block content %}
-      <ul>
-      {% for user in users %}
-        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-      {% endfor %}
-      </ul>
-    {% endblock %}
-
-Philosophy
-----------
-
-Application logic is for the controller but don't try to make the life
-for the template designer too hard by giving him too few functionality.
-
-For more informations visit the new `Jinja2 webpage`_ and `documentation`_.
-
-.. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security)
-.. _Django: https://www.djangoproject.com/
-.. _Jinja2 webpage: http://jinja.pocoo.org/
-.. _documentation: http://jinja.pocoo.org/2/documentation/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/LICENSE.txt
deleted file mode 100644
index 10145a264..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-Copyright (c) 2009 by the Jinja Team, see AUTHORS for more details.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/METADATA
deleted file mode 100644
index 40f2b46b4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/METADATA
+++ /dev/null
@@ -1,68 +0,0 @@
-Metadata-Version: 2.0
-Name: Jinja2
-Version: 2.10
-Summary: A small but fast and easy to use stand-alone template engine written in pure python.
-Home-page: http://jinja.pocoo.org/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description-Content-Type: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Requires-Dist: MarkupSafe (>=0.23)
-Provides-Extra: i18n
-Requires-Dist: Babel (>=0.8); extra == 'i18n'
-
-
-Jinja2
-~~~~~~
-
-Jinja2 is a template engine written in pure Python.  It provides a
-`Django`_ inspired non-XML syntax but supports inline expressions and
-an optional `sandboxed`_ environment.
-
-Nutshell
---------
-
-Here a small example of a Jinja template::
-
-    {% extends 'base.html' %}
-    {% block title %}Memberlist{% endblock %}
-    {% block content %}
-      <ul>
-      {% for user in users %}
-        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-      {% endfor %}
-      </ul>
-    {% endblock %}
-
-Philosophy
-----------
-
-Application logic is for the controller but don't try to make the life
-for the template designer too hard by giving him too few functionality.
-
-For more informations visit the new `Jinja2 webpage`_ and `documentation`_.
-
-.. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security)
-.. _Django: https://www.djangoproject.com/
-.. _Jinja2 webpage: http://jinja.pocoo.org/
-.. _documentation: http://jinja.pocoo.org/2/documentation/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/RECORD
deleted file mode 100644
index df39fb01e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/RECORD
+++ /dev/null
@@ -1,61 +0,0 @@
-Jinja2-2.10.dist-info/DESCRIPTION.rst,sha256=b5ckFDoM7vVtz_mAsJD4OPteFKCqE7beu353g4COoYI,978
-Jinja2-2.10.dist-info/LICENSE.txt,sha256=JvzUNv3Io51EiWrAPm8d_SXjhJnEjyDYvB3Tvwqqils,1554
-Jinja2-2.10.dist-info/METADATA,sha256=18EgU8zR6-av-0-5y_gXebzK4GnBB_76lALUsl-6QHM,2258
-Jinja2-2.10.dist-info/RECORD,,
-Jinja2-2.10.dist-info/WHEEL,sha256=kdsN-5OJAZIiHN-iO4Rhl82KyS0bDWf4uBwMbkNafr8,110
-Jinja2-2.10.dist-info/entry_points.txt,sha256=NdzVcOrqyNyKDxD09aERj__3bFx2paZhizFDsKmVhiA,72
-Jinja2-2.10.dist-info/metadata.json,sha256=NPUJ9TMBxVQAv_kTJzvU8HwmP-4XZvbK9mz6_4YUVl4,1473
-Jinja2-2.10.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
-jinja2/__init__.py,sha256=xJHjaMoy51_KXn1wf0cysH6tUUifUxZCwSOfcJGEYZw,2614
-jinja2/_compat.py,sha256=xP60CE5Qr8FTYcDE1f54tbZLKGvMwYml4-8T7Q4KG9k,2596
-jinja2/_identifier.py,sha256=W1QBSY-iJsyt6oR_nKSuNNCzV95vLIOYgUNPUI1d5gU,1726
-jinja2/asyncfilters.py,sha256=cTDPvrS8Hp_IkwsZ1m9af_lr5nHysw7uTa5gV0NmZVE,4144
-jinja2/asyncsupport.py,sha256=UErQ3YlTLaSjFb94P4MVn08-aVD9jJxty2JVfMRb-1M,7878
-jinja2/bccache.py,sha256=nQldx0ZRYANMyfvOihRoYFKSlUdd5vJkS7BjxNwlOZM,12794
-jinja2/compiler.py,sha256=BqC5U6JxObSRhblyT_a6Tp5GtEU5z3US1a4jLQaxxgo,65386
-jinja2/constants.py,sha256=uwwV8ZUhHhacAuz5PTwckfsbqBaqM7aKfyJL7kGX5YQ,1626
-jinja2/debug.py,sha256=WTVeUFGUa4v6ReCsYv-iVPa3pkNB75OinJt3PfxNdXs,12045
-jinja2/defaults.py,sha256=Em-95hmsJxIenDCZFB1YSvf9CNhe9rBmytN3yUrBcWA,1400
-jinja2/environment.py,sha256=VnkAkqw8JbjZct4tAyHlpBrka2vqB-Z58RAP-32P1ZY,50849
-jinja2/exceptions.py,sha256=_Rj-NVi98Q6AiEjYQOsP8dEIdu5AlmRHzcSNOPdWix4,4428
-jinja2/ext.py,sha256=atMQydEC86tN1zUsdQiHw5L5cF62nDbqGue25Yiu3N4,24500
-jinja2/filters.py,sha256=yOAJk0MsH-_gEC0i0U6NweVQhbtYaC-uE8xswHFLF4w,36528
-jinja2/idtracking.py,sha256=2GbDSzIvGArEBGLkovLkqEfmYxmWsEf8c3QZwM4uNsw,9197
-jinja2/lexer.py,sha256=ySEPoXd1g7wRjsuw23uimS6nkGN5aqrYwcOKxCaVMBQ,28559
-jinja2/loaders.py,sha256=xiTuURKAEObyym0nU8PCIXu_Qp8fn0AJ5oIADUUm-5Q,17382
-jinja2/meta.py,sha256=fmKHxkmZYAOm9QyWWy8EMd6eefAIh234rkBMW2X4ZR8,4340
-jinja2/nativetypes.py,sha256=_sJhS8f-8Q0QMIC0dm1YEdLyxEyoO-kch8qOL5xUDfE,7308
-jinja2/nodes.py,sha256=L10L_nQDfubLhO3XjpF9qz46FSh2clL-3e49ogVlMmA,30853
-jinja2/optimizer.py,sha256=MsdlFACJ0FRdPtjmCAdt7JQ9SGrXFaDNUaslsWQaG3M,1722
-jinja2/parser.py,sha256=lPzTEbcpTRBLw8ii6OYyExHeAhaZLMA05Hpv4ll3ULk,35875
-jinja2/runtime.py,sha256=DHdD38Pq8gj7uWQC5usJyWFoNWL317A9AvXOW_CLB34,27755
-jinja2/sandbox.py,sha256=TVyZHlNqqTzsv9fv2NvJNmSdWRHTguhyMHdxjWms32U,16708
-jinja2/tests.py,sha256=iJQLwbapZr-EKquTG_fVOVdwHUUKf3SX9eNkjQDF8oU,4237
-jinja2/utils.py,sha256=q24VupGZotQ-uOyrJxCaXtDWhZC1RgsQG7kcdmjck2Q,20629
-jinja2/visitor.py,sha256=JD1H1cANA29JcntFfN5fPyqQxB4bI4wC00BzZa-XHks,3316
-Jinja2-2.10.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-jinja2/__pycache__/compiler.cpython-35.pyc,,
-jinja2/__pycache__/runtime.cpython-35.pyc,,
-jinja2/__pycache__/defaults.cpython-35.pyc,,
-jinja2/__pycache__/tests.cpython-35.pyc,,
-jinja2/__pycache__/idtracking.cpython-35.pyc,,
-jinja2/__pycache__/debug.cpython-35.pyc,,
-jinja2/__pycache__/meta.cpython-35.pyc,,
-jinja2/__pycache__/filters.cpython-35.pyc,,
-jinja2/__pycache__/_identifier.cpython-35.pyc,,
-jinja2/__pycache__/sandbox.cpython-35.pyc,,
-jinja2/__pycache__/environment.cpython-35.pyc,,
-jinja2/__pycache__/nativetypes.cpython-35.pyc,,
-jinja2/__pycache__/constants.cpython-35.pyc,,
-jinja2/__pycache__/_compat.cpython-35.pyc,,
-jinja2/__pycache__/__init__.cpython-35.pyc,,
-jinja2/__pycache__/ext.cpython-35.pyc,,
-jinja2/__pycache__/loaders.cpython-35.pyc,,
-jinja2/__pycache__/visitor.cpython-35.pyc,,
-jinja2/__pycache__/parser.cpython-35.pyc,,
-jinja2/__pycache__/exceptions.cpython-35.pyc,,
-jinja2/__pycache__/lexer.cpython-35.pyc,,
-jinja2/__pycache__/nodes.cpython-35.pyc,,
-jinja2/__pycache__/utils.cpython-35.pyc,,
-jinja2/__pycache__/optimizer.cpython-35.pyc,,
-jinja2/__pycache__/bccache.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/WHEEL
deleted file mode 100644
index 7332a419c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.30.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/entry_points.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/entry_points.txt
deleted file mode 100644
index 32e6b7530..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/entry_points.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-
-    [babel.extractors]
-    jinja2 = jinja2.ext:babel_extract[i18n]
-    
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/metadata.json
deleted file mode 100644
index 7f5dc3879..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Text Processing :: Markup :: HTML"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}, "project_urls": {"Home": "http://jinja.pocoo.org/"}}, "python.exports": {"babel.extractors": {"jinja2": "jinja2.ext:babel_extract [i18n]"}}}, "extras": ["i18n"], "generator": "bdist_wheel (0.30.0)", "license": "BSD", "metadata_version": "2.0", "name": "Jinja2", "run_requires": [{"extra": "i18n", "requires": ["Babel (>=0.8)"]}, {"requires": ["MarkupSafe (>=0.23)"]}], "summary": "A small but fast and easy to use stand-alone template engine written in pure python.", "version": "2.10"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/top_level.txt
deleted file mode 100644
index 7f7afbf3b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Jinja2-2.10.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-jinja2
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/DESCRIPTION.rst
deleted file mode 100644
index 846295411..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,71 +0,0 @@
-MarkupSafe
-==========
-
-MarkupSafe implements a text object that escapes characters so it is
-safe to use in HTML and XML. Characters that have special meanings are
-replaced so that they display as the actual characters. This mitigates
-injection attacks, meaning untrusted user input can safely be displayed
-on a page.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U MarkupSafe
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-Examples
---------
-
-.. code-block:: pycon
-
-    >>> from markupsafe import Markup, escape
-    >>> # escape replaces special characters and wraps in Markup
-    >>> escape('<script>alert(document.cookie);</script>')
-    Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
-    >>> # wrap in Markup to mark text "safe" and prevent escaping
-    >>> Markup('<strong>Hello</strong>')
-    Markup('<strong>hello</strong>')
-    >>> escape(Markup('<strong>Hello</strong>'))
-    Markup('<strong>hello</strong>')
-    >>> # Markup is a text subclass (str on Python 3, unicode on Python 2)
-    >>> # methods and operators escape their arguments
-    >>> template = Markup("Hello <em>%s</em>")
-    >>> template % '"World"'
-    Markup('Hello <em>&#34;World&#34;</em>')
-
-
-Donate
-------
-
-The Pallets organization develops and supports MarkupSafe and other
-libraries that use it. In order to grow the community of contributors
-and users, and allow the maintainers to devote more time to the
-projects, `please donate today`_.
-
-.. _please donate today: https://psfmember.org/civicrm/contribute/transact?reset=1&id=20
-
-
-Links
------
-
-*   Website: https://www.palletsprojects.com/p/markupsafe/
-*   Documentation: https://markupsafe.palletsprojects.com/
-*   License: `BSD <https://github.com/pallets/markupsafe/blob/master/LICENSE.rst>`_
-*   Releases: https://pypi.org/project/MarkupSafe/
-*   Code: https://github.com/pallets/markupsafe
-*   Issue tracker: https://github.com/pallets/markupsafe/issues
-*   Test status:
-
-    *   Linux, Mac: https://travis-ci.org/pallets/markupsafe
-    *   Windows: https://ci.appveyor.com/project/pallets/markupsafe
-
-*   Test coverage: https://codecov.io/gh/pallets/markupsafe
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/LICENSE.txt
deleted file mode 100644
index 28c925898..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-`BSD 3-Clause <https://opensource.org/licenses/BSD-3-Clause>`_
-
-Copyright © 2010 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
--   Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
--   Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
--   Neither the name of the copyright holder nor the names of its
-    contributors may be used to endorse or promote products derived from
-    this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/METADATA
deleted file mode 100644
index 2c9311c17..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/METADATA
+++ /dev/null
@@ -1,103 +0,0 @@
-Metadata-Version: 2.0
-Name: MarkupSafe
-Version: 1.1.0
-Summary: Safely add untrusted strings to HTML/XML markup.
-Home-page: https://www.palletsprojects.com/p/markupsafe/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets Team
-Maintainer-email: contact@palletsprojects.com
-License: BSD
-Project-URL: Issue tracker, https://github.com/pallets/markupsafe/issues
-Project-URL: Documentation, https://markupsafe.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/markupsafe
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*
-
-MarkupSafe
-==========
-
-MarkupSafe implements a text object that escapes characters so it is
-safe to use in HTML and XML. Characters that have special meanings are
-replaced so that they display as the actual characters. This mitigates
-injection attacks, meaning untrusted user input can safely be displayed
-on a page.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U MarkupSafe
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-Examples
---------
-
-.. code-block:: pycon
-
-    >>> from markupsafe import Markup, escape
-    >>> # escape replaces special characters and wraps in Markup
-    >>> escape('<script>alert(document.cookie);</script>')
-    Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
-    >>> # wrap in Markup to mark text "safe" and prevent escaping
-    >>> Markup('<strong>Hello</strong>')
-    Markup('<strong>hello</strong>')
-    >>> escape(Markup('<strong>Hello</strong>'))
-    Markup('<strong>hello</strong>')
-    >>> # Markup is a text subclass (str on Python 3, unicode on Python 2)
-    >>> # methods and operators escape their arguments
-    >>> template = Markup("Hello <em>%s</em>")
-    >>> template % '"World"'
-    Markup('Hello <em>&#34;World&#34;</em>')
-
-
-Donate
-------
-
-The Pallets organization develops and supports MarkupSafe and other
-libraries that use it. In order to grow the community of contributors
-and users, and allow the maintainers to devote more time to the
-projects, `please donate today`_.
-
-.. _please donate today: https://psfmember.org/civicrm/contribute/transact?reset=1&id=20
-
-
-Links
------
-
-*   Website: https://www.palletsprojects.com/p/markupsafe/
-*   Documentation: https://markupsafe.palletsprojects.com/
-*   License: `BSD <https://github.com/pallets/markupsafe/blob/master/LICENSE.rst>`_
-*   Releases: https://pypi.org/project/MarkupSafe/
-*   Code: https://github.com/pallets/markupsafe
-*   Issue tracker: https://github.com/pallets/markupsafe/issues
-*   Test status:
-
-    *   Linux, Mac: https://travis-ci.org/pallets/markupsafe
-    *   Windows: https://ci.appveyor.com/project/pallets/markupsafe
-
-*   Test coverage: https://codecov.io/gh/pallets/markupsafe
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/RECORD
deleted file mode 100644
index f7e87753c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/RECORD
+++ /dev/null
@@ -1,18 +0,0 @@
-MarkupSafe-1.1.0.dist-info/DESCRIPTION.rst,sha256=GwJ8N8dZrINcQx0mTZIp38Iffc8H6WxrWp7QM_RGx8E,2176
-MarkupSafe-1.1.0.dist-info/LICENSE.txt,sha256=7V249lpOdvRv2m6SF9gCDtq_nsg8tFpdeTdsWWM_g9M,1614
-MarkupSafe-1.1.0.dist-info/METADATA,sha256=Y7T_CrTlW50AVHED4sxgiLju_iv_2k8wsVA-_H9hwwo,3585
-MarkupSafe-1.1.0.dist-info/RECORD,,
-MarkupSafe-1.1.0.dist-info/WHEEL,sha256=XekceigvR3RgV2lSKBNPrVEZtjCY_9tSD5WaFaU8G_c,104
-MarkupSafe-1.1.0.dist-info/metadata.json,sha256=pbQItuQFFr4yxuwPj2Yfwzpuxy8f5_3aYgefKIE4dSU,1396
-MarkupSafe-1.1.0.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
-markupsafe/__init__.py,sha256=T5J4pS7LRx1xRqfV3xz-QN_D9pSmfVDJnTrc2cTO4Ro,10164
-markupsafe/_compat.py,sha256=3oSvQpEFzsJ29NKVy-Fqk6ZlRxmlCB5k0G21aN0zNtQ,596
-markupsafe/_constants.py,sha256=ueEz1Jxdw5TKWBbhPr4Ad_2L2MSEh73AYiYe4l3cZy4,4728
-markupsafe/_native.py,sha256=fUrjjbRXIpHM-8l9QXFJ2xg5rv_48U2aN99plyL0kfs,1911
-markupsafe/_speedups.c,sha256=VfElhhq9oulHEd2wBZ2MX9A80r4jFovsVGQD2zxmVk0,9883
-markupsafe/_speedups.cpython-35m-arm-linux-gnueabihf.so,sha256=DI_CzQZNAK0K5gHHis_k2c1XM5zAF9cxGDeyEh9-k54,41808
-MarkupSafe-1.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-markupsafe/__pycache__/_constants.cpython-35.pyc,,
-markupsafe/__pycache__/_native.cpython-35.pyc,,
-markupsafe/__pycache__/_compat.cpython-35.pyc,,
-markupsafe/__pycache__/__init__.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/WHEEL
deleted file mode 100644
index 7f43a4e93..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/WHEEL
+++ /dev/null
@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.29.0)
-Root-Is-Purelib: false
-Tag: cp35-cp35m-linux_armv7l
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/metadata.json
deleted file mode 100644
index 6e33752a8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Text Processing :: Markup :: HTML"], "extensions": {"python.details": {"contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}, {"email": "contact@palletsprojects.com", "name": "Pallets Team", "role": "maintainer"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}, "project_urls": {"Home": "https://www.palletsprojects.com/p/markupsafe/"}}}, "generator": "bdist_wheel (0.29.0)", "license": "BSD", "metadata_version": "2.0", "name": "MarkupSafe", "project_url": "Issue tracker, https://github.com/pallets/markupsafe/issues", "requires_python": ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*", "summary": "Safely add untrusted strings to HTML/XML markup.", "version": "1.1.0"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/top_level.txt
deleted file mode 100644
index 75bf72925..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/MarkupSafe-1.1.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-markupsafe
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/DESCRIPTION.rst
deleted file mode 100644
index 675f08d10..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,80 +0,0 @@
-Werkzeug
-========
-
-Werkzeug is a comprehensive `WSGI`_ web application library. It began as
-a simple collection of various utilities for WSGI applications and has
-become one of the most advanced WSGI utility libraries.
-
-It includes:
-
-* An interactive debugger that allows inspecting stack traces and source
-  code in the browser with an interactive interpreter for any frame in
-  the stack.
-* A full-featured request object with objects to interact with headers,
-  query args, form data, files, and cookies.
-* A response object that can wrap other WSGI applications and handle
-  streaming data.
-* A routing system for matching URLs to endpoints and generating URLs
-  for endpoints, with an extensible system for capturing variables from
-  URLs.
-* HTTP utilities to handle entity tags, cache control, dates, user
-  agents, cookies, files, and more.
-* A threaded WSGI server for use while developing applications locally.
-* A test client for simulating HTTP requests during testing without
-  requiring running a server.
-
-Werkzeug is Unicode aware and doesn't enforce any dependencies. It is up
-to the developer to choose a template engine, database adapter, and even
-how to handle requests. It can be used to build all sorts of end user
-applications such as blogs, wikis, or bulletin boards.
-
-`Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
-providing more structure and patterns for defining powerful
-applications.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Werkzeug
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from werkzeug.wrappers import Request, Response
-
-    @Request.application
-    def application(request):
-        return Response('Hello, World!')
-
-    if __name__ == '__main__':
-        from werkzeug.serving import run_simple
-        run_simple('localhost', 4000, application)
-
-
-Links
------
-
-* Website: https://www.palletsprojects.com/p/werkzeug/
-* Releases: https://pypi.org/project/Werkzeug/
-* Code: https://github.com/pallets/werkzeug
-* Issue tracker: https://github.com/pallets/werkzeug/issues
-* Test status:
-
-  * Linux, Mac: https://travis-ci.org/pallets/werkzeug
-  * Windows: https://ci.appveyor.com/project/davidism/werkzeug
-
-* Test coverage: https://codecov.io/gh/pallets/werkzeug
-
-.. _WSGI: https://wsgi.readthedocs.io/en/latest/
-.. _Flask: https://www.palletsprojects.com/p/flask/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/LICENSE.txt
deleted file mode 100644
index 1cc75bb0e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-Copyright © 2007 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/METADATA
deleted file mode 100644
index bfc3c4e89..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/METADATA
+++ /dev/null
@@ -1,116 +0,0 @@
-Metadata-Version: 2.0
-Name: Werkzeug
-Version: 0.14.1
-Summary: The comprehensive WSGI web application library.
-Home-page: https://www.palletsprojects.org/p/werkzeug/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description-Content-Type: UNKNOWN
-Platform: any
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Provides-Extra: dev
-Requires-Dist: coverage; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: sphinx; extra == 'dev'
-Requires-Dist: tox; extra == 'dev'
-Provides-Extra: termcolor
-Requires-Dist: termcolor; extra == 'termcolor'
-Provides-Extra: watchdog
-Requires-Dist: watchdog; extra == 'watchdog'
-
-Werkzeug
-========
-
-Werkzeug is a comprehensive `WSGI`_ web application library. It began as
-a simple collection of various utilities for WSGI applications and has
-become one of the most advanced WSGI utility libraries.
-
-It includes:
-
-* An interactive debugger that allows inspecting stack traces and source
-  code in the browser with an interactive interpreter for any frame in
-  the stack.
-* A full-featured request object with objects to interact with headers,
-  query args, form data, files, and cookies.
-* A response object that can wrap other WSGI applications and handle
-  streaming data.
-* A routing system for matching URLs to endpoints and generating URLs
-  for endpoints, with an extensible system for capturing variables from
-  URLs.
-* HTTP utilities to handle entity tags, cache control, dates, user
-  agents, cookies, files, and more.
-* A threaded WSGI server for use while developing applications locally.
-* A test client for simulating HTTP requests during testing without
-  requiring running a server.
-
-Werkzeug is Unicode aware and doesn't enforce any dependencies. It is up
-to the developer to choose a template engine, database adapter, and even
-how to handle requests. It can be used to build all sorts of end user
-applications such as blogs, wikis, or bulletin boards.
-
-`Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
-providing more structure and patterns for defining powerful
-applications.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Werkzeug
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from werkzeug.wrappers import Request, Response
-
-    @Request.application
-    def application(request):
-        return Response('Hello, World!')
-
-    if __name__ == '__main__':
-        from werkzeug.serving import run_simple
-        run_simple('localhost', 4000, application)
-
-
-Links
------
-
-* Website: https://www.palletsprojects.com/p/werkzeug/
-* Releases: https://pypi.org/project/Werkzeug/
-* Code: https://github.com/pallets/werkzeug
-* Issue tracker: https://github.com/pallets/werkzeug/issues
-* Test status:
-
-  * Linux, Mac: https://travis-ci.org/pallets/werkzeug
-  * Windows: https://ci.appveyor.com/project/davidism/werkzeug
-
-* Test coverage: https://codecov.io/gh/pallets/werkzeug
-
-.. _WSGI: https://wsgi.readthedocs.io/en/latest/
-.. _Flask: https://www.palletsprojects.com/p/flask/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/RECORD
deleted file mode 100644
index 2a1b850ee..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/RECORD
+++ /dev/null
@@ -1,97 +0,0 @@
-Werkzeug-0.14.1.dist-info/DESCRIPTION.rst,sha256=rOCN36jwsWtWsTpqPG96z7FMilB5qI1CIARSKRuUmz8,2452
-Werkzeug-0.14.1.dist-info/LICENSE.txt,sha256=xndz_dD4m269AF9l_Xbl5V3tM1N3C1LoZC2PEPxWO-8,1534
-Werkzeug-0.14.1.dist-info/METADATA,sha256=FbfadrPdJNUWAxMOKxGUtHe5R3IDSBKYYmAz3FvI3uY,3872
-Werkzeug-0.14.1.dist-info/RECORD,,
-Werkzeug-0.14.1.dist-info/WHEEL,sha256=GrqQvamwgBV4nLoJe0vhYRSWzWsx7xjlt74FT0SWYfE,110
-Werkzeug-0.14.1.dist-info/metadata.json,sha256=4489UTt6HBp2NQil95-pBkjU4Je93SMHvMxZ_rjOpqA,1452
-Werkzeug-0.14.1.dist-info/top_level.txt,sha256=QRyj2VjwJoQkrwjwFIOlB8Xg3r9un0NtqVHQF-15xaw,9
-werkzeug/__init__.py,sha256=NR0d4n_-U9BLVKlOISean3zUt2vBwhvK-AZE6M0sC0k,6842
-werkzeug/_compat.py,sha256=8c4U9o6A_TR9nKCcTbpZNxpqCXcXDVIbFawwKM2s92c,6311
-werkzeug/_internal.py,sha256=GhEyGMlsSz_tYjsDWO9TG35VN7304MM8gjKDrXLEdVc,13873
-werkzeug/_reloader.py,sha256=AyPphcOHPbu6qzW0UbrVvTDJdre5WgpxbhIJN_TqzUc,9264
-werkzeug/datastructures.py,sha256=3IgNKNqrz-ZjmAG7y3YgEYK-enDiMT_b652PsypWcYg,90080
-werkzeug/exceptions.py,sha256=3wp95Hqj9FqV8MdikV99JRcHse_fSMn27V8tgP5Hw2c,20505
-werkzeug/filesystem.py,sha256=hHWeWo_gqLMzTRfYt8-7n2wWcWUNTnDyudQDLOBEICE,2175
-werkzeug/formparser.py,sha256=mUuCwjzjb8_E4RzrAT2AioLuZSYpqR1KXTK6LScRYzA,21722
-werkzeug/http.py,sha256=RQg4MJuhRv2isNRiEh__Phh09ebpfT3Kuu_GfrZ54_c,40079
-werkzeug/local.py,sha256=QdQhWV5L8p1Y1CJ1CDStwxaUs24SuN5aebHwjVD08C8,14553
-werkzeug/posixemulation.py,sha256=xEF2Bxc-vUCPkiu4IbfWVd3LW7DROYAT-ExW6THqyzw,3519
-werkzeug/routing.py,sha256=2JVtdSgxKGeANy4Z_FP-dKESvKtkYGCZ1J2fARCLGCY,67214
-werkzeug/script.py,sha256=DwaVDcXdaOTffdNvlBdLitxWXjKaRVT32VbhDtljFPY,11365
-werkzeug/security.py,sha256=0m107exslz4QJLWQCpfQJ04z3re4eGHVggRvrQVAdWc,9193
-werkzeug/serving.py,sha256=A0flnIJHufdn2QJ9oeuHfrXwP3LzP8fn3rNW6hbxKUg,31926
-werkzeug/test.py,sha256=XmECSmnpASiYQTct4oMiWr0LT5jHWCtKqnpYKZd2ui8,36100
-werkzeug/testapp.py,sha256=3HQRW1sHZKXuAjCvFMet4KXtQG3loYTFnvn6LWt-4zI,9396
-werkzeug/urls.py,sha256=dUeLg2IeTm0WLmSvFeD4hBZWGdOs-uHudR5-t8n9zPo,36771
-werkzeug/useragents.py,sha256=BhYMf4cBTHyN4U0WsQedePIocmNlH_34C-UwqSThGCc,5865
-werkzeug/utils.py,sha256=BrY1j0DHQ8RTb0K1StIobKuMJhN9SQQkWEARbrh2qpk,22972
-werkzeug/websocket.py,sha256=PpSeDxXD_0UsPAa5hQhQNM6mxibeUgn8lA8eRqiS0vM,11344
-werkzeug/wrappers.py,sha256=kbyL_aFjxELwPgMwfNCYjKu-CR6kNkh-oO8wv3GXbk8,84511
-werkzeug/wsgi.py,sha256=1Nob-aeChWQf7MsiicO8RZt6J90iRzEcik44ev9Qu8s,49347
-werkzeug/contrib/__init__.py,sha256=f7PfttZhbrImqpr5Ezre8CXgwvcGUJK7zWNpO34WWrw,623
-werkzeug/contrib/atom.py,sha256=qqfJcfIn2RYY-3hO3Oz0aLq9YuNubcPQ_KZcNsDwVJo,15575
-werkzeug/contrib/cache.py,sha256=xBImHNj09BmX_7kC5NUCx8f_l4L8_O7zi0jCL21UZKE,32163
-werkzeug/contrib/fixers.py,sha256=gR06T-w71ur-tHQ_31kP_4jpOncPJ4Wc1dOqTvYusr8,10179
-werkzeug/contrib/iterio.py,sha256=RlqDvGhz0RneTpzE8dVc-yWCUv4nkPl1jEc_EDp2fH0,10814
-werkzeug/contrib/jsrouting.py,sha256=QTmgeDoKXvNK02KzXgx9lr3cAH6fAzpwF5bBdPNvJPs,8564
-werkzeug/contrib/limiter.py,sha256=iS8-ahPZ-JLRnmfIBzxpm7O_s3lPsiDMVWv7llAIDCI,1334
-werkzeug/contrib/lint.py,sha256=Mj9NeUN7s4zIUWeQOAVjrmtZIcl3Mm2yDe9BSIr9YGE,12558
-werkzeug/contrib/profiler.py,sha256=ISwCWvwVyGpDLRBRpLjo_qUWma6GXYBrTAco4PEQSHY,5151
-werkzeug/contrib/securecookie.py,sha256=uWMyHDHY3lkeBRiCSayGqWkAIy4a7xAbSE_Hln9ecqc,12196
-werkzeug/contrib/sessions.py,sha256=39LVNvLbm5JWpbxM79WC2l87MJFbqeISARjwYbkJatw,12577
-werkzeug/contrib/testtools.py,sha256=G9xN-qeihJlhExrIZMCahvQOIDxdL9NiX874jiiHFMs,2453
-werkzeug/contrib/wrappers.py,sha256=v7OYlz7wQtDlS9fey75UiRZ1IkUWqCpzbhsLy4k14Hw,10398
-werkzeug/debug/__init__.py,sha256=uSn9BqCZ5E3ySgpoZtundpROGsn-uYvZtSFiTfAX24M,17452
-werkzeug/debug/console.py,sha256=n3-dsKk1TsjnN-u4ZgmuWCU_HO0qw5IA7ttjhyyMM6I,5607
-werkzeug/debug/repr.py,sha256=bKqstDYGfECpeLerd48s_hxuqK4b6UWnjMu3d_DHO8I,9340
-werkzeug/debug/tbtools.py,sha256=rBudXCmkVdAKIcdhxANxgf09g6kQjJWW9_5bjSpr4OY,18451
-werkzeug/debug/shared/FONT_LICENSE,sha256=LwAVEI1oYnvXiNMT9SnCH_TaLCxCpeHziDrMg0gPkAI,4673
-werkzeug/debug/shared/console.png,sha256=bxax6RXXlvOij_KeqvSNX0ojJf83YbnZ7my-3Gx9w2A,507
-werkzeug/debug/shared/debugger.js,sha256=PKPVYuyO4SX1hkqLOwCLvmIEO5154WatFYaXE-zIfKI,6264
-werkzeug/debug/shared/jquery.js,sha256=7LkWEzqTdpEfELxcZZlS6wAx5Ff13zZ83lYO2_ujj7g,95957
-werkzeug/debug/shared/less.png,sha256=-4-kNRaXJSONVLahrQKUxMwXGm9R4OnZ9SxDGpHlIR4,191
-werkzeug/debug/shared/more.png,sha256=GngN7CioHQoV58rH6ojnkYi8c_qED2Aka5FO5UXrReY,200
-werkzeug/debug/shared/source.png,sha256=RoGcBTE4CyCB85GBuDGTFlAnUqxwTBiIfDqW15EpnUQ,818
-werkzeug/debug/shared/style.css,sha256=IEO0PC2pWmh2aEyGCaN--txuWsRCliuhlbEhPDFwh0A,6270
-werkzeug/debug/shared/ubuntu.ttf,sha256=1eaHFyepmy4FyDvjLVzpITrGEBu_CZYY94jE0nED1c0,70220
-Werkzeug-0.14.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-werkzeug/__pycache__/utils.cpython-35.pyc,,
-werkzeug/__pycache__/posixemulation.cpython-35.pyc,,
-werkzeug/__pycache__/wrappers.cpython-35.pyc,,
-werkzeug/__pycache__/useragents.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/wrappers.cpython-35.pyc,,
-werkzeug/debug/__pycache__/console.cpython-35.pyc,,
-werkzeug/__pycache__/websocket.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/lint.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/cache.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/sessions.cpython-35.pyc,,
-werkzeug/__pycache__/test.cpython-35.pyc,,
-werkzeug/__pycache__/wsgi.cpython-35.pyc,,
-werkzeug/debug/__pycache__/repr.cpython-35.pyc,,
-werkzeug/__pycache__/_compat.cpython-35.pyc,,
-werkzeug/debug/__pycache__/__init__.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/iterio.cpython-35.pyc,,
-werkzeug/debug/__pycache__/tbtools.cpython-35.pyc,,
-werkzeug/__pycache__/testapp.cpython-35.pyc,,
-werkzeug/__pycache__/urls.cpython-35.pyc,,
-werkzeug/__pycache__/security.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/testtools.cpython-35.pyc,,
-werkzeug/__pycache__/_reloader.cpython-35.pyc,,
-werkzeug/__pycache__/datastructures.cpython-35.pyc,,
-werkzeug/__pycache__/_internal.cpython-35.pyc,,
-werkzeug/__pycache__/script.cpython-35.pyc,,
-werkzeug/__pycache__/routing.cpython-35.pyc,,
-werkzeug/__pycache__/serving.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/fixers.cpython-35.pyc,,
-werkzeug/__pycache__/http.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/jsrouting.cpython-35.pyc,,
-werkzeug/__pycache__/filesystem.cpython-35.pyc,,
-werkzeug/__pycache__/local.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/atom.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/securecookie.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/__init__.cpython-35.pyc,,
-werkzeug/__pycache__/formparser.cpython-35.pyc,,
-werkzeug/__pycache__/exceptions.cpython-35.pyc,,
-werkzeug/__pycache__/__init__.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/limiter.cpython-35.pyc,,
-werkzeug/contrib/__pycache__/profiler.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/WHEEL
deleted file mode 100644
index 0de529b1e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.26.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/metadata.json
deleted file mode 100644
index bca8d1262..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"generator": "bdist_wheel (0.26.0)", "summary": "The comprehensive WSGI web application library.", "classifiers": ["Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"project_urls": {"Home": "https://www.palletsprojects.org/p/werkzeug/"}, "contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}}}, "license": "BSD", "metadata_version": "2.0", "name": "Werkzeug", "platform": "any", "extras": ["dev", "termcolor", "watchdog"], "run_requires": [{"requires": ["coverage", "pytest", "sphinx", "tox"], "extra": "dev"}, {"requires": ["termcolor"], "extra": "termcolor"}, {"requires": ["watchdog"], "extra": "watchdog"}], "version": "0.14.1"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/top_level.txt
deleted file mode 100644
index 6fe8da849..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/Werkzeug-0.14.1.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-werkzeug
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/__pycache__/easy_install.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/__pycache__/easy_install.cpython-35.pyc
deleted file mode 100644
index 8a44c40e5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/__pycache__/easy_install.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__init__.py
deleted file mode 100644
index d3c33660a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__init__.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-click
-~~~~~
-
-Click is a simple Python module inspired by the stdlib optparse to make
-writing command line scripts fun. Unlike other modules, it's based
-around a simple API that does not come with too much magic and is
-composable.
-
-:copyright: © 2014 by the Pallets team.
-:license: BSD, see LICENSE.rst for more details.
-"""
-
-# Core classes
-from .core import Context, BaseCommand, Command, MultiCommand, Group, \
-     CommandCollection, Parameter, Option, Argument
-
-# Globals
-from .globals import get_current_context
-
-# Decorators
-from .decorators import pass_context, pass_obj, make_pass_decorator, \
-     command, group, argument, option, confirmation_option, \
-     password_option, version_option, help_option
-
-# Types
-from .types import ParamType, File, Path, Choice, IntRange, Tuple, \
-     DateTime, STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED, FloatRange
-
-# Utilities
-from .utils import echo, get_binary_stream, get_text_stream, open_file, \
-     format_filename, get_app_dir, get_os_args
-
-# Terminal functions
-from .termui import prompt, confirm, get_terminal_size, echo_via_pager, \
-     progressbar, clear, style, unstyle, secho, edit, launch, getchar, \
-     pause
-
-# Exceptions
-from .exceptions import ClickException, UsageError, BadParameter, \
-     FileError, Abort, NoSuchOption, BadOptionUsage, BadArgumentUsage, \
-     MissingParameter
-
-# Formatting
-from .formatting import HelpFormatter, wrap_text
-
-# Parsing
-from .parser import OptionParser
-
-
-__all__ = [
-    # Core classes
-    'Context', 'BaseCommand', 'Command', 'MultiCommand', 'Group',
-    'CommandCollection', 'Parameter', 'Option', 'Argument',
-
-    # Globals
-    'get_current_context',
-
-    # Decorators
-    'pass_context', 'pass_obj', 'make_pass_decorator', 'command', 'group',
-    'argument', 'option', 'confirmation_option', 'password_option',
-    'version_option', 'help_option',
-
-    # Types
-    'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple',
-    'DateTime', 'STRING', 'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
-    'FloatRange',
-
-    # Utilities
-    'echo', 'get_binary_stream', 'get_text_stream', 'open_file',
-    'format_filename', 'get_app_dir', 'get_os_args',
-
-    # Terminal functions
-    'prompt', 'confirm', 'get_terminal_size', 'echo_via_pager',
-    'progressbar', 'clear', 'style', 'unstyle', 'secho', 'edit', 'launch',
-    'getchar', 'pause',
-
-    # Exceptions
-    'ClickException', 'UsageError', 'BadParameter', 'FileError',
-    'Abort', 'NoSuchOption', 'BadOptionUsage', 'BadArgumentUsage',
-    'MissingParameter',
-
-    # Formatting
-    'HelpFormatter', 'wrap_text',
-
-    # Parsing
-    'OptionParser',
-]
-
-
-# Controls if click should emit the warning about the use of unicode
-# literals.
-disable_unicode_literals_warning = False
-
-
-__version__ = '7.0'
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 567ecc3ad..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_bashcomplete.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_bashcomplete.cpython-35.pyc
deleted file mode 100644
index 35bb8fdf4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_bashcomplete.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 6a7d4b46a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_termui_impl.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_termui_impl.cpython-35.pyc
deleted file mode 100644
index e29b98379..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_termui_impl.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_textwrap.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_textwrap.cpython-35.pyc
deleted file mode 100644
index f0308c4ac..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_textwrap.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_unicodefun.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_unicodefun.cpython-35.pyc
deleted file mode 100644
index 003f4524a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_unicodefun.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_winconsole.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_winconsole.cpython-35.pyc
deleted file mode 100644
index b525baea8..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/_winconsole.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/core.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/core.cpython-35.pyc
deleted file mode 100644
index 19d47dfb1..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/core.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/decorators.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/decorators.cpython-35.pyc
deleted file mode 100644
index cf1437e4c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/decorators.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/exceptions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/exceptions.cpython-35.pyc
deleted file mode 100644
index 4fa5f8660..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/exceptions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/formatting.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/formatting.cpython-35.pyc
deleted file mode 100644
index eb8d429cb..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/formatting.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/globals.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/globals.cpython-35.pyc
deleted file mode 100644
index 41c8969c4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/globals.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/parser.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/parser.cpython-35.pyc
deleted file mode 100644
index 5bb8f1cc4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/parser.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/termui.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/termui.cpython-35.pyc
deleted file mode 100644
index 9ae9d0e5f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/termui.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/testing.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/testing.cpython-35.pyc
deleted file mode 100644
index e51a6f2b5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/testing.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/types.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/types.cpython-35.pyc
deleted file mode 100644
index 4bf81982c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/types.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/utils.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/utils.cpython-35.pyc
deleted file mode 100644
index a3cd73809..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/__pycache__/utils.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_bashcomplete.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_bashcomplete.py
deleted file mode 100644
index a5f1084c9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_bashcomplete.py
+++ /dev/null
@@ -1,293 +0,0 @@
-import copy
-import os
-import re
-
-from .utils import echo
-from .parser import split_arg_string
-from .core import MultiCommand, Option, Argument
-from .types import Choice
-
-try:
-    from collections import abc
-except ImportError:
-    import collections as abc
-
-WORDBREAK = '='
-
-# Note, only BASH version 4.4 and later have the nosort option.
-COMPLETION_SCRIPT_BASH = '''
-%(complete_func)s() {
-    local IFS=$'\n'
-    COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
-                   COMP_CWORD=$COMP_CWORD \\
-                   %(autocomplete_var)s=complete $1 ) )
-    return 0
-}
-
-%(complete_func)setup() {
-    local COMPLETION_OPTIONS=""
-    local BASH_VERSION_ARR=(${BASH_VERSION//./ })
-    # Only BASH version 4.4 and later have the nosort option.
-    if [ ${BASH_VERSION_ARR[0]} -gt 4 ] || ([ ${BASH_VERSION_ARR[0]} -eq 4 ] && [ ${BASH_VERSION_ARR[1]} -ge 4 ]); then
-        COMPLETION_OPTIONS="-o nosort"
-    fi
-
-    complete $COMPLETION_OPTIONS -F %(complete_func)s %(script_names)s
-}
-
-%(complete_func)setup
-'''
-
-COMPLETION_SCRIPT_ZSH = '''
-%(complete_func)s() {
-    local -a completions
-    local -a completions_with_descriptions
-    local -a response
-    response=("${(@f)$( env COMP_WORDS=\"${words[*]}\" \\
-                        COMP_CWORD=$((CURRENT-1)) \\
-                        %(autocomplete_var)s=\"complete_zsh\" \\
-                        %(script_names)s )}")
-
-    for key descr in ${(kv)response}; do
-      if [[ "$descr" == "_" ]]; then
-          completions+=("$key")
-      else
-          completions_with_descriptions+=("$key":"$descr")
-      fi
-    done
-
-    if [ -n "$completions_with_descriptions" ]; then
-        _describe -V unsorted completions_with_descriptions -U -Q
-    fi
-
-    if [ -n "$completions" ]; then
-        compadd -U -V unsorted -Q -a completions
-    fi
-    compstate[insert]="automenu"
-}
-
-compdef %(complete_func)s %(script_names)s
-'''
-
-_invalid_ident_char_re = re.compile(r'[^a-zA-Z0-9_]')
-
-
-def get_completion_script(prog_name, complete_var, shell):
-    cf_name = _invalid_ident_char_re.sub('', prog_name.replace('-', '_'))
-    script = COMPLETION_SCRIPT_ZSH if shell == 'zsh' else COMPLETION_SCRIPT_BASH
-    return (script % {
-        'complete_func': '_%s_completion' % cf_name,
-        'script_names': prog_name,
-        'autocomplete_var': complete_var,
-    }).strip() + ';'
-
-
-def resolve_ctx(cli, prog_name, args):
-    """
-    Parse into a hierarchy of contexts. Contexts are connected through the parent variable.
-    :param cli: command definition
-    :param prog_name: the program that is running
-    :param args: full list of args
-    :return: the final context/command parsed
-    """
-    ctx = cli.make_context(prog_name, args, resilient_parsing=True)
-    args = ctx.protected_args + ctx.args
-    while args:
-        if isinstance(ctx.command, MultiCommand):
-            if not ctx.command.chain:
-                cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
-                if cmd is None:
-                    return ctx
-                ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                       resilient_parsing=True)
-                args = ctx.protected_args + ctx.args
-            else:
-                # Walk chained subcommand contexts saving the last one.
-                while args:
-                    cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
-                    if cmd is None:
-                        return ctx
-                    sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                               allow_extra_args=True,
-                                               allow_interspersed_args=False,
-                                               resilient_parsing=True)
-                    args = sub_ctx.args
-                ctx = sub_ctx
-                args = sub_ctx.protected_args + sub_ctx.args
-        else:
-            break
-    return ctx
-
-
-def start_of_option(param_str):
-    """
-    :param param_str: param_str to check
-    :return: whether or not this is the start of an option declaration (i.e. starts "-" or "--")
-    """
-    return param_str and param_str[:1] == '-'
-
-
-def is_incomplete_option(all_args, cmd_param):
-    """
-    :param all_args: the full original list of args supplied
-    :param cmd_param: the current command paramter
-    :return: whether or not the last option declaration (i.e. starts "-" or "--") is incomplete and
-    corresponds to this cmd_param. In other words whether this cmd_param option can still accept
-    values
-    """
-    if not isinstance(cmd_param, Option):
-        return False
-    if cmd_param.is_flag:
-        return False
-    last_option = None
-    for index, arg_str in enumerate(reversed([arg for arg in all_args if arg != WORDBREAK])):
-        if index + 1 > cmd_param.nargs:
-            break
-        if start_of_option(arg_str):
-            last_option = arg_str
-
-    return True if last_option and last_option in cmd_param.opts else False
-
-
-def is_incomplete_argument(current_params, cmd_param):
-    """
-    :param current_params: the current params and values for this argument as already entered
-    :param cmd_param: the current command parameter
-    :return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
-    other words whether or not the this cmd_param argument can still accept values
-    """
-    if not isinstance(cmd_param, Argument):
-        return False
-    current_param_values = current_params[cmd_param.name]
-    if current_param_values is None:
-        return True
-    if cmd_param.nargs == -1:
-        return True
-    if isinstance(current_param_values, abc.Iterable) \
-            and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
-        return True
-    return False
-
-
-def get_user_autocompletions(ctx, args, incomplete, cmd_param):
-    """
-    :param ctx: context associated with the parsed command
-    :param args: full list of args
-    :param incomplete: the incomplete text to autocomplete
-    :param cmd_param: command definition
-    :return: all the possible user-specified completions for the param
-    """
-    results = []
-    if isinstance(cmd_param.type, Choice):
-        # Choices don't support descriptions.
-        results = [(c, None)
-                   for c in cmd_param.type.choices if str(c).startswith(incomplete)]
-    elif cmd_param.autocompletion is not None:
-        dynamic_completions = cmd_param.autocompletion(ctx=ctx,
-                                                       args=args,
-                                                       incomplete=incomplete)
-        results = [c if isinstance(c, tuple) else (c, None)
-                   for c in dynamic_completions]
-    return results
-
-
-def get_visible_commands_starting_with(ctx, starts_with):
-    """
-    :param ctx: context associated with the parsed command
-    :starts_with: string that visible commands must start with.
-    :return: all visible (not hidden) commands that start with starts_with.
-    """
-    for c in ctx.command.list_commands(ctx):
-        if c.startswith(starts_with):
-            command = ctx.command.get_command(ctx, c)
-            if not command.hidden:
-                yield command
-
-
-def add_subcommand_completions(ctx, incomplete, completions_out):
-    # Add subcommand completions.
-    if isinstance(ctx.command, MultiCommand):
-        completions_out.extend(
-            [(c.name, c.get_short_help_str()) for c in get_visible_commands_starting_with(ctx, incomplete)])
-
-    # Walk up the context list and add any other completion possibilities from chained commands
-    while ctx.parent is not None:
-        ctx = ctx.parent
-        if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
-            remaining_commands = [c for c in get_visible_commands_starting_with(ctx, incomplete)
-                                  if c.name not in ctx.protected_args]
-            completions_out.extend([(c.name, c.get_short_help_str()) for c in remaining_commands])
-
-
-def get_choices(cli, prog_name, args, incomplete):
-    """
-    :param cli: command definition
-    :param prog_name: the program that is running
-    :param args: full list of args
-    :param incomplete: the incomplete text to autocomplete
-    :return: all the possible completions for the incomplete
-    """
-    all_args = copy.deepcopy(args)
-
-    ctx = resolve_ctx(cli, prog_name, args)
-    if ctx is None:
-        return []
-
-    # In newer versions of bash long opts with '='s are partitioned, but it's easier to parse
-    # without the '='
-    if start_of_option(incomplete) and WORDBREAK in incomplete:
-        partition_incomplete = incomplete.partition(WORDBREAK)
-        all_args.append(partition_incomplete[0])
-        incomplete = partition_incomplete[2]
-    elif incomplete == WORDBREAK:
-        incomplete = ''
-
-    completions = []
-    if start_of_option(incomplete):
-        # completions for partial options
-        for param in ctx.command.params:
-            if isinstance(param, Option) and not param.hidden:
-                param_opts = [param_opt for param_opt in param.opts +
-                              param.secondary_opts if param_opt not in all_args or param.multiple]
-                completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
-        return completions
-    # completion for option values from user supplied values
-    for param in ctx.command.params:
-        if is_incomplete_option(all_args, param):
-            return get_user_autocompletions(ctx, all_args, incomplete, param)
-    # completion for argument values from user supplied values
-    for param in ctx.command.params:
-        if is_incomplete_argument(ctx.params, param):
-            return get_user_autocompletions(ctx, all_args, incomplete, param)
-
-    add_subcommand_completions(ctx, incomplete, completions)
-    # Sort before returning so that proper ordering can be enforced in custom types.
-    return sorted(completions)
-
-
-def do_complete(cli, prog_name, include_descriptions):
-    cwords = split_arg_string(os.environ['COMP_WORDS'])
-    cword = int(os.environ['COMP_CWORD'])
-    args = cwords[1:cword]
-    try:
-        incomplete = cwords[cword]
-    except IndexError:
-        incomplete = ''
-
-    for item in get_choices(cli, prog_name, args, incomplete):
-        echo(item[0])
-        if include_descriptions:
-            # ZSH has trouble dealing with empty array parameters when returned from commands, so use a well defined character '_' to indicate no description is present.
-            echo(item[1] if item[1] else '_')
-
-    return True
-
-
-def bashcomplete(cli, prog_name, complete_var, complete_instr):
-    if complete_instr.startswith('source'):
-        shell = 'zsh' if complete_instr == 'source_zsh' else 'bash'
-        echo(get_completion_script(prog_name, complete_var, shell))
-        return True
-    elif complete_instr == 'complete' or complete_instr == 'complete_zsh':
-        return do_complete(cli, prog_name, complete_instr == 'complete_zsh')
-    return False
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_compat.py
deleted file mode 100644
index 937e2301d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_compat.py
+++ /dev/null
@@ -1,703 +0,0 @@
-import re
-import io
-import os
-import sys
-import codecs
-from weakref import WeakKeyDictionary
-
-
-PY2 = sys.version_info[0] == 2
-CYGWIN = sys.platform.startswith('cygwin')
-# Determine local App Engine environment, per Google's own suggestion
-APP_ENGINE = ('APPENGINE_RUNTIME' in os.environ and
-              'Development/' in os.environ['SERVER_SOFTWARE'])
-WIN = sys.platform.startswith('win') and not APP_ENGINE
-DEFAULT_COLUMNS = 80
-
-
-_ansi_re = re.compile(r'\033\[((?:\d|;)*)([a-zA-Z])')
-
-
-def get_filesystem_encoding():
-    return sys.getfilesystemencoding() or sys.getdefaultencoding()
-
-
-def _make_text_stream(stream, encoding, errors,
-                      force_readable=False, force_writable=False):
-    if encoding is None:
-        encoding = get_best_encoding(stream)
-    if errors is None:
-        errors = 'replace'
-    return _NonClosingTextIOWrapper(stream, encoding, errors,
-                                    line_buffering=True,
-                                    force_readable=force_readable,
-                                    force_writable=force_writable)
-
-
-def is_ascii_encoding(encoding):
-    """Checks if a given encoding is ascii."""
-    try:
-        return codecs.lookup(encoding).name == 'ascii'
-    except LookupError:
-        return False
-
-
-def get_best_encoding(stream):
-    """Returns the default stream encoding if not found."""
-    rv = getattr(stream, 'encoding', None) or sys.getdefaultencoding()
-    if is_ascii_encoding(rv):
-        return 'utf-8'
-    return rv
-
-
-class _NonClosingTextIOWrapper(io.TextIOWrapper):
-
-    def __init__(self, stream, encoding, errors,
-                 force_readable=False, force_writable=False, **extra):
-        self._stream = stream = _FixupStream(stream, force_readable,
-                                             force_writable)
-        io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
-
-    # The io module is a place where the Python 3 text behavior
-    # was forced upon Python 2, so we need to unbreak
-    # it to look like Python 2.
-    if PY2:
-        def write(self, x):
-            if isinstance(x, str) or is_bytes(x):
-                try:
-                    self.flush()
-                except Exception:
-                    pass
-                return self.buffer.write(str(x))
-            return io.TextIOWrapper.write(self, x)
-
-        def writelines(self, lines):
-            for line in lines:
-                self.write(line)
-
-    def __del__(self):
-        try:
-            self.detach()
-        except Exception:
-            pass
-
-    def isatty(self):
-        # https://bitbucket.org/pypy/pypy/issue/1803
-        return self._stream.isatty()
-
-
-class _FixupStream(object):
-    """The new io interface needs more from streams than streams
-    traditionally implement.  As such, this fix-up code is necessary in
-    some circumstances.
-
-    The forcing of readable and writable flags are there because some tools
-    put badly patched objects on sys (one such offender are certain version
-    of jupyter notebook).
-    """
-
-    def __init__(self, stream, force_readable=False, force_writable=False):
-        self._stream = stream
-        self._force_readable = force_readable
-        self._force_writable = force_writable
-
-    def __getattr__(self, name):
-        return getattr(self._stream, name)
-
-    def read1(self, size):
-        f = getattr(self._stream, 'read1', None)
-        if f is not None:
-            return f(size)
-        # We only dispatch to readline instead of read in Python 2 as we
-        # do not want cause problems with the different implementation
-        # of line buffering.
-        if PY2:
-            return self._stream.readline(size)
-        return self._stream.read(size)
-
-    def readable(self):
-        if self._force_readable:
-            return True
-        x = getattr(self._stream, 'readable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.read(0)
-        except Exception:
-            return False
-        return True
-
-    def writable(self):
-        if self._force_writable:
-            return True
-        x = getattr(self._stream, 'writable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.write('')
-        except Exception:
-            try:
-                self._stream.write(b'')
-            except Exception:
-                return False
-        return True
-
-    def seekable(self):
-        x = getattr(self._stream, 'seekable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.seek(self._stream.tell())
-        except Exception:
-            return False
-        return True
-
-
-if PY2:
-    text_type = unicode
-    bytes = str
-    raw_input = raw_input
-    string_types = (str, unicode)
-    int_types = (int, long)
-    iteritems = lambda x: x.iteritems()
-    range_type = xrange
-
-    def is_bytes(x):
-        return isinstance(x, (buffer, bytearray))
-
-    _identifier_re = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
-
-    # For Windows, we need to force stdout/stdin/stderr to binary if it's
-    # fetched for that.  This obviously is not the most correct way to do
-    # it as it changes global state.  Unfortunately, there does not seem to
-    # be a clear better way to do it as just reopening the file in binary
-    # mode does not change anything.
-    #
-    # An option would be to do what Python 3 does and to open the file as
-    # binary only, patch it back to the system, and then use a wrapper
-    # stream that converts newlines.  It's not quite clear what's the
-    # correct option here.
-    #
-    # This code also lives in _winconsole for the fallback to the console
-    # emulation stream.
-    #
-    # There are also Windows environments where the `msvcrt` module is not
-    # available (which is why we use try-catch instead of the WIN variable
-    # here), such as the Google App Engine development server on Windows. In
-    # those cases there is just nothing we can do.
-    def set_binary_mode(f):
-        return f
-
-    try:
-        import msvcrt
-    except ImportError:
-        pass
-    else:
-        def set_binary_mode(f):
-            try:
-                fileno = f.fileno()
-            except Exception:
-                pass
-            else:
-                msvcrt.setmode(fileno, os.O_BINARY)
-            return f
-
-    try:
-        import fcntl
-    except ImportError:
-        pass
-    else:
-        def set_binary_mode(f):
-            try:
-                fileno = f.fileno()
-            except Exception:
-                pass
-            else:
-                flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
-                fcntl.fcntl(fileno, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
-            return f
-
-    def isidentifier(x):
-        return _identifier_re.search(x) is not None
-
-    def get_binary_stdin():
-        return set_binary_mode(sys.stdin)
-
-    def get_binary_stdout():
-        _wrap_std_stream('stdout')
-        return set_binary_mode(sys.stdout)
-
-    def get_binary_stderr():
-        _wrap_std_stream('stderr')
-        return set_binary_mode(sys.stderr)
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdin, encoding, errors,
-                                 force_readable=True)
-
-    def get_text_stdout(encoding=None, errors=None):
-        _wrap_std_stream('stdout')
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdout, encoding, errors,
-                                 force_writable=True)
-
-    def get_text_stderr(encoding=None, errors=None):
-        _wrap_std_stream('stderr')
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stderr, encoding, errors,
-                                 force_writable=True)
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
-        return value
-else:
-    import io
-    text_type = str
-    raw_input = input
-    string_types = (str,)
-    int_types = (int,)
-    range_type = range
-    isidentifier = lambda x: x.isidentifier()
-    iteritems = lambda x: iter(x.items())
-
-    def is_bytes(x):
-        return isinstance(x, (bytes, memoryview, bytearray))
-
-    def _is_binary_reader(stream, default=False):
-        try:
-            return isinstance(stream.read(0), bytes)
-        except Exception:
-            return default
-            # This happens in some cases where the stream was already
-            # closed.  In this case, we assume the default.
-
-    def _is_binary_writer(stream, default=False):
-        try:
-            stream.write(b'')
-        except Exception:
-            try:
-                stream.write('')
-                return False
-            except Exception:
-                pass
-            return default
-        return True
-
-    def _find_binary_reader(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detaching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_reader(stream, False):
-            return stream
-
-        buf = getattr(stream, 'buffer', None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_reader(buf, True):
-            return buf
-
-    def _find_binary_writer(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detatching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_writer(stream, False):
-            return stream
-
-        buf = getattr(stream, 'buffer', None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_writer(buf, True):
-            return buf
-
-    def _stream_is_misconfigured(stream):
-        """A stream is misconfigured if its encoding is ASCII."""
-        # If the stream does not have an encoding set, we assume it's set
-        # to ASCII.  This appears to happen in certain unittest
-        # environments.  It's not quite clear what the correct behavior is
-        # but this at least will force Click to recover somehow.
-        return is_ascii_encoding(getattr(stream, 'encoding', None) or 'ascii')
-
-    def _is_compatible_text_stream(stream, encoding, errors):
-        stream_encoding = getattr(stream, 'encoding', None)
-        stream_errors = getattr(stream, 'errors', None)
-
-        # Perfect match.
-        if stream_encoding == encoding and stream_errors == errors:
-            return True
-
-        # Otherwise, it's only a compatible stream if we did not ask for
-        # an encoding.
-        if encoding is None:
-            return stream_encoding is not None
-
-        return False
-
-    def _force_correct_text_reader(text_reader, encoding, errors,
-                                   force_readable=False):
-        if _is_binary_reader(text_reader, False):
-            binary_reader = text_reader
-        else:
-            # If there is no target encoding set, we need to verify that the
-            # reader is not actually misconfigured.
-            if encoding is None and not _stream_is_misconfigured(text_reader):
-                return text_reader
-
-            if _is_compatible_text_stream(text_reader, encoding, errors):
-                return text_reader
-
-            # If the reader has no encoding, we try to find the underlying
-            # binary reader for it.  If that fails because the environment is
-            # misconfigured, we silently go with the same reader because this
-            # is too common to happen.  In that case, mojibake is better than
-            # exceptions.
-            binary_reader = _find_binary_reader(text_reader)
-            if binary_reader is None:
-                return text_reader
-
-        # At this point, we default the errors to replace instead of strict
-        # because nobody handles those errors anyways and at this point
-        # we're so fundamentally fucked that nothing can repair it.
-        if errors is None:
-            errors = 'replace'
-        return _make_text_stream(binary_reader, encoding, errors,
-                                 force_readable=force_readable)
-
-    def _force_correct_text_writer(text_writer, encoding, errors,
-                                   force_writable=False):
-        if _is_binary_writer(text_writer, False):
-            binary_writer = text_writer
-        else:
-            # If there is no target encoding set, we need to verify that the
-            # writer is not actually misconfigured.
-            if encoding is None and not _stream_is_misconfigured(text_writer):
-                return text_writer
-
-            if _is_compatible_text_stream(text_writer, encoding, errors):
-                return text_writer
-
-            # If the writer has no encoding, we try to find the underlying
-            # binary writer for it.  If that fails because the environment is
-            # misconfigured, we silently go with the same writer because this
-            # is too common to happen.  In that case, mojibake is better than
-            # exceptions.
-            binary_writer = _find_binary_writer(text_writer)
-            if binary_writer is None:
-                return text_writer
-
-        # At this point, we default the errors to replace instead of strict
-        # because nobody handles those errors anyways and at this point
-        # we're so fundamentally fucked that nothing can repair it.
-        if errors is None:
-            errors = 'replace'
-        return _make_text_stream(binary_writer, encoding, errors,
-                                 force_writable=force_writable)
-
-    def get_binary_stdin():
-        reader = _find_binary_reader(sys.stdin)
-        if reader is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdin.')
-        return reader
-
-    def get_binary_stdout():
-        writer = _find_binary_writer(sys.stdout)
-        if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdout.')
-        return writer
-
-    def get_binary_stderr():
-        writer = _find_binary_writer(sys.stderr)
-        if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stderr.')
-        return writer
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_reader(sys.stdin, encoding, errors,
-                                          force_readable=True)
-
-    def get_text_stdout(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(sys.stdout, encoding, errors,
-                                          force_writable=True)
-
-    def get_text_stderr(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(sys.stderr, encoding, errors,
-                                          force_writable=True)
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
-        else:
-            value = value.encode('utf-8', 'surrogateescape') \
-                .decode('utf-8', 'replace')
-        return value
-
-
-def get_streerror(e, default=None):
-    if hasattr(e, 'strerror'):
-        msg = e.strerror
-    else:
-        if default is not None:
-            msg = default
-        else:
-            msg = str(e)
-    if isinstance(msg, bytes):
-        msg = msg.decode('utf-8', 'replace')
-    return msg
-
-
-def open_stream(filename, mode='r', encoding=None, errors='strict',
-                atomic=False):
-    # Standard streams first.  These are simple because they don't need
-    # special handling for the atomic flag.  It's entirely ignored.
-    if filename == '-':
-        if any(m in mode for m in ['w', 'a', 'x']):
-            if 'b' in mode:
-                return get_binary_stdout(), False
-            return get_text_stdout(encoding=encoding, errors=errors), False
-        if 'b' in mode:
-            return get_binary_stdin(), False
-        return get_text_stdin(encoding=encoding, errors=errors), False
-
-    # Non-atomic writes directly go out through the regular open functions.
-    if not atomic:
-        if encoding is None:
-            return open(filename, mode), True
-        return io.open(filename, mode, encoding=encoding, errors=errors), True
-
-    # Some usability stuff for atomic writes
-    if 'a' in mode:
-        raise ValueError(
-            'Appending to an existing file is not supported, because that '
-            'would involve an expensive `copy`-operation to a temporary '
-            'file. Open the file in normal `w`-mode and copy explicitly '
-            'if that\'s what you\'re after.'
-        )
-    if 'x' in mode:
-        raise ValueError('Use the `overwrite`-parameter instead.')
-    if 'w' not in mode:
-        raise ValueError('Atomic writes only make sense with `w`-mode.')
-
-    # Atomic writes are more complicated.  They work by opening a file
-    # as a proxy in the same folder and then using the fdopen
-    # functionality to wrap it in a Python file.  Then we wrap it in an
-    # atomic file that moves the file over on close.
-    import tempfile
-    fd, tmp_filename = tempfile.mkstemp(dir=os.path.dirname(filename),
-                                        prefix='.__atomic-write')
-
-    if encoding is not None:
-        f = io.open(fd, mode, encoding=encoding, errors=errors)
-    else:
-        f = os.fdopen(fd, mode)
-
-    return _AtomicFile(f, tmp_filename, os.path.realpath(filename)), True
-
-
-# Used in a destructor call, needs extra protection from interpreter cleanup.
-if hasattr(os, 'replace'):
-    _replace = os.replace
-    _can_replace = True
-else:
-    _replace = os.rename
-    _can_replace = not WIN
-
-
-class _AtomicFile(object):
-
-    def __init__(self, f, tmp_filename, real_filename):
-        self._f = f
-        self._tmp_filename = tmp_filename
-        self._real_filename = real_filename
-        self.closed = False
-
-    @property
-    def name(self):
-        return self._real_filename
-
-    def close(self, delete=False):
-        if self.closed:
-            return
-        self._f.close()
-        if not _can_replace:
-            try:
-                os.remove(self._real_filename)
-            except OSError:
-                pass
-        _replace(self._tmp_filename, self._real_filename)
-        self.closed = True
-
-    def __getattr__(self, name):
-        return getattr(self._f, name)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close(delete=exc_type is not None)
-
-    def __repr__(self):
-        return repr(self._f)
-
-
-auto_wrap_for_ansi = None
-colorama = None
-get_winterm_size = None
-
-
-def strip_ansi(value):
-    return _ansi_re.sub('', value)
-
-
-def should_strip_ansi(stream=None, color=None):
-    if color is None:
-        if stream is None:
-            stream = sys.stdin
-        return not isatty(stream)
-    return not color
-
-
-# If we're on Windows, we provide transparent integration through
-# colorama.  This will make ANSI colors through the echo function
-# work automatically.
-if WIN:
-    # Windows has a smaller terminal
-    DEFAULT_COLUMNS = 79
-
-    from ._winconsole import _get_windows_console_stream, _wrap_std_stream
-
-    def _get_argv_encoding():
-        import locale
-        return locale.getpreferredencoding()
-
-    if PY2:
-        def raw_input(prompt=''):
-            sys.stderr.flush()
-            if prompt:
-                stdout = _default_text_stdout()
-                stdout.write(prompt)
-            stdin = _default_text_stdin()
-            return stdin.readline().rstrip('\r\n')
-
-    try:
-        import colorama
-    except ImportError:
-        pass
-    else:
-        _ansi_stream_wrappers = WeakKeyDictionary()
-
-        def auto_wrap_for_ansi(stream, color=None):
-            """This function wraps a stream so that calls through colorama
-            are issued to the win32 console API to recolor on demand.  It
-            also ensures to reset the colors if a write call is interrupted
-            to not destroy the console afterwards.
-            """
-            try:
-                cached = _ansi_stream_wrappers.get(stream)
-            except Exception:
-                cached = None
-            if cached is not None:
-                return cached
-            strip = should_strip_ansi(stream, color)
-            ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
-            rv = ansi_wrapper.stream
-            _write = rv.write
-
-            def _safe_write(s):
-                try:
-                    return _write(s)
-                except:
-                    ansi_wrapper.reset_all()
-                    raise
-
-            rv.write = _safe_write
-            try:
-                _ansi_stream_wrappers[stream] = rv
-            except Exception:
-                pass
-            return rv
-
-        def get_winterm_size():
-            win = colorama.win32.GetConsoleScreenBufferInfo(
-                colorama.win32.STDOUT).srWindow
-            return win.Right - win.Left, win.Bottom - win.Top
-else:
-    def _get_argv_encoding():
-        return getattr(sys.stdin, 'encoding', None) or get_filesystem_encoding()
-
-    _get_windows_console_stream = lambda *x: None
-    _wrap_std_stream = lambda *x: None
-
-
-def term_len(x):
-    return len(strip_ansi(x))
-
-
-def isatty(stream):
-    try:
-        return stream.isatty()
-    except Exception:
-        return False
-
-
-def _make_cached_stream_func(src_func, wrapper_func):
-    cache = WeakKeyDictionary()
-    def func():
-        stream = src_func()
-        try:
-            rv = cache.get(stream)
-        except Exception:
-            rv = None
-        if rv is not None:
-            return rv
-        rv = wrapper_func()
-        try:
-            stream = src_func()  # In case wrapper_func() modified the stream
-            cache[stream] = rv
-        except Exception:
-            pass
-        return rv
-    return func
-
-
-_default_text_stdin = _make_cached_stream_func(
-    lambda: sys.stdin, get_text_stdin)
-_default_text_stdout = _make_cached_stream_func(
-    lambda: sys.stdout, get_text_stdout)
-_default_text_stderr = _make_cached_stream_func(
-    lambda: sys.stderr, get_text_stderr)
-
-
-binary_streams = {
-    'stdin': get_binary_stdin,
-    'stdout': get_binary_stdout,
-    'stderr': get_binary_stderr,
-}
-
-text_streams = {
-    'stdin': get_text_stdin,
-    'stdout': get_text_stdout,
-    'stderr': get_text_stderr,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_termui_impl.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_termui_impl.py
deleted file mode 100644
index 00a8e5ef1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_termui_impl.py
+++ /dev/null
@@ -1,621 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-click._termui_impl
-~~~~~~~~~~~~~~~~~~
-
-This module contains implementations for the termui module. To keep the
-import time of Click down, some infrequently used functionality is
-placed in this module and only imported as needed.
-
-:copyright: © 2014 by the Pallets team.
-:license: BSD, see LICENSE.rst for more details.
-"""
-
-import os
-import sys
-import time
-import math
-import contextlib
-from ._compat import _default_text_stdout, range_type, PY2, isatty, \
-     open_stream, strip_ansi, term_len, get_best_encoding, WIN, int_types, \
-     CYGWIN
-from .utils import echo
-from .exceptions import ClickException
-
-
-if os.name == 'nt':
-    BEFORE_BAR = '\r'
-    AFTER_BAR = '\n'
-else:
-    BEFORE_BAR = '\r\033[?25l'
-    AFTER_BAR = '\033[?25h\n'
-
-
-def _length_hint(obj):
-    """Returns the length hint of an object."""
-    try:
-        return len(obj)
-    except (AttributeError, TypeError):
-        try:
-            get_hint = type(obj).__length_hint__
-        except AttributeError:
-            return None
-        try:
-            hint = get_hint(obj)
-        except TypeError:
-            return None
-        if hint is NotImplemented or \
-           not isinstance(hint, int_types) or \
-           hint < 0:
-            return None
-        return hint
-
-
-class ProgressBar(object):
-
-    def __init__(self, iterable, length=None, fill_char='#', empty_char=' ',
-                 bar_template='%(bar)s', info_sep='  ', show_eta=True,
-                 show_percent=None, show_pos=False, item_show_func=None,
-                 label=None, file=None, color=None, width=30):
-        self.fill_char = fill_char
-        self.empty_char = empty_char
-        self.bar_template = bar_template
-        self.info_sep = info_sep
-        self.show_eta = show_eta
-        self.show_percent = show_percent
-        self.show_pos = show_pos
-        self.item_show_func = item_show_func
-        self.label = label or ''
-        if file is None:
-            file = _default_text_stdout()
-        self.file = file
-        self.color = color
-        self.width = width
-        self.autowidth = width == 0
-
-        if length is None:
-            length = _length_hint(iterable)
-        if iterable is None:
-            if length is None:
-                raise TypeError('iterable or length is required')
-            iterable = range_type(length)
-        self.iter = iter(iterable)
-        self.length = length
-        self.length_known = length is not None
-        self.pos = 0
-        self.avg = []
-        self.start = self.last_eta = time.time()
-        self.eta_known = False
-        self.finished = False
-        self.max_width = None
-        self.entered = False
-        self.current_item = None
-        self.is_hidden = not isatty(self.file)
-        self._last_line = None
-        self.short_limit = 0.5
-
-    def __enter__(self):
-        self.entered = True
-        self.render_progress()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.render_finish()
-
-    def __iter__(self):
-        if not self.entered:
-            raise RuntimeError('You need to use progress bars in a with block.')
-        self.render_progress()
-        return self.generator()
-
-    def is_fast(self):
-        return time.time() - self.start <= self.short_limit
-
-    def render_finish(self):
-        if self.is_hidden or self.is_fast():
-            return
-        self.file.write(AFTER_BAR)
-        self.file.flush()
-
-    @property
-    def pct(self):
-        if self.finished:
-            return 1.0
-        return min(self.pos / (float(self.length) or 1), 1.0)
-
-    @property
-    def time_per_iteration(self):
-        if not self.avg:
-            return 0.0
-        return sum(self.avg) / float(len(self.avg))
-
-    @property
-    def eta(self):
-        if self.length_known and not self.finished:
-            return self.time_per_iteration * (self.length - self.pos)
-        return 0.0
-
-    def format_eta(self):
-        if self.eta_known:
-            t = int(self.eta)
-            seconds = t % 60
-            t //= 60
-            minutes = t % 60
-            t //= 60
-            hours = t % 24
-            t //= 24
-            if t > 0:
-                days = t
-                return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
-            else:
-                return '%02d:%02d:%02d' % (hours, minutes, seconds)
-        return ''
-
-    def format_pos(self):
-        pos = str(self.pos)
-        if self.length_known:
-            pos += '/%s' % self.length
-        return pos
-
-    def format_pct(self):
-        return ('% 4d%%' % int(self.pct * 100))[1:]
-
-    def format_bar(self):
-        if self.length_known:
-            bar_length = int(self.pct * self.width)
-            bar = self.fill_char * bar_length
-            bar += self.empty_char * (self.width - bar_length)
-        elif self.finished:
-            bar = self.fill_char * self.width
-        else:
-            bar = list(self.empty_char * (self.width or 1))
-            if self.time_per_iteration != 0:
-                bar[int((math.cos(self.pos * self.time_per_iteration)
-                    / 2.0 + 0.5) * self.width)] = self.fill_char
-            bar = ''.join(bar)
-        return bar
-
-    def format_progress_line(self):
-        show_percent = self.show_percent
-
-        info_bits = []
-        if self.length_known and show_percent is None:
-            show_percent = not self.show_pos
-
-        if self.show_pos:
-            info_bits.append(self.format_pos())
-        if show_percent:
-            info_bits.append(self.format_pct())
-        if self.show_eta and self.eta_known and not self.finished:
-            info_bits.append(self.format_eta())
-        if self.item_show_func is not None:
-            item_info = self.item_show_func(self.current_item)
-            if item_info is not None:
-                info_bits.append(item_info)
-
-        return (self.bar_template % {
-            'label': self.label,
-            'bar': self.format_bar(),
-            'info': self.info_sep.join(info_bits)
-        }).rstrip()
-
-    def render_progress(self):
-        from .termui import get_terminal_size
-
-        if self.is_hidden:
-            return
-
-        buf = []
-        # Update width in case the terminal has been resized
-        if self.autowidth:
-            old_width = self.width
-            self.width = 0
-            clutter_length = term_len(self.format_progress_line())
-            new_width = max(0, get_terminal_size()[0] - clutter_length)
-            if new_width < old_width:
-                buf.append(BEFORE_BAR)
-                buf.append(' ' * self.max_width)
-                self.max_width = new_width
-            self.width = new_width
-
-        clear_width = self.width
-        if self.max_width is not None:
-            clear_width = self.max_width
-
-        buf.append(BEFORE_BAR)
-        line = self.format_progress_line()
-        line_len = term_len(line)
-        if self.max_width is None or self.max_width < line_len:
-            self.max_width = line_len
-
-        buf.append(line)
-        buf.append(' ' * (clear_width - line_len))
-        line = ''.join(buf)
-        # Render the line only if it changed.
-
-        if line != self._last_line and not self.is_fast():
-            self._last_line = line
-            echo(line, file=self.file, color=self.color, nl=False)
-            self.file.flush()
-
-    def make_step(self, n_steps):
-        self.pos += n_steps
-        if self.length_known and self.pos >= self.length:
-            self.finished = True
-
-        if (time.time() - self.last_eta) < 1.0:
-            return
-
-        self.last_eta = time.time()
-
-        # self.avg is a rolling list of length <= 7 of steps where steps are
-        # defined as time elapsed divided by the total progress through
-        # self.length.
-        if self.pos:
-            step = (time.time() - self.start) / self.pos
-        else:
-            step = time.time() - self.start
-
-        self.avg = self.avg[-6:] + [step]
-
-        self.eta_known = self.length_known
-
-    def update(self, n_steps):
-        self.make_step(n_steps)
-        self.render_progress()
-
-    def finish(self):
-        self.eta_known = 0
-        self.current_item = None
-        self.finished = True
-
-    def generator(self):
-        """
-        Returns a generator which yields the items added to the bar during
-        construction, and updates the progress bar *after* the yielded block
-        returns.
-        """
-        if not self.entered:
-            raise RuntimeError('You need to use progress bars in a with block.')
-
-        if self.is_hidden:
-            for rv in self.iter:
-                yield rv
-        else:
-            for rv in self.iter:
-                self.current_item = rv
-                yield rv
-                self.update(1)
-            self.finish()
-            self.render_progress()
-
-
-def pager(generator, color=None):
-    """Decide what method to use for paging through text."""
-    stdout = _default_text_stdout()
-    if not isatty(sys.stdin) or not isatty(stdout):
-        return _nullpager(stdout, generator, color)
-    pager_cmd = (os.environ.get('PAGER', None) or '').strip()
-    if pager_cmd:
-        if WIN:
-            return _tempfilepager(generator, pager_cmd, color)
-        return _pipepager(generator, pager_cmd, color)
-    if os.environ.get('TERM') in ('dumb', 'emacs'):
-        return _nullpager(stdout, generator, color)
-    if WIN or sys.platform.startswith('os2'):
-        return _tempfilepager(generator, 'more <', color)
-    if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
-        return _pipepager(generator, 'less', color)
-
-    import tempfile
-    fd, filename = tempfile.mkstemp()
-    os.close(fd)
-    try:
-        if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
-            return _pipepager(generator, 'more', color)
-        return _nullpager(stdout, generator, color)
-    finally:
-        os.unlink(filename)
-
-
-def _pipepager(generator, cmd, color):
-    """Page through text by feeding it to another program.  Invoking a
-    pager through this might support colors.
-    """
-    import subprocess
-    env = dict(os.environ)
-
-    # If we're piping to less we might support colors under the
-    # condition that
-    cmd_detail = cmd.rsplit('/', 1)[-1].split()
-    if color is None and cmd_detail[0] == 'less':
-        less_flags = os.environ.get('LESS', '') + ' '.join(cmd_detail[1:])
-        if not less_flags:
-            env['LESS'] = '-R'
-            color = True
-        elif 'r' in less_flags or 'R' in less_flags:
-            color = True
-
-    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
-                         env=env)
-    encoding = get_best_encoding(c.stdin)
-    try:
-        for text in generator:
-            if not color:
-                text = strip_ansi(text)
-
-            c.stdin.write(text.encode(encoding, 'replace'))
-    except (IOError, KeyboardInterrupt):
-        pass
-    else:
-        c.stdin.close()
-
-    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
-    # search or other commands inside less).
-    #
-    # That means when the user hits ^C, the parent process (click) terminates,
-    # but less is still alive, paging the output and messing up the terminal.
-    #
-    # If the user wants to make the pager exit on ^C, they should set
-    # `LESS='-K'`. It's not our decision to make.
-    while True:
-        try:
-            c.wait()
-        except KeyboardInterrupt:
-            pass
-        else:
-            break
-
-
-def _tempfilepager(generator, cmd, color):
-    """Page through text by invoking a program on a temporary file."""
-    import tempfile
-    filename = tempfile.mktemp()
-    # TODO: This never terminates if the passed generator never terminates.
-    text = "".join(generator)
-    if not color:
-        text = strip_ansi(text)
-    encoding = get_best_encoding(sys.stdout)
-    with open_stream(filename, 'wb')[0] as f:
-        f.write(text.encode(encoding))
-    try:
-        os.system(cmd + ' "' + filename + '"')
-    finally:
-        os.unlink(filename)
-
-
-def _nullpager(stream, generator, color):
-    """Simply print unformatted text.  This is the ultimate fallback."""
-    for text in generator:
-        if not color:
-            text = strip_ansi(text)
-        stream.write(text)
-
-
-class Editor(object):
-
-    def __init__(self, editor=None, env=None, require_save=True,
-                 extension='.txt'):
-        self.editor = editor
-        self.env = env
-        self.require_save = require_save
-        self.extension = extension
-
-    def get_editor(self):
-        if self.editor is not None:
-            return self.editor
-        for key in 'VISUAL', 'EDITOR':
-            rv = os.environ.get(key)
-            if rv:
-                return rv
-        if WIN:
-            return 'notepad'
-        for editor in 'vim', 'nano':
-            if os.system('which %s >/dev/null 2>&1' % editor) == 0:
-                return editor
-        return 'vi'
-
-    def edit_file(self, filename):
-        import subprocess
-        editor = self.get_editor()
-        if self.env:
-            environ = os.environ.copy()
-            environ.update(self.env)
-        else:
-            environ = None
-        try:
-            c = subprocess.Popen('%s "%s"' % (editor, filename),
-                                 env=environ, shell=True)
-            exit_code = c.wait()
-            if exit_code != 0:
-                raise ClickException('%s: Editing failed!' % editor)
-        except OSError as e:
-            raise ClickException('%s: Editing failed: %s' % (editor, e))
-
-    def edit(self, text):
-        import tempfile
-
-        text = text or ''
-        if text and not text.endswith('\n'):
-            text += '\n'
-
-        fd, name = tempfile.mkstemp(prefix='editor-', suffix=self.extension)
-        try:
-            if WIN:
-                encoding = 'utf-8-sig'
-                text = text.replace('\n', '\r\n')
-            else:
-                encoding = 'utf-8'
-            text = text.encode(encoding)
-
-            f = os.fdopen(fd, 'wb')
-            f.write(text)
-            f.close()
-            timestamp = os.path.getmtime(name)
-
-            self.edit_file(name)
-
-            if self.require_save \
-               and os.path.getmtime(name) == timestamp:
-                return None
-
-            f = open(name, 'rb')
-            try:
-                rv = f.read()
-            finally:
-                f.close()
-            return rv.decode('utf-8-sig').replace('\r\n', '\n')
-        finally:
-            os.unlink(name)
-
-
-def open_url(url, wait=False, locate=False):
-    import subprocess
-
-    def _unquote_file(url):
-        try:
-            import urllib
-        except ImportError:
-            import urllib
-        if url.startswith('file://'):
-            url = urllib.unquote(url[7:])
-        return url
-
-    if sys.platform == 'darwin':
-        args = ['open']
-        if wait:
-            args.append('-W')
-        if locate:
-            args.append('-R')
-        args.append(_unquote_file(url))
-        null = open('/dev/null', 'w')
-        try:
-            return subprocess.Popen(args, stderr=null).wait()
-        finally:
-            null.close()
-    elif WIN:
-        if locate:
-            url = _unquote_file(url)
-            args = 'explorer /select,"%s"' % _unquote_file(
-                url.replace('"', ''))
-        else:
-            args = 'start %s "" "%s"' % (
-                wait and '/WAIT' or '', url.replace('"', ''))
-        return os.system(args)
-    elif CYGWIN:
-        if locate:
-            url = _unquote_file(url)
-            args = 'cygstart "%s"' % (os.path.dirname(url).replace('"', ''))
-        else:
-            args = 'cygstart %s "%s"' % (
-                wait and '-w' or '', url.replace('"', ''))
-        return os.system(args)
-
-    try:
-        if locate:
-            url = os.path.dirname(_unquote_file(url)) or '.'
-        else:
-            url = _unquote_file(url)
-        c = subprocess.Popen(['xdg-open', url])
-        if wait:
-            return c.wait()
-        return 0
-    except OSError:
-        if url.startswith(('http://', 'https://')) and not locate and not wait:
-            import webbrowser
-            webbrowser.open(url)
-            return 0
-        return 1
-
-
-def _translate_ch_to_exc(ch):
-    if ch == u'\x03':
-        raise KeyboardInterrupt()
-    if ch == u'\x04' and not WIN:  # Unix-like, Ctrl+D
-        raise EOFError()
-    if ch == u'\x1a' and WIN:      # Windows, Ctrl+Z
-        raise EOFError()
-
-
-if WIN:
-    import msvcrt
-
-    @contextlib.contextmanager
-    def raw_terminal():
-        yield
-
-    def getchar(echo):
-        # The function `getch` will return a bytes object corresponding to
-        # the pressed character. Since Windows 10 build 1803, it will also
-        # return \x00 when called a second time after pressing a regular key.
-        #
-        # `getwch` does not share this probably-bugged behavior. Moreover, it
-        # returns a Unicode object by default, which is what we want.
-        #
-        # Either of these functions will return \x00 or \xe0 to indicate
-        # a special key, and you need to call the same function again to get
-        # the "rest" of the code. The fun part is that \u00e0 is
-        # "latin small letter a with grave", so if you type that on a French
-        # keyboard, you _also_ get a \xe0.
-        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
-        # resulting Unicode string reads as "a with grave" + "capital H".
-        # This is indistinguishable from when the user actually types
-        # "a with grave" and then "capital H".
-        #
-        # When \xe0 is returned, we assume it's part of a special-key sequence
-        # and call `getwch` again, but that means that when the user types
-        # the \u00e0 character, `getchar` doesn't return until a second
-        # character is typed.
-        # The alternative is returning immediately, but that would mess up
-        # cross-platform handling of arrow keys and others that start with
-        # \xe0. Another option is using `getch`, but then we can't reliably
-        # read non-ASCII characters, because return values of `getch` are
-        # limited to the current 8-bit codepage.
-        #
-        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
-        # is doing the right thing in more situations than with `getch`.
-        if echo:
-            func = msvcrt.getwche
-        else:
-            func = msvcrt.getwch
-
-        rv = func()
-        if rv in (u'\x00', u'\xe0'):
-            # \x00 and \xe0 are control characters that indicate special key,
-            # see above.
-            rv += func()
-        _translate_ch_to_exc(rv)
-        return rv
-else:
-    import tty
-    import termios
-
-    @contextlib.contextmanager
-    def raw_terminal():
-        if not isatty(sys.stdin):
-            f = open('/dev/tty')
-            fd = f.fileno()
-        else:
-            fd = sys.stdin.fileno()
-            f = None
-        try:
-            old_settings = termios.tcgetattr(fd)
-            try:
-                tty.setraw(fd)
-                yield fd
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                sys.stdout.flush()
-                if f is not None:
-                    f.close()
-        except termios.error:
-            pass
-
-    def getchar(echo):
-        with raw_terminal() as fd:
-            ch = os.read(fd, 32)
-            ch = ch.decode(get_best_encoding(sys.stdin), 'replace')
-            if echo and isatty(sys.stdout):
-                sys.stdout.write(ch)
-            _translate_ch_to_exc(ch)
-            return ch
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_textwrap.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_textwrap.py
deleted file mode 100644
index 7e776031e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_textwrap.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import textwrap
-from contextlib import contextmanager
-
-
-class TextWrapper(textwrap.TextWrapper):
-
-    def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
-        space_left = max(width - cur_len, 1)
-
-        if self.break_long_words:
-            last = reversed_chunks[-1]
-            cut = last[:space_left]
-            res = last[space_left:]
-            cur_line.append(cut)
-            reversed_chunks[-1] = res
-        elif not cur_line:
-            cur_line.append(reversed_chunks.pop())
-
-    @contextmanager
-    def extra_indent(self, indent):
-        old_initial_indent = self.initial_indent
-        old_subsequent_indent = self.subsequent_indent
-        self.initial_indent += indent
-        self.subsequent_indent += indent
-        try:
-            yield
-        finally:
-            self.initial_indent = old_initial_indent
-            self.subsequent_indent = old_subsequent_indent
-
-    def indent_only(self, text):
-        rv = []
-        for idx, line in enumerate(text.splitlines()):
-            indent = self.initial_indent
-            if idx > 0:
-                indent = self.subsequent_indent
-            rv.append(indent + line)
-        return '\n'.join(rv)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_unicodefun.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_unicodefun.py
deleted file mode 100644
index 620edff37..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_unicodefun.py
+++ /dev/null
@@ -1,125 +0,0 @@
-import os
-import sys
-import codecs
-
-from ._compat import PY2
-
-
-# If someone wants to vendor click, we want to ensure the
-# correct package is discovered.  Ideally we could use a
-# relative import here but unfortunately Python does not
-# support that.
-click = sys.modules[__name__.rsplit('.', 1)[0]]
-
-
-def _find_unicode_literals_frame():
-    import __future__
-    if not hasattr(sys, '_getframe'):  # not all Python implementations have it
-        return 0
-    frm = sys._getframe(1)
-    idx = 1
-    while frm is not None:
-        if frm.f_globals.get('__name__', '').startswith('click.'):
-            frm = frm.f_back
-            idx += 1
-        elif frm.f_code.co_flags & __future__.unicode_literals.compiler_flag:
-            return idx
-        else:
-            break
-    return 0
-
-
-def _check_for_unicode_literals():
-    if not __debug__:
-        return
-    if not PY2 or click.disable_unicode_literals_warning:
-        return
-    bad_frame = _find_unicode_literals_frame()
-    if bad_frame <= 0:
-        return
-    from warnings import warn
-    warn(Warning('Click detected the use of the unicode_literals '
-                 '__future__ import.  This is heavily discouraged '
-                 'because it can introduce subtle bugs in your '
-                 'code.  You should instead use explicit u"" literals '
-                 'for your unicode strings.  For more information see '
-                 'https://click.palletsprojects.com/python3/'),
-         stacklevel=bad_frame)
-
-
-def _verify_python3_env():
-    """Ensures that the environment is good for unicode on Python 3."""
-    if PY2:
-        return
-    try:
-        import locale
-        fs_enc = codecs.lookup(locale.getpreferredencoding()).name
-    except Exception:
-        fs_enc = 'ascii'
-    if fs_enc != 'ascii':
-        return
-
-    extra = ''
-    if os.name == 'posix':
-        import subprocess
-        try:
-            rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
-                                  stderr=subprocess.PIPE).communicate()[0]
-        except OSError:
-            rv = b''
-        good_locales = set()
-        has_c_utf8 = False
-
-        # Make sure we're operating on text here.
-        if isinstance(rv, bytes):
-            rv = rv.decode('ascii', 'replace')
-
-        for line in rv.splitlines():
-            locale = line.strip()
-            if locale.lower().endswith(('.utf-8', '.utf8')):
-                good_locales.add(locale)
-                if locale.lower() in ('c.utf8', 'c.utf-8'):
-                    has_c_utf8 = True
-
-        extra += '\n\n'
-        if not good_locales:
-            extra += (
-                'Additional information: on this system no suitable UTF-8\n'
-                'locales were discovered.  This most likely requires resolving\n'
-                'by reconfiguring the locale system.'
-            )
-        elif has_c_utf8:
-            extra += (
-                'This system supports the C.UTF-8 locale which is recommended.\n'
-                'You might be able to resolve your issue by exporting the\n'
-                'following environment variables:\n\n'
-                '    export LC_ALL=C.UTF-8\n'
-                '    export LANG=C.UTF-8'
-            )
-        else:
-            extra += (
-                'This system lists a couple of UTF-8 supporting locales that\n'
-                'you can pick from.  The following suitable locales were\n'
-                'discovered: %s'
-            ) % ', '.join(sorted(good_locales))
-
-        bad_locale = None
-        for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
-            if locale and locale.lower().endswith(('.utf-8', '.utf8')):
-                bad_locale = locale
-            if locale is not None:
-                break
-        if bad_locale is not None:
-            extra += (
-                '\n\nClick discovered that you exported a UTF-8 locale\n'
-                'but the locale system could not pick up from it because\n'
-                'it does not exist.  The exported locale is "%s" but it\n'
-                'is not supported'
-            ) % bad_locale
-
-    raise RuntimeError(
-        'Click will abort further execution because Python 3 was'
-        ' configured to use ASCII as encoding for the environment.'
-        ' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
-        ' mitigation steps.' + extra
-    )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_winconsole.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_winconsole.py
deleted file mode 100644
index bbb080dda..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/_winconsole.py
+++ /dev/null
@@ -1,307 +0,0 @@
-# -*- coding: utf-8 -*-
-# This module is based on the excellent work by Adam Bartoš who
-# provided a lot of what went into the implementation here in
-# the discussion to issue1602 in the Python bug tracker.
-#
-# There are some general differences in regards to how this works
-# compared to the original patches as we do not need to patch
-# the entire interpreter but just work in our little world of
-# echo and prmopt.
-
-import io
-import os
-import sys
-import zlib
-import time
-import ctypes
-import msvcrt
-from ._compat import _NonClosingTextIOWrapper, text_type, PY2
-from ctypes import byref, POINTER, c_int, c_char, c_char_p, \
-     c_void_p, py_object, c_ssize_t, c_ulong, windll, WINFUNCTYPE
-try:
-    from ctypes import pythonapi
-    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
-    PyBuffer_Release = pythonapi.PyBuffer_Release
-except ImportError:
-    pythonapi = None
-from ctypes.wintypes import LPWSTR, LPCWSTR
-
-
-c_ssize_p = POINTER(c_ssize_t)
-
-kernel32 = windll.kernel32
-GetStdHandle = kernel32.GetStdHandle
-ReadConsoleW = kernel32.ReadConsoleW
-WriteConsoleW = kernel32.WriteConsoleW
-GetLastError = kernel32.GetLastError
-GetCommandLineW = WINFUNCTYPE(LPWSTR)(
-    ('GetCommandLineW', windll.kernel32))
-CommandLineToArgvW = WINFUNCTYPE(
-    POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
-        ('CommandLineToArgvW', windll.shell32))
-
-
-STDIN_HANDLE = GetStdHandle(-10)
-STDOUT_HANDLE = GetStdHandle(-11)
-STDERR_HANDLE = GetStdHandle(-12)
-
-
-PyBUF_SIMPLE = 0
-PyBUF_WRITABLE = 1
-
-ERROR_SUCCESS = 0
-ERROR_NOT_ENOUGH_MEMORY = 8
-ERROR_OPERATION_ABORTED = 995
-
-STDIN_FILENO = 0
-STDOUT_FILENO = 1
-STDERR_FILENO = 2
-
-EOF = b'\x1a'
-MAX_BYTES_WRITTEN = 32767
-
-
-class Py_buffer(ctypes.Structure):
-    _fields_ = [
-        ('buf', c_void_p),
-        ('obj', py_object),
-        ('len', c_ssize_t),
-        ('itemsize', c_ssize_t),
-        ('readonly', c_int),
-        ('ndim', c_int),
-        ('format', c_char_p),
-        ('shape', c_ssize_p),
-        ('strides', c_ssize_p),
-        ('suboffsets', c_ssize_p),
-        ('internal', c_void_p)
-    ]
-
-    if PY2:
-        _fields_.insert(-1, ('smalltable', c_ssize_t * 2))
-
-
-# On PyPy we cannot get buffers so our ability to operate here is
-# serverly limited.
-if pythonapi is None:
-    get_buffer = None
-else:
-    def get_buffer(obj, writable=False):
-        buf = Py_buffer()
-        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
-        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
-        try:
-            buffer_type = c_char * buf.len
-            return buffer_type.from_address(buf.buf)
-        finally:
-            PyBuffer_Release(byref(buf))
-
-
-class _WindowsConsoleRawIOBase(io.RawIOBase):
-
-    def __init__(self, handle):
-        self.handle = handle
-
-    def isatty(self):
-        io.RawIOBase.isatty(self)
-        return True
-
-
-class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
-
-    def readable(self):
-        return True
-
-    def readinto(self, b):
-        bytes_to_be_read = len(b)
-        if not bytes_to_be_read:
-            return 0
-        elif bytes_to_be_read % 2:
-            raise ValueError('cannot read odd number of bytes from '
-                             'UTF-16-LE encoded console')
-
-        buffer = get_buffer(b, writable=True)
-        code_units_to_be_read = bytes_to_be_read // 2
-        code_units_read = c_ulong()
-
-        rv = ReadConsoleW(self.handle, buffer, code_units_to_be_read,
-                          byref(code_units_read), None)
-        if GetLastError() == ERROR_OPERATION_ABORTED:
-            # wait for KeyboardInterrupt
-            time.sleep(0.1)
-        if not rv:
-            raise OSError('Windows error: %s' % GetLastError())
-
-        if buffer[0] == EOF:
-            return 0
-        return 2 * code_units_read.value
-
-
-class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
-
-    def writable(self):
-        return True
-
-    @staticmethod
-    def _get_error_message(errno):
-        if errno == ERROR_SUCCESS:
-            return 'ERROR_SUCCESS'
-        elif errno == ERROR_NOT_ENOUGH_MEMORY:
-            return 'ERROR_NOT_ENOUGH_MEMORY'
-        return 'Windows error %s' % errno
-
-    def write(self, b):
-        bytes_to_be_written = len(b)
-        buf = get_buffer(b)
-        code_units_to_be_written = min(bytes_to_be_written,
-                                       MAX_BYTES_WRITTEN) // 2
-        code_units_written = c_ulong()
-
-        WriteConsoleW(self.handle, buf, code_units_to_be_written,
-                      byref(code_units_written), None)
-        bytes_written = 2 * code_units_written.value
-
-        if bytes_written == 0 and bytes_to_be_written > 0:
-            raise OSError(self._get_error_message(GetLastError()))
-        return bytes_written
-
-
-class ConsoleStream(object):
-
-    def __init__(self, text_stream, byte_stream):
-        self._text_stream = text_stream
-        self.buffer = byte_stream
-
-    @property
-    def name(self):
-        return self.buffer.name
-
-    def write(self, x):
-        if isinstance(x, text_type):
-            return self._text_stream.write(x)
-        try:
-            self.flush()
-        except Exception:
-            pass
-        return self.buffer.write(x)
-
-    def writelines(self, lines):
-        for line in lines:
-            self.write(line)
-
-    def __getattr__(self, name):
-        return getattr(self._text_stream, name)
-
-    def isatty(self):
-        return self.buffer.isatty()
-
-    def __repr__(self):
-        return '<ConsoleStream name=%r encoding=%r>' % (
-            self.name,
-            self.encoding,
-        )
-
-
-class WindowsChunkedWriter(object):
-    """
-    Wraps a stream (such as stdout), acting as a transparent proxy for all
-    attribute access apart from method 'write()' which we wrap to write in
-    limited chunks due to a Windows limitation on binary console streams.
-    """
-    def __init__(self, wrapped):
-        # double-underscore everything to prevent clashes with names of
-        # attributes on the wrapped stream object.
-        self.__wrapped = wrapped
-
-    def __getattr__(self, name):
-        return getattr(self.__wrapped, name)
-
-    def write(self, text):
-        total_to_write = len(text)
-        written = 0
-
-        while written < total_to_write:
-            to_write = min(total_to_write - written, MAX_BYTES_WRITTEN)
-            self.__wrapped.write(text[written:written+to_write])
-            written += to_write
-
-
-_wrapped_std_streams = set()
-
-
-def _wrap_std_stream(name):
-    # Python 2 & Windows 7 and below
-    if PY2 and sys.getwindowsversion()[:2] <= (6, 1) and name not in _wrapped_std_streams:
-        setattr(sys, name, WindowsChunkedWriter(getattr(sys, name)))
-        _wrapped_std_streams.add(name)
-
-
-def _get_text_stdin(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stdout(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stderr(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-if PY2:
-    def _hash_py_argv():
-        return zlib.crc32('\x00'.join(sys.argv[1:]))
-
-    _initial_argv_hash = _hash_py_argv()
-
-    def _get_windows_argv():
-        argc = c_int(0)
-        argv_unicode = CommandLineToArgvW(GetCommandLineW(), byref(argc))
-        argv = [argv_unicode[i] for i in range(0, argc.value)]
-
-        if not hasattr(sys, 'frozen'):
-            argv = argv[1:]
-            while len(argv) > 0:
-                arg = argv[0]
-                if not arg.startswith('-') or arg == '-':
-                    break
-                argv = argv[1:]
-                if arg.startswith(('-c', '-m')):
-                    break
-
-        return argv[1:]
-
-
-_stream_factories = {
-    0: _get_text_stdin,
-    1: _get_text_stdout,
-    2: _get_text_stderr,
-}
-
-
-def _get_windows_console_stream(f, encoding, errors):
-    if get_buffer is not None and \
-       encoding in ('utf-16-le', None) \
-       and errors in ('strict', None) and \
-       hasattr(f, 'isatty') and f.isatty():
-        func = _stream_factories.get(f.fileno())
-        if func is not None:
-            if not PY2:
-                f = getattr(f, 'buffer', None)
-                if f is None:
-                    return None
-            else:
-                # If we are on Python 2 we need to set the stream that we
-                # deal with to binary mode as otherwise the exercise if a
-                # bit moot.  The same problems apply as for
-                # get_binary_stdin and friends from _compat.
-                msvcrt.setmode(f.fileno(), os.O_BINARY)
-            return func(f)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/core.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/core.py
deleted file mode 100644
index 7a1e3422b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/core.py
+++ /dev/null
@@ -1,1856 +0,0 @@
-import errno
-import inspect
-import os
-import sys
-from contextlib import contextmanager
-from itertools import repeat
-from functools import update_wrapper
-
-from .types import convert_type, IntRange, BOOL
-from .utils import PacifyFlushWrapper, make_str, make_default_short_help, \
-     echo, get_os_args
-from .exceptions import ClickException, UsageError, BadParameter, Abort, \
-     MissingParameter, Exit
-from .termui import prompt, confirm, style
-from .formatting import HelpFormatter, join_options
-from .parser import OptionParser, split_opt
-from .globals import push_context, pop_context
-
-from ._compat import PY2, isidentifier, iteritems, string_types
-from ._unicodefun import _check_for_unicode_literals, _verify_python3_env
-
-
-_missing = object()
-
-
-SUBCOMMAND_METAVAR = 'COMMAND [ARGS]...'
-SUBCOMMANDS_METAVAR = 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...'
-
-DEPRECATED_HELP_NOTICE = ' (DEPRECATED)'
-DEPRECATED_INVOKE_NOTICE = 'DeprecationWarning: ' + \
-                           'The command %(name)s is deprecated.'
-
-
-def _maybe_show_deprecated_notice(cmd):
-    if cmd.deprecated:
-        echo(style(DEPRECATED_INVOKE_NOTICE % {'name': cmd.name}, fg='red'), err=True)
-
-
-def fast_exit(code):
-    """Exit without garbage collection, this speeds up exit by about 10ms for
-    things like bash completion.
-    """
-    sys.stdout.flush()
-    sys.stderr.flush()
-    os._exit(code)
-
-
-def _bashcomplete(cmd, prog_name, complete_var=None):
-    """Internal handler for the bash completion support."""
-    if complete_var is None:
-        complete_var = '_%s_COMPLETE' % (prog_name.replace('-', '_')).upper()
-    complete_instr = os.environ.get(complete_var)
-    if not complete_instr:
-        return
-
-    from ._bashcomplete import bashcomplete
-    if bashcomplete(cmd, prog_name, complete_var, complete_instr):
-        fast_exit(1)
-
-
-def _check_multicommand(base_command, cmd_name, cmd, register=False):
-    if not base_command.chain or not isinstance(cmd, MultiCommand):
-        return
-    if register:
-        hint = 'It is not possible to add multi commands as children to ' \
-               'another multi command that is in chain mode'
-    else:
-        hint = 'Found a multi command as subcommand to a multi command ' \
-               'that is in chain mode.  This is not supported'
-    raise RuntimeError('%s.  Command "%s" is set to chain and "%s" was '
-                       'added as subcommand but it in itself is a '
-                       'multi command.  ("%s" is a %s within a chained '
-                       '%s named "%s").' % (
-                           hint, base_command.name, cmd_name,
-                           cmd_name, cmd.__class__.__name__,
-                           base_command.__class__.__name__,
-                           base_command.name))
-
-
-def batch(iterable, batch_size):
-    return list(zip(*repeat(iter(iterable), batch_size)))
-
-
-def invoke_param_callback(callback, ctx, param, value):
-    code = getattr(callback, '__code__', None)
-    args = getattr(code, 'co_argcount', 3)
-
-    if args < 3:
-        # This will become a warning in Click 3.0:
-        from warnings import warn
-        warn(Warning('Invoked legacy parameter callback "%s".  The new '
-                     'signature for such callbacks starting with '
-                     'click 2.0 is (ctx, param, value).'
-                     % callback), stacklevel=3)
-        return callback(ctx, value)
-    return callback(ctx, param, value)
-
-
-@contextmanager
-def augment_usage_errors(ctx, param=None):
-    """Context manager that attaches extra information to exceptions that
-    fly.
-    """
-    try:
-        yield
-    except BadParameter as e:
-        if e.ctx is None:
-            e.ctx = ctx
-        if param is not None and e.param is None:
-            e.param = param
-        raise
-    except UsageError as e:
-        if e.ctx is None:
-            e.ctx = ctx
-        raise
-
-
-def iter_params_for_processing(invocation_order, declaration_order):
-    """Given a sequence of parameters in the order as should be considered
-    for processing and an iterable of parameters that exist, this returns
-    a list in the correct order as they should be processed.
-    """
-    def sort_key(item):
-        try:
-            idx = invocation_order.index(item)
-        except ValueError:
-            idx = float('inf')
-        return (not item.is_eager, idx)
-
-    return sorted(declaration_order, key=sort_key)
-
-
-class Context(object):
-    """The context is a special internal object that holds state relevant
-    for the script execution at every single level.  It's normally invisible
-    to commands unless they opt-in to getting access to it.
-
-    The context is useful as it can pass internal objects around and can
-    control special execution features such as reading data from
-    environment variables.
-
-    A context can be used as context manager in which case it will call
-    :meth:`close` on teardown.
-
-    .. versionadded:: 2.0
-       Added the `resilient_parsing`, `help_option_names`,
-       `token_normalize_func` parameters.
-
-    .. versionadded:: 3.0
-       Added the `allow_extra_args` and `allow_interspersed_args`
-       parameters.
-
-    .. versionadded:: 4.0
-       Added the `color`, `ignore_unknown_options`, and
-       `max_content_width` parameters.
-
-    :param command: the command class for this context.
-    :param parent: the parent context.
-    :param info_name: the info name for this invocation.  Generally this
-                      is the most descriptive name for the script or
-                      command.  For the toplevel script it is usually
-                      the name of the script, for commands below it it's
-                      the name of the script.
-    :param obj: an arbitrary object of user data.
-    :param auto_envvar_prefix: the prefix to use for automatic environment
-                               variables.  If this is `None` then reading
-                               from environment variables is disabled.  This
-                               does not affect manually set environment
-                               variables which are always read.
-    :param default_map: a dictionary (like object) with default values
-                        for parameters.
-    :param terminal_width: the width of the terminal.  The default is
-                           inherit from parent context.  If no context
-                           defines the terminal width then auto
-                           detection will be applied.
-    :param max_content_width: the maximum width for content rendered by
-                              Click (this currently only affects help
-                              pages).  This defaults to 80 characters if
-                              not overridden.  In other words: even if the
-                              terminal is larger than that, Click will not
-                              format things wider than 80 characters by
-                              default.  In addition to that, formatters might
-                              add some safety mapping on the right.
-    :param resilient_parsing: if this flag is enabled then Click will
-                              parse without any interactivity or callback
-                              invocation.  Default values will also be
-                              ignored.  This is useful for implementing
-                              things such as completion support.
-    :param allow_extra_args: if this is set to `True` then extra arguments
-                             at the end will not raise an error and will be
-                             kept on the context.  The default is to inherit
-                             from the command.
-    :param allow_interspersed_args: if this is set to `False` then options
-                                    and arguments cannot be mixed.  The
-                                    default is to inherit from the command.
-    :param ignore_unknown_options: instructs click to ignore options it does
-                                   not know and keeps them for later
-                                   processing.
-    :param help_option_names: optionally a list of strings that define how
-                              the default help parameter is named.  The
-                              default is ``['--help']``.
-    :param token_normalize_func: an optional function that is used to
-                                 normalize tokens (options, choices,
-                                 etc.).  This for instance can be used to
-                                 implement case insensitive behavior.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.  This is only needed if ANSI
-                  codes are used in texts that Click prints which is by
-                  default not the case.  This for instance would affect
-                  help output.
-    """
-
-    def __init__(self, command, parent=None, info_name=None, obj=None,
-                 auto_envvar_prefix=None, default_map=None,
-                 terminal_width=None, max_content_width=None,
-                 resilient_parsing=False, allow_extra_args=None,
-                 allow_interspersed_args=None,
-                 ignore_unknown_options=None, help_option_names=None,
-                 token_normalize_func=None, color=None):
-        #: the parent context or `None` if none exists.
-        self.parent = parent
-        #: the :class:`Command` for this context.
-        self.command = command
-        #: the descriptive information name
-        self.info_name = info_name
-        #: the parsed parameters except if the value is hidden in which
-        #: case it's not remembered.
-        self.params = {}
-        #: the leftover arguments.
-        self.args = []
-        #: protected arguments.  These are arguments that are prepended
-        #: to `args` when certain parsing scenarios are encountered but
-        #: must be never propagated to another arguments.  This is used
-        #: to implement nested parsing.
-        self.protected_args = []
-        if obj is None and parent is not None:
-            obj = parent.obj
-        #: the user object stored.
-        self.obj = obj
-        self._meta = getattr(parent, 'meta', {})
-
-        #: A dictionary (-like object) with defaults for parameters.
-        if default_map is None \
-           and parent is not None \
-           and parent.default_map is not None:
-            default_map = parent.default_map.get(info_name)
-        self.default_map = default_map
-
-        #: This flag indicates if a subcommand is going to be executed. A
-        #: group callback can use this information to figure out if it's
-        #: being executed directly or because the execution flow passes
-        #: onwards to a subcommand. By default it's None, but it can be
-        #: the name of the subcommand to execute.
-        #:
-        #: If chaining is enabled this will be set to ``'*'`` in case
-        #: any commands are executed.  It is however not possible to
-        #: figure out which ones.  If you require this knowledge you
-        #: should use a :func:`resultcallback`.
-        self.invoked_subcommand = None
-
-        if terminal_width is None and parent is not None:
-            terminal_width = parent.terminal_width
-        #: The width of the terminal (None is autodetection).
-        self.terminal_width = terminal_width
-
-        if max_content_width is None and parent is not None:
-            max_content_width = parent.max_content_width
-        #: The maximum width of formatted content (None implies a sensible
-        #: default which is 80 for most things).
-        self.max_content_width = max_content_width
-
-        if allow_extra_args is None:
-            allow_extra_args = command.allow_extra_args
-        #: Indicates if the context allows extra args or if it should
-        #: fail on parsing.
-        #:
-        #: .. versionadded:: 3.0
-        self.allow_extra_args = allow_extra_args
-
-        if allow_interspersed_args is None:
-            allow_interspersed_args = command.allow_interspersed_args
-        #: Indicates if the context allows mixing of arguments and
-        #: options or not.
-        #:
-        #: .. versionadded:: 3.0
-        self.allow_interspersed_args = allow_interspersed_args
-
-        if ignore_unknown_options is None:
-            ignore_unknown_options = command.ignore_unknown_options
-        #: Instructs click to ignore options that a command does not
-        #: understand and will store it on the context for later
-        #: processing.  This is primarily useful for situations where you
-        #: want to call into external programs.  Generally this pattern is
-        #: strongly discouraged because it's not possibly to losslessly
-        #: forward all arguments.
-        #:
-        #: .. versionadded:: 4.0
-        self.ignore_unknown_options = ignore_unknown_options
-
-        if help_option_names is None:
-            if parent is not None:
-                help_option_names = parent.help_option_names
-            else:
-                help_option_names = ['--help']
-
-        #: The names for the help options.
-        self.help_option_names = help_option_names
-
-        if token_normalize_func is None and parent is not None:
-            token_normalize_func = parent.token_normalize_func
-
-        #: An optional normalization function for tokens.  This is
-        #: options, choices, commands etc.
-        self.token_normalize_func = token_normalize_func
-
-        #: Indicates if resilient parsing is enabled.  In that case Click
-        #: will do its best to not cause any failures and default values
-        #: will be ignored. Useful for completion.
-        self.resilient_parsing = resilient_parsing
-
-        # If there is no envvar prefix yet, but the parent has one and
-        # the command on this level has a name, we can expand the envvar
-        # prefix automatically.
-        if auto_envvar_prefix is None:
-            if parent is not None \
-               and parent.auto_envvar_prefix is not None and \
-               self.info_name is not None:
-                auto_envvar_prefix = '%s_%s' % (parent.auto_envvar_prefix,
-                                           self.info_name.upper())
-        else:
-            auto_envvar_prefix = auto_envvar_prefix.upper()
-        self.auto_envvar_prefix = auto_envvar_prefix
-
-        if color is None and parent is not None:
-            color = parent.color
-
-        #: Controls if styling output is wanted or not.
-        self.color = color
-
-        self._close_callbacks = []
-        self._depth = 0
-
-    def __enter__(self):
-        self._depth += 1
-        push_context(self)
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self._depth -= 1
-        if self._depth == 0:
-            self.close()
-        pop_context()
-
-    @contextmanager
-    def scope(self, cleanup=True):
-        """This helper method can be used with the context object to promote
-        it to the current thread local (see :func:`get_current_context`).
-        The default behavior of this is to invoke the cleanup functions which
-        can be disabled by setting `cleanup` to `False`.  The cleanup
-        functions are typically used for things such as closing file handles.
-
-        If the cleanup is intended the context object can also be directly
-        used as a context manager.
-
-        Example usage::
-
-            with ctx.scope():
-                assert get_current_context() is ctx
-
-        This is equivalent::
-
-            with ctx:
-                assert get_current_context() is ctx
-
-        .. versionadded:: 5.0
-
-        :param cleanup: controls if the cleanup functions should be run or
-                        not.  The default is to run these functions.  In
-                        some situations the context only wants to be
-                        temporarily pushed in which case this can be disabled.
-                        Nested pushes automatically defer the cleanup.
-        """
-        if not cleanup:
-            self._depth += 1
-        try:
-            with self as rv:
-                yield rv
-        finally:
-            if not cleanup:
-                self._depth -= 1
-
-    @property
-    def meta(self):
-        """This is a dictionary which is shared with all the contexts
-        that are nested.  It exists so that click utilities can store some
-        state here if they need to.  It is however the responsibility of
-        that code to manage this dictionary well.
-
-        The keys are supposed to be unique dotted strings.  For instance
-        module paths are a good choice for it.  What is stored in there is
-        irrelevant for the operation of click.  However what is important is
-        that code that places data here adheres to the general semantics of
-        the system.
-
-        Example usage::
-
-            LANG_KEY = __name__ + '.lang'
-
-            def set_language(value):
-                ctx = get_current_context()
-                ctx.meta[LANG_KEY] = value
-
-            def get_language():
-                return get_current_context().meta.get(LANG_KEY, 'en_US')
-
-        .. versionadded:: 5.0
-        """
-        return self._meta
-
-    def make_formatter(self):
-        """Creates the formatter for the help and usage output."""
-        return HelpFormatter(width=self.terminal_width,
-                             max_width=self.max_content_width)
-
-    def call_on_close(self, f):
-        """This decorator remembers a function as callback that should be
-        executed when the context tears down.  This is most useful to bind
-        resource handling to the script execution.  For instance, file objects
-        opened by the :class:`File` type will register their close callbacks
-        here.
-
-        :param f: the function to execute on teardown.
-        """
-        self._close_callbacks.append(f)
-        return f
-
-    def close(self):
-        """Invokes all close callbacks."""
-        for cb in self._close_callbacks:
-            cb()
-        self._close_callbacks = []
-
-    @property
-    def command_path(self):
-        """The computed command path.  This is used for the ``usage``
-        information on the help page.  It's automatically created by
-        combining the info names of the chain of contexts to the root.
-        """
-        rv = ''
-        if self.info_name is not None:
-            rv = self.info_name
-        if self.parent is not None:
-            rv = self.parent.command_path + ' ' + rv
-        return rv.lstrip()
-
-    def find_root(self):
-        """Finds the outermost context."""
-        node = self
-        while node.parent is not None:
-            node = node.parent
-        return node
-
-    def find_object(self, object_type):
-        """Finds the closest object of a given type."""
-        node = self
-        while node is not None:
-            if isinstance(node.obj, object_type):
-                return node.obj
-            node = node.parent
-
-    def ensure_object(self, object_type):
-        """Like :meth:`find_object` but sets the innermost object to a
-        new instance of `object_type` if it does not exist.
-        """
-        rv = self.find_object(object_type)
-        if rv is None:
-            self.obj = rv = object_type()
-        return rv
-
-    def lookup_default(self, name):
-        """Looks up the default for a parameter name.  This by default
-        looks into the :attr:`default_map` if available.
-        """
-        if self.default_map is not None:
-            rv = self.default_map.get(name)
-            if callable(rv):
-                rv = rv()
-            return rv
-
-    def fail(self, message):
-        """Aborts the execution of the program with a specific error
-        message.
-
-        :param message: the error message to fail with.
-        """
-        raise UsageError(message, self)
-
-    def abort(self):
-        """Aborts the script."""
-        raise Abort()
-
-    def exit(self, code=0):
-        """Exits the application with a given exit code."""
-        raise Exit(code)
-
-    def get_usage(self):
-        """Helper method to get formatted usage string for the current
-        context and command.
-        """
-        return self.command.get_usage(self)
-
-    def get_help(self):
-        """Helper method to get formatted help page for the current
-        context and command.
-        """
-        return self.command.get_help(self)
-
-    def invoke(*args, **kwargs):
-        """Invokes a command callback in exactly the way it expects.  There
-        are two ways to invoke this method:
-
-        1.  the first argument can be a callback and all other arguments and
-            keyword arguments are forwarded directly to the function.
-        2.  the first argument is a click command object.  In that case all
-            arguments are forwarded as well but proper click parameters
-            (options and click arguments) must be keyword arguments and Click
-            will fill in defaults.
-
-        Note that before Click 3.2 keyword arguments were not properly filled
-        in against the intention of this code and no context was created.  For
-        more information about this change and why it was done in a bugfix
-        release see :ref:`upgrade-to-3.2`.
-        """
-        self, callback = args[:2]
-        ctx = self
-
-        # It's also possible to invoke another command which might or
-        # might not have a callback.  In that case we also fill
-        # in defaults and make a new context for this command.
-        if isinstance(callback, Command):
-            other_cmd = callback
-            callback = other_cmd.callback
-            ctx = Context(other_cmd, info_name=other_cmd.name, parent=self)
-            if callback is None:
-                raise TypeError('The given command does not have a '
-                                'callback that can be invoked.')
-
-            for param in other_cmd.params:
-                if param.name not in kwargs and param.expose_value:
-                    kwargs[param.name] = param.get_default(ctx)
-
-        args = args[2:]
-        with augment_usage_errors(self):
-            with ctx:
-                return callback(*args, **kwargs)
-
-    def forward(*args, **kwargs):
-        """Similar to :meth:`invoke` but fills in default keyword
-        arguments from the current context if the other command expects
-        it.  This cannot invoke callbacks directly, only other commands.
-        """
-        self, cmd = args[:2]
-
-        # It's also possible to invoke another command which might or
-        # might not have a callback.
-        if not isinstance(cmd, Command):
-            raise TypeError('Callback is not a command.')
-
-        for param in self.params:
-            if param not in kwargs:
-                kwargs[param] = self.params[param]
-
-        return self.invoke(cmd, **kwargs)
-
-
-class BaseCommand(object):
-    """The base command implements the minimal API contract of commands.
-    Most code will never use this as it does not implement a lot of useful
-    functionality but it can act as the direct subclass of alternative
-    parsing methods that do not depend on the Click parser.
-
-    For instance, this can be used to bridge Click and other systems like
-    argparse or docopt.
-
-    Because base commands do not implement a lot of the API that other
-    parts of Click take for granted, they are not supported for all
-    operations.  For instance, they cannot be used with the decorators
-    usually and they have no built-in callback system.
-
-    .. versionchanged:: 2.0
-       Added the `context_settings` parameter.
-
-    :param name: the name of the command to use unless a group overrides it.
-    :param context_settings: an optional dictionary with defaults that are
-                             passed to the context object.
-    """
-    #: the default for the :attr:`Context.allow_extra_args` flag.
-    allow_extra_args = False
-    #: the default for the :attr:`Context.allow_interspersed_args` flag.
-    allow_interspersed_args = True
-    #: the default for the :attr:`Context.ignore_unknown_options` flag.
-    ignore_unknown_options = False
-
-    def __init__(self, name, context_settings=None):
-        #: the name the command thinks it has.  Upon registering a command
-        #: on a :class:`Group` the group will default the command name
-        #: with this information.  You should instead use the
-        #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
-        self.name = name
-        if context_settings is None:
-            context_settings = {}
-        #: an optional dictionary with defaults passed to the context.
-        self.context_settings = context_settings
-
-    def get_usage(self, ctx):
-        raise NotImplementedError('Base commands cannot get usage')
-
-    def get_help(self, ctx):
-        raise NotImplementedError('Base commands cannot get help')
-
-    def make_context(self, info_name, args, parent=None, **extra):
-        """This function when given an info name and arguments will kick
-        off the parsing and create a new :class:`Context`.  It does not
-        invoke the actual command callback though.
-
-        :param info_name: the info name for this invokation.  Generally this
-                          is the most descriptive name for the script or
-                          command.  For the toplevel script it's usually
-                          the name of the script, for commands below it it's
-                          the name of the script.
-        :param args: the arguments to parse as list of strings.
-        :param parent: the parent context if available.
-        :param extra: extra keyword arguments forwarded to the context
-                      constructor.
-        """
-        for key, value in iteritems(self.context_settings):
-            if key not in extra:
-                extra[key] = value
-        ctx = Context(self, info_name=info_name, parent=parent, **extra)
-        with ctx.scope(cleanup=False):
-            self.parse_args(ctx, args)
-        return ctx
-
-    def parse_args(self, ctx, args):
-        """Given a context and a list of arguments this creates the parser
-        and parses the arguments, then modifies the context as necessary.
-        This is automatically invoked by :meth:`make_context`.
-        """
-        raise NotImplementedError('Base commands do not know how to parse '
-                                  'arguments.')
-
-    def invoke(self, ctx):
-        """Given a context, this invokes the command.  The default
-        implementation is raising a not implemented error.
-        """
-        raise NotImplementedError('Base commands are not invokable by default')
-
-    def main(self, args=None, prog_name=None, complete_var=None,
-             standalone_mode=True, **extra):
-        """This is the way to invoke a script with all the bells and
-        whistles as a command line application.  This will always terminate
-        the application after a call.  If this is not wanted, ``SystemExit``
-        needs to be caught.
-
-        This method is also available by directly calling the instance of
-        a :class:`Command`.
-
-        .. versionadded:: 3.0
-           Added the `standalone_mode` flag to control the standalone mode.
-
-        :param args: the arguments that should be used for parsing.  If not
-                     provided, ``sys.argv[1:]`` is used.
-        :param prog_name: the program name that should be used.  By default
-                          the program name is constructed by taking the file
-                          name from ``sys.argv[0]``.
-        :param complete_var: the environment variable that controls the
-                             bash completion support.  The default is
-                             ``"_<prog_name>_COMPLETE"`` with prog_name in
-                             uppercase.
-        :param standalone_mode: the default behavior is to invoke the script
-                                in standalone mode.  Click will then
-                                handle exceptions and convert them into
-                                error messages and the function will never
-                                return but shut down the interpreter.  If
-                                this is set to `False` they will be
-                                propagated to the caller and the return
-                                value of this function is the return value
-                                of :meth:`invoke`.
-        :param extra: extra keyword arguments are forwarded to the context
-                      constructor.  See :class:`Context` for more information.
-        """
-        # If we are in Python 3, we will verify that the environment is
-        # sane at this point or reject further execution to avoid a
-        # broken script.
-        if not PY2:
-            _verify_python3_env()
-        else:
-            _check_for_unicode_literals()
-
-        if args is None:
-            args = get_os_args()
-        else:
-            args = list(args)
-
-        if prog_name is None:
-            prog_name = make_str(os.path.basename(
-                sys.argv and sys.argv[0] or __file__))
-
-        # Hook for the Bash completion.  This only activates if the Bash
-        # completion is actually enabled, otherwise this is quite a fast
-        # noop.
-        _bashcomplete(self, prog_name, complete_var)
-
-        try:
-            try:
-                with self.make_context(prog_name, args, **extra) as ctx:
-                    rv = self.invoke(ctx)
-                    if not standalone_mode:
-                        return rv
-                    # it's not safe to `ctx.exit(rv)` here!
-                    # note that `rv` may actually contain data like "1" which
-                    # has obvious effects
-                    # more subtle case: `rv=[None, None]` can come out of
-                    # chained commands which all returned `None` -- so it's not
-                    # even always obvious that `rv` indicates success/failure
-                    # by its truthiness/falsiness
-                    ctx.exit()
-            except (EOFError, KeyboardInterrupt):
-                echo(file=sys.stderr)
-                raise Abort()
-            except ClickException as e:
-                if not standalone_mode:
-                    raise
-                e.show()
-                sys.exit(e.exit_code)
-            except IOError as e:
-                if e.errno == errno.EPIPE:
-                    sys.stdout = PacifyFlushWrapper(sys.stdout)
-                    sys.stderr = PacifyFlushWrapper(sys.stderr)
-                    sys.exit(1)
-                else:
-                    raise
-        except Exit as e:
-            if standalone_mode:
-                sys.exit(e.exit_code)
-            else:
-                # in non-standalone mode, return the exit code
-                # note that this is only reached if `self.invoke` above raises
-                # an Exit explicitly -- thus bypassing the check there which
-                # would return its result
-                # the results of non-standalone execution may therefore be
-                # somewhat ambiguous: if there are codepaths which lead to
-                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
-                # tell the difference between the two
-                return e.exit_code
-        except Abort:
-            if not standalone_mode:
-                raise
-            echo('Aborted!', file=sys.stderr)
-            sys.exit(1)
-
-    def __call__(self, *args, **kwargs):
-        """Alias for :meth:`main`."""
-        return self.main(*args, **kwargs)
-
-
-class Command(BaseCommand):
-    """Commands are the basic building block of command line interfaces in
-    Click.  A basic command handles command line parsing and might dispatch
-    more parsing to commands nested below it.
-
-    .. versionchanged:: 2.0
-       Added the `context_settings` parameter.
-
-    :param name: the name of the command to use unless a group overrides it.
-    :param context_settings: an optional dictionary with defaults that are
-                             passed to the context object.
-    :param callback: the callback to invoke.  This is optional.
-    :param params: the parameters to register with this command.  This can
-                   be either :class:`Option` or :class:`Argument` objects.
-    :param help: the help string to use for this command.
-    :param epilog: like the help string but it's printed at the end of the
-                   help page after everything else.
-    :param short_help: the short help to use for this command.  This is
-                       shown on the command listing of the parent command.
-    :param add_help_option: by default each command registers a ``--help``
-                            option.  This can be disabled by this parameter.
-    :param hidden: hide this command from help outputs.
-
-    :param deprecated: issues a message indicating that
-                             the command is deprecated.
-    """
-
-    def __init__(self, name, context_settings=None, callback=None,
-                 params=None, help=None, epilog=None, short_help=None,
-                 options_metavar='[OPTIONS]', add_help_option=True,
-                 hidden=False, deprecated=False):
-        BaseCommand.__init__(self, name, context_settings)
-        #: the callback to execute when the command fires.  This might be
-        #: `None` in which case nothing happens.
-        self.callback = callback
-        #: the list of parameters for this command in the order they
-        #: should show up in the help page and execute.  Eager parameters
-        #: will automatically be handled before non eager ones.
-        self.params = params or []
-        # if a form feed (page break) is found in the help text, truncate help
-        # text to the content preceding the first form feed
-        if help and '\f' in help:
-            help = help.split('\f', 1)[0]
-        self.help = help
-        self.epilog = epilog
-        self.options_metavar = options_metavar
-        self.short_help = short_help
-        self.add_help_option = add_help_option
-        self.hidden = hidden
-        self.deprecated = deprecated
-
-    def get_usage(self, ctx):
-        formatter = ctx.make_formatter()
-        self.format_usage(ctx, formatter)
-        return formatter.getvalue().rstrip('\n')
-
-    def get_params(self, ctx):
-        rv = self.params
-        help_option = self.get_help_option(ctx)
-        if help_option is not None:
-            rv = rv + [help_option]
-        return rv
-
-    def format_usage(self, ctx, formatter):
-        """Writes the usage line into the formatter."""
-        pieces = self.collect_usage_pieces(ctx)
-        formatter.write_usage(ctx.command_path, ' '.join(pieces))
-
-    def collect_usage_pieces(self, ctx):
-        """Returns all the pieces that go into the usage line and returns
-        it as a list of strings.
-        """
-        rv = [self.options_metavar]
-        for param in self.get_params(ctx):
-            rv.extend(param.get_usage_pieces(ctx))
-        return rv
-
-    def get_help_option_names(self, ctx):
-        """Returns the names for the help option."""
-        all_names = set(ctx.help_option_names)
-        for param in self.params:
-            all_names.difference_update(param.opts)
-            all_names.difference_update(param.secondary_opts)
-        return all_names
-
-    def get_help_option(self, ctx):
-        """Returns the help option object."""
-        help_options = self.get_help_option_names(ctx)
-        if not help_options or not self.add_help_option:
-            return
-
-        def show_help(ctx, param, value):
-            if value and not ctx.resilient_parsing:
-                echo(ctx.get_help(), color=ctx.color)
-                ctx.exit()
-        return Option(help_options, is_flag=True,
-                      is_eager=True, expose_value=False,
-                      callback=show_help,
-                      help='Show this message and exit.')
-
-    def make_parser(self, ctx):
-        """Creates the underlying option parser for this command."""
-        parser = OptionParser(ctx)
-        for param in self.get_params(ctx):
-            param.add_to_parser(parser, ctx)
-        return parser
-
-    def get_help(self, ctx):
-        """Formats the help into a string and returns it.  This creates a
-        formatter and will call into the following formatting methods:
-        """
-        formatter = ctx.make_formatter()
-        self.format_help(ctx, formatter)
-        return formatter.getvalue().rstrip('\n')
-
-    def get_short_help_str(self, limit=45):
-        """Gets short help for the command or makes it by shortening the long help string."""
-        return self.short_help or self.help and make_default_short_help(self.help, limit) or ''
-
-    def format_help(self, ctx, formatter):
-        """Writes the help into the formatter if it exists.
-
-        This calls into the following methods:
-
-        -   :meth:`format_usage`
-        -   :meth:`format_help_text`
-        -   :meth:`format_options`
-        -   :meth:`format_epilog`
-        """
-        self.format_usage(ctx, formatter)
-        self.format_help_text(ctx, formatter)
-        self.format_options(ctx, formatter)
-        self.format_epilog(ctx, formatter)
-
-    def format_help_text(self, ctx, formatter):
-        """Writes the help text to the formatter if it exists."""
-        if self.help:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                help_text = self.help
-                if self.deprecated:
-                    help_text += DEPRECATED_HELP_NOTICE
-                formatter.write_text(help_text)
-        elif self.deprecated:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                formatter.write_text(DEPRECATED_HELP_NOTICE)
-
-    def format_options(self, ctx, formatter):
-        """Writes all the options into the formatter if they exist."""
-        opts = []
-        for param in self.get_params(ctx):
-            rv = param.get_help_record(ctx)
-            if rv is not None:
-                opts.append(rv)
-
-        if opts:
-            with formatter.section('Options'):
-                formatter.write_dl(opts)
-
-    def format_epilog(self, ctx, formatter):
-        """Writes the epilog into the formatter if it exists."""
-        if self.epilog:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                formatter.write_text(self.epilog)
-
-    def parse_args(self, ctx, args):
-        parser = self.make_parser(ctx)
-        opts, args, param_order = parser.parse_args(args=args)
-
-        for param in iter_params_for_processing(
-                param_order, self.get_params(ctx)):
-            value, args = param.handle_parse_result(ctx, opts, args)
-
-        if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
-            ctx.fail('Got unexpected extra argument%s (%s)'
-                     % (len(args) != 1 and 's' or '',
-                        ' '.join(map(make_str, args))))
-
-        ctx.args = args
-        return args
-
-    def invoke(self, ctx):
-        """Given a context, this invokes the attached callback (if it exists)
-        in the right way.
-        """
-        _maybe_show_deprecated_notice(self)
-        if self.callback is not None:
-            return ctx.invoke(self.callback, **ctx.params)
-
-
-class MultiCommand(Command):
-    """A multi command is the basic implementation of a command that
-    dispatches to subcommands.  The most common version is the
-    :class:`Group`.
-
-    :param invoke_without_command: this controls how the multi command itself
-                                   is invoked.  By default it's only invoked
-                                   if a subcommand is provided.
-    :param no_args_is_help: this controls what happens if no arguments are
-                            provided.  This option is enabled by default if
-                            `invoke_without_command` is disabled or disabled
-                            if it's enabled.  If enabled this will add
-                            ``--help`` as argument if no arguments are
-                            passed.
-    :param subcommand_metavar: the string that is used in the documentation
-                               to indicate the subcommand place.
-    :param chain: if this is set to `True` chaining of multiple subcommands
-                  is enabled.  This restricts the form of commands in that
-                  they cannot have optional arguments but it allows
-                  multiple commands to be chained together.
-    :param result_callback: the result callback to attach to this multi
-                            command.
-    """
-    allow_extra_args = True
-    allow_interspersed_args = False
-
-    def __init__(self, name=None, invoke_without_command=False,
-                 no_args_is_help=None, subcommand_metavar=None,
-                 chain=False, result_callback=None, **attrs):
-        Command.__init__(self, name, **attrs)
-        if no_args_is_help is None:
-            no_args_is_help = not invoke_without_command
-        self.no_args_is_help = no_args_is_help
-        self.invoke_without_command = invoke_without_command
-        if subcommand_metavar is None:
-            if chain:
-                subcommand_metavar = SUBCOMMANDS_METAVAR
-            else:
-                subcommand_metavar = SUBCOMMAND_METAVAR
-        self.subcommand_metavar = subcommand_metavar
-        self.chain = chain
-        #: The result callback that is stored.  This can be set or
-        #: overridden with the :func:`resultcallback` decorator.
-        self.result_callback = result_callback
-
-        if self.chain:
-            for param in self.params:
-                if isinstance(param, Argument) and not param.required:
-                    raise RuntimeError('Multi commands in chain mode cannot '
-                                       'have optional arguments.')
-
-    def collect_usage_pieces(self, ctx):
-        rv = Command.collect_usage_pieces(self, ctx)
-        rv.append(self.subcommand_metavar)
-        return rv
-
-    def format_options(self, ctx, formatter):
-        Command.format_options(self, ctx, formatter)
-        self.format_commands(ctx, formatter)
-
-    def resultcallback(self, replace=False):
-        """Adds a result callback to the chain command.  By default if a
-        result callback is already registered this will chain them but
-        this can be disabled with the `replace` parameter.  The result
-        callback is invoked with the return value of the subcommand
-        (or the list of return values from all subcommands if chaining
-        is enabled) as well as the parameters as they would be passed
-        to the main callback.
-
-        Example::
-
-            @click.group()
-            @click.option('-i', '--input', default=23)
-            def cli(input):
-                return 42
-
-            @cli.resultcallback()
-            def process_result(result, input):
-                return result + input
-
-        .. versionadded:: 3.0
-
-        :param replace: if set to `True` an already existing result
-                        callback will be removed.
-        """
-        def decorator(f):
-            old_callback = self.result_callback
-            if old_callback is None or replace:
-                self.result_callback = f
-                return f
-            def function(__value, *args, **kwargs):
-                return f(old_callback(__value, *args, **kwargs),
-                         *args, **kwargs)
-            self.result_callback = rv = update_wrapper(function, f)
-            return rv
-        return decorator
-
-    def format_commands(self, ctx, formatter):
-        """Extra format methods for multi methods that adds all the commands
-        after the options.
-        """
-        commands = []
-        for subcommand in self.list_commands(ctx):
-            cmd = self.get_command(ctx, subcommand)
-            # What is this, the tool lied about a command.  Ignore it
-            if cmd is None:
-                continue
-            if cmd.hidden:
-                continue
-
-            commands.append((subcommand, cmd))
-
-        # allow for 3 times the default spacing
-        if len(commands):
-            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
-
-            rows = []
-            for subcommand, cmd in commands:
-                help = cmd.get_short_help_str(limit)
-                rows.append((subcommand, help))
-
-            if rows:
-                with formatter.section('Commands'):
-                    formatter.write_dl(rows)
-
-    def parse_args(self, ctx, args):
-        if not args and self.no_args_is_help and not ctx.resilient_parsing:
-            echo(ctx.get_help(), color=ctx.color)
-            ctx.exit()
-
-        rest = Command.parse_args(self, ctx, args)
-        if self.chain:
-            ctx.protected_args = rest
-            ctx.args = []
-        elif rest:
-            ctx.protected_args, ctx.args = rest[:1], rest[1:]
-
-        return ctx.args
-
-    def invoke(self, ctx):
-        def _process_result(value):
-            if self.result_callback is not None:
-                value = ctx.invoke(self.result_callback, value,
-                                   **ctx.params)
-            return value
-
-        if not ctx.protected_args:
-            # If we are invoked without command the chain flag controls
-            # how this happens.  If we are not in chain mode, the return
-            # value here is the return value of the command.
-            # If however we are in chain mode, the return value is the
-            # return value of the result processor invoked with an empty
-            # list (which means that no subcommand actually was executed).
-            if self.invoke_without_command:
-                if not self.chain:
-                    return Command.invoke(self, ctx)
-                with ctx:
-                    Command.invoke(self, ctx)
-                    return _process_result([])
-            ctx.fail('Missing command.')
-
-        # Fetch args back out
-        args = ctx.protected_args + ctx.args
-        ctx.args = []
-        ctx.protected_args = []
-
-        # If we're not in chain mode, we only allow the invocation of a
-        # single command but we also inform the current context about the
-        # name of the command to invoke.
-        if not self.chain:
-            # Make sure the context is entered so we do not clean up
-            # resources until the result processor has worked.
-            with ctx:
-                cmd_name, cmd, args = self.resolve_command(ctx, args)
-                ctx.invoked_subcommand = cmd_name
-                Command.invoke(self, ctx)
-                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
-                with sub_ctx:
-                    return _process_result(sub_ctx.command.invoke(sub_ctx))
-
-        # In chain mode we create the contexts step by step, but after the
-        # base command has been invoked.  Because at that point we do not
-        # know the subcommands yet, the invoked subcommand attribute is
-        # set to ``*`` to inform the command that subcommands are executed
-        # but nothing else.
-        with ctx:
-            ctx.invoked_subcommand = args and '*' or None
-            Command.invoke(self, ctx)
-
-            # Otherwise we make every single context and invoke them in a
-            # chain.  In that case the return value to the result processor
-            # is the list of all invoked subcommand's results.
-            contexts = []
-            while args:
-                cmd_name, cmd, args = self.resolve_command(ctx, args)
-                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
-                                           allow_extra_args=True,
-                                           allow_interspersed_args=False)
-                contexts.append(sub_ctx)
-                args, sub_ctx.args = sub_ctx.args, []
-
-            rv = []
-            for sub_ctx in contexts:
-                with sub_ctx:
-                    rv.append(sub_ctx.command.invoke(sub_ctx))
-            return _process_result(rv)
-
-    def resolve_command(self, ctx, args):
-        cmd_name = make_str(args[0])
-        original_cmd_name = cmd_name
-
-        # Get the command
-        cmd = self.get_command(ctx, cmd_name)
-
-        # If we can't find the command but there is a normalization
-        # function available, we try with that one.
-        if cmd is None and ctx.token_normalize_func is not None:
-            cmd_name = ctx.token_normalize_func(cmd_name)
-            cmd = self.get_command(ctx, cmd_name)
-
-        # If we don't find the command we want to show an error message
-        # to the user that it was not provided.  However, there is
-        # something else we should do: if the first argument looks like
-        # an option we want to kick off parsing again for arguments to
-        # resolve things like --help which now should go to the main
-        # place.
-        if cmd is None and not ctx.resilient_parsing:
-            if split_opt(cmd_name)[0]:
-                self.parse_args(ctx, ctx.args)
-            ctx.fail('No such command "%s".' % original_cmd_name)
-
-        return cmd_name, cmd, args[1:]
-
-    def get_command(self, ctx, cmd_name):
-        """Given a context and a command name, this returns a
-        :class:`Command` object if it exists or returns `None`.
-        """
-        raise NotImplementedError()
-
-    def list_commands(self, ctx):
-        """Returns a list of subcommand names in the order they should
-        appear.
-        """
-        return []
-
-
-class Group(MultiCommand):
-    """A group allows a command to have subcommands attached.  This is the
-    most common way to implement nesting in Click.
-
-    :param commands: a dictionary of commands.
-    """
-
-    def __init__(self, name=None, commands=None, **attrs):
-        MultiCommand.__init__(self, name, **attrs)
-        #: the registered subcommands by their exported names.
-        self.commands = commands or {}
-
-    def add_command(self, cmd, name=None):
-        """Registers another :class:`Command` with this group.  If the name
-        is not provided, the name of the command is used.
-        """
-        name = name or cmd.name
-        if name is None:
-            raise TypeError('Command has no name.')
-        _check_multicommand(self, name, cmd, register=True)
-        self.commands[name] = cmd
-
-    def command(self, *args, **kwargs):
-        """A shortcut decorator for declaring and attaching a command to
-        the group.  This takes the same arguments as :func:`command` but
-        immediately registers the created command with this instance by
-        calling into :meth:`add_command`.
-        """
-        def decorator(f):
-            cmd = command(*args, **kwargs)(f)
-            self.add_command(cmd)
-            return cmd
-        return decorator
-
-    def group(self, *args, **kwargs):
-        """A shortcut decorator for declaring and attaching a group to
-        the group.  This takes the same arguments as :func:`group` but
-        immediately registers the created command with this instance by
-        calling into :meth:`add_command`.
-        """
-        def decorator(f):
-            cmd = group(*args, **kwargs)(f)
-            self.add_command(cmd)
-            return cmd
-        return decorator
-
-    def get_command(self, ctx, cmd_name):
-        return self.commands.get(cmd_name)
-
-    def list_commands(self, ctx):
-        return sorted(self.commands)
-
-
-class CommandCollection(MultiCommand):
-    """A command collection is a multi command that merges multiple multi
-    commands together into one.  This is a straightforward implementation
-    that accepts a list of different multi commands as sources and
-    provides all the commands for each of them.
-    """
-
-    def __init__(self, name=None, sources=None, **attrs):
-        MultiCommand.__init__(self, name, **attrs)
-        #: The list of registered multi commands.
-        self.sources = sources or []
-
-    def add_source(self, multi_cmd):
-        """Adds a new multi command to the chain dispatcher."""
-        self.sources.append(multi_cmd)
-
-    def get_command(self, ctx, cmd_name):
-        for source in self.sources:
-            rv = source.get_command(ctx, cmd_name)
-            if rv is not None:
-                if self.chain:
-                    _check_multicommand(self, cmd_name, rv)
-                return rv
-
-    def list_commands(self, ctx):
-        rv = set()
-        for source in self.sources:
-            rv.update(source.list_commands(ctx))
-        return sorted(rv)
-
-
-class Parameter(object):
-    r"""A parameter to a command comes in two versions: they are either
-    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
-    not supported by design as some of the internals for parsing are
-    intentionally not finalized.
-
-    Some settings are supported by both options and arguments.
-
-    .. versionchanged:: 2.0
-       Changed signature for parameter callback to also be passed the
-       parameter.  In Click 2.0, the old callback format will still work,
-       but it will raise a warning to give you change to migrate the
-       code easier.
-
-    :param param_decls: the parameter declarations for this option or
-                        argument.  This is a list of flags or argument
-                        names.
-    :param type: the type that should be used.  Either a :class:`ParamType`
-                 or a Python type.  The later is converted into the former
-                 automatically if supported.
-    :param required: controls if this is optional or not.
-    :param default: the default value if omitted.  This can also be a callable,
-                    in which case it's invoked when the default is needed
-                    without any arguments.
-    :param callback: a callback that should be executed after the parameter
-                     was matched.  This is called as ``fn(ctx, param,
-                     value)`` and needs to return the value.  Before Click
-                     2.0, the signature was ``(ctx, value)``.
-    :param nargs: the number of arguments to match.  If not ``1`` the return
-                  value is a tuple instead of single value.  The default for
-                  nargs is ``1`` (except if the type is a tuple, then it's
-                  the arity of the tuple).
-    :param metavar: how the value is represented in the help page.
-    :param expose_value: if this is `True` then the value is passed onwards
-                         to the command callback and stored on the context,
-                         otherwise it's skipped.
-    :param is_eager: eager values are processed before non eager ones.  This
-                     should not be set for arguments or it will inverse the
-                     order of processing.
-    :param envvar: a string or list of strings that are environment variables
-                   that should be checked.
-    """
-    param_type_name = 'parameter'
-
-    def __init__(self, param_decls=None, type=None, required=False,
-                 default=None, callback=None, nargs=None, metavar=None,
-                 expose_value=True, is_eager=False, envvar=None,
-                 autocompletion=None):
-        self.name, self.opts, self.secondary_opts = \
-            self._parse_decls(param_decls or (), expose_value)
-
-        self.type = convert_type(type, default)
-
-        # Default nargs to what the type tells us if we have that
-        # information available.
-        if nargs is None:
-            if self.type.is_composite:
-                nargs = self.type.arity
-            else:
-                nargs = 1
-
-        self.required = required
-        self.callback = callback
-        self.nargs = nargs
-        self.multiple = False
-        self.expose_value = expose_value
-        self.default = default
-        self.is_eager = is_eager
-        self.metavar = metavar
-        self.envvar = envvar
-        self.autocompletion = autocompletion
-
-    @property
-    def human_readable_name(self):
-        """Returns the human readable name of this parameter.  This is the
-        same as the name for options, but the metavar for arguments.
-        """
-        return self.name
-
-    def make_metavar(self):
-        if self.metavar is not None:
-            return self.metavar
-        metavar = self.type.get_metavar(self)
-        if metavar is None:
-            metavar = self.type.name.upper()
-        if self.nargs != 1:
-            metavar += '...'
-        return metavar
-
-    def get_default(self, ctx):
-        """Given a context variable this calculates the default value."""
-        # Otherwise go with the regular default.
-        if callable(self.default):
-            rv = self.default()
-        else:
-            rv = self.default
-        return self.type_cast_value(ctx, rv)
-
-    def add_to_parser(self, parser, ctx):
-        pass
-
-    def consume_value(self, ctx, opts):
-        value = opts.get(self.name)
-        if value is None:
-            value = self.value_from_envvar(ctx)
-        if value is None:
-            value = ctx.lookup_default(self.name)
-        return value
-
-    def type_cast_value(self, ctx, value):
-        """Given a value this runs it properly through the type system.
-        This automatically handles things like `nargs` and `multiple` as
-        well as composite types.
-        """
-        if self.type.is_composite:
-            if self.nargs <= 1:
-                raise TypeError('Attempted to invoke composite type '
-                                'but nargs has been set to %s.  This is '
-                                'not supported; nargs needs to be set to '
-                                'a fixed value > 1.' % self.nargs)
-            if self.multiple:
-                return tuple(self.type(x or (), self, ctx) for x in value or ())
-            return self.type(value or (), self, ctx)
-
-        def _convert(value, level):
-            if level == 0:
-                return self.type(value, self, ctx)
-            return tuple(_convert(x, level - 1) for x in value or ())
-        return _convert(value, (self.nargs != 1) + bool(self.multiple))
-
-    def process_value(self, ctx, value):
-        """Given a value and context this runs the logic to convert the
-        value as necessary.
-        """
-        # If the value we were given is None we do nothing.  This way
-        # code that calls this can easily figure out if something was
-        # not provided.  Otherwise it would be converted into an empty
-        # tuple for multiple invocations which is inconvenient.
-        if value is not None:
-            return self.type_cast_value(ctx, value)
-
-    def value_is_missing(self, value):
-        if value is None:
-            return True
-        if (self.nargs != 1 or self.multiple) and value == ():
-            return True
-        return False
-
-    def full_process_value(self, ctx, value):
-        value = self.process_value(ctx, value)
-
-        if value is None and not ctx.resilient_parsing:
-            value = self.get_default(ctx)
-
-        if self.required and self.value_is_missing(value):
-            raise MissingParameter(ctx=ctx, param=self)
-
-        return value
-
-    def resolve_envvar_value(self, ctx):
-        if self.envvar is None:
-            return
-        if isinstance(self.envvar, (tuple, list)):
-            for envvar in self.envvar:
-                rv = os.environ.get(envvar)
-                if rv is not None:
-                    return rv
-        else:
-            return os.environ.get(self.envvar)
-
-    def value_from_envvar(self, ctx):
-        rv = self.resolve_envvar_value(ctx)
-        if rv is not None and self.nargs != 1:
-            rv = self.type.split_envvar_value(rv)
-        return rv
-
-    def handle_parse_result(self, ctx, opts, args):
-        with augment_usage_errors(ctx, param=self):
-            value = self.consume_value(ctx, opts)
-            try:
-                value = self.full_process_value(ctx, value)
-            except Exception:
-                if not ctx.resilient_parsing:
-                    raise
-                value = None
-            if self.callback is not None:
-                try:
-                    value = invoke_param_callback(
-                        self.callback, ctx, self, value)
-                except Exception:
-                    if not ctx.resilient_parsing:
-                        raise
-
-        if self.expose_value:
-            ctx.params[self.name] = value
-        return value, args
-
-    def get_help_record(self, ctx):
-        pass
-
-    def get_usage_pieces(self, ctx):
-        return []
-
-    def get_error_hint(self, ctx):
-        """Get a stringified version of the param for use in error messages to
-        indicate which param caused the error.
-        """
-        hint_list = self.opts or [self.human_readable_name]
-        return ' / '.join('"%s"' % x for x in hint_list)
-
-
-class Option(Parameter):
-    """Options are usually optional values on the command line and
-    have some extra features that arguments don't have.
-
-    All other parameters are passed onwards to the parameter constructor.
-
-    :param show_default: controls if the default value should be shown on the
-                         help page. Normally, defaults are not shown. If this
-                         value is a string, it shows the string instead of the
-                         value. This is particularly useful for dynamic options.
-    :param show_envvar: controls if an environment variable should be shown on
-                        the help page.  Normally, environment variables
-                        are not shown.
-    :param prompt: if set to `True` or a non empty string then the user will be
-                   prompted for input.  If set to `True` the prompt will be the
-                   option name capitalized.
-    :param confirmation_prompt: if set then the value will need to be confirmed
-                                if it was prompted for.
-    :param hide_input: if this is `True` then the input on the prompt will be
-                       hidden from the user.  This is useful for password
-                       input.
-    :param is_flag: forces this option to act as a flag.  The default is
-                    auto detection.
-    :param flag_value: which value should be used for this flag if it's
-                       enabled.  This is set to a boolean automatically if
-                       the option string contains a slash to mark two options.
-    :param multiple: if this is set to `True` then the argument is accepted
-                     multiple times and recorded.  This is similar to ``nargs``
-                     in how it works but supports arbitrary number of
-                     arguments.
-    :param count: this flag makes an option increment an integer.
-    :param allow_from_autoenv: if this is enabled then the value of this
-                               parameter will be pulled from an environment
-                               variable in case a prefix is defined on the
-                               context.
-    :param help: the help string.
-    :param hidden: hide this option from help outputs.
-    """
-    param_type_name = 'option'
-
-    def __init__(self, param_decls=None, show_default=False,
-                 prompt=False, confirmation_prompt=False,
-                 hide_input=False, is_flag=None, flag_value=None,
-                 multiple=False, count=False, allow_from_autoenv=True,
-                 type=None, help=None, hidden=False, show_choices=True,
-                 show_envvar=False, **attrs):
-        default_is_missing = attrs.get('default', _missing) is _missing
-        Parameter.__init__(self, param_decls, type=type, **attrs)
-
-        if prompt is True:
-            prompt_text = self.name.replace('_', ' ').capitalize()
-        elif prompt is False:
-            prompt_text = None
-        else:
-            prompt_text = prompt
-        self.prompt = prompt_text
-        self.confirmation_prompt = confirmation_prompt
-        self.hide_input = hide_input
-        self.hidden = hidden
-
-        # Flags
-        if is_flag is None:
-            if flag_value is not None:
-                is_flag = True
-            else:
-                is_flag = bool(self.secondary_opts)
-        if is_flag and default_is_missing:
-            self.default = False
-        if flag_value is None:
-            flag_value = not self.default
-        self.is_flag = is_flag
-        self.flag_value = flag_value
-        if self.is_flag and isinstance(self.flag_value, bool) \
-           and type is None:
-            self.type = BOOL
-            self.is_bool_flag = True
-        else:
-            self.is_bool_flag = False
-
-        # Counting
-        self.count = count
-        if count:
-            if type is None:
-                self.type = IntRange(min=0)
-            if default_is_missing:
-                self.default = 0
-
-        self.multiple = multiple
-        self.allow_from_autoenv = allow_from_autoenv
-        self.help = help
-        self.show_default = show_default
-        self.show_choices = show_choices
-        self.show_envvar = show_envvar
-
-        # Sanity check for stuff we don't support
-        if __debug__:
-            if self.nargs < 0:
-                raise TypeError('Options cannot have nargs < 0')
-            if self.prompt and self.is_flag and not self.is_bool_flag:
-                raise TypeError('Cannot prompt for flags that are not bools.')
-            if not self.is_bool_flag and self.secondary_opts:
-                raise TypeError('Got secondary option for non boolean flag.')
-            if self.is_bool_flag and self.hide_input \
-               and self.prompt is not None:
-                raise TypeError('Hidden input does not work with boolean '
-                                'flag prompts.')
-            if self.count:
-                if self.multiple:
-                    raise TypeError('Options cannot be multiple and count '
-                                    'at the same time.')
-                elif self.is_flag:
-                    raise TypeError('Options cannot be count and flags at '
-                                    'the same time.')
-
-    def _parse_decls(self, decls, expose_value):
-        opts = []
-        secondary_opts = []
-        name = None
-        possible_names = []
-
-        for decl in decls:
-            if isidentifier(decl):
-                if name is not None:
-                    raise TypeError('Name defined twice')
-                name = decl
-            else:
-                split_char = decl[:1] == '/' and ';' or '/'
-                if split_char in decl:
-                    first, second = decl.split(split_char, 1)
-                    first = first.rstrip()
-                    if first:
-                        possible_names.append(split_opt(first))
-                        opts.append(first)
-                    second = second.lstrip()
-                    if second:
-                        secondary_opts.append(second.lstrip())
-                else:
-                    possible_names.append(split_opt(decl))
-                    opts.append(decl)
-
-        if name is None and possible_names:
-            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
-            name = possible_names[0][1].replace('-', '_').lower()
-            if not isidentifier(name):
-                name = None
-
-        if name is None:
-            if not expose_value:
-                return None, opts, secondary_opts
-            raise TypeError('Could not determine name for option')
-
-        if not opts and not secondary_opts:
-            raise TypeError('No options defined but a name was passed (%s). '
-                            'Did you mean to declare an argument instead '
-                            'of an option?' % name)
-
-        return name, opts, secondary_opts
-
-    def add_to_parser(self, parser, ctx):
-        kwargs = {
-            'dest': self.name,
-            'nargs': self.nargs,
-            'obj': self,
-        }
-
-        if self.multiple:
-            action = 'append'
-        elif self.count:
-            action = 'count'
-        else:
-            action = 'store'
-
-        if self.is_flag:
-            kwargs.pop('nargs', None)
-            if self.is_bool_flag and self.secondary_opts:
-                parser.add_option(self.opts, action=action + '_const',
-                                  const=True, **kwargs)
-                parser.add_option(self.secondary_opts, action=action +
-                                  '_const', const=False, **kwargs)
-            else:
-                parser.add_option(self.opts, action=action + '_const',
-                                  const=self.flag_value,
-                                  **kwargs)
-        else:
-            kwargs['action'] = action
-            parser.add_option(self.opts, **kwargs)
-
-    def get_help_record(self, ctx):
-        if self.hidden:
-            return
-        any_prefix_is_slash = []
-
-        def _write_opts(opts):
-            rv, any_slashes = join_options(opts)
-            if any_slashes:
-                any_prefix_is_slash[:] = [True]
-            if not self.is_flag and not self.count:
-                rv += ' ' + self.make_metavar()
-            return rv
-
-        rv = [_write_opts(self.opts)]
-        if self.secondary_opts:
-            rv.append(_write_opts(self.secondary_opts))
-
-        help = self.help or ''
-        extra = []
-        if self.show_envvar:
-            envvar = self.envvar
-            if envvar is None:
-                if self.allow_from_autoenv and \
-                    ctx.auto_envvar_prefix is not None:
-                    envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
-            if envvar is not None:
-              extra.append('env var: %s' % (
-                           ', '.join('%s' % d for d in envvar)
-                           if isinstance(envvar, (list, tuple))
-                           else envvar, ))
-        if self.default is not None and self.show_default:
-            if isinstance(self.show_default, string_types):
-                default_string = '({})'.format(self.show_default)
-            elif isinstance(self.default, (list, tuple)):
-                default_string = ', '.join('%s' % d for d in self.default)
-            elif inspect.isfunction(self.default):
-                default_string = "(dynamic)"
-            else:
-                default_string = self.default
-            extra.append('default: {}'.format(default_string))
-
-        if self.required:
-            extra.append('required')
-        if extra:
-            help = '%s[%s]' % (help and help + '  ' or '', '; '.join(extra))
-
-        return ((any_prefix_is_slash and '; ' or ' / ').join(rv), help)
-
-    def get_default(self, ctx):
-        # If we're a non boolean flag out default is more complex because
-        # we need to look at all flags in the same group to figure out
-        # if we're the the default one in which case we return the flag
-        # value as default.
-        if self.is_flag and not self.is_bool_flag:
-            for param in ctx.command.params:
-                if param.name == self.name and param.default:
-                    return param.flag_value
-            return None
-        return Parameter.get_default(self, ctx)
-
-    def prompt_for_value(self, ctx):
-        """This is an alternative flow that can be activated in the full
-        value processing if a value does not exist.  It will prompt the
-        user until a valid value exists and then returns the processed
-        value as result.
-        """
-        # Calculate the default before prompting anything to be stable.
-        default = self.get_default(ctx)
-
-        # If this is a prompt for a flag we need to handle this
-        # differently.
-        if self.is_bool_flag:
-            return confirm(self.prompt, default)
-
-        return prompt(self.prompt, default=default, type=self.type,
-                      hide_input=self.hide_input, show_choices=self.show_choices,
-                      confirmation_prompt=self.confirmation_prompt,
-                      value_proc=lambda x: self.process_value(ctx, x))
-
-    def resolve_envvar_value(self, ctx):
-        rv = Parameter.resolve_envvar_value(self, ctx)
-        if rv is not None:
-            return rv
-        if self.allow_from_autoenv and \
-           ctx.auto_envvar_prefix is not None:
-            envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
-            return os.environ.get(envvar)
-
-    def value_from_envvar(self, ctx):
-        rv = self.resolve_envvar_value(ctx)
-        if rv is None:
-            return None
-        value_depth = (self.nargs != 1) + bool(self.multiple)
-        if value_depth > 0 and rv is not None:
-            rv = self.type.split_envvar_value(rv)
-            if self.multiple and self.nargs != 1:
-                rv = batch(rv, self.nargs)
-        return rv
-
-    def full_process_value(self, ctx, value):
-        if value is None and self.prompt is not None \
-           and not ctx.resilient_parsing:
-            return self.prompt_for_value(ctx)
-        return Parameter.full_process_value(self, ctx, value)
-
-
-class Argument(Parameter):
-    """Arguments are positional parameters to a command.  They generally
-    provide fewer features than options but can have infinite ``nargs``
-    and are required by default.
-
-    All parameters are passed onwards to the parameter constructor.
-    """
-    param_type_name = 'argument'
-
-    def __init__(self, param_decls, required=None, **attrs):
-        if required is None:
-            if attrs.get('default') is not None:
-                required = False
-            else:
-                required = attrs.get('nargs', 1) > 0
-        Parameter.__init__(self, param_decls, required=required, **attrs)
-        if self.default is not None and self.nargs < 0:
-            raise TypeError('nargs=-1 in combination with a default value '
-                            'is not supported.')
-
-    @property
-    def human_readable_name(self):
-        if self.metavar is not None:
-            return self.metavar
-        return self.name.upper()
-
-    def make_metavar(self):
-        if self.metavar is not None:
-            return self.metavar
-        var = self.type.get_metavar(self)
-        if not var:
-            var = self.name.upper()
-        if not self.required:
-            var = '[%s]' % var
-        if self.nargs != 1:
-            var += '...'
-        return var
-
-    def _parse_decls(self, decls, expose_value):
-        if not decls:
-            if not expose_value:
-                return None, [], []
-            raise TypeError('Could not determine name for argument')
-        if len(decls) == 1:
-            name = arg = decls[0]
-            name = name.replace('-', '_').lower()
-        else:
-            raise TypeError('Arguments take exactly one '
-                            'parameter declaration, got %d' % len(decls))
-        return name, [arg], []
-
-    def get_usage_pieces(self, ctx):
-        return [self.make_metavar()]
-
-    def get_error_hint(self, ctx):
-        return '"%s"' % self.make_metavar()
-
-    def add_to_parser(self, parser, ctx):
-        parser.add_argument(dest=self.name, nargs=self.nargs,
-                            obj=self)
-
-
-# Circular dependency between decorators and core
-from .decorators import command, group
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/decorators.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/decorators.py
deleted file mode 100644
index c57c53086..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/decorators.py
+++ /dev/null
@@ -1,311 +0,0 @@
-import sys
-import inspect
-
-from functools import update_wrapper
-
-from ._compat import iteritems
-from ._unicodefun import _check_for_unicode_literals
-from .utils import echo
-from .globals import get_current_context
-
-
-def pass_context(f):
-    """Marks a callback as wanting to receive the current context
-    object as first argument.
-    """
-    def new_func(*args, **kwargs):
-        return f(get_current_context(), *args, **kwargs)
-    return update_wrapper(new_func, f)
-
-
-def pass_obj(f):
-    """Similar to :func:`pass_context`, but only pass the object on the
-    context onwards (:attr:`Context.obj`).  This is useful if that object
-    represents the state of a nested system.
-    """
-    def new_func(*args, **kwargs):
-        return f(get_current_context().obj, *args, **kwargs)
-    return update_wrapper(new_func, f)
-
-
-def make_pass_decorator(object_type, ensure=False):
-    """Given an object type this creates a decorator that will work
-    similar to :func:`pass_obj` but instead of passing the object of the
-    current context, it will find the innermost context of type
-    :func:`object_type`.
-
-    This generates a decorator that works roughly like this::
-
-        from functools import update_wrapper
-
-        def decorator(f):
-            @pass_context
-            def new_func(ctx, *args, **kwargs):
-                obj = ctx.find_object(object_type)
-                return ctx.invoke(f, obj, *args, **kwargs)
-            return update_wrapper(new_func, f)
-        return decorator
-
-    :param object_type: the type of the object to pass.
-    :param ensure: if set to `True`, a new object will be created and
-                   remembered on the context if it's not there yet.
-    """
-    def decorator(f):
-        def new_func(*args, **kwargs):
-            ctx = get_current_context()
-            if ensure:
-                obj = ctx.ensure_object(object_type)
-            else:
-                obj = ctx.find_object(object_type)
-            if obj is None:
-                raise RuntimeError('Managed to invoke callback without a '
-                                   'context object of type %r existing'
-                                   % object_type.__name__)
-            return ctx.invoke(f, obj, *args, **kwargs)
-        return update_wrapper(new_func, f)
-    return decorator
-
-
-def _make_command(f, name, attrs, cls):
-    if isinstance(f, Command):
-        raise TypeError('Attempted to convert a callback into a '
-                        'command twice.')
-    try:
-        params = f.__click_params__
-        params.reverse()
-        del f.__click_params__
-    except AttributeError:
-        params = []
-    help = attrs.get('help')
-    if help is None:
-        help = inspect.getdoc(f)
-        if isinstance(help, bytes):
-            help = help.decode('utf-8')
-    else:
-        help = inspect.cleandoc(help)
-    attrs['help'] = help
-    _check_for_unicode_literals()
-    return cls(name=name or f.__name__.lower().replace('_', '-'),
-               callback=f, params=params, **attrs)
-
-
-def command(name=None, cls=None, **attrs):
-    r"""Creates a new :class:`Command` and uses the decorated function as
-    callback.  This will also automatically attach all decorated
-    :func:`option`\s and :func:`argument`\s as parameters to the command.
-
-    The name of the command defaults to the name of the function.  If you
-    want to change that, you can pass the intended name as the first
-    argument.
-
-    All keyword arguments are forwarded to the underlying command class.
-
-    Once decorated the function turns into a :class:`Command` instance
-    that can be invoked as a command line utility or be attached to a
-    command :class:`Group`.
-
-    :param name: the name of the command.  This defaults to the function
-                 name with underscores replaced by dashes.
-    :param cls: the command class to instantiate.  This defaults to
-                :class:`Command`.
-    """
-    if cls is None:
-        cls = Command
-    def decorator(f):
-        cmd = _make_command(f, name, attrs, cls)
-        cmd.__doc__ = f.__doc__
-        return cmd
-    return decorator
-
-
-def group(name=None, **attrs):
-    """Creates a new :class:`Group` with a function as callback.  This
-    works otherwise the same as :func:`command` just that the `cls`
-    parameter is set to :class:`Group`.
-    """
-    attrs.setdefault('cls', Group)
-    return command(name, **attrs)
-
-
-def _param_memo(f, param):
-    if isinstance(f, Command):
-        f.params.append(param)
-    else:
-        if not hasattr(f, '__click_params__'):
-            f.__click_params__ = []
-        f.__click_params__.append(param)
-
-
-def argument(*param_decls, **attrs):
-    """Attaches an argument to the command.  All positional arguments are
-    passed as parameter declarations to :class:`Argument`; all keyword
-    arguments are forwarded unchanged (except ``cls``).
-    This is equivalent to creating an :class:`Argument` instance manually
-    and attaching it to the :attr:`Command.params` list.
-
-    :param cls: the argument class to instantiate.  This defaults to
-                :class:`Argument`.
-    """
-    def decorator(f):
-        ArgumentClass = attrs.pop('cls', Argument)
-        _param_memo(f, ArgumentClass(param_decls, **attrs))
-        return f
-    return decorator
-
-
-def option(*param_decls, **attrs):
-    """Attaches an option to the command.  All positional arguments are
-    passed as parameter declarations to :class:`Option`; all keyword
-    arguments are forwarded unchanged (except ``cls``).
-    This is equivalent to creating an :class:`Option` instance manually
-    and attaching it to the :attr:`Command.params` list.
-
-    :param cls: the option class to instantiate.  This defaults to
-                :class:`Option`.
-    """
-    def decorator(f):
-        # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
-        option_attrs = attrs.copy()
-
-        if 'help' in option_attrs:
-            option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
-        OptionClass = option_attrs.pop('cls', Option)
-        _param_memo(f, OptionClass(param_decls, **option_attrs))
-        return f
-    return decorator
-
-
-def confirmation_option(*param_decls, **attrs):
-    """Shortcut for confirmation prompts that can be ignored by passing
-    ``--yes`` as parameter.
-
-    This is equivalent to decorating a function with :func:`option` with
-    the following parameters::
-
-        def callback(ctx, param, value):
-            if not value:
-                ctx.abort()
-
-        @click.command()
-        @click.option('--yes', is_flag=True, callback=callback,
-                      expose_value=False, prompt='Do you want to continue?')
-        def dropdb():
-            pass
-    """
-    def decorator(f):
-        def callback(ctx, param, value):
-            if not value:
-                ctx.abort()
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('callback', callback)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('prompt', 'Do you want to continue?')
-        attrs.setdefault('help', 'Confirm the action without prompting.')
-        return option(*(param_decls or ('--yes',)), **attrs)(f)
-    return decorator
-
-
-def password_option(*param_decls, **attrs):
-    """Shortcut for password prompts.
-
-    This is equivalent to decorating a function with :func:`option` with
-    the following parameters::
-
-        @click.command()
-        @click.option('--password', prompt=True, confirmation_prompt=True,
-                      hide_input=True)
-        def changeadmin(password):
-            pass
-    """
-    def decorator(f):
-        attrs.setdefault('prompt', True)
-        attrs.setdefault('confirmation_prompt', True)
-        attrs.setdefault('hide_input', True)
-        return option(*(param_decls or ('--password',)), **attrs)(f)
-    return decorator
-
-
-def version_option(version=None, *param_decls, **attrs):
-    """Adds a ``--version`` option which immediately ends the program
-    printing out the version number.  This is implemented as an eager
-    option that prints the version and exits the program in the callback.
-
-    :param version: the version number to show.  If not provided Click
-                    attempts an auto discovery via setuptools.
-    :param prog_name: the name of the program (defaults to autodetection)
-    :param message: custom message to show instead of the default
-                    (``'%(prog)s, version %(version)s'``)
-    :param others: everything else is forwarded to :func:`option`.
-    """
-    if version is None:
-        if hasattr(sys, '_getframe'):
-            module = sys._getframe(1).f_globals.get('__name__')
-        else:
-            module = ''
-
-    def decorator(f):
-        prog_name = attrs.pop('prog_name', None)
-        message = attrs.pop('message', '%(prog)s, version %(version)s')
-
-        def callback(ctx, param, value):
-            if not value or ctx.resilient_parsing:
-                return
-            prog = prog_name
-            if prog is None:
-                prog = ctx.find_root().info_name
-            ver = version
-            if ver is None:
-                try:
-                    import pkg_resources
-                except ImportError:
-                    pass
-                else:
-                    for dist in pkg_resources.working_set:
-                        scripts = dist.get_entry_map().get('console_scripts') or {}
-                        for script_name, entry_point in iteritems(scripts):
-                            if entry_point.module_name == module:
-                                ver = dist.version
-                                break
-                if ver is None:
-                    raise RuntimeError('Could not determine version')
-            echo(message % {
-                'prog': prog,
-                'version': ver,
-            }, color=ctx.color)
-            ctx.exit()
-
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('is_eager', True)
-        attrs.setdefault('help', 'Show the version and exit.')
-        attrs['callback'] = callback
-        return option(*(param_decls or ('--version',)), **attrs)(f)
-    return decorator
-
-
-def help_option(*param_decls, **attrs):
-    """Adds a ``--help`` option which immediately ends the program
-    printing out the help page.  This is usually unnecessary to add as
-    this is added by default to all commands unless suppressed.
-
-    Like :func:`version_option`, this is implemented as eager option that
-    prints in the callback and exits.
-
-    All arguments are forwarded to :func:`option`.
-    """
-    def decorator(f):
-        def callback(ctx, param, value):
-            if value and not ctx.resilient_parsing:
-                echo(ctx.get_help(), color=ctx.color)
-                ctx.exit()
-        attrs.setdefault('is_flag', True)
-        attrs.setdefault('expose_value', False)
-        attrs.setdefault('help', 'Show this message and exit.')
-        attrs.setdefault('is_eager', True)
-        attrs['callback'] = callback
-        return option(*(param_decls or ('--help',)), **attrs)(f)
-    return decorator
-
-
-# Circular dependencies between core and decorators
-from .core import Command, Group, Argument, Option
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/exceptions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/exceptions.py
deleted file mode 100644
index 6fa17658c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/exceptions.py
+++ /dev/null
@@ -1,235 +0,0 @@
-from ._compat import PY2, filename_to_ui, get_text_stderr
-from .utils import echo
-
-
-def _join_param_hints(param_hint):
-    if isinstance(param_hint, (tuple, list)):
-        return ' / '.join('"%s"' % x for x in param_hint)
-    return param_hint
-
-
-class ClickException(Exception):
-    """An exception that Click can handle and show to the user."""
-
-    #: The exit code for this exception
-    exit_code = 1
-
-    def __init__(self, message):
-        ctor_msg = message
-        if PY2:
-            if ctor_msg is not None:
-                ctor_msg = ctor_msg.encode('utf-8')
-        Exception.__init__(self, ctor_msg)
-        self.message = message
-
-    def format_message(self):
-        return self.message
-
-    def __str__(self):
-        return self.message
-
-    if PY2:
-        __unicode__ = __str__
-
-        def __str__(self):
-            return self.message.encode('utf-8')
-
-    def show(self, file=None):
-        if file is None:
-            file = get_text_stderr()
-        echo('Error: %s' % self.format_message(), file=file)
-
-
-class UsageError(ClickException):
-    """An internal exception that signals a usage error.  This typically
-    aborts any further handling.
-
-    :param message: the error message to display.
-    :param ctx: optionally the context that caused this error.  Click will
-                fill in the context automatically in some situations.
-    """
-    exit_code = 2
-
-    def __init__(self, message, ctx=None):
-        ClickException.__init__(self, message)
-        self.ctx = ctx
-        self.cmd = self.ctx and self.ctx.command or None
-
-    def show(self, file=None):
-        if file is None:
-            file = get_text_stderr()
-        color = None
-        hint = ''
-        if (self.cmd is not None and
-                self.cmd.get_help_option(self.ctx) is not None):
-            hint = ('Try "%s %s" for help.\n'
-                    % (self.ctx.command_path, self.ctx.help_option_names[0]))
-        if self.ctx is not None:
-            color = self.ctx.color
-            echo(self.ctx.get_usage() + '\n%s' % hint, file=file, color=color)
-        echo('Error: %s' % self.format_message(), file=file, color=color)
-
-
-class BadParameter(UsageError):
-    """An exception that formats out a standardized error message for a
-    bad parameter.  This is useful when thrown from a callback or type as
-    Click will attach contextual information to it (for instance, which
-    parameter it is).
-
-    .. versionadded:: 2.0
-
-    :param param: the parameter object that caused this error.  This can
-                  be left out, and Click will attach this info itself
-                  if possible.
-    :param param_hint: a string that shows up as parameter name.  This
-                       can be used as alternative to `param` in cases
-                       where custom validation should happen.  If it is
-                       a string it's used as such, if it's a list then
-                       each item is quoted and separated.
-    """
-
-    def __init__(self, message, ctx=None, param=None,
-                 param_hint=None):
-        UsageError.__init__(self, message, ctx)
-        self.param = param
-        self.param_hint = param_hint
-
-    def format_message(self):
-        if self.param_hint is not None:
-            param_hint = self.param_hint
-        elif self.param is not None:
-            param_hint = self.param.get_error_hint(self.ctx)
-        else:
-            return 'Invalid value: %s' % self.message
-        param_hint = _join_param_hints(param_hint)
-
-        return 'Invalid value for %s: %s' % (param_hint, self.message)
-
-
-class MissingParameter(BadParameter):
-    """Raised if click required an option or argument but it was not
-    provided when invoking the script.
-
-    .. versionadded:: 4.0
-
-    :param param_type: a string that indicates the type of the parameter.
-                       The default is to inherit the parameter type from
-                       the given `param`.  Valid values are ``'parameter'``,
-                       ``'option'`` or ``'argument'``.
-    """
-
-    def __init__(self, message=None, ctx=None, param=None,
-                 param_hint=None, param_type=None):
-        BadParameter.__init__(self, message, ctx, param, param_hint)
-        self.param_type = param_type
-
-    def format_message(self):
-        if self.param_hint is not None:
-            param_hint = self.param_hint
-        elif self.param is not None:
-            param_hint = self.param.get_error_hint(self.ctx)
-        else:
-            param_hint = None
-        param_hint = _join_param_hints(param_hint)
-
-        param_type = self.param_type
-        if param_type is None and self.param is not None:
-            param_type = self.param.param_type_name
-
-        msg = self.message
-        if self.param is not None:
-            msg_extra = self.param.type.get_missing_message(self.param)
-            if msg_extra:
-                if msg:
-                    msg += '.  ' + msg_extra
-                else:
-                    msg = msg_extra
-
-        return 'Missing %s%s%s%s' % (
-            param_type,
-            param_hint and ' %s' % param_hint or '',
-            msg and '.  ' or '.',
-            msg or '',
-        )
-
-
-class NoSuchOption(UsageError):
-    """Raised if click attempted to handle an option that does not
-    exist.
-
-    .. versionadded:: 4.0
-    """
-
-    def __init__(self, option_name, message=None, possibilities=None,
-                 ctx=None):
-        if message is None:
-            message = 'no such option: %s' % option_name
-        UsageError.__init__(self, message, ctx)
-        self.option_name = option_name
-        self.possibilities = possibilities
-
-    def format_message(self):
-        bits = [self.message]
-        if self.possibilities:
-            if len(self.possibilities) == 1:
-                bits.append('Did you mean %s?' % self.possibilities[0])
-            else:
-                possibilities = sorted(self.possibilities)
-                bits.append('(Possible options: %s)' % ', '.join(possibilities))
-        return '  '.join(bits)
-
-
-class BadOptionUsage(UsageError):
-    """Raised if an option is generally supplied but the use of the option
-    was incorrect.  This is for instance raised if the number of arguments
-    for an option is not correct.
-
-    .. versionadded:: 4.0
-
-    :param option_name: the name of the option being used incorrectly.
-    """
-
-    def __init__(self, option_name, message, ctx=None):
-        UsageError.__init__(self, message, ctx)
-        self.option_name = option_name
-
-
-class BadArgumentUsage(UsageError):
-    """Raised if an argument is generally supplied but the use of the argument
-    was incorrect.  This is for instance raised if the number of values
-    for an argument is not correct.
-
-    .. versionadded:: 6.0
-    """
-
-    def __init__(self, message, ctx=None):
-        UsageError.__init__(self, message, ctx)
-
-
-class FileError(ClickException):
-    """Raised if a file cannot be opened."""
-
-    def __init__(self, filename, hint=None):
-        ui_filename = filename_to_ui(filename)
-        if hint is None:
-            hint = 'unknown error'
-        ClickException.__init__(self, hint)
-        self.ui_filename = ui_filename
-        self.filename = filename
-
-    def format_message(self):
-        return 'Could not open file %s: %s' % (self.ui_filename, self.message)
-
-
-class Abort(RuntimeError):
-    """An internal signalling exception that signals Click to abort."""
-
-
-class Exit(RuntimeError):
-    """An exception that indicates that the application should exit with some
-    status code.
-
-    :param code: the status code to exit with.
-    """
-    def __init__(self, code=0):
-        self.exit_code = code
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/formatting.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/formatting.py
deleted file mode 100644
index a3d6a4d38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/formatting.py
+++ /dev/null
@@ -1,256 +0,0 @@
-from contextlib import contextmanager
-from .termui import get_terminal_size
-from .parser import split_opt
-from ._compat import term_len
-
-
-# Can force a width.  This is used by the test system
-FORCED_WIDTH = None
-
-
-def measure_table(rows):
-    widths = {}
-    for row in rows:
-        for idx, col in enumerate(row):
-            widths[idx] = max(widths.get(idx, 0), term_len(col))
-    return tuple(y for x, y in sorted(widths.items()))
-
-
-def iter_rows(rows, col_count):
-    for row in rows:
-        row = tuple(row)
-        yield row + ('',) * (col_count - len(row))
-
-
-def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
-              preserve_paragraphs=False):
-    """A helper function that intelligently wraps text.  By default, it
-    assumes that it operates on a single paragraph of text but if the
-    `preserve_paragraphs` parameter is provided it will intelligently
-    handle paragraphs (defined by two empty lines).
-
-    If paragraphs are handled, a paragraph can be prefixed with an empty
-    line containing the ``\\b`` character (``\\x08``) to indicate that
-    no rewrapping should happen in that block.
-
-    :param text: the text that should be rewrapped.
-    :param width: the maximum width for the text.
-    :param initial_indent: the initial indent that should be placed on the
-                           first line as a string.
-    :param subsequent_indent: the indent string that should be placed on
-                              each consecutive line.
-    :param preserve_paragraphs: if this flag is set then the wrapping will
-                                intelligently handle paragraphs.
-    """
-    from ._textwrap import TextWrapper
-    text = text.expandtabs()
-    wrapper = TextWrapper(width, initial_indent=initial_indent,
-                          subsequent_indent=subsequent_indent,
-                          replace_whitespace=False)
-    if not preserve_paragraphs:
-        return wrapper.fill(text)
-
-    p = []
-    buf = []
-    indent = None
-
-    def _flush_par():
-        if not buf:
-            return
-        if buf[0].strip() == '\b':
-            p.append((indent or 0, True, '\n'.join(buf[1:])))
-        else:
-            p.append((indent or 0, False, ' '.join(buf)))
-        del buf[:]
-
-    for line in text.splitlines():
-        if not line:
-            _flush_par()
-            indent = None
-        else:
-            if indent is None:
-                orig_len = term_len(line)
-                line = line.lstrip()
-                indent = orig_len - term_len(line)
-            buf.append(line)
-    _flush_par()
-
-    rv = []
-    for indent, raw, text in p:
-        with wrapper.extra_indent(' ' * indent):
-            if raw:
-                rv.append(wrapper.indent_only(text))
-            else:
-                rv.append(wrapper.fill(text))
-
-    return '\n\n'.join(rv)
-
-
-class HelpFormatter(object):
-    """This class helps with formatting text-based help pages.  It's
-    usually just needed for very special internal cases, but it's also
-    exposed so that developers can write their own fancy outputs.
-
-    At present, it always writes into memory.
-
-    :param indent_increment: the additional increment for each level.
-    :param width: the width for the text.  This defaults to the terminal
-                  width clamped to a maximum of 78.
-    """
-
-    def __init__(self, indent_increment=2, width=None, max_width=None):
-        self.indent_increment = indent_increment
-        if max_width is None:
-            max_width = 80
-        if width is None:
-            width = FORCED_WIDTH
-            if width is None:
-                width = max(min(get_terminal_size()[0], max_width) - 2, 50)
-        self.width = width
-        self.current_indent = 0
-        self.buffer = []
-
-    def write(self, string):
-        """Writes a unicode string into the internal buffer."""
-        self.buffer.append(string)
-
-    def indent(self):
-        """Increases the indentation."""
-        self.current_indent += self.indent_increment
-
-    def dedent(self):
-        """Decreases the indentation."""
-        self.current_indent -= self.indent_increment
-
-    def write_usage(self, prog, args='', prefix='Usage: '):
-        """Writes a usage line into the buffer.
-
-        :param prog: the program name.
-        :param args: whitespace separated list of arguments.
-        :param prefix: the prefix for the first line.
-        """
-        usage_prefix = '%*s%s ' % (self.current_indent, prefix, prog)
-        text_width = self.width - self.current_indent
-
-        if text_width >= (term_len(usage_prefix) + 20):
-            # The arguments will fit to the right of the prefix.
-            indent = ' ' * term_len(usage_prefix)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=usage_prefix,
-                                 subsequent_indent=indent))
-        else:
-            # The prefix is too long, put the arguments on the next line.
-            self.write(usage_prefix)
-            self.write('\n')
-            indent = ' ' * (max(self.current_indent, term_len(prefix)) + 4)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=indent,
-                                 subsequent_indent=indent))
-
-        self.write('\n')
-
-    def write_heading(self, heading):
-        """Writes a heading into the buffer."""
-        self.write('%*s%s:\n' % (self.current_indent, '', heading))
-
-    def write_paragraph(self):
-        """Writes a paragraph into the buffer."""
-        if self.buffer:
-            self.write('\n')
-
-    def write_text(self, text):
-        """Writes re-indented text into the buffer.  This rewraps and
-        preserves paragraphs.
-        """
-        text_width = max(self.width - self.current_indent, 11)
-        indent = ' ' * self.current_indent
-        self.write(wrap_text(text, text_width,
-                             initial_indent=indent,
-                             subsequent_indent=indent,
-                             preserve_paragraphs=True))
-        self.write('\n')
-
-    def write_dl(self, rows, col_max=30, col_spacing=2):
-        """Writes a definition list into the buffer.  This is how options
-        and commands are usually formatted.
-
-        :param rows: a list of two item tuples for the terms and values.
-        :param col_max: the maximum width of the first column.
-        :param col_spacing: the number of spaces between the first and
-                            second column.
-        """
-        rows = list(rows)
-        widths = measure_table(rows)
-        if len(widths) != 2:
-            raise TypeError('Expected two columns for definition list')
-
-        first_col = min(widths[0], col_max) + col_spacing
-
-        for first, second in iter_rows(rows, len(widths)):
-            self.write('%*s%s' % (self.current_indent, '', first))
-            if not second:
-                self.write('\n')
-                continue
-            if term_len(first) <= first_col - col_spacing:
-                self.write(' ' * (first_col - term_len(first)))
-            else:
-                self.write('\n')
-                self.write(' ' * (first_col + self.current_indent))
-
-            text_width = max(self.width - first_col - 2, 10)
-            lines = iter(wrap_text(second, text_width).splitlines())
-            if lines:
-                self.write(next(lines) + '\n')
-                for line in lines:
-                    self.write('%*s%s\n' % (
-                        first_col + self.current_indent, '', line))
-            else:
-                self.write('\n')
-
-    @contextmanager
-    def section(self, name):
-        """Helpful context manager that writes a paragraph, a heading,
-        and the indents.
-
-        :param name: the section name that is written as heading.
-        """
-        self.write_paragraph()
-        self.write_heading(name)
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    @contextmanager
-    def indentation(self):
-        """A context manager that increases the indentation."""
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    def getvalue(self):
-        """Returns the buffer contents."""
-        return ''.join(self.buffer)
-
-
-def join_options(options):
-    """Given a list of option strings this joins them in the most appropriate
-    way and returns them in the form ``(formatted_string,
-    any_prefix_is_slash)`` where the second item in the tuple is a flag that
-    indicates if any of the option prefixes was a slash.
-    """
-    rv = []
-    any_prefix_is_slash = False
-    for opt in options:
-        prefix = split_opt(opt)[0]
-        if prefix == '/':
-            any_prefix_is_slash = True
-        rv.append((len(prefix), opt))
-
-    rv.sort(key=lambda x: x[0])
-
-    rv = ', '.join(x[1] for x in rv)
-    return rv, any_prefix_is_slash
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/globals.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/globals.py
deleted file mode 100644
index 843b594ab..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/globals.py
+++ /dev/null
@@ -1,48 +0,0 @@
-from threading import local
-
-
-_local = local()
-
-
-def get_current_context(silent=False):
-    """Returns the current click context.  This can be used as a way to
-    access the current context object from anywhere.  This is a more implicit
-    alternative to the :func:`pass_context` decorator.  This function is
-    primarily useful for helpers such as :func:`echo` which might be
-    interested in changing its behavior based on the current context.
-
-    To push the current context, :meth:`Context.scope` can be used.
-
-    .. versionadded:: 5.0
-
-    :param silent: is set to `True` the return value is `None` if no context
-                   is available.  The default behavior is to raise a
-                   :exc:`RuntimeError`.
-    """
-    try:
-        return getattr(_local, 'stack')[-1]
-    except (AttributeError, IndexError):
-        if not silent:
-            raise RuntimeError('There is no active click context.')
-
-
-def push_context(ctx):
-    """Pushes a new context to the current stack."""
-    _local.__dict__.setdefault('stack', []).append(ctx)
-
-
-def pop_context():
-    """Removes the top level from the stack."""
-    _local.stack.pop()
-
-
-def resolve_color_default(color=None):
-    """"Internal helper to get the default value of the color flag.  If a
-    value is passed it's returned unchanged, otherwise it's looked up from
-    the current context.
-    """
-    if color is not None:
-        return color
-    ctx = get_current_context(silent=True)
-    if ctx is not None:
-        return ctx.color
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/parser.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/parser.py
deleted file mode 100644
index 1c3ae9c8e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/parser.py
+++ /dev/null
@@ -1,427 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-click.parser
-~~~~~~~~~~~~
-
-This module started out as largely a copy paste from the stdlib's
-optparse module with the features removed that we do not need from
-optparse because we implement them in Click on a higher level (for
-instance type handling, help formatting and a lot more).
-
-The plan is to remove more and more from here over time.
-
-The reason this is a different module and not optparse from the stdlib
-is that there are differences in 2.x and 3.x about the error messages
-generated and optparse in the stdlib uses gettext for no good reason
-and might cause us issues.
-"""
-
-import re
-from collections import deque
-from .exceptions import UsageError, NoSuchOption, BadOptionUsage, \
-     BadArgumentUsage
-
-
-def _unpack_args(args, nargs_spec):
-    """Given an iterable of arguments and an iterable of nargs specifications,
-    it returns a tuple with all the unpacked arguments at the first index
-    and all remaining arguments as the second.
-
-    The nargs specification is the number of arguments that should be consumed
-    or `-1` to indicate that this position should eat up all the remainders.
-
-    Missing items are filled with `None`.
-    """
-    args = deque(args)
-    nargs_spec = deque(nargs_spec)
-    rv = []
-    spos = None
-
-    def _fetch(c):
-        try:
-            if spos is None:
-                return c.popleft()
-            else:
-                return c.pop()
-        except IndexError:
-            return None
-
-    while nargs_spec:
-        nargs = _fetch(nargs_spec)
-        if nargs == 1:
-            rv.append(_fetch(args))
-        elif nargs > 1:
-            x = [_fetch(args) for _ in range(nargs)]
-            # If we're reversed, we're pulling in the arguments in reverse,
-            # so we need to turn them around.
-            if spos is not None:
-                x.reverse()
-            rv.append(tuple(x))
-        elif nargs < 0:
-            if spos is not None:
-                raise TypeError('Cannot have two nargs < 0')
-            spos = len(rv)
-            rv.append(None)
-
-    # spos is the position of the wildcard (star).  If it's not `None`,
-    # we fill it with the remainder.
-    if spos is not None:
-        rv[spos] = tuple(args)
-        args = []
-        rv[spos + 1:] = reversed(rv[spos + 1:])
-
-    return tuple(rv), list(args)
-
-
-def _error_opt_args(nargs, opt):
-    if nargs == 1:
-        raise BadOptionUsage(opt, '%s option requires an argument' % opt)
-    raise BadOptionUsage(opt, '%s option requires %d arguments' % (opt, nargs))
-
-
-def split_opt(opt):
-    first = opt[:1]
-    if first.isalnum():
-        return '', opt
-    if opt[1:2] == first:
-        return opt[:2], opt[2:]
-    return first, opt[1:]
-
-
-def normalize_opt(opt, ctx):
-    if ctx is None or ctx.token_normalize_func is None:
-        return opt
-    prefix, opt = split_opt(opt)
-    return prefix + ctx.token_normalize_func(opt)
-
-
-def split_arg_string(string):
-    """Given an argument string this attempts to split it into small parts."""
-    rv = []
-    for match in re.finditer(r"('([^'\\]*(?:\\.[^'\\]*)*)'"
-                             r'|"([^"\\]*(?:\\.[^"\\]*)*)"'
-                             r'|\S+)\s*', string, re.S):
-        arg = match.group().strip()
-        if arg[:1] == arg[-1:] and arg[:1] in '"\'':
-            arg = arg[1:-1].encode('ascii', 'backslashreplace') \
-                .decode('unicode-escape')
-        try:
-            arg = type(string)(arg)
-        except UnicodeError:
-            pass
-        rv.append(arg)
-    return rv
-
-
-class Option(object):
-
-    def __init__(self, opts, dest, action=None, nargs=1, const=None, obj=None):
-        self._short_opts = []
-        self._long_opts = []
-        self.prefixes = set()
-
-        for opt in opts:
-            prefix, value = split_opt(opt)
-            if not prefix:
-                raise ValueError('Invalid start character for option (%s)'
-                                 % opt)
-            self.prefixes.add(prefix[0])
-            if len(prefix) == 1 and len(value) == 1:
-                self._short_opts.append(opt)
-            else:
-                self._long_opts.append(opt)
-                self.prefixes.add(prefix)
-
-        if action is None:
-            action = 'store'
-
-        self.dest = dest
-        self.action = action
-        self.nargs = nargs
-        self.const = const
-        self.obj = obj
-
-    @property
-    def takes_value(self):
-        return self.action in ('store', 'append')
-
-    def process(self, value, state):
-        if self.action == 'store':
-            state.opts[self.dest] = value
-        elif self.action == 'store_const':
-            state.opts[self.dest] = self.const
-        elif self.action == 'append':
-            state.opts.setdefault(self.dest, []).append(value)
-        elif self.action == 'append_const':
-            state.opts.setdefault(self.dest, []).append(self.const)
-        elif self.action == 'count':
-            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1
-        else:
-            raise ValueError('unknown action %r' % self.action)
-        state.order.append(self.obj)
-
-
-class Argument(object):
-
-    def __init__(self, dest, nargs=1, obj=None):
-        self.dest = dest
-        self.nargs = nargs
-        self.obj = obj
-
-    def process(self, value, state):
-        if self.nargs > 1:
-            holes = sum(1 for x in value if x is None)
-            if holes == len(value):
-                value = None
-            elif holes != 0:
-                raise BadArgumentUsage('argument %s takes %d values'
-                                       % (self.dest, self.nargs))
-        state.opts[self.dest] = value
-        state.order.append(self.obj)
-
-
-class ParsingState(object):
-
-    def __init__(self, rargs):
-        self.opts = {}
-        self.largs = []
-        self.rargs = rargs
-        self.order = []
-
-
-class OptionParser(object):
-    """The option parser is an internal class that is ultimately used to
-    parse options and arguments.  It's modelled after optparse and brings
-    a similar but vastly simplified API.  It should generally not be used
-    directly as the high level Click classes wrap it for you.
-
-    It's not nearly as extensible as optparse or argparse as it does not
-    implement features that are implemented on a higher level (such as
-    types or defaults).
-
-    :param ctx: optionally the :class:`~click.Context` where this parser
-                should go with.
-    """
-
-    def __init__(self, ctx=None):
-        #: The :class:`~click.Context` for this parser.  This might be
-        #: `None` for some advanced use cases.
-        self.ctx = ctx
-        #: This controls how the parser deals with interspersed arguments.
-        #: If this is set to `False`, the parser will stop on the first
-        #: non-option.  Click uses this to implement nested subcommands
-        #: safely.
-        self.allow_interspersed_args = True
-        #: This tells the parser how to deal with unknown options.  By
-        #: default it will error out (which is sensible), but there is a
-        #: second mode where it will ignore it and continue processing
-        #: after shifting all the unknown options into the resulting args.
-        self.ignore_unknown_options = False
-        if ctx is not None:
-            self.allow_interspersed_args = ctx.allow_interspersed_args
-            self.ignore_unknown_options = ctx.ignore_unknown_options
-        self._short_opt = {}
-        self._long_opt = {}
-        self._opt_prefixes = set(['-', '--'])
-        self._args = []
-
-    def add_option(self, opts, dest, action=None, nargs=1, const=None,
-                   obj=None):
-        """Adds a new option named `dest` to the parser.  The destination
-        is not inferred (unlike with optparse) and needs to be explicitly
-        provided.  Action can be any of ``store``, ``store_const``,
-        ``append``, ``appnd_const`` or ``count``.
-
-        The `obj` can be used to identify the option in the order list
-        that is returned from the parser.
-        """
-        if obj is None:
-            obj = dest
-        opts = [normalize_opt(opt, self.ctx) for opt in opts]
-        option = Option(opts, dest, action=action, nargs=nargs,
-                        const=const, obj=obj)
-        self._opt_prefixes.update(option.prefixes)
-        for opt in option._short_opts:
-            self._short_opt[opt] = option
-        for opt in option._long_opts:
-            self._long_opt[opt] = option
-
-    def add_argument(self, dest, nargs=1, obj=None):
-        """Adds a positional argument named `dest` to the parser.
-
-        The `obj` can be used to identify the option in the order list
-        that is returned from the parser.
-        """
-        if obj is None:
-            obj = dest
-        self._args.append(Argument(dest=dest, nargs=nargs, obj=obj))
-
-    def parse_args(self, args):
-        """Parses positional arguments and returns ``(values, args, order)``
-        for the parsed options and arguments as well as the leftover
-        arguments if there are any.  The order is a list of objects as they
-        appear on the command line.  If arguments appear multiple times they
-        will be memorized multiple times as well.
-        """
-        state = ParsingState(args)
-        try:
-            self._process_args_for_options(state)
-            self._process_args_for_args(state)
-        except UsageError:
-            if self.ctx is None or not self.ctx.resilient_parsing:
-                raise
-        return state.opts, state.largs, state.order
-
-    def _process_args_for_args(self, state):
-        pargs, args = _unpack_args(state.largs + state.rargs,
-                                   [x.nargs for x in self._args])
-
-        for idx, arg in enumerate(self._args):
-            arg.process(pargs[idx], state)
-
-        state.largs = args
-        state.rargs = []
-
-    def _process_args_for_options(self, state):
-        while state.rargs:
-            arg = state.rargs.pop(0)
-            arglen = len(arg)
-            # Double dashes always handled explicitly regardless of what
-            # prefixes are valid.
-            if arg == '--':
-                return
-            elif arg[:1] in self._opt_prefixes and arglen > 1:
-                self._process_opts(arg, state)
-            elif self.allow_interspersed_args:
-                state.largs.append(arg)
-            else:
-                state.rargs.insert(0, arg)
-                return
-
-        # Say this is the original argument list:
-        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
-        #                            ^
-        # (we are about to process arg(i)).
-        #
-        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
-        # [arg0, ..., arg(i-1)] (any options and their arguments will have
-        # been removed from largs).
-        #
-        # The while loop will usually consume 1 or more arguments per pass.
-        # If it consumes 1 (eg. arg is an option that takes no arguments),
-        # then after _process_arg() is done the situation is:
-        #
-        #   largs = subset of [arg0, ..., arg(i)]
-        #   rargs = [arg(i+1), ..., arg(N-1)]
-        #
-        # If allow_interspersed_args is false, largs will always be
-        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
-        # not a very interesting subset!
-
-    def _match_long_opt(self, opt, explicit_value, state):
-        if opt not in self._long_opt:
-            possibilities = [word for word in self._long_opt
-                             if word.startswith(opt)]
-            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
-
-        option = self._long_opt[opt]
-        if option.takes_value:
-            # At this point it's safe to modify rargs by injecting the
-            # explicit value, because no exception is raised in this
-            # branch.  This means that the inserted value will be fully
-            # consumed.
-            if explicit_value is not None:
-                state.rargs.insert(0, explicit_value)
-
-            nargs = option.nargs
-            if len(state.rargs) < nargs:
-                _error_opt_args(nargs, opt)
-            elif nargs == 1:
-                value = state.rargs.pop(0)
-            else:
-                value = tuple(state.rargs[:nargs])
-                del state.rargs[:nargs]
-
-        elif explicit_value is not None:
-            raise BadOptionUsage(opt, '%s option does not take a value' % opt)
-
-        else:
-            value = None
-
-        option.process(value, state)
-
-    def _match_short_opt(self, arg, state):
-        stop = False
-        i = 1
-        prefix = arg[0]
-        unknown_options = []
-
-        for ch in arg[1:]:
-            opt = normalize_opt(prefix + ch, self.ctx)
-            option = self._short_opt.get(opt)
-            i += 1
-
-            if not option:
-                if self.ignore_unknown_options:
-                    unknown_options.append(ch)
-                    continue
-                raise NoSuchOption(opt, ctx=self.ctx)
-            if option.takes_value:
-                # Any characters left in arg?  Pretend they're the
-                # next arg, and stop consuming characters of arg.
-                if i < len(arg):
-                    state.rargs.insert(0, arg[i:])
-                    stop = True
-
-                nargs = option.nargs
-                if len(state.rargs) < nargs:
-                    _error_opt_args(nargs, opt)
-                elif nargs == 1:
-                    value = state.rargs.pop(0)
-                else:
-                    value = tuple(state.rargs[:nargs])
-                    del state.rargs[:nargs]
-
-            else:
-                value = None
-
-            option.process(value, state)
-
-            if stop:
-                break
-
-        # If we got any unknown options we re-combinate the string of the
-        # remaining options and re-attach the prefix, then report that
-        # to the state as new larg.  This way there is basic combinatorics
-        # that can be achieved while still ignoring unknown arguments.
-        if self.ignore_unknown_options and unknown_options:
-            state.largs.append(prefix + ''.join(unknown_options))
-
-    def _process_opts(self, arg, state):
-        explicit_value = None
-        # Long option handling happens in two parts.  The first part is
-        # supporting explicitly attached values.  In any case, we will try
-        # to long match the option first.
-        if '=' in arg:
-            long_opt, explicit_value = arg.split('=', 1)
-        else:
-            long_opt = arg
-        norm_long_opt = normalize_opt(long_opt, self.ctx)
-
-        # At this point we will match the (assumed) long option through
-        # the long option matching code.  Note that this allows options
-        # like "-foo" to be matched as long options.
-        try:
-            self._match_long_opt(norm_long_opt, explicit_value, state)
-        except NoSuchOption:
-            # At this point the long option matching failed, and we need
-            # to try with short options.  However there is a special rule
-            # which says, that if we have a two character options prefix
-            # (applies to "--foo" for instance), we do not dispatch to the
-            # short option code and will instead raise the no option
-            # error.
-            if arg[:2] not in self._opt_prefixes:
-                return self._match_short_opt(arg, state)
-            if not self.ignore_unknown_options:
-                raise
-            state.largs.append(arg)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/termui.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/termui.py
deleted file mode 100644
index bf9a3aa16..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/termui.py
+++ /dev/null
@@ -1,606 +0,0 @@
-import os
-import sys
-import struct
-import inspect
-import itertools
-
-from ._compat import raw_input, text_type, string_types, \
-     isatty, strip_ansi, get_winterm_size, DEFAULT_COLUMNS, WIN
-from .utils import echo
-from .exceptions import Abort, UsageError
-from .types import convert_type, Choice, Path
-from .globals import resolve_color_default
-
-
-# The prompt functions to use.  The doc tools currently override these
-# functions to customize how they work.
-visible_prompt_func = raw_input
-
-_ansi_colors = {
-    'black': 30,
-    'red': 31,
-    'green': 32,
-    'yellow': 33,
-    'blue': 34,
-    'magenta': 35,
-    'cyan': 36,
-    'white': 37,
-    'reset': 39,
-    'bright_black': 90,
-    'bright_red': 91,
-    'bright_green': 92,
-    'bright_yellow': 93,
-    'bright_blue': 94,
-    'bright_magenta': 95,
-    'bright_cyan': 96,
-    'bright_white': 97,
-}
-_ansi_reset_all = '\033[0m'
-
-
-def hidden_prompt_func(prompt):
-    import getpass
-    return getpass.getpass(prompt)
-
-
-def _build_prompt(text, suffix, show_default=False, default=None, show_choices=True, type=None):
-    prompt = text
-    if type is not None and show_choices and isinstance(type, Choice):
-        prompt += ' (' + ", ".join(map(str, type.choices)) + ')'
-    if default is not None and show_default:
-        prompt = '%s [%s]' % (prompt, default)
-    return prompt + suffix
-
-
-def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
-           type=None, value_proc=None, prompt_suffix=': ', show_default=True,
-           err=False, show_choices=True):
-    """Prompts a user for input.  This is a convenience function that can
-    be used to prompt a user for input later.
-
-    If the user aborts the input by sending a interrupt signal, this
-    function will catch it and raise a :exc:`Abort` exception.
-
-    .. versionadded:: 7.0
-       Added the show_choices parameter.
-
-    .. versionadded:: 6.0
-       Added unicode support for cmd.exe on Windows.
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param text: the text to show for the prompt.
-    :param default: the default value to use if no input happens.  If this
-                    is not given it will prompt until it's aborted.
-    :param hide_input: if this is set to true then the input value will
-                       be hidden.
-    :param confirmation_prompt: asks for confirmation for the value.
-    :param type: the type to use to check the value against.
-    :param value_proc: if this parameter is provided it's a function that
-                       is invoked instead of the type conversion to
-                       convert a value.
-    :param prompt_suffix: a suffix that should be added to the prompt.
-    :param show_default: shows or hides the default value in the prompt.
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    :param show_choices: Show or hide choices if the passed type is a Choice.
-                         For example if type is a Choice of either day or week,
-                         show_choices is true and text is "Group by" then the
-                         prompt will be "Group by (day, week): ".
-    """
-    result = None
-
-    def prompt_func(text):
-        f = hide_input and hidden_prompt_func or visible_prompt_func
-        try:
-            # Write the prompt separately so that we get nice
-            # coloring through colorama on Windows
-            echo(text, nl=False, err=err)
-            return f('')
-        except (KeyboardInterrupt, EOFError):
-            # getpass doesn't print a newline if the user aborts input with ^C.
-            # Allegedly this behavior is inherited from getpass(3).
-            # A doc bug has been filed at https://bugs.python.org/issue24711
-            if hide_input:
-                echo(None, err=err)
-            raise Abort()
-
-    if value_proc is None:
-        value_proc = convert_type(type, default)
-
-    prompt = _build_prompt(text, prompt_suffix, show_default, default, show_choices, type)
-
-    while 1:
-        while 1:
-            value = prompt_func(prompt)
-            if value:
-                break
-            elif default is not None:
-                if isinstance(value_proc, Path):
-                    # validate Path default value(exists, dir_okay etc.)
-                    value = default
-                    break
-                return default
-        try:
-            result = value_proc(value)
-        except UsageError as e:
-            echo('Error: %s' % e.message, err=err)
-            continue
-        if not confirmation_prompt:
-            return result
-        while 1:
-            value2 = prompt_func('Repeat for confirmation: ')
-            if value2:
-                break
-        if value == value2:
-            return result
-        echo('Error: the two entered values do not match', err=err)
-
-
-def confirm(text, default=False, abort=False, prompt_suffix=': ',
-            show_default=True, err=False):
-    """Prompts for confirmation (yes/no question).
-
-    If the user aborts the input by sending a interrupt signal this
-    function will catch it and raise a :exc:`Abort` exception.
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param text: the question to ask.
-    :param default: the default for the prompt.
-    :param abort: if this is set to `True` a negative answer aborts the
-                  exception by raising :exc:`Abort`.
-    :param prompt_suffix: a suffix that should be added to the prompt.
-    :param show_default: shows or hides the default value in the prompt.
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    """
-    prompt = _build_prompt(text, prompt_suffix, show_default,
-                           default and 'Y/n' or 'y/N')
-    while 1:
-        try:
-            # Write the prompt separately so that we get nice
-            # coloring through colorama on Windows
-            echo(prompt, nl=False, err=err)
-            value = visible_prompt_func('').lower().strip()
-        except (KeyboardInterrupt, EOFError):
-            raise Abort()
-        if value in ('y', 'yes'):
-            rv = True
-        elif value in ('n', 'no'):
-            rv = False
-        elif value == '':
-            rv = default
-        else:
-            echo('Error: invalid input', err=err)
-            continue
-        break
-    if abort and not rv:
-        raise Abort()
-    return rv
-
-
-def get_terminal_size():
-    """Returns the current size of the terminal as tuple in the form
-    ``(width, height)`` in columns and rows.
-    """
-    # If shutil has get_terminal_size() (Python 3.3 and later) use that
-    if sys.version_info >= (3, 3):
-        import shutil
-        shutil_get_terminal_size = getattr(shutil, 'get_terminal_size', None)
-        if shutil_get_terminal_size:
-            sz = shutil_get_terminal_size()
-            return sz.columns, sz.lines
-
-    # We provide a sensible default for get_winterm_size() when being invoked
-    # inside a subprocess. Without this, it would not provide a useful input.
-    if get_winterm_size is not None:
-        size = get_winterm_size()
-        if size == (0, 0):
-            return (79, 24)
-        else:
-            return size
-
-    def ioctl_gwinsz(fd):
-        try:
-            import fcntl
-            import termios
-            cr = struct.unpack(
-                'hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
-        except Exception:
-            return
-        return cr
-
-    cr = ioctl_gwinsz(0) or ioctl_gwinsz(1) or ioctl_gwinsz(2)
-    if not cr:
-        try:
-            fd = os.open(os.ctermid(), os.O_RDONLY)
-            try:
-                cr = ioctl_gwinsz(fd)
-            finally:
-                os.close(fd)
-        except Exception:
-            pass
-    if not cr or not cr[0] or not cr[1]:
-        cr = (os.environ.get('LINES', 25),
-              os.environ.get('COLUMNS', DEFAULT_COLUMNS))
-    return int(cr[1]), int(cr[0])
-
-
-def echo_via_pager(text_or_generator, color=None):
-    """This function takes a text and shows it via an environment specific
-    pager on stdout.
-
-    .. versionchanged:: 3.0
-       Added the `color` flag.
-
-    :param text_or_generator: the text to page, or alternatively, a
-                              generator emitting the text to page.
-    :param color: controls if the pager supports ANSI colors or not.  The
-                  default is autodetection.
-    """
-    color = resolve_color_default(color)
-
-    if inspect.isgeneratorfunction(text_or_generator):
-        i = text_or_generator()
-    elif isinstance(text_or_generator, string_types):
-        i = [text_or_generator]
-    else:
-        i = iter(text_or_generator)
-
-    # convert every element of i to a text type if necessary
-    text_generator = (el if isinstance(el, string_types) else text_type(el)
-                      for el in i)
-
-    from ._termui_impl import pager
-    return pager(itertools.chain(text_generator, "\n"), color)
-
-
-def progressbar(iterable=None, length=None, label=None, show_eta=True,
-                show_percent=None, show_pos=False,
-                item_show_func=None, fill_char='#', empty_char='-',
-                bar_template='%(label)s  [%(bar)s]  %(info)s',
-                info_sep='  ', width=36, file=None, color=None):
-    """This function creates an iterable context manager that can be used
-    to iterate over something while showing a progress bar.  It will
-    either iterate over the `iterable` or `length` items (that are counted
-    up).  While iteration happens, this function will print a rendered
-    progress bar to the given `file` (defaults to stdout) and will attempt
-    to calculate remaining time and more.  By default, this progress bar
-    will not be rendered if the file is not a terminal.
-
-    The context manager creates the progress bar.  When the context
-    manager is entered the progress bar is already displayed.  With every
-    iteration over the progress bar, the iterable passed to the bar is
-    advanced and the bar is updated.  When the context manager exits,
-    a newline is printed and the progress bar is finalized on screen.
-
-    No printing must happen or the progress bar will be unintentionally
-    destroyed.
-
-    Example usage::
-
-        with progressbar(items) as bar:
-            for item in bar:
-                do_something_with(item)
-
-    Alternatively, if no iterable is specified, one can manually update the
-    progress bar through the `update()` method instead of directly
-    iterating over the progress bar.  The update method accepts the number
-    of steps to increment the bar with::
-
-        with progressbar(length=chunks.total_bytes) as bar:
-            for chunk in chunks:
-                process_chunk(chunk)
-                bar.update(chunks.bytes)
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 4.0
-       Added the `color` parameter.  Added a `update` method to the
-       progressbar object.
-
-    :param iterable: an iterable to iterate over.  If not provided the length
-                     is required.
-    :param length: the number of items to iterate over.  By default the
-                   progressbar will attempt to ask the iterator about its
-                   length, which might or might not work.  If an iterable is
-                   also provided this parameter can be used to override the
-                   length.  If an iterable is not provided the progress bar
-                   will iterate over a range of that length.
-    :param label: the label to show next to the progress bar.
-    :param show_eta: enables or disables the estimated time display.  This is
-                     automatically disabled if the length cannot be
-                     determined.
-    :param show_percent: enables or disables the percentage display.  The
-                         default is `True` if the iterable has a length or
-                         `False` if not.
-    :param show_pos: enables or disables the absolute position display.  The
-                     default is `False`.
-    :param item_show_func: a function called with the current item which
-                           can return a string to show the current item
-                           next to the progress bar.  Note that the current
-                           item can be `None`!
-    :param fill_char: the character to use to show the filled part of the
-                      progress bar.
-    :param empty_char: the character to use to show the non-filled part of
-                       the progress bar.
-    :param bar_template: the format string to use as template for the bar.
-                         The parameters in it are ``label`` for the label,
-                         ``bar`` for the progress bar and ``info`` for the
-                         info section.
-    :param info_sep: the separator between multiple info items (eta etc.)
-    :param width: the width of the progress bar in characters, 0 means full
-                  terminal width
-    :param file: the file to write to.  If this is not a terminal then
-                 only the label is printed.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.  This is only needed if ANSI
-                  codes are included anywhere in the progress bar output
-                  which is not the case by default.
-    """
-    from ._termui_impl import ProgressBar
-    color = resolve_color_default(color)
-    return ProgressBar(iterable=iterable, length=length, show_eta=show_eta,
-                       show_percent=show_percent, show_pos=show_pos,
-                       item_show_func=item_show_func, fill_char=fill_char,
-                       empty_char=empty_char, bar_template=bar_template,
-                       info_sep=info_sep, file=file, label=label,
-                       width=width, color=color)
-
-
-def clear():
-    """Clears the terminal screen.  This will have the effect of clearing
-    the whole visible space of the terminal and moving the cursor to the
-    top left.  This does not do anything if not connected to a terminal.
-
-    .. versionadded:: 2.0
-    """
-    if not isatty(sys.stdout):
-        return
-    # If we're on Windows and we don't have colorama available, then we
-    # clear the screen by shelling out.  Otherwise we can use an escape
-    # sequence.
-    if WIN:
-        os.system('cls')
-    else:
-        sys.stdout.write('\033[2J\033[1;1H')
-
-
-def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
-          blink=None, reverse=None, reset=True):
-    """Styles a text with ANSI styles and returns the new string.  By
-    default the styling is self contained which means that at the end
-    of the string a reset code is issued.  This can be prevented by
-    passing ``reset=False``.
-
-    Examples::
-
-        click.echo(click.style('Hello World!', fg='green'))
-        click.echo(click.style('ATTENTION!', blink=True))
-        click.echo(click.style('Some things', reverse=True, fg='cyan'))
-
-    Supported color names:
-
-    * ``black`` (might be a gray)
-    * ``red``
-    * ``green``
-    * ``yellow`` (might be an orange)
-    * ``blue``
-    * ``magenta``
-    * ``cyan``
-    * ``white`` (might be light gray)
-    * ``bright_black``
-    * ``bright_red``
-    * ``bright_green``
-    * ``bright_yellow``
-    * ``bright_blue``
-    * ``bright_magenta``
-    * ``bright_cyan``
-    * ``bright_white``
-    * ``reset`` (reset the color code only)
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 7.0
-       Added support for bright colors.
-
-    :param text: the string to style with ansi codes.
-    :param fg: if provided this will become the foreground color.
-    :param bg: if provided this will become the background color.
-    :param bold: if provided this will enable or disable bold mode.
-    :param dim: if provided this will enable or disable dim mode.  This is
-                badly supported.
-    :param underline: if provided this will enable or disable underline.
-    :param blink: if provided this will enable or disable blinking.
-    :param reverse: if provided this will enable or disable inverse
-                    rendering (foreground becomes background and the
-                    other way round).
-    :param reset: by default a reset-all code is added at the end of the
-                  string which means that styles do not carry over.  This
-                  can be disabled to compose styles.
-    """
-    bits = []
-    if fg:
-        try:
-            bits.append('\033[%dm' % (_ansi_colors[fg]))
-        except KeyError:
-            raise TypeError('Unknown color %r' % fg)
-    if bg:
-        try:
-            bits.append('\033[%dm' % (_ansi_colors[bg] + 10))
-        except KeyError:
-            raise TypeError('Unknown color %r' % bg)
-    if bold is not None:
-        bits.append('\033[%dm' % (1 if bold else 22))
-    if dim is not None:
-        bits.append('\033[%dm' % (2 if dim else 22))
-    if underline is not None:
-        bits.append('\033[%dm' % (4 if underline else 24))
-    if blink is not None:
-        bits.append('\033[%dm' % (5 if blink else 25))
-    if reverse is not None:
-        bits.append('\033[%dm' % (7 if reverse else 27))
-    bits.append(text)
-    if reset:
-        bits.append(_ansi_reset_all)
-    return ''.join(bits)
-
-
-def unstyle(text):
-    """Removes ANSI styling information from a string.  Usually it's not
-    necessary to use this function as Click's echo function will
-    automatically remove styling if necessary.
-
-    .. versionadded:: 2.0
-
-    :param text: the text to remove style information from.
-    """
-    return strip_ansi(text)
-
-
-def secho(message=None, file=None, nl=True, err=False, color=None, **styles):
-    """This function combines :func:`echo` and :func:`style` into one
-    call.  As such the following two calls are the same::
-
-        click.secho('Hello World!', fg='green')
-        click.echo(click.style('Hello World!', fg='green'))
-
-    All keyword arguments are forwarded to the underlying functions
-    depending on which one they go with.
-
-    .. versionadded:: 2.0
-    """
-    if message is not None:
-        message = style(message, **styles)
-    return echo(message, file=file, nl=nl, err=err, color=color)
-
-
-def edit(text=None, editor=None, env=None, require_save=True,
-         extension='.txt', filename=None):
-    r"""Edits the given text in the defined editor.  If an editor is given
-    (should be the full path to the executable but the regular operating
-    system search path is used for finding the executable) it overrides
-    the detected editor.  Optionally, some environment variables can be
-    used.  If the editor is closed without changes, `None` is returned.  In
-    case a file is edited directly the return value is always `None` and
-    `require_save` and `extension` are ignored.
-
-    If the editor cannot be opened a :exc:`UsageError` is raised.
-
-    Note for Windows: to simplify cross-platform usage, the newlines are
-    automatically converted from POSIX to Windows and vice versa.  As such,
-    the message here will have ``\n`` as newline markers.
-
-    :param text: the text to edit.
-    :param editor: optionally the editor to use.  Defaults to automatic
-                   detection.
-    :param env: environment variables to forward to the editor.
-    :param require_save: if this is true, then not saving in the editor
-                         will make the return value become `None`.
-    :param extension: the extension to tell the editor about.  This defaults
-                      to `.txt` but changing this might change syntax
-                      highlighting.
-    :param filename: if provided it will edit this file instead of the
-                     provided text contents.  It will not use a temporary
-                     file as an indirection in that case.
-    """
-    from ._termui_impl import Editor
-    editor = Editor(editor=editor, env=env, require_save=require_save,
-                    extension=extension)
-    if filename is None:
-        return editor.edit(text)
-    editor.edit_file(filename)
-
-
-def launch(url, wait=False, locate=False):
-    """This function launches the given URL (or filename) in the default
-    viewer application for this file type.  If this is an executable, it
-    might launch the executable in a new session.  The return value is
-    the exit code of the launched application.  Usually, ``0`` indicates
-    success.
-
-    Examples::
-
-        click.launch('https://click.palletsprojects.com/')
-        click.launch('/my/downloaded/file', locate=True)
-
-    .. versionadded:: 2.0
-
-    :param url: URL or filename of the thing to launch.
-    :param wait: waits for the program to stop.
-    :param locate: if this is set to `True` then instead of launching the
-                   application associated with the URL it will attempt to
-                   launch a file manager with the file located.  This
-                   might have weird effects if the URL does not point to
-                   the filesystem.
-    """
-    from ._termui_impl import open_url
-    return open_url(url, wait=wait, locate=locate)
-
-
-# If this is provided, getchar() calls into this instead.  This is used
-# for unittesting purposes.
-_getchar = None
-
-
-def getchar(echo=False):
-    """Fetches a single character from the terminal and returns it.  This
-    will always return a unicode character and under certain rare
-    circumstances this might return more than one character.  The
-    situations which more than one character is returned is when for
-    whatever reason multiple characters end up in the terminal buffer or
-    standard input was not actually a terminal.
-
-    Note that this will always read from the terminal, even if something
-    is piped into the standard input.
-
-    Note for Windows: in rare cases when typing non-ASCII characters, this
-    function might wait for a second character and then return both at once.
-    This is because certain Unicode characters look like special-key markers.
-
-    .. versionadded:: 2.0
-
-    :param echo: if set to `True`, the character read will also show up on
-                 the terminal.  The default is to not show it.
-    """
-    f = _getchar
-    if f is None:
-        from ._termui_impl import getchar as f
-    return f(echo)
-
-
-def raw_terminal():
-    from ._termui_impl import raw_terminal as f
-    return f()
-
-
-def pause(info='Press any key to continue ...', err=False):
-    """This command stops execution and waits for the user to press any
-    key to continue.  This is similar to the Windows batch "pause"
-    command.  If the program is not run through a terminal, this command
-    will instead do nothing.
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param info: the info string to print before pausing.
-    :param err: if set to message goes to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    """
-    if not isatty(sys.stdin) or not isatty(sys.stdout):
-        return
-    try:
-        if info:
-            echo(info, nl=False, err=err)
-        try:
-            getchar()
-        except (KeyboardInterrupt, EOFError):
-            pass
-    finally:
-        if info:
-            echo(err=err)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/testing.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/testing.py
deleted file mode 100644
index 1b2924e0b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/testing.py
+++ /dev/null
@@ -1,374 +0,0 @@
-import os
-import sys
-import shutil
-import tempfile
-import contextlib
-import shlex
-
-from ._compat import iteritems, PY2, string_types
-
-
-# If someone wants to vendor click, we want to ensure the
-# correct package is discovered.  Ideally we could use a
-# relative import here but unfortunately Python does not
-# support that.
-clickpkg = sys.modules[__name__.rsplit('.', 1)[0]]
-
-
-if PY2:
-    from cStringIO import StringIO
-else:
-    import io
-    from ._compat import _find_binary_reader
-
-
-class EchoingStdin(object):
-
-    def __init__(self, input, output):
-        self._input = input
-        self._output = output
-
-    def __getattr__(self, x):
-        return getattr(self._input, x)
-
-    def _echo(self, rv):
-        self._output.write(rv)
-        return rv
-
-    def read(self, n=-1):
-        return self._echo(self._input.read(n))
-
-    def readline(self, n=-1):
-        return self._echo(self._input.readline(n))
-
-    def readlines(self):
-        return [self._echo(x) for x in self._input.readlines()]
-
-    def __iter__(self):
-        return iter(self._echo(x) for x in self._input)
-
-    def __repr__(self):
-        return repr(self._input)
-
-
-def make_input_stream(input, charset):
-    # Is already an input stream.
-    if hasattr(input, 'read'):
-        if PY2:
-            return input
-        rv = _find_binary_reader(input)
-        if rv is not None:
-            return rv
-        raise TypeError('Could not find binary reader for input stream.')
-
-    if input is None:
-        input = b''
-    elif not isinstance(input, bytes):
-        input = input.encode(charset)
-    if PY2:
-        return StringIO(input)
-    return io.BytesIO(input)
-
-
-class Result(object):
-    """Holds the captured result of an invoked CLI script."""
-
-    def __init__(self, runner, stdout_bytes, stderr_bytes, exit_code,
-                 exception, exc_info=None):
-        #: The runner that created the result
-        self.runner = runner
-        #: The standard output as bytes.
-        self.stdout_bytes = stdout_bytes
-        #: The standard error as bytes, or False(y) if not available
-        self.stderr_bytes = stderr_bytes
-        #: The exit code as integer.
-        self.exit_code = exit_code
-        #: The exception that happened if one did.
-        self.exception = exception
-        #: The traceback
-        self.exc_info = exc_info
-
-    @property
-    def output(self):
-        """The (standard) output as unicode string."""
-        return self.stdout
-
-    @property
-    def stdout(self):
-        """The standard output as unicode string."""
-        return self.stdout_bytes.decode(self.runner.charset, 'replace') \
-            .replace('\r\n', '\n')
-
-    @property
-    def stderr(self):
-        """The standard error as unicode string."""
-        if not self.stderr_bytes:
-            raise ValueError("stderr not separately captured")
-        return self.stderr_bytes.decode(self.runner.charset, 'replace') \
-            .replace('\r\n', '\n')
-
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            type(self).__name__,
-            self.exception and repr(self.exception) or 'okay',
-        )
-
-
-class CliRunner(object):
-    """The CLI runner provides functionality to invoke a Click command line
-    script for unittesting purposes in a isolated environment.  This only
-    works in single-threaded systems without any concurrency as it changes the
-    global interpreter state.
-
-    :param charset: the character set for the input and output data.  This is
-                    UTF-8 by default and should not be changed currently as
-                    the reporting to Click only works in Python 2 properly.
-    :param env: a dictionary with environment variables for overriding.
-    :param echo_stdin: if this is set to `True`, then reading from stdin writes
-                       to stdout.  This is useful for showing examples in
-                       some circumstances.  Note that regular prompts
-                       will automatically echo the input.
-    :param mix_stderr: if this is set to `False`, then stdout and stderr are
-                       preserved as independent streams.  This is useful for
-                       Unix-philosophy apps that have predictable stdout and
-                       noisy stderr, such that each may be measured
-                       independently
-    """
-
-    def __init__(self, charset=None, env=None, echo_stdin=False,
-                 mix_stderr=True):
-        if charset is None:
-            charset = 'utf-8'
-        self.charset = charset
-        self.env = env or {}
-        self.echo_stdin = echo_stdin
-        self.mix_stderr = mix_stderr
-
-    def get_default_prog_name(self, cli):
-        """Given a command object it will return the default program name
-        for it.  The default is the `name` attribute or ``"root"`` if not
-        set.
-        """
-        return cli.name or 'root'
-
-    def make_env(self, overrides=None):
-        """Returns the environment overrides for invoking a script."""
-        rv = dict(self.env)
-        if overrides:
-            rv.update(overrides)
-        return rv
-
-    @contextlib.contextmanager
-    def isolation(self, input=None, env=None, color=False):
-        """A context manager that sets up the isolation for invoking of a
-        command line tool.  This sets up stdin with the given input data
-        and `os.environ` with the overrides from the given dictionary.
-        This also rebinds some internals in Click to be mocked (like the
-        prompt functionality).
-
-        This is automatically done in the :meth:`invoke` method.
-
-        .. versionadded:: 4.0
-           The ``color`` parameter was added.
-
-        :param input: the input stream to put into sys.stdin.
-        :param env: the environment overrides as dictionary.
-        :param color: whether the output should contain color codes. The
-                      application can still override this explicitly.
-        """
-        input = make_input_stream(input, self.charset)
-
-        old_stdin = sys.stdin
-        old_stdout = sys.stdout
-        old_stderr = sys.stderr
-        old_forced_width = clickpkg.formatting.FORCED_WIDTH
-        clickpkg.formatting.FORCED_WIDTH = 80
-
-        env = self.make_env(env)
-
-        if PY2:
-            bytes_output = StringIO()
-            if self.echo_stdin:
-                input = EchoingStdin(input, bytes_output)
-            sys.stdout = bytes_output
-            if not self.mix_stderr:
-                bytes_error = StringIO()
-                sys.stderr = bytes_error
-        else:
-            bytes_output = io.BytesIO()
-            if self.echo_stdin:
-                input = EchoingStdin(input, bytes_output)
-            input = io.TextIOWrapper(input, encoding=self.charset)
-            sys.stdout = io.TextIOWrapper(
-                bytes_output, encoding=self.charset)
-            if not self.mix_stderr:
-                bytes_error = io.BytesIO()
-                sys.stderr = io.TextIOWrapper(
-                    bytes_error, encoding=self.charset)
-
-        if self.mix_stderr:
-            sys.stderr = sys.stdout
-
-        sys.stdin = input
-
-        def visible_input(prompt=None):
-            sys.stdout.write(prompt or '')
-            val = input.readline().rstrip('\r\n')
-            sys.stdout.write(val + '\n')
-            sys.stdout.flush()
-            return val
-
-        def hidden_input(prompt=None):
-            sys.stdout.write((prompt or '') + '\n')
-            sys.stdout.flush()
-            return input.readline().rstrip('\r\n')
-
-        def _getchar(echo):
-            char = sys.stdin.read(1)
-            if echo:
-                sys.stdout.write(char)
-                sys.stdout.flush()
-            return char
-
-        default_color = color
-
-        def should_strip_ansi(stream=None, color=None):
-            if color is None:
-                return not default_color
-            return not color
-
-        old_visible_prompt_func = clickpkg.termui.visible_prompt_func
-        old_hidden_prompt_func = clickpkg.termui.hidden_prompt_func
-        old__getchar_func = clickpkg.termui._getchar
-        old_should_strip_ansi = clickpkg.utils.should_strip_ansi
-        clickpkg.termui.visible_prompt_func = visible_input
-        clickpkg.termui.hidden_prompt_func = hidden_input
-        clickpkg.termui._getchar = _getchar
-        clickpkg.utils.should_strip_ansi = should_strip_ansi
-
-        old_env = {}
-        try:
-            for key, value in iteritems(env):
-                old_env[key] = os.environ.get(key)
-                if value is None:
-                    try:
-                        del os.environ[key]
-                    except Exception:
-                        pass
-                else:
-                    os.environ[key] = value
-            yield (bytes_output, not self.mix_stderr and bytes_error)
-        finally:
-            for key, value in iteritems(old_env):
-                if value is None:
-                    try:
-                        del os.environ[key]
-                    except Exception:
-                        pass
-                else:
-                    os.environ[key] = value
-            sys.stdout = old_stdout
-            sys.stderr = old_stderr
-            sys.stdin = old_stdin
-            clickpkg.termui.visible_prompt_func = old_visible_prompt_func
-            clickpkg.termui.hidden_prompt_func = old_hidden_prompt_func
-            clickpkg.termui._getchar = old__getchar_func
-            clickpkg.utils.should_strip_ansi = old_should_strip_ansi
-            clickpkg.formatting.FORCED_WIDTH = old_forced_width
-
-    def invoke(self, cli, args=None, input=None, env=None,
-               catch_exceptions=True, color=False, mix_stderr=False, **extra):
-        """Invokes a command in an isolated environment.  The arguments are
-        forwarded directly to the command line script, the `extra` keyword
-        arguments are passed to the :meth:`~clickpkg.Command.main` function of
-        the command.
-
-        This returns a :class:`Result` object.
-
-        .. versionadded:: 3.0
-           The ``catch_exceptions`` parameter was added.
-
-        .. versionchanged:: 3.0
-           The result object now has an `exc_info` attribute with the
-           traceback if available.
-
-        .. versionadded:: 4.0
-           The ``color`` parameter was added.
-
-        :param cli: the command to invoke
-        :param args: the arguments to invoke. It may be given as an iterable
-                     or a string. When given as string it will be interpreted
-                     as a Unix shell command. More details at
-                     :func:`shlex.split`.
-        :param input: the input data for `sys.stdin`.
-        :param env: the environment overrides.
-        :param catch_exceptions: Whether to catch any other exceptions than
-                                 ``SystemExit``.
-        :param extra: the keyword arguments to pass to :meth:`main`.
-        :param color: whether the output should contain color codes. The
-                      application can still override this explicitly.
-        """
-        exc_info = None
-        with self.isolation(input=input, env=env, color=color) as outstreams:
-            exception = None
-            exit_code = 0
-
-            if isinstance(args, string_types):
-                args = shlex.split(args)
-
-            try:
-                prog_name = extra.pop("prog_name")
-            except KeyError:
-                prog_name = self.get_default_prog_name(cli)
-
-            try:
-                cli.main(args=args or (), prog_name=prog_name, **extra)
-            except SystemExit as e:
-                exc_info = sys.exc_info()
-                exit_code = e.code
-                if exit_code is None:
-                    exit_code = 0
-
-                if exit_code != 0:
-                    exception = e
-
-                if not isinstance(exit_code, int):
-                    sys.stdout.write(str(exit_code))
-                    sys.stdout.write('\n')
-                    exit_code = 1
-
-            except Exception as e:
-                if not catch_exceptions:
-                    raise
-                exception = e
-                exit_code = 1
-                exc_info = sys.exc_info()
-            finally:
-                sys.stdout.flush()
-                stdout = outstreams[0].getvalue()
-                stderr = outstreams[1] and outstreams[1].getvalue()
-
-        return Result(runner=self,
-                      stdout_bytes=stdout,
-                      stderr_bytes=stderr,
-                      exit_code=exit_code,
-                      exception=exception,
-                      exc_info=exc_info)
-
-    @contextlib.contextmanager
-    def isolated_filesystem(self):
-        """A context manager that creates a temporary folder and changes
-        the current working directory to it for isolated filesystem tests.
-        """
-        cwd = os.getcwd()
-        t = tempfile.mkdtemp()
-        os.chdir(t)
-        try:
-            yield t
-        finally:
-            os.chdir(cwd)
-            try:
-                shutil.rmtree(t)
-            except (OSError, IOError):
-                pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/types.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/types.py
deleted file mode 100644
index 1f88032f5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/types.py
+++ /dev/null
@@ -1,668 +0,0 @@
-import os
-import stat
-from datetime import datetime
-
-from ._compat import open_stream, text_type, filename_to_ui, \
-    get_filesystem_encoding, get_streerror, _get_argv_encoding, PY2
-from .exceptions import BadParameter
-from .utils import safecall, LazyFile
-
-
-class ParamType(object):
-    """Helper for converting values through types.  The following is
-    necessary for a valid type:
-
-    *   it needs a name
-    *   it needs to pass through None unchanged
-    *   it needs to convert from a string
-    *   it needs to convert its result type through unchanged
-        (eg: needs to be idempotent)
-    *   it needs to be able to deal with param and context being `None`.
-        This can be the case when the object is used with prompt
-        inputs.
-    """
-    is_composite = False
-
-    #: the descriptive name of this type
-    name = None
-
-    #: if a list of this type is expected and the value is pulled from a
-    #: string environment variable, this is what splits it up.  `None`
-    #: means any whitespace.  For all parameters the general rule is that
-    #: whitespace splits them up.  The exception are paths and files which
-    #: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
-    #: Windows).
-    envvar_list_splitter = None
-
-    def __call__(self, value, param=None, ctx=None):
-        if value is not None:
-            return self.convert(value, param, ctx)
-
-    def get_metavar(self, param):
-        """Returns the metavar default for this param if it provides one."""
-
-    def get_missing_message(self, param):
-        """Optionally might return extra information about a missing
-        parameter.
-
-        .. versionadded:: 2.0
-        """
-
-    def convert(self, value, param, ctx):
-        """Converts the value.  This is not invoked for values that are
-        `None` (the missing value).
-        """
-        return value
-
-    def split_envvar_value(self, rv):
-        """Given a value from an environment variable this splits it up
-        into small chunks depending on the defined envvar list splitter.
-
-        If the splitter is set to `None`, which means that whitespace splits,
-        then leading and trailing whitespace is ignored.  Otherwise, leading
-        and trailing splitters usually lead to empty items being included.
-        """
-        return (rv or '').split(self.envvar_list_splitter)
-
-    def fail(self, message, param=None, ctx=None):
-        """Helper method to fail with an invalid value message."""
-        raise BadParameter(message, ctx=ctx, param=param)
-
-
-class CompositeParamType(ParamType):
-    is_composite = True
-
-    @property
-    def arity(self):
-        raise NotImplementedError()
-
-
-class FuncParamType(ParamType):
-
-    def __init__(self, func):
-        self.name = func.__name__
-        self.func = func
-
-    def convert(self, value, param, ctx):
-        try:
-            return self.func(value)
-        except ValueError:
-            try:
-                value = text_type(value)
-            except UnicodeError:
-                value = str(value).decode('utf-8', 'replace')
-            self.fail(value, param, ctx)
-
-
-class UnprocessedParamType(ParamType):
-    name = 'text'
-
-    def convert(self, value, param, ctx):
-        return value
-
-    def __repr__(self):
-        return 'UNPROCESSED'
-
-
-class StringParamType(ParamType):
-    name = 'text'
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, bytes):
-            enc = _get_argv_encoding()
-            try:
-                value = value.decode(enc)
-            except UnicodeError:
-                fs_enc = get_filesystem_encoding()
-                if fs_enc != enc:
-                    try:
-                        value = value.decode(fs_enc)
-                    except UnicodeError:
-                        value = value.decode('utf-8', 'replace')
-            return value
-        return value
-
-    def __repr__(self):
-        return 'STRING'
-
-
-class Choice(ParamType):
-    """The choice type allows a value to be checked against a fixed set
-    of supported values. All of these values have to be strings.
-
-    You should only pass a list or tuple of choices. Other iterables
-    (like generators) may lead to surprising results.
-
-    See :ref:`choice-opts` for an example.
-
-    :param case_sensitive: Set to false to make choices case
-        insensitive. Defaults to true.
-    """
-
-    name = 'choice'
-
-    def __init__(self, choices, case_sensitive=True):
-        self.choices = choices
-        self.case_sensitive = case_sensitive
-
-    def get_metavar(self, param):
-        return '[%s]' % '|'.join(self.choices)
-
-    def get_missing_message(self, param):
-        return 'Choose from:\n\t%s.' % ',\n\t'.join(self.choices)
-
-    def convert(self, value, param, ctx):
-        # Exact match
-        if value in self.choices:
-            return value
-
-        # Match through normalization and case sensitivity
-        # first do token_normalize_func, then lowercase
-        # preserve original `value` to produce an accurate message in
-        # `self.fail`
-        normed_value = value
-        normed_choices = self.choices
-
-        if ctx is not None and \
-           ctx.token_normalize_func is not None:
-            normed_value = ctx.token_normalize_func(value)
-            normed_choices = [ctx.token_normalize_func(choice) for choice in
-                              self.choices]
-
-        if not self.case_sensitive:
-            normed_value = normed_value.lower()
-            normed_choices = [choice.lower() for choice in normed_choices]
-
-        if normed_value in normed_choices:
-            return normed_value
-
-        self.fail('invalid choice: %s. (choose from %s)' %
-                  (value, ', '.join(self.choices)), param, ctx)
-
-    def __repr__(self):
-        return 'Choice(%r)' % list(self.choices)
-
-
-class DateTime(ParamType):
-    """The DateTime type converts date strings into `datetime` objects.
-
-    The format strings which are checked are configurable, but default to some
-    common (non-timezone aware) ISO 8601 formats.
-
-    When specifying *DateTime* formats, you should only pass a list or a tuple.
-    Other iterables, like generators, may lead to surprising results.
-
-    The format strings are processed using ``datetime.strptime``, and this
-    consequently defines the format strings which are allowed.
-
-    Parsing is tried using each format, in order, and the first format which
-    parses successfully is used.
-
-    :param formats: A list or tuple of date format strings, in the order in
-                    which they should be tried. Defaults to
-                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
-                    ``'%Y-%m-%d %H:%M:%S'``.
-    """
-    name = 'datetime'
-
-    def __init__(self, formats=None):
-        self.formats = formats or [
-            '%Y-%m-%d',
-            '%Y-%m-%dT%H:%M:%S',
-            '%Y-%m-%d %H:%M:%S'
-        ]
-
-    def get_metavar(self, param):
-        return '[{}]'.format('|'.join(self.formats))
-
-    def _try_to_convert_date(self, value, format):
-        try:
-            return datetime.strptime(value, format)
-        except ValueError:
-            return None
-
-    def convert(self, value, param, ctx):
-        # Exact match
-        for format in self.formats:
-            dtime = self._try_to_convert_date(value, format)
-            if dtime:
-                return dtime
-
-        self.fail(
-            'invalid datetime format: {}. (choose from {})'.format(
-                value, ', '.join(self.formats)))
-
-    def __repr__(self):
-        return 'DateTime'
-
-
-class IntParamType(ParamType):
-    name = 'integer'
-
-    def convert(self, value, param, ctx):
-        try:
-            return int(value)
-        except (ValueError, UnicodeError):
-            self.fail('%s is not a valid integer' % value, param, ctx)
-
-    def __repr__(self):
-        return 'INT'
-
-
-class IntRange(IntParamType):
-    """A parameter that works similar to :data:`click.INT` but restricts
-    the value to fit into a range.  The default behavior is to fail if the
-    value falls outside the range, but it can also be silently clamped
-    between the two edges.
-
-    See :ref:`ranges` for an example.
-    """
-    name = 'integer range'
-
-    def __init__(self, min=None, max=None, clamp=False):
-        self.min = min
-        self.max = max
-        self.clamp = clamp
-
-    def convert(self, value, param, ctx):
-        rv = IntParamType.convert(self, value, param, ctx)
-        if self.clamp:
-            if self.min is not None and rv < self.min:
-                return self.min
-            if self.max is not None and rv > self.max:
-                return self.max
-        if self.min is not None and rv < self.min or \
-           self.max is not None and rv > self.max:
-            if self.min is None:
-                self.fail('%s is bigger than the maximum valid value '
-                          '%s.' % (rv, self.max), param, ctx)
-            elif self.max is None:
-                self.fail('%s is smaller than the minimum valid value '
-                          '%s.' % (rv, self.min), param, ctx)
-            else:
-                self.fail('%s is not in the valid range of %s to %s.'
-                          % (rv, self.min, self.max), param, ctx)
-        return rv
-
-    def __repr__(self):
-        return 'IntRange(%r, %r)' % (self.min, self.max)
-
-
-class FloatParamType(ParamType):
-    name = 'float'
-
-    def convert(self, value, param, ctx):
-        try:
-            return float(value)
-        except (UnicodeError, ValueError):
-            self.fail('%s is not a valid floating point value' %
-                      value, param, ctx)
-
-    def __repr__(self):
-        return 'FLOAT'
-
-
-class FloatRange(FloatParamType):
-    """A parameter that works similar to :data:`click.FLOAT` but restricts
-    the value to fit into a range.  The default behavior is to fail if the
-    value falls outside the range, but it can also be silently clamped
-    between the two edges.
-
-    See :ref:`ranges` for an example.
-    """
-    name = 'float range'
-
-    def __init__(self, min=None, max=None, clamp=False):
-        self.min = min
-        self.max = max
-        self.clamp = clamp
-
-    def convert(self, value, param, ctx):
-        rv = FloatParamType.convert(self, value, param, ctx)
-        if self.clamp:
-            if self.min is not None and rv < self.min:
-                return self.min
-            if self.max is not None and rv > self.max:
-                return self.max
-        if self.min is not None and rv < self.min or \
-           self.max is not None and rv > self.max:
-            if self.min is None:
-                self.fail('%s is bigger than the maximum valid value '
-                          '%s.' % (rv, self.max), param, ctx)
-            elif self.max is None:
-                self.fail('%s is smaller than the minimum valid value '
-                          '%s.' % (rv, self.min), param, ctx)
-            else:
-                self.fail('%s is not in the valid range of %s to %s.'
-                          % (rv, self.min, self.max), param, ctx)
-        return rv
-
-    def __repr__(self):
-        return 'FloatRange(%r, %r)' % (self.min, self.max)
-
-
-class BoolParamType(ParamType):
-    name = 'boolean'
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, bool):
-            return bool(value)
-        value = value.lower()
-        if value in ('true', 't', '1', 'yes', 'y'):
-            return True
-        elif value in ('false', 'f', '0', 'no', 'n'):
-            return False
-        self.fail('%s is not a valid boolean' % value, param, ctx)
-
-    def __repr__(self):
-        return 'BOOL'
-
-
-class UUIDParameterType(ParamType):
-    name = 'uuid'
-
-    def convert(self, value, param, ctx):
-        import uuid
-        try:
-            if PY2 and isinstance(value, text_type):
-                value = value.encode('ascii')
-            return uuid.UUID(value)
-        except (UnicodeError, ValueError):
-            self.fail('%s is not a valid UUID value' % value, param, ctx)
-
-    def __repr__(self):
-        return 'UUID'
-
-
-class File(ParamType):
-    """Declares a parameter to be a file for reading or writing.  The file
-    is automatically closed once the context tears down (after the command
-    finished working).
-
-    Files can be opened for reading or writing.  The special value ``-``
-    indicates stdin or stdout depending on the mode.
-
-    By default, the file is opened for reading text data, but it can also be
-    opened in binary mode or for writing.  The encoding parameter can be used
-    to force a specific encoding.
-
-    The `lazy` flag controls if the file should be opened immediately or upon
-    first IO. The default is to be non-lazy for standard input and output
-    streams as well as files opened for reading, `lazy` otherwise. When opening a
-    file lazily for reading, it is still opened temporarily for validation, but
-    will not be held open until first IO. lazy is mainly useful when opening
-    for writing to avoid creating the file until it is needed.
-
-    Starting with Click 2.0, files can also be opened atomically in which
-    case all writes go into a separate file in the same folder and upon
-    completion the file will be moved over to the original location.  This
-    is useful if a file regularly read by other users is modified.
-
-    See :ref:`file-args` for more information.
-    """
-    name = 'filename'
-    envvar_list_splitter = os.path.pathsep
-
-    def __init__(self, mode='r', encoding=None, errors='strict', lazy=None,
-                 atomic=False):
-        self.mode = mode
-        self.encoding = encoding
-        self.errors = errors
-        self.lazy = lazy
-        self.atomic = atomic
-
-    def resolve_lazy_flag(self, value):
-        if self.lazy is not None:
-            return self.lazy
-        if value == '-':
-            return False
-        elif 'w' in self.mode:
-            return True
-        return False
-
-    def convert(self, value, param, ctx):
-        try:
-            if hasattr(value, 'read') or hasattr(value, 'write'):
-                return value
-
-            lazy = self.resolve_lazy_flag(value)
-
-            if lazy:
-                f = LazyFile(value, self.mode, self.encoding, self.errors,
-                             atomic=self.atomic)
-                if ctx is not None:
-                    ctx.call_on_close(f.close_intelligently)
-                return f
-
-            f, should_close = open_stream(value, self.mode,
-                                          self.encoding, self.errors,
-                                          atomic=self.atomic)
-            # If a context is provided, we automatically close the file
-            # at the end of the context execution (or flush out).  If a
-            # context does not exist, it's the caller's responsibility to
-            # properly close the file.  This for instance happens when the
-            # type is used with prompts.
-            if ctx is not None:
-                if should_close:
-                    ctx.call_on_close(safecall(f.close))
-                else:
-                    ctx.call_on_close(safecall(f.flush))
-            return f
-        except (IOError, OSError) as e:
-            self.fail('Could not open file: %s: %s' % (
-                filename_to_ui(value),
-                get_streerror(e),
-            ), param, ctx)
-
-
-class Path(ParamType):
-    """The path type is similar to the :class:`File` type but it performs
-    different checks.  First of all, instead of returning an open file
-    handle it returns just the filename.  Secondly, it can perform various
-    basic checks about what the file or directory should be.
-
-    .. versionchanged:: 6.0
-       `allow_dash` was added.
-
-    :param exists: if set to true, the file or directory needs to exist for
-                   this value to be valid.  If this is not required and a
-                   file does indeed not exist, then all further checks are
-                   silently skipped.
-    :param file_okay: controls if a file is a possible value.
-    :param dir_okay: controls if a directory is a possible value.
-    :param writable: if true, a writable check is performed.
-    :param readable: if true, a readable check is performed.
-    :param resolve_path: if this is true, then the path is fully resolved
-                         before the value is passed onwards.  This means
-                         that it's absolute and symlinks are resolved.  It
-                         will not expand a tilde-prefix, as this is
-                         supposed to be done by the shell only.
-    :param allow_dash: If this is set to `True`, a single dash to indicate
-                       standard streams is permitted.
-    :param path_type: optionally a string type that should be used to
-                      represent the path.  The default is `None` which
-                      means the return value will be either bytes or
-                      unicode depending on what makes most sense given the
-                      input data Click deals with.
-    """
-    envvar_list_splitter = os.path.pathsep
-
-    def __init__(self, exists=False, file_okay=True, dir_okay=True,
-                 writable=False, readable=True, resolve_path=False,
-                 allow_dash=False, path_type=None):
-        self.exists = exists
-        self.file_okay = file_okay
-        self.dir_okay = dir_okay
-        self.writable = writable
-        self.readable = readable
-        self.resolve_path = resolve_path
-        self.allow_dash = allow_dash
-        self.type = path_type
-
-        if self.file_okay and not self.dir_okay:
-            self.name = 'file'
-            self.path_type = 'File'
-        elif self.dir_okay and not self.file_okay:
-            self.name = 'directory'
-            self.path_type = 'Directory'
-        else:
-            self.name = 'path'
-            self.path_type = 'Path'
-
-    def coerce_path_result(self, rv):
-        if self.type is not None and not isinstance(rv, self.type):
-            if self.type is text_type:
-                rv = rv.decode(get_filesystem_encoding())
-            else:
-                rv = rv.encode(get_filesystem_encoding())
-        return rv
-
-    def convert(self, value, param, ctx):
-        rv = value
-
-        is_dash = self.file_okay and self.allow_dash and rv in (b'-', '-')
-
-        if not is_dash:
-            if self.resolve_path:
-                rv = os.path.realpath(rv)
-
-            try:
-                st = os.stat(rv)
-            except OSError:
-                if not self.exists:
-                    return self.coerce_path_result(rv)
-                self.fail('%s "%s" does not exist.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
-
-            if not self.file_okay and stat.S_ISREG(st.st_mode):
-                self.fail('%s "%s" is a file.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
-            if not self.dir_okay and stat.S_ISDIR(st.st_mode):
-                self.fail('%s "%s" is a directory.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
-            if self.writable and not os.access(value, os.W_OK):
-                self.fail('%s "%s" is not writable.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
-            if self.readable and not os.access(value, os.R_OK):
-                self.fail('%s "%s" is not readable.' % (
-                    self.path_type,
-                    filename_to_ui(value)
-                ), param, ctx)
-
-        return self.coerce_path_result(rv)
-
-
-class Tuple(CompositeParamType):
-    """The default behavior of Click is to apply a type on a value directly.
-    This works well in most cases, except for when `nargs` is set to a fixed
-    count and different types should be used for different items.  In this
-    case the :class:`Tuple` type can be used.  This type can only be used
-    if `nargs` is set to a fixed number.
-
-    For more information see :ref:`tuple-type`.
-
-    This can be selected by using a Python tuple literal as a type.
-
-    :param types: a list of types that should be used for the tuple items.
-    """
-
-    def __init__(self, types):
-        self.types = [convert_type(ty) for ty in types]
-
-    @property
-    def name(self):
-        return "<" + " ".join(ty.name for ty in self.types) + ">"
-
-    @property
-    def arity(self):
-        return len(self.types)
-
-    def convert(self, value, param, ctx):
-        if len(value) != len(self.types):
-            raise TypeError('It would appear that nargs is set to conflict '
-                            'with the composite type arity.')
-        return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
-
-
-def convert_type(ty, default=None):
-    """Converts a callable or python ty into the most appropriate param
-    ty.
-    """
-    guessed_type = False
-    if ty is None and default is not None:
-        if isinstance(default, tuple):
-            ty = tuple(map(type, default))
-        else:
-            ty = type(default)
-        guessed_type = True
-
-    if isinstance(ty, tuple):
-        return Tuple(ty)
-    if isinstance(ty, ParamType):
-        return ty
-    if ty is text_type or ty is str or ty is None:
-        return STRING
-    if ty is int:
-        return INT
-    # Booleans are only okay if not guessed.  This is done because for
-    # flags the default value is actually a bit of a lie in that it
-    # indicates which of the flags is the one we want.  See get_default()
-    # for more information.
-    if ty is bool and not guessed_type:
-        return BOOL
-    if ty is float:
-        return FLOAT
-    if guessed_type:
-        return STRING
-
-    # Catch a common mistake
-    if __debug__:
-        try:
-            if issubclass(ty, ParamType):
-                raise AssertionError('Attempted to use an uninstantiated '
-                                     'parameter type (%s).' % ty)
-        except TypeError:
-            pass
-    return FuncParamType(ty)
-
-
-#: A dummy parameter type that just does nothing.  From a user's
-#: perspective this appears to just be the same as `STRING` but internally
-#: no string conversion takes place.  This is necessary to achieve the
-#: same bytes/unicode behavior on Python 2/3 in situations where you want
-#: to not convert argument types.  This is usually useful when working
-#: with file paths as they can appear in bytes and unicode.
-#:
-#: For path related uses the :class:`Path` type is a better choice but
-#: there are situations where an unprocessed type is useful which is why
-#: it is is provided.
-#:
-#: .. versionadded:: 4.0
-UNPROCESSED = UnprocessedParamType()
-
-#: A unicode string parameter type which is the implicit default.  This
-#: can also be selected by using ``str`` as type.
-STRING = StringParamType()
-
-#: An integer parameter.  This can also be selected by using ``int`` as
-#: type.
-INT = IntParamType()
-
-#: A floating point value parameter.  This can also be selected by using
-#: ``float`` as type.
-FLOAT = FloatParamType()
-
-#: A boolean parameter.  This is the default for boolean flags.  This can
-#: also be selected by using ``bool`` as a type.
-BOOL = BoolParamType()
-
-#: A UUID parameter.
-UUID = UUIDParameterType()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/utils.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/utils.py
deleted file mode 100644
index fc84369fc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/click/utils.py
+++ /dev/null
@@ -1,440 +0,0 @@
-import os
-import sys
-
-from .globals import resolve_color_default
-
-from ._compat import text_type, open_stream, get_filesystem_encoding, \
-    get_streerror, string_types, PY2, binary_streams, text_streams, \
-    filename_to_ui, auto_wrap_for_ansi, strip_ansi, should_strip_ansi, \
-    _default_text_stdout, _default_text_stderr, is_bytes, WIN
-
-if not PY2:
-    from ._compat import _find_binary_writer
-elif WIN:
-    from ._winconsole import _get_windows_argv, \
-         _hash_py_argv, _initial_argv_hash
-
-
-echo_native_types = string_types + (bytes, bytearray)
-
-
-def _posixify(name):
-    return '-'.join(name.split()).lower()
-
-
-def safecall(func):
-    """Wraps a function so that it swallows exceptions."""
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception:
-            pass
-    return wrapper
-
-
-def make_str(value):
-    """Converts a value into a valid string."""
-    if isinstance(value, bytes):
-        try:
-            return value.decode(get_filesystem_encoding())
-        except UnicodeError:
-            return value.decode('utf-8', 'replace')
-    return text_type(value)
-
-
-def make_default_short_help(help, max_length=45):
-    """Return a condensed version of help string."""
-    words = help.split()
-    total_length = 0
-    result = []
-    done = False
-
-    for word in words:
-        if word[-1:] == '.':
-            done = True
-        new_length = result and 1 + len(word) or len(word)
-        if total_length + new_length > max_length:
-            result.append('...')
-            done = True
-        else:
-            if result:
-                result.append(' ')
-            result.append(word)
-        if done:
-            break
-        total_length += new_length
-
-    return ''.join(result)
-
-
-class LazyFile(object):
-    """A lazy file works like a regular file but it does not fully open
-    the file but it does perform some basic checks early to see if the
-    filename parameter does make sense.  This is useful for safely opening
-    files for writing.
-    """
-
-    def __init__(self, filename, mode='r', encoding=None, errors='strict',
-                 atomic=False):
-        self.name = filename
-        self.mode = mode
-        self.encoding = encoding
-        self.errors = errors
-        self.atomic = atomic
-
-        if filename == '-':
-            self._f, self.should_close = open_stream(filename, mode,
-                                                     encoding, errors)
-        else:
-            if 'r' in mode:
-                # Open and close the file in case we're opening it for
-                # reading so that we can catch at least some errors in
-                # some cases early.
-                open(filename, mode).close()
-            self._f = None
-            self.should_close = True
-
-    def __getattr__(self, name):
-        return getattr(self.open(), name)
-
-    def __repr__(self):
-        if self._f is not None:
-            return repr(self._f)
-        return '<unopened file %r %s>' % (self.name, self.mode)
-
-    def open(self):
-        """Opens the file if it's not yet open.  This call might fail with
-        a :exc:`FileError`.  Not handling this error will produce an error
-        that Click shows.
-        """
-        if self._f is not None:
-            return self._f
-        try:
-            rv, self.should_close = open_stream(self.name, self.mode,
-                                                self.encoding,
-                                                self.errors,
-                                                atomic=self.atomic)
-        except (IOError, OSError) as e:
-            from .exceptions import FileError
-            raise FileError(self.name, hint=get_streerror(e))
-        self._f = rv
-        return rv
-
-    def close(self):
-        """Closes the underlying file, no matter what."""
-        if self._f is not None:
-            self._f.close()
-
-    def close_intelligently(self):
-        """This function only closes the file if it was opened by the lazy
-        file wrapper.  For instance this will never close stdin.
-        """
-        if self.should_close:
-            self.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close_intelligently()
-
-    def __iter__(self):
-        self.open()
-        return iter(self._f)
-
-
-class KeepOpenFile(object):
-
-    def __init__(self, file):
-        self._file = file
-
-    def __getattr__(self, name):
-        return getattr(self._file, name)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        pass
-
-    def __repr__(self):
-        return repr(self._file)
-
-    def __iter__(self):
-        return iter(self._file)
-
-
-def echo(message=None, file=None, nl=True, err=False, color=None):
-    """Prints a message plus a newline to the given file or stdout.  On
-    first sight, this looks like the print function, but it has improved
-    support for handling Unicode and binary data that does not fail no
-    matter how badly configured the system is.
-
-    Primarily it means that you can print binary data as well as Unicode
-    data on both 2.x and 3.x to the given file in the most appropriate way
-    possible.  This is a very carefree function in that it will try its
-    best to not fail.  As of Click 6.0 this includes support for unicode
-    output on the Windows console.
-
-    In addition to that, if `colorama`_ is installed, the echo function will
-    also support clever handling of ANSI codes.  Essentially it will then
-    do the following:
-
-    -   add transparent handling of ANSI color codes on Windows.
-    -   hide ANSI codes automatically if the destination file is not a
-        terminal.
-
-    .. _colorama: https://pypi.org/project/colorama/
-
-    .. versionchanged:: 6.0
-       As of Click 6.0 the echo function will properly support unicode
-       output on the windows console.  Not that click does not modify
-       the interpreter in any way which means that `sys.stdout` or the
-       print statement or function will still not provide unicode support.
-
-    .. versionchanged:: 2.0
-       Starting with version 2.0 of Click, the echo function will work
-       with colorama if it's installed.
-
-    .. versionadded:: 3.0
-       The `err` parameter was added.
-
-    .. versionchanged:: 4.0
-       Added the `color` flag.
-
-    :param message: the message to print
-    :param file: the file to write to (defaults to ``stdout``)
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``.  This is faster and easier than calling
-                :func:`get_text_stderr` yourself.
-    :param nl: if set to `True` (the default) a newline is printed afterwards.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.
-    """
-    if file is None:
-        if err:
-            file = _default_text_stderr()
-        else:
-            file = _default_text_stdout()
-
-    # Convert non bytes/text into the native string type.
-    if message is not None and not isinstance(message, echo_native_types):
-        message = text_type(message)
-
-    if nl:
-        message = message or u''
-        if isinstance(message, text_type):
-            message += u'\n'
-        else:
-            message += b'\n'
-
-    # If there is a message, and we're in Python 3, and the value looks
-    # like bytes, we manually need to find the binary stream and write the
-    # message in there.  This is done separately so that most stream
-    # types will work as you would expect.  Eg: you can write to StringIO
-    # for other cases.
-    if message and not PY2 and is_bytes(message):
-        binary_file = _find_binary_writer(file)
-        if binary_file is not None:
-            file.flush()
-            binary_file.write(message)
-            binary_file.flush()
-            return
-
-    # ANSI-style support.  If there is no message or we are dealing with
-    # bytes nothing is happening.  If we are connected to a file we want
-    # to strip colors.  If we are on windows we either wrap the stream
-    # to strip the color or we use the colorama support to translate the
-    # ansi codes to API calls.
-    if message and not is_bytes(message):
-        color = resolve_color_default(color)
-        if should_strip_ansi(file, color):
-            message = strip_ansi(message)
-        elif WIN:
-            if auto_wrap_for_ansi is not None:
-                file = auto_wrap_for_ansi(file)
-            elif not color:
-                message = strip_ansi(message)
-
-    if message:
-        file.write(message)
-    file.flush()
-
-
-def get_binary_stream(name):
-    """Returns a system stream for byte processing.  This essentially
-    returns the stream from the sys module with the given name but it
-    solves some compatibility issues between different Python versions.
-    Primarily this function is necessary for getting binary streams on
-    Python 3.
-
-    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
-                 ``'stdout'`` and ``'stderr'``
-    """
-    opener = binary_streams.get(name)
-    if opener is None:
-        raise TypeError('Unknown standard stream %r' % name)
-    return opener()
-
-
-def get_text_stream(name, encoding=None, errors='strict'):
-    """Returns a system stream for text processing.  This usually returns
-    a wrapped stream around a binary stream returned from
-    :func:`get_binary_stream` but it also can take shortcuts on Python 3
-    for already correctly configured streams.
-
-    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
-                 ``'stdout'`` and ``'stderr'``
-    :param encoding: overrides the detected default encoding.
-    :param errors: overrides the default error mode.
-    """
-    opener = text_streams.get(name)
-    if opener is None:
-        raise TypeError('Unknown standard stream %r' % name)
-    return opener(encoding, errors)
-
-
-def open_file(filename, mode='r', encoding=None, errors='strict',
-              lazy=False, atomic=False):
-    """This is similar to how the :class:`File` works but for manual
-    usage.  Files are opened non lazy by default.  This can open regular
-    files as well as stdin/stdout if ``'-'`` is passed.
-
-    If stdin/stdout is returned the stream is wrapped so that the context
-    manager will not close the stream accidentally.  This makes it possible
-    to always use the function like this without having to worry to
-    accidentally close a standard stream::
-
-        with open_file(filename) as f:
-            ...
-
-    .. versionadded:: 3.0
-
-    :param filename: the name of the file to open (or ``'-'`` for stdin/stdout).
-    :param mode: the mode in which to open the file.
-    :param encoding: the encoding to use.
-    :param errors: the error handling for this file.
-    :param lazy: can be flipped to true to open the file lazily.
-    :param atomic: in atomic mode writes go into a temporary file and it's
-                   moved on close.
-    """
-    if lazy:
-        return LazyFile(filename, mode, encoding, errors, atomic=atomic)
-    f, should_close = open_stream(filename, mode, encoding, errors,
-                                  atomic=atomic)
-    if not should_close:
-        f = KeepOpenFile(f)
-    return f
-
-
-def get_os_args():
-    """This returns the argument part of sys.argv in the most appropriate
-    form for processing.  What this means is that this return value is in
-    a format that works for Click to process but does not necessarily
-    correspond well to what's actually standard for the interpreter.
-
-    On most environments the return value is ``sys.argv[:1]`` unchanged.
-    However if you are on Windows and running Python 2 the return value
-    will actually be a list of unicode strings instead because the
-    default behavior on that platform otherwise will not be able to
-    carry all possible values that sys.argv can have.
-
-    .. versionadded:: 6.0
-    """
-    # We can only extract the unicode argv if sys.argv has not been
-    # changed since the startup of the application.
-    if PY2 and WIN and _initial_argv_hash == _hash_py_argv():
-        return _get_windows_argv()
-    return sys.argv[1:]
-
-
-def format_filename(filename, shorten=False):
-    """Formats a filename for user display.  The main purpose of this
-    function is to ensure that the filename can be displayed at all.  This
-    will decode the filename to unicode if necessary in a way that it will
-    not fail.  Optionally, it can shorten the filename to not include the
-    full path to the filename.
-
-    :param filename: formats a filename for UI display.  This will also convert
-                     the filename into unicode without failing.
-    :param shorten: this optionally shortens the filename to strip of the
-                    path that leads up to it.
-    """
-    if shorten:
-        filename = os.path.basename(filename)
-    return filename_to_ui(filename)
-
-
-def get_app_dir(app_name, roaming=True, force_posix=False):
-    r"""Returns the config folder for the application.  The default behavior
-    is to return whatever is most appropriate for the operating system.
-
-    To give you an idea, for an app called ``"Foo Bar"``, something like
-    the following folders could be returned:
-
-    Mac OS X:
-      ``~/Library/Application Support/Foo Bar``
-    Mac OS X (POSIX):
-      ``~/.foo-bar``
-    Unix:
-      ``~/.config/foo-bar``
-    Unix (POSIX):
-      ``~/.foo-bar``
-    Win XP (roaming):
-      ``C:\Documents and Settings\<user>\Local Settings\Application Data\Foo Bar``
-    Win XP (not roaming):
-      ``C:\Documents and Settings\<user>\Application Data\Foo Bar``
-    Win 7 (roaming):
-      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
-    Win 7 (not roaming):
-      ``C:\Users\<user>\AppData\Local\Foo Bar``
-
-    .. versionadded:: 2.0
-
-    :param app_name: the application name.  This should be properly capitalized
-                     and can contain whitespace.
-    :param roaming: controls if the folder should be roaming or not on Windows.
-                    Has no affect otherwise.
-    :param force_posix: if this is set to `True` then on any POSIX system the
-                        folder will be stored in the home folder with a leading
-                        dot instead of the XDG config home or darwin's
-                        application support folder.
-    """
-    if WIN:
-        key = roaming and 'APPDATA' or 'LOCALAPPDATA'
-        folder = os.environ.get(key)
-        if folder is None:
-            folder = os.path.expanduser('~')
-        return os.path.join(folder, app_name)
-    if force_posix:
-        return os.path.join(os.path.expanduser('~/.' + _posixify(app_name)))
-    if sys.platform == 'darwin':
-        return os.path.join(os.path.expanduser(
-            '~/Library/Application Support'), app_name)
-    return os.path.join(
-        os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config')),
-        _posixify(app_name))
-
-
-class PacifyFlushWrapper(object):
-    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
-    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
-    of the Python interpreter. Notably ``.flush()`` is always called on
-    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
-    other cleanup code, and the case where the underlying file is not a broken
-    pipe, all calls and attributes are proxied.
-    """
-
-    def __init__(self, wrapped):
-        self.wrapped = wrapped
-
-    def flush(self):
-        try:
-            self.wrapped.flush()
-        except IOError as e:
-            import errno
-            if e.errno != errno.EPIPE:
-                raise
-
-    def __getattr__(self, attr):
-        return getattr(self.wrapped, attr)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/easy_install.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/easy_install.py
deleted file mode 100644
index d87e98403..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/easy_install.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Run the EasyInstall command"""
-
-if __name__ == '__main__':
-    from setuptools.command.easy_install import main
-    main()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__init__.py
deleted file mode 100644
index ded198224..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__init__.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask
-    ~~~~~
-
-    A microframework based on Werkzeug.  It's extensively documented
-    and follows best practice patterns.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-__version__ = '1.0.2'
-
-# utilities we import from Werkzeug and Jinja2 that are unused
-# in the module but are exported as public interface.
-from werkzeug.exceptions import abort
-from werkzeug.utils import redirect
-from jinja2 import Markup, escape
-
-from .app import Flask, Request, Response
-from .config import Config
-from .helpers import url_for, flash, send_file, send_from_directory, \
-     get_flashed_messages, get_template_attribute, make_response, safe_join, \
-     stream_with_context
-from .globals import current_app, g, request, session, _request_ctx_stack, \
-     _app_ctx_stack
-from .ctx import has_request_context, has_app_context, \
-     after_this_request, copy_current_request_context
-from .blueprints import Blueprint
-from .templating import render_template, render_template_string
-
-# the signals
-from .signals import signals_available, template_rendered, request_started, \
-     request_finished, got_request_exception, request_tearing_down, \
-     appcontext_tearing_down, appcontext_pushed, \
-     appcontext_popped, message_flashed, before_render_template
-
-# We're not exposing the actual json module but a convenient wrapper around
-# it.
-from . import json
-
-# This was the only thing that Flask used to export at one point and it had
-# a more generic name.
-jsonify = json.jsonify
-
-# backwards compat, goes away in 1.0
-from .sessions import SecureCookieSession as Session
-json_available = True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__main__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__main__.py
deleted file mode 100644
index 4aee65437..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__main__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.__main__
-    ~~~~~~~~~~~~~~
-
-    Alias for flask.run for the command line.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-if __name__ == '__main__':
-    from .cli import main
-    main(as_module=True)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 36aa24ba5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__main__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__main__.cpython-35.pyc
deleted file mode 100644
index 8db3dbfe6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/__main__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 2b4cf2d94..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/app.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/app.cpython-35.pyc
deleted file mode 100644
index 4f50f6610..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/app.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/blueprints.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/blueprints.cpython-35.pyc
deleted file mode 100644
index 6430b39a6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/blueprints.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/cli.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/cli.cpython-35.pyc
deleted file mode 100644
index b389a5481..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/cli.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/config.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/config.cpython-35.pyc
deleted file mode 100644
index a1c3f8c92..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/config.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/ctx.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/ctx.cpython-35.pyc
deleted file mode 100644
index cf379442c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/ctx.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/debughelpers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/debughelpers.cpython-35.pyc
deleted file mode 100644
index 9d60e3773..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/debughelpers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/globals.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/globals.cpython-35.pyc
deleted file mode 100644
index a2b33fedc..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/globals.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/helpers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/helpers.cpython-35.pyc
deleted file mode 100644
index d25ecf220..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/helpers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/logging.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/logging.cpython-35.pyc
deleted file mode 100644
index 48d79a115..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/logging.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/sessions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/sessions.cpython-35.pyc
deleted file mode 100644
index b57058639..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/sessions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/signals.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/signals.cpython-35.pyc
deleted file mode 100644
index 0315ad1bd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/signals.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/templating.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/templating.cpython-35.pyc
deleted file mode 100644
index 98636d6b1..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/templating.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/testing.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/testing.cpython-35.pyc
deleted file mode 100644
index b0acae3e7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/testing.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/views.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/views.cpython-35.pyc
deleted file mode 100644
index fc71422a5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/views.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/wrappers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/wrappers.cpython-35.pyc
deleted file mode 100644
index 32a79104b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/__pycache__/wrappers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/_compat.py
deleted file mode 100644
index a3b5b9c1c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/_compat.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask._compat
-    ~~~~~~~~~~~~~
-
-    Some py2/py3 compatibility support based on a stripped down
-    version of six so we don't have to depend on a specific version
-    of it.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import sys
-
-PY2 = sys.version_info[0] == 2
-_identity = lambda x: x
-
-
-if not PY2:
-    text_type = str
-    string_types = (str,)
-    integer_types = (int,)
-
-    iterkeys = lambda d: iter(d.keys())
-    itervalues = lambda d: iter(d.values())
-    iteritems = lambda d: iter(d.items())
-
-    from inspect import getfullargspec as getargspec
-    from io import StringIO
-
-    def reraise(tp, value, tb=None):
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-    implements_to_string = _identity
-
-else:
-    text_type = unicode
-    string_types = (str, unicode)
-    integer_types = (int, long)
-
-    iterkeys = lambda d: d.iterkeys()
-    itervalues = lambda d: d.itervalues()
-    iteritems = lambda d: d.iteritems()
-
-    from inspect import getargspec
-    from cStringIO import StringIO
-
-    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
-
-    def implements_to_string(cls):
-        cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
-        return cls
-
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a
-    # dummy metaclass for one level of class instantiation that replaces
-    # itself with the actual metaclass.
-    class metaclass(type):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-# Certain versions of pypy have a bug where clearing the exception stack
-# breaks the __exit__ function in a very peculiar way.  The second level of
-# exception blocks is necessary because pypy seems to forget to check if an
-# exception happened until the next bytecode instruction?
-#
-# Relevant PyPy bugfix commit:
-# https://bitbucket.org/pypy/pypy/commits/77ecf91c635a287e88e60d8ddb0f4e9df4003301
-# According to ronan on #pypy IRC, it is released in PyPy2 2.3 and later
-# versions.
-#
-# Ubuntu 14.04 has PyPy 2.2.1, which does exhibit this bug.
-BROKEN_PYPY_CTXMGR_EXIT = False
-if hasattr(sys, 'pypy_version_info'):
-    class _Mgr(object):
-        def __enter__(self):
-            return self
-        def __exit__(self, *args):
-            if hasattr(sys, 'exc_clear'):
-                # Python 3 (PyPy3) doesn't have exc_clear
-                sys.exc_clear()
-    try:
-        try:
-            with _Mgr():
-                raise AssertionError()
-        except:
-            raise
-    except TypeError:
-        BROKEN_PYPY_CTXMGR_EXIT = True
-    except AssertionError:
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/app.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/app.py
deleted file mode 100644
index 87c590034..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/app.py
+++ /dev/null
@@ -1,2315 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.app
-    ~~~~~~~~~
-
-    This module implements the central WSGI application object.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-import sys
-import warnings
-from datetime import timedelta
-from functools import update_wrapper
-from itertools import chain
-from threading import Lock
-
-from werkzeug.datastructures import Headers, ImmutableDict
-from werkzeug.exceptions import BadRequest, BadRequestKeyError, HTTPException, \
-    InternalServerError, MethodNotAllowed, default_exceptions
-from werkzeug.routing import BuildError, Map, RequestRedirect, Rule
-
-from . import cli, json
-from ._compat import integer_types, reraise, string_types, text_type
-from .config import Config, ConfigAttribute
-from .ctx import AppContext, RequestContext, _AppCtxGlobals
-from .globals import _request_ctx_stack, g, request, session
-from .helpers import (
-    _PackageBoundObject,
-    _endpoint_from_view_func, find_package, get_env, get_debug_flag,
-    get_flashed_messages, locked_cached_property, url_for, get_load_dotenv
-)
-from .logging import create_logger
-from .sessions import SecureCookieSessionInterface
-from .signals import appcontext_tearing_down, got_request_exception, \
-    request_finished, request_started, request_tearing_down
-from .templating import DispatchingJinjaLoader, Environment, \
-    _default_template_ctx_processor
-from .wrappers import Request, Response
-
-# a singleton sentinel value for parameter defaults
-_sentinel = object()
-
-
-def _make_timedelta(value):
-    if not isinstance(value, timedelta):
-        return timedelta(seconds=value)
-    return value
-
-
-def setupmethod(f):
-    """Wraps a method so that it performs a check in debug mode if the
-    first request was already handled.
-    """
-    def wrapper_func(self, *args, **kwargs):
-        if self.debug and self._got_first_request:
-            raise AssertionError('A setup function was called after the '
-                'first request was handled.  This usually indicates a bug '
-                'in the application where a module was not imported '
-                'and decorators or other functionality was called too late.\n'
-                'To fix this make sure to import all your view modules, '
-                'database models and everything related at a central place '
-                'before the application starts serving requests.')
-        return f(self, *args, **kwargs)
-    return update_wrapper(wrapper_func, f)
-
-
-class Flask(_PackageBoundObject):
-    """The flask object implements a WSGI application and acts as the central
-    object.  It is passed the name of the module or package of the
-    application.  Once it is created it will act as a central registry for
-    the view functions, the URL rules, template configuration and much more.
-
-    The name of the package is used to resolve resources from inside the
-    package or the folder the module is contained in depending on if the
-    package parameter resolves to an actual python package (a folder with
-    an :file:`__init__.py` file inside) or a standard module (just a ``.py`` file).
-
-    For more information about resource loading, see :func:`open_resource`.
-
-    Usually you create a :class:`Flask` instance in your main module or
-    in the :file:`__init__.py` file of your package like this::
-
-        from flask import Flask
-        app = Flask(__name__)
-
-    .. admonition:: About the First Parameter
-
-        The idea of the first parameter is to give Flask an idea of what
-        belongs to your application.  This name is used to find resources
-        on the filesystem, can be used by extensions to improve debugging
-        information and a lot more.
-
-        So it's important what you provide there.  If you are using a single
-        module, `__name__` is always the correct value.  If you however are
-        using a package, it's usually recommended to hardcode the name of
-        your package there.
-
-        For example if your application is defined in :file:`yourapplication/app.py`
-        you should create it with one of the two versions below::
-
-            app = Flask('yourapplication')
-            app = Flask(__name__.split('.')[0])
-
-        Why is that?  The application will work even with `__name__`, thanks
-        to how resources are looked up.  However it will make debugging more
-        painful.  Certain extensions can make assumptions based on the
-        import name of your application.  For example the Flask-SQLAlchemy
-        extension will look for the code in your application that triggered
-        an SQL query in debug mode.  If the import name is not properly set
-        up, that debugging information is lost.  (For example it would only
-        pick up SQL queries in `yourapplication.app` and not
-        `yourapplication.views.frontend`)
-
-    .. versionadded:: 0.7
-       The `static_url_path`, `static_folder`, and `template_folder`
-       parameters were added.
-
-    .. versionadded:: 0.8
-       The `instance_path` and `instance_relative_config` parameters were
-       added.
-
-    .. versionadded:: 0.11
-       The `root_path` parameter was added.
-
-    .. versionadded:: 1.0
-       The ``host_matching`` and ``static_host`` parameters were added.
-
-    .. versionadded:: 1.0
-       The ``subdomain_matching`` parameter was added. Subdomain
-       matching needs to be enabled manually now. Setting
-       :data:`SERVER_NAME` does not implicitly enable it.
-
-    :param import_name: the name of the application package
-    :param static_url_path: can be used to specify a different path for the
-                            static files on the web.  Defaults to the name
-                            of the `static_folder` folder.
-    :param static_folder: the folder with static files that should be served
-                          at `static_url_path`.  Defaults to the ``'static'``
-                          folder in the root path of the application.
-    :param static_host: the host to use when adding the static route.
-        Defaults to None. Required when using ``host_matching=True``
-        with a ``static_folder`` configured.
-    :param host_matching: set ``url_map.host_matching`` attribute.
-        Defaults to False.
-    :param subdomain_matching: consider the subdomain relative to
-        :data:`SERVER_NAME` when matching routes. Defaults to False.
-    :param template_folder: the folder that contains the templates that should
-                            be used by the application.  Defaults to
-                            ``'templates'`` folder in the root path of the
-                            application.
-    :param instance_path: An alternative instance path for the application.
-                          By default the folder ``'instance'`` next to the
-                          package or module is assumed to be the instance
-                          path.
-    :param instance_relative_config: if set to ``True`` relative filenames
-                                     for loading the config are assumed to
-                                     be relative to the instance path instead
-                                     of the application root.
-    :param root_path: Flask by default will automatically calculate the path
-                      to the root of the application.  In certain situations
-                      this cannot be achieved (for instance if the package
-                      is a Python 3 namespace package) and needs to be
-                      manually defined.
-    """
-
-    #: The class that is used for request objects.  See :class:`~flask.Request`
-    #: for more information.
-    request_class = Request
-
-    #: The class that is used for response objects.  See
-    #: :class:`~flask.Response` for more information.
-    response_class = Response
-
-    #: The class that is used for the Jinja environment.
-    #:
-    #: .. versionadded:: 0.11
-    jinja_environment = Environment
-
-    #: The class that is used for the :data:`~flask.g` instance.
-    #:
-    #: Example use cases for a custom class:
-    #:
-    #: 1. Store arbitrary attributes on flask.g.
-    #: 2. Add a property for lazy per-request database connectors.
-    #: 3. Return None instead of AttributeError on unexpected attributes.
-    #: 4. Raise exception if an unexpected attr is set, a "controlled" flask.g.
-    #:
-    #: In Flask 0.9 this property was called `request_globals_class` but it
-    #: was changed in 0.10 to :attr:`app_ctx_globals_class` because the
-    #: flask.g object is now application context scoped.
-    #:
-    #: .. versionadded:: 0.10
-    app_ctx_globals_class = _AppCtxGlobals
-
-    #: The class that is used for the ``config`` attribute of this app.
-    #: Defaults to :class:`~flask.Config`.
-    #:
-    #: Example use cases for a custom class:
-    #:
-    #: 1. Default values for certain config options.
-    #: 2. Access to config values through attributes in addition to keys.
-    #:
-    #: .. versionadded:: 0.11
-    config_class = Config
-
-    #: The testing flag.  Set this to ``True`` to enable the test mode of
-    #: Flask extensions (and in the future probably also Flask itself).
-    #: For example this might activate test helpers that have an
-    #: additional runtime cost which should not be enabled by default.
-    #:
-    #: If this is enabled and PROPAGATE_EXCEPTIONS is not changed from the
-    #: default it's implicitly enabled.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: ``TESTING`` configuration key.  Defaults to ``False``.
-    testing = ConfigAttribute('TESTING')
-
-    #: If a secret key is set, cryptographic components can use this to
-    #: sign cookies and other things. Set this to a complex random value
-    #: when you want to use the secure cookie for instance.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: :data:`SECRET_KEY` configuration key. Defaults to ``None``.
-    secret_key = ConfigAttribute('SECRET_KEY')
-
-    #: The secure cookie uses this for the name of the session cookie.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: ``SESSION_COOKIE_NAME`` configuration key.  Defaults to ``'session'``
-    session_cookie_name = ConfigAttribute('SESSION_COOKIE_NAME')
-
-    #: A :class:`~datetime.timedelta` which is used to set the expiration
-    #: date of a permanent session.  The default is 31 days which makes a
-    #: permanent session survive for roughly one month.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: ``PERMANENT_SESSION_LIFETIME`` configuration key.  Defaults to
-    #: ``timedelta(days=31)``
-    permanent_session_lifetime = ConfigAttribute('PERMANENT_SESSION_LIFETIME',
-        get_converter=_make_timedelta)
-
-    #: A :class:`~datetime.timedelta` which is used as default cache_timeout
-    #: for the :func:`send_file` functions. The default is 12 hours.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: ``SEND_FILE_MAX_AGE_DEFAULT`` configuration key. This configuration
-    #: variable can also be set with an integer value used as seconds.
-    #: Defaults to ``timedelta(hours=12)``
-    send_file_max_age_default = ConfigAttribute('SEND_FILE_MAX_AGE_DEFAULT',
-        get_converter=_make_timedelta)
-
-    #: Enable this if you want to use the X-Sendfile feature.  Keep in
-    #: mind that the server has to support this.  This only affects files
-    #: sent with the :func:`send_file` method.
-    #:
-    #: .. versionadded:: 0.2
-    #:
-    #: This attribute can also be configured from the config with the
-    #: ``USE_X_SENDFILE`` configuration key.  Defaults to ``False``.
-    use_x_sendfile = ConfigAttribute('USE_X_SENDFILE')
-
-    #: The JSON encoder class to use.  Defaults to :class:`~flask.json.JSONEncoder`.
-    #:
-    #: .. versionadded:: 0.10
-    json_encoder = json.JSONEncoder
-
-    #: The JSON decoder class to use.  Defaults to :class:`~flask.json.JSONDecoder`.
-    #:
-    #: .. versionadded:: 0.10
-    json_decoder = json.JSONDecoder
-
-    #: Options that are passed directly to the Jinja2 environment.
-    jinja_options = ImmutableDict(
-        extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']
-    )
-
-    #: Default configuration parameters.
-    default_config = ImmutableDict({
-        'ENV':                                  None,
-        'DEBUG':                                None,
-        'TESTING':                              False,
-        'PROPAGATE_EXCEPTIONS':                 None,
-        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
-        'SECRET_KEY':                           None,
-        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
-        'USE_X_SENDFILE':                       False,
-        'SERVER_NAME':                          None,
-        'APPLICATION_ROOT':                     '/',
-        'SESSION_COOKIE_NAME':                  'session',
-        'SESSION_COOKIE_DOMAIN':                None,
-        'SESSION_COOKIE_PATH':                  None,
-        'SESSION_COOKIE_HTTPONLY':              True,
-        'SESSION_COOKIE_SECURE':                False,
-        'SESSION_COOKIE_SAMESITE':              None,
-        'SESSION_REFRESH_EACH_REQUEST':         True,
-        'MAX_CONTENT_LENGTH':                   None,
-        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
-        'TRAP_BAD_REQUEST_ERRORS':              None,
-        'TRAP_HTTP_EXCEPTIONS':                 False,
-        'EXPLAIN_TEMPLATE_LOADING':             False,
-        'PREFERRED_URL_SCHEME':                 'http',
-        'JSON_AS_ASCII':                        True,
-        'JSON_SORT_KEYS':                       True,
-        'JSONIFY_PRETTYPRINT_REGULAR':          False,
-        'JSONIFY_MIMETYPE':                     'application/json',
-        'TEMPLATES_AUTO_RELOAD':                None,
-        'MAX_COOKIE_SIZE': 4093,
-    })
-
-    #: The rule object to use for URL rules created.  This is used by
-    #: :meth:`add_url_rule`.  Defaults to :class:`werkzeug.routing.Rule`.
-    #:
-    #: .. versionadded:: 0.7
-    url_rule_class = Rule
-
-    #: the test client that is used with when `test_client` is used.
-    #:
-    #: .. versionadded:: 0.7
-    test_client_class = None
-
-    #: The :class:`~click.testing.CliRunner` subclass, by default
-    #: :class:`~flask.testing.FlaskCliRunner` that is used by
-    #: :meth:`test_cli_runner`. Its ``__init__`` method should take a
-    #: Flask app object as the first argument.
-    #:
-    #: .. versionadded:: 1.0
-    test_cli_runner_class = None
-
-    #: the session interface to use.  By default an instance of
-    #: :class:`~flask.sessions.SecureCookieSessionInterface` is used here.
-    #:
-    #: .. versionadded:: 0.8
-    session_interface = SecureCookieSessionInterface()
-
-    # TODO remove the next three attrs when Sphinx :inherited-members: works
-    # https://github.com/sphinx-doc/sphinx/issues/741
-
-    #: The name of the package or module that this app belongs to. Do not
-    #: change this once it is set by the constructor.
-    import_name = None
-
-    #: Location of the template files to be added to the template lookup.
-    #: ``None`` if templates should not be added.
-    template_folder = None
-
-    #: Absolute path to the package on the filesystem. Used to look up
-    #: resources contained in the package.
-    root_path = None
-
-    def __init__(
-        self,
-        import_name,
-        static_url_path=None,
-        static_folder='static',
-        static_host=None,
-        host_matching=False,
-        subdomain_matching=False,
-        template_folder='templates',
-        instance_path=None,
-        instance_relative_config=False,
-        root_path=None
-    ):
-        _PackageBoundObject.__init__(
-            self,
-            import_name,
-            template_folder=template_folder,
-            root_path=root_path
-        )
-
-        if static_url_path is not None:
-            self.static_url_path = static_url_path
-
-        if static_folder is not None:
-            self.static_folder = static_folder
-
-        if instance_path is None:
-            instance_path = self.auto_find_instance_path()
-        elif not os.path.isabs(instance_path):
-            raise ValueError(
-                'If an instance path is provided it must be absolute.'
-                ' A relative path was given instead.'
-            )
-
-        #: Holds the path to the instance folder.
-        #:
-        #: .. versionadded:: 0.8
-        self.instance_path = instance_path
-
-        #: The configuration dictionary as :class:`Config`.  This behaves
-        #: exactly like a regular dictionary but supports additional methods
-        #: to load a config from files.
-        self.config = self.make_config(instance_relative_config)
-
-        #: A dictionary of all view functions registered.  The keys will
-        #: be function names which are also used to generate URLs and
-        #: the values are the function objects themselves.
-        #: To register a view function, use the :meth:`route` decorator.
-        self.view_functions = {}
-
-        #: A dictionary of all registered error handlers.  The key is ``None``
-        #: for error handlers active on the application, otherwise the key is
-        #: the name of the blueprint.  Each key points to another dictionary
-        #: where the key is the status code of the http exception.  The
-        #: special key ``None`` points to a list of tuples where the first item
-        #: is the class for the instance check and the second the error handler
-        #: function.
-        #:
-        #: To register an error handler, use the :meth:`errorhandler`
-        #: decorator.
-        self.error_handler_spec = {}
-
-        #: A list of functions that are called when :meth:`url_for` raises a
-        #: :exc:`~werkzeug.routing.BuildError`.  Each function registered here
-        #: is called with `error`, `endpoint` and `values`.  If a function
-        #: returns ``None`` or raises a :exc:`BuildError` the next function is
-        #: tried.
-        #:
-        #: .. versionadded:: 0.9
-        self.url_build_error_handlers = []
-
-        #: A dictionary with lists of functions that will be called at the
-        #: beginning of each request. The key of the dictionary is the name of
-        #: the blueprint this function is active for, or ``None`` for all
-        #: requests. To register a function, use the :meth:`before_request`
-        #: decorator.
-        self.before_request_funcs = {}
-
-        #: A list of functions that will be called at the beginning of the
-        #: first request to this instance. To register a function, use the
-        #: :meth:`before_first_request` decorator.
-        #:
-        #: .. versionadded:: 0.8
-        self.before_first_request_funcs = []
-
-        #: A dictionary with lists of functions that should be called after
-        #: each request.  The key of the dictionary is the name of the blueprint
-        #: this function is active for, ``None`` for all requests.  This can for
-        #: example be used to close database connections. To register a function
-        #: here, use the :meth:`after_request` decorator.
-        self.after_request_funcs = {}
-
-        #: A dictionary with lists of functions that are called after
-        #: each request, even if an exception has occurred. The key of the
-        #: dictionary is the name of the blueprint this function is active for,
-        #: ``None`` for all requests. These functions are not allowed to modify
-        #: the request, and their return values are ignored. If an exception
-        #: occurred while processing the request, it gets passed to each
-        #: teardown_request function. To register a function here, use the
-        #: :meth:`teardown_request` decorator.
-        #:
-        #: .. versionadded:: 0.7
-        self.teardown_request_funcs = {}
-
-        #: A list of functions that are called when the application context
-        #: is destroyed.  Since the application context is also torn down
-        #: if the request ends this is the place to store code that disconnects
-        #: from databases.
-        #:
-        #: .. versionadded:: 0.9
-        self.teardown_appcontext_funcs = []
-
-        #: A dictionary with lists of functions that are called before the
-        #: :attr:`before_request_funcs` functions. The key of the dictionary is
-        #: the name of the blueprint this function is active for, or ``None``
-        #: for all requests. To register a function, use
-        #: :meth:`url_value_preprocessor`.
-        #:
-        #: .. versionadded:: 0.7
-        self.url_value_preprocessors = {}
-
-        #: A dictionary with lists of functions that can be used as URL value
-        #: preprocessors.  The key ``None`` here is used for application wide
-        #: callbacks, otherwise the key is the name of the blueprint.
-        #: Each of these functions has the chance to modify the dictionary
-        #: of URL values before they are used as the keyword arguments of the
-        #: view function.  For each function registered this one should also
-        #: provide a :meth:`url_defaults` function that adds the parameters
-        #: automatically again that were removed that way.
-        #:
-        #: .. versionadded:: 0.7
-        self.url_default_functions = {}
-
-        #: A dictionary with list of functions that are called without argument
-        #: to populate the template context.  The key of the dictionary is the
-        #: name of the blueprint this function is active for, ``None`` for all
-        #: requests.  Each returns a dictionary that the template context is
-        #: updated with.  To register a function here, use the
-        #: :meth:`context_processor` decorator.
-        self.template_context_processors = {
-            None: [_default_template_ctx_processor]
-        }
-
-        #: A list of shell context processor functions that should be run
-        #: when a shell context is created.
-        #:
-        #: .. versionadded:: 0.11
-        self.shell_context_processors = []
-
-        #: all the attached blueprints in a dictionary by name.  Blueprints
-        #: can be attached multiple times so this dictionary does not tell
-        #: you how often they got attached.
-        #:
-        #: .. versionadded:: 0.7
-        self.blueprints = {}
-        self._blueprint_order = []
-
-        #: a place where extensions can store application specific state.  For
-        #: example this is where an extension could store database engines and
-        #: similar things.  For backwards compatibility extensions should register
-        #: themselves like this::
-        #:
-        #:      if not hasattr(app, 'extensions'):
-        #:          app.extensions = {}
-        #:      app.extensions['extensionname'] = SomeObject()
-        #:
-        #: The key must match the name of the extension module. For example in
-        #: case of a "Flask-Foo" extension in `flask_foo`, the key would be
-        #: ``'foo'``.
-        #:
-        #: .. versionadded:: 0.7
-        self.extensions = {}
-
-        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
-        #: this to change the routing converters after the class was created
-        #: but before any routes are connected.  Example::
-        #:
-        #:    from werkzeug.routing import BaseConverter
-        #:
-        #:    class ListConverter(BaseConverter):
-        #:        def to_python(self, value):
-        #:            return value.split(',')
-        #:        def to_url(self, values):
-        #:            return ','.join(super(ListConverter, self).to_url(value)
-        #:                            for value in values)
-        #:
-        #:    app = Flask(__name__)
-        #:    app.url_map.converters['list'] = ListConverter
-        self.url_map = Map()
-
-        self.url_map.host_matching = host_matching
-        self.subdomain_matching = subdomain_matching
-
-        # tracks internally if the application already handled at least one
-        # request.
-        self._got_first_request = False
-        self._before_request_lock = Lock()
-
-        # Add a static route using the provided static_url_path, static_host,
-        # and static_folder if there is a configured static_folder.
-        # Note we do this without checking if static_folder exists.
-        # For one, it might be created while the server is running (e.g. during
-        # development). Also, Google App Engine stores static files somewhere
-        if self.has_static_folder:
-            assert bool(static_host) == host_matching, 'Invalid static_host/host_matching combination'
-            self.add_url_rule(
-                self.static_url_path + '/<path:filename>',
-                endpoint='static',
-                host=static_host,
-                view_func=self.send_static_file
-            )
-
-        #: The click command line context for this application.  Commands
-        #: registered here show up in the :command:`flask` command once the
-        #: application has been discovered.  The default commands are
-        #: provided by Flask itself and can be overridden.
-        #:
-        #: This is an instance of a :class:`click.Group` object.
-        self.cli = cli.AppGroup(self.name)
-
-    @locked_cached_property
-    def name(self):
-        """The name of the application.  This is usually the import name
-        with the difference that it's guessed from the run file if the
-        import name is main.  This name is used as a display name when
-        Flask needs the name of the application.  It can be set and overridden
-        to change the value.
-
-        .. versionadded:: 0.8
-        """
-        if self.import_name == '__main__':
-            fn = getattr(sys.modules['__main__'], '__file__', None)
-            if fn is None:
-                return '__main__'
-            return os.path.splitext(os.path.basename(fn))[0]
-        return self.import_name
-
-    @property
-    def propagate_exceptions(self):
-        """Returns the value of the ``PROPAGATE_EXCEPTIONS`` configuration
-        value in case it's set, otherwise a sensible default is returned.
-
-        .. versionadded:: 0.7
-        """
-        rv = self.config['PROPAGATE_EXCEPTIONS']
-        if rv is not None:
-            return rv
-        return self.testing or self.debug
-
-    @property
-    def preserve_context_on_exception(self):
-        """Returns the value of the ``PRESERVE_CONTEXT_ON_EXCEPTION``
-        configuration value in case it's set, otherwise a sensible default
-        is returned.
-
-        .. versionadded:: 0.7
-        """
-        rv = self.config['PRESERVE_CONTEXT_ON_EXCEPTION']
-        if rv is not None:
-            return rv
-        return self.debug
-
-    @locked_cached_property
-    def logger(self):
-        """The ``'flask.app'`` logger, a standard Python
-        :class:`~logging.Logger`.
-
-        In debug mode, the logger's :attr:`~logging.Logger.level` will be set
-        to :data:`~logging.DEBUG`.
-
-        If there are no handlers configured, a default handler will be added.
-        See :ref:`logging` for more information.
-
-        .. versionchanged:: 1.0
-            Behavior was simplified. The logger is always named
-            ``flask.app``. The level is only set during configuration, it
-            doesn't check ``app.debug`` each time. Only one format is used,
-            not different ones depending on ``app.debug``. No handlers are
-            removed, and a handler is only added if no handlers are already
-            configured.
-
-        .. versionadded:: 0.3
-        """
-        return create_logger(self)
-
-    @locked_cached_property
-    def jinja_env(self):
-        """The Jinja2 environment used to load templates."""
-        return self.create_jinja_environment()
-
-    @property
-    def got_first_request(self):
-        """This attribute is set to ``True`` if the application started
-        handling the first request.
-
-        .. versionadded:: 0.8
-        """
-        return self._got_first_request
-
-    def make_config(self, instance_relative=False):
-        """Used to create the config attribute by the Flask constructor.
-        The `instance_relative` parameter is passed in from the constructor
-        of Flask (there named `instance_relative_config`) and indicates if
-        the config should be relative to the instance path or the root path
-        of the application.
-
-        .. versionadded:: 0.8
-        """
-        root_path = self.root_path
-        if instance_relative:
-            root_path = self.instance_path
-        defaults = dict(self.default_config)
-        defaults['ENV'] = get_env()
-        defaults['DEBUG'] = get_debug_flag()
-        return self.config_class(root_path, defaults)
-
-    def auto_find_instance_path(self):
-        """Tries to locate the instance path if it was not provided to the
-        constructor of the application class.  It will basically calculate
-        the path to a folder named ``instance`` next to your main file or
-        the package.
-
-        .. versionadded:: 0.8
-        """
-        prefix, package_path = find_package(self.import_name)
-        if prefix is None:
-            return os.path.join(package_path, 'instance')
-        return os.path.join(prefix, 'var', self.name + '-instance')
-
-    def open_instance_resource(self, resource, mode='rb'):
-        """Opens a resource from the application's instance folder
-        (:attr:`instance_path`).  Otherwise works like
-        :meth:`open_resource`.  Instance resources can also be opened for
-        writing.
-
-        :param resource: the name of the resource.  To access resources within
-                         subfolders use forward slashes as separator.
-        :param mode: resource file opening mode, default is 'rb'.
-        """
-        return open(os.path.join(self.instance_path, resource), mode)
-
-    def _get_templates_auto_reload(self):
-        """Reload templates when they are changed. Used by
-        :meth:`create_jinja_environment`.
-
-        This attribute can be configured with :data:`TEMPLATES_AUTO_RELOAD`. If
-        not set, it will be enabled in debug mode.
-
-        .. versionadded:: 1.0
-            This property was added but the underlying config and behavior
-            already existed.
-        """
-        rv = self.config['TEMPLATES_AUTO_RELOAD']
-        return rv if rv is not None else self.debug
-
-    def _set_templates_auto_reload(self, value):
-        self.config['TEMPLATES_AUTO_RELOAD'] = value
-
-    templates_auto_reload = property(
-        _get_templates_auto_reload, _set_templates_auto_reload
-    )
-    del _get_templates_auto_reload, _set_templates_auto_reload
-
-    def create_jinja_environment(self):
-        """Creates the Jinja2 environment based on :attr:`jinja_options`
-        and :meth:`select_jinja_autoescape`.  Since 0.7 this also adds
-        the Jinja2 globals and filters after initialization.  Override
-        this function to customize the behavior.
-
-        .. versionadded:: 0.5
-        .. versionchanged:: 0.11
-           ``Environment.auto_reload`` set in accordance with
-           ``TEMPLATES_AUTO_RELOAD`` configuration option.
-        """
-        options = dict(self.jinja_options)
-
-        if 'autoescape' not in options:
-            options['autoescape'] = self.select_jinja_autoescape
-
-        if 'auto_reload' not in options:
-            options['auto_reload'] = self.templates_auto_reload
-
-        rv = self.jinja_environment(self, **options)
-        rv.globals.update(
-            url_for=url_for,
-            get_flashed_messages=get_flashed_messages,
-            config=self.config,
-            # request, session and g are normally added with the
-            # context processor for efficiency reasons but for imported
-            # templates we also want the proxies in there.
-            request=request,
-            session=session,
-            g=g
-        )
-        rv.filters['tojson'] = json.tojson_filter
-        return rv
-
-    def create_global_jinja_loader(self):
-        """Creates the loader for the Jinja2 environment.  Can be used to
-        override just the loader and keeping the rest unchanged.  It's
-        discouraged to override this function.  Instead one should override
-        the :meth:`jinja_loader` function instead.
-
-        The global loader dispatches between the loaders of the application
-        and the individual blueprints.
-
-        .. versionadded:: 0.7
-        """
-        return DispatchingJinjaLoader(self)
-
-    def select_jinja_autoescape(self, filename):
-        """Returns ``True`` if autoescaping should be active for the given
-        template name. If no template name is given, returns `True`.
-
-        .. versionadded:: 0.5
-        """
-        if filename is None:
-            return True
-        return filename.endswith(('.html', '.htm', '.xml', '.xhtml'))
-
-    def update_template_context(self, context):
-        """Update the template context with some commonly used variables.
-        This injects request, session, config and g into the template
-        context as well as everything template context processors want
-        to inject.  Note that the as of Flask 0.6, the original values
-        in the context will not be overridden if a context processor
-        decides to return a value with the same key.
-
-        :param context: the context as a dictionary that is updated in place
-                        to add extra variables.
-        """
-        funcs = self.template_context_processors[None]
-        reqctx = _request_ctx_stack.top
-        if reqctx is not None:
-            bp = reqctx.request.blueprint
-            if bp is not None and bp in self.template_context_processors:
-                funcs = chain(funcs, self.template_context_processors[bp])
-        orig_ctx = context.copy()
-        for func in funcs:
-            context.update(func())
-        # make sure the original values win.  This makes it possible to
-        # easier add new variables in context processors without breaking
-        # existing views.
-        context.update(orig_ctx)
-
-    def make_shell_context(self):
-        """Returns the shell context for an interactive shell for this
-        application.  This runs all the registered shell context
-        processors.
-
-        .. versionadded:: 0.11
-        """
-        rv = {'app': self, 'g': g}
-        for processor in self.shell_context_processors:
-            rv.update(processor())
-        return rv
-
-    #: What environment the app is running in. Flask and extensions may
-    #: enable behaviors based on the environment, such as enabling debug
-    #: mode. This maps to the :data:`ENV` config key. This is set by the
-    #: :envvar:`FLASK_ENV` environment variable and may not behave as
-    #: expected if set in code.
-    #:
-    #: **Do not enable development when deploying in production.**
-    #:
-    #: Default: ``'production'``
-    env = ConfigAttribute('ENV')
-
-    def _get_debug(self):
-        return self.config['DEBUG']
-
-    def _set_debug(self, value):
-        self.config['DEBUG'] = value
-        self.jinja_env.auto_reload = self.templates_auto_reload
-
-    #: Whether debug mode is enabled. When using ``flask run`` to start
-    #: the development server, an interactive debugger will be shown for
-    #: unhandled exceptions, and the server will be reloaded when code
-    #: changes. This maps to the :data:`DEBUG` config key. This is
-    #: enabled when :attr:`env` is ``'development'`` and is overridden
-    #: by the ``FLASK_DEBUG`` environment variable. It may not behave as
-    #: expected if set in code.
-    #:
-    #: **Do not enable debug mode when deploying in production.**
-    #:
-    #: Default: ``True`` if :attr:`env` is ``'development'``, or
-    #: ``False`` otherwise.
-    debug = property(_get_debug, _set_debug)
-    del _get_debug, _set_debug
-
-    def run(self, host=None, port=None, debug=None,
-            load_dotenv=True, **options):
-        """Runs the application on a local development server.
-
-        Do not use ``run()`` in a production setting. It is not intended to
-        meet security and performance requirements for a production server.
-        Instead, see :ref:`deployment` for WSGI server recommendations.
-
-        If the :attr:`debug` flag is set the server will automatically reload
-        for code changes and show a debugger in case an exception happened.
-
-        If you want to run the application in debug mode, but disable the
-        code execution on the interactive debugger, you can pass
-        ``use_evalex=False`` as parameter.  This will keep the debugger's
-        traceback screen active, but disable code execution.
-
-        It is not recommended to use this function for development with
-        automatic reloading as this is badly supported.  Instead you should
-        be using the :command:`flask` command line script's ``run`` support.
-
-        .. admonition:: Keep in Mind
-
-           Flask will suppress any server error with a generic error page
-           unless it is in debug mode.  As such to enable just the
-           interactive debugger without the code reloading, you have to
-           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
-           Setting ``use_debugger`` to ``True`` without being in debug mode
-           won't catch any exceptions because there won't be any to
-           catch.
-
-        :param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
-            have the server available externally as well. Defaults to
-            ``'127.0.0.1'`` or the host in the ``SERVER_NAME`` config variable
-            if present.
-        :param port: the port of the webserver. Defaults to ``5000`` or the
-            port defined in the ``SERVER_NAME`` config variable if present.
-        :param debug: if given, enable or disable debug mode. See
-            :attr:`debug`.
-        :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
-            files to set environment variables. Will also change the working
-            directory to the directory containing the first file found.
-        :param options: the options to be forwarded to the underlying Werkzeug
-            server. See :func:`werkzeug.serving.run_simple` for more
-            information.
-
-        .. versionchanged:: 1.0
-            If installed, python-dotenv will be used to load environment
-            variables from :file:`.env` and :file:`.flaskenv` files.
-
-            If set, the :envvar:`FLASK_ENV` and :envvar:`FLASK_DEBUG`
-            environment variables will override :attr:`env` and
-            :attr:`debug`.
-
-            Threaded mode is enabled by default.
-
-        .. versionchanged:: 0.10
-            The default port is now picked from the ``SERVER_NAME``
-            variable.
-        """
-        # Change this into a no-op if the server is invoked from the
-        # command line. Have a look at cli.py for more information.
-        if os.environ.get('FLASK_RUN_FROM_CLI') == 'true':
-            from .debughelpers import explain_ignored_app_run
-            explain_ignored_app_run()
-            return
-
-        if get_load_dotenv(load_dotenv):
-            cli.load_dotenv()
-
-            # if set, let env vars override previous values
-            if 'FLASK_ENV' in os.environ:
-                self.env = get_env()
-                self.debug = get_debug_flag()
-            elif 'FLASK_DEBUG' in os.environ:
-                self.debug = get_debug_flag()
-
-        # debug passed to method overrides all other sources
-        if debug is not None:
-            self.debug = bool(debug)
-
-        _host = '127.0.0.1'
-        _port = 5000
-        server_name = self.config.get('SERVER_NAME')
-        sn_host, sn_port = None, None
-
-        if server_name:
-            sn_host, _, sn_port = server_name.partition(':')
-
-        host = host or sn_host or _host
-        port = int(port or sn_port or _port)
-
-        options.setdefault('use_reloader', self.debug)
-        options.setdefault('use_debugger', self.debug)
-        options.setdefault('threaded', True)
-
-        cli.show_server_banner(self.env, self.debug, self.name, False)
-
-        from werkzeug.serving import run_simple
-
-        try:
-            run_simple(host, port, self, **options)
-        finally:
-            # reset the first request information if the development server
-            # reset normally.  This makes it possible to restart the server
-            # without reloader and that stuff from an interactive shell.
-            self._got_first_request = False
-
-    def test_client(self, use_cookies=True, **kwargs):
-        """Creates a test client for this application.  For information
-        about unit testing head over to :ref:`testing`.
-
-        Note that if you are testing for assertions or exceptions in your
-        application code, you must set ``app.testing = True`` in order for the
-        exceptions to propagate to the test client.  Otherwise, the exception
-        will be handled by the application (not visible to the test client) and
-        the only indication of an AssertionError or other exception will be a
-        500 status code response to the test client.  See the :attr:`testing`
-        attribute.  For example::
-
-            app.testing = True
-            client = app.test_client()
-
-        The test client can be used in a ``with`` block to defer the closing down
-        of the context until the end of the ``with`` block.  This is useful if
-        you want to access the context locals for testing::
-
-            with app.test_client() as c:
-                rv = c.get('/?vodka=42')
-                assert request.args['vodka'] == '42'
-
-        Additionally, you may pass optional keyword arguments that will then
-        be passed to the application's :attr:`test_client_class` constructor.
-        For example::
-
-            from flask.testing import FlaskClient
-
-            class CustomClient(FlaskClient):
-                def __init__(self, *args, **kwargs):
-                    self._authentication = kwargs.pop("authentication")
-                    super(CustomClient,self).__init__( *args, **kwargs)
-
-            app.test_client_class = CustomClient
-            client = app.test_client(authentication='Basic ....')
-
-        See :class:`~flask.testing.FlaskClient` for more information.
-
-        .. versionchanged:: 0.4
-           added support for ``with`` block usage for the client.
-
-        .. versionadded:: 0.7
-           The `use_cookies` parameter was added as well as the ability
-           to override the client to be used by setting the
-           :attr:`test_client_class` attribute.
-
-        .. versionchanged:: 0.11
-           Added `**kwargs` to support passing additional keyword arguments to
-           the constructor of :attr:`test_client_class`.
-        """
-        cls = self.test_client_class
-        if cls is None:
-            from flask.testing import FlaskClient as cls
-        return cls(self, self.response_class, use_cookies=use_cookies, **kwargs)
-
-    def test_cli_runner(self, **kwargs):
-        """Create a CLI runner for testing CLI commands.
-        See :ref:`testing-cli`.
-
-        Returns an instance of :attr:`test_cli_runner_class`, by default
-        :class:`~flask.testing.FlaskCliRunner`. The Flask app object is
-        passed as the first argument.
-
-        .. versionadded:: 1.0
-        """
-        cls = self.test_cli_runner_class
-
-        if cls is None:
-            from flask.testing import FlaskCliRunner as cls
-
-        return cls(self, **kwargs)
-
-    def open_session(self, request):
-        """Creates or opens a new session.  Default implementation stores all
-        session data in a signed cookie.  This requires that the
-        :attr:`secret_key` is set.  Instead of overriding this method
-        we recommend replacing the :class:`session_interface`.
-
-        .. deprecated: 1.0
-            Will be removed in 1.1. Use ``session_interface.open_session``
-            instead.
-
-        :param request: an instance of :attr:`request_class`.
-        """
-
-        warnings.warn(DeprecationWarning(
-            '"open_session" is deprecated and will be removed in 1.1. Use'
-            ' "session_interface.open_session" instead.'
-        ))
-        return self.session_interface.open_session(self, request)
-
-    def save_session(self, session, response):
-        """Saves the session if it needs updates.  For the default
-        implementation, check :meth:`open_session`.  Instead of overriding this
-        method we recommend replacing the :class:`session_interface`.
-
-        .. deprecated: 1.0
-            Will be removed in 1.1. Use ``session_interface.save_session``
-            instead.
-
-        :param session: the session to be saved (a
-                        :class:`~werkzeug.contrib.securecookie.SecureCookie`
-                        object)
-        :param response: an instance of :attr:`response_class`
-        """
-
-        warnings.warn(DeprecationWarning(
-            '"save_session" is deprecated and will be removed in 1.1. Use'
-            ' "session_interface.save_session" instead.'
-        ))
-        return self.session_interface.save_session(self, session, response)
-
-    def make_null_session(self):
-        """Creates a new instance of a missing session.  Instead of overriding
-        this method we recommend replacing the :class:`session_interface`.
-
-        .. deprecated: 1.0
-            Will be removed in 1.1. Use ``session_interface.make_null_session``
-            instead.
-
-        .. versionadded:: 0.7
-        """
-
-        warnings.warn(DeprecationWarning(
-            '"make_null_session" is deprecated and will be removed in 1.1. Use'
-            ' "session_interface.make_null_session" instead.'
-        ))
-        return self.session_interface.make_null_session(self)
-
-    @setupmethod
-    def register_blueprint(self, blueprint, **options):
-        """Register a :class:`~flask.Blueprint` on the application. Keyword
-        arguments passed to this method will override the defaults set on the
-        blueprint.
-
-        Calls the blueprint's :meth:`~flask.Blueprint.register` method after
-        recording the blueprint in the application's :attr:`blueprints`.
-
-        :param blueprint: The blueprint to register.
-        :param url_prefix: Blueprint routes will be prefixed with this.
-        :param subdomain: Blueprint routes will match on this subdomain.
-        :param url_defaults: Blueprint routes will use these default values for
-            view arguments.
-        :param options: Additional keyword arguments are passed to
-            :class:`~flask.blueprints.BlueprintSetupState`. They can be
-            accessed in :meth:`~flask.Blueprint.record` callbacks.
-
-        .. versionadded:: 0.7
-        """
-        first_registration = False
-
-        if blueprint.name in self.blueprints:
-            assert self.blueprints[blueprint.name] is blueprint, (
-                'A name collision occurred between blueprints %r and %r. Both'
-                ' share the same name "%s". Blueprints that are created on the'
-                ' fly need unique names.' % (
-                    blueprint, self.blueprints[blueprint.name], blueprint.name
-                )
-            )
-        else:
-            self.blueprints[blueprint.name] = blueprint
-            self._blueprint_order.append(blueprint)
-            first_registration = True
-
-        blueprint.register(self, options, first_registration)
-
-    def iter_blueprints(self):
-        """Iterates over all blueprints by the order they were registered.
-
-        .. versionadded:: 0.11
-        """
-        return iter(self._blueprint_order)
-
-    @setupmethod
-    def add_url_rule(self, rule, endpoint=None, view_func=None,
-                     provide_automatic_options=None, **options):
-        """Connects a URL rule.  Works exactly like the :meth:`route`
-        decorator.  If a view_func is provided it will be registered with the
-        endpoint.
-
-        Basically this example::
-
-            @app.route('/')
-            def index():
-                pass
-
-        Is equivalent to the following::
-
-            def index():
-                pass
-            app.add_url_rule('/', 'index', index)
-
-        If the view_func is not provided you will need to connect the endpoint
-        to a view function like so::
-
-            app.view_functions['index'] = index
-
-        Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
-        to customize the behavior via subclassing you only need to change
-        this method.
-
-        For more information refer to :ref:`url-route-registrations`.
-
-        .. versionchanged:: 0.2
-           `view_func` parameter added.
-
-        .. versionchanged:: 0.6
-           ``OPTIONS`` is added automatically as method.
-
-        :param rule: the URL rule as string
-        :param endpoint: the endpoint for the registered URL rule.  Flask
-                         itself assumes the name of the view function as
-                         endpoint
-        :param view_func: the function to call when serving a request to the
-                          provided endpoint
-        :param provide_automatic_options: controls whether the ``OPTIONS``
-            method should be added automatically. This can also be controlled
-            by setting the ``view_func.provide_automatic_options = False``
-            before adding the rule.
-        :param options: the options to be forwarded to the underlying
-                        :class:`~werkzeug.routing.Rule` object.  A change
-                        to Werkzeug is handling of method options.  methods
-                        is a list of methods this rule should be limited
-                        to (``GET``, ``POST`` etc.).  By default a rule
-                        just listens for ``GET`` (and implicitly ``HEAD``).
-                        Starting with Flask 0.6, ``OPTIONS`` is implicitly
-                        added and handled by the standard request handling.
-        """
-        if endpoint is None:
-            endpoint = _endpoint_from_view_func(view_func)
-        options['endpoint'] = endpoint
-        methods = options.pop('methods', None)
-
-        # if the methods are not given and the view_func object knows its
-        # methods we can use that instead.  If neither exists, we go with
-        # a tuple of only ``GET`` as default.
-        if methods is None:
-            methods = getattr(view_func, 'methods', None) or ('GET',)
-        if isinstance(methods, string_types):
-            raise TypeError('Allowed methods have to be iterables of strings, '
-                            'for example: @app.route(..., methods=["POST"])')
-        methods = set(item.upper() for item in methods)
-
-        # Methods that should always be added
-        required_methods = set(getattr(view_func, 'required_methods', ()))
-
-        # starting with Flask 0.8 the view_func object can disable and
-        # force-enable the automatic options handling.
-        if provide_automatic_options is None:
-            provide_automatic_options = getattr(view_func,
-                'provide_automatic_options', None)
-
-        if provide_automatic_options is None:
-            if 'OPTIONS' not in methods:
-                provide_automatic_options = True
-                required_methods.add('OPTIONS')
-            else:
-                provide_automatic_options = False
-
-        # Add the required methods now.
-        methods |= required_methods
-
-        rule = self.url_rule_class(rule, methods=methods, **options)
-        rule.provide_automatic_options = provide_automatic_options
-
-        self.url_map.add(rule)
-        if view_func is not None:
-            old_func = self.view_functions.get(endpoint)
-            if old_func is not None and old_func != view_func:
-                raise AssertionError('View function mapping is overwriting an '
-                                     'existing endpoint function: %s' % endpoint)
-            self.view_functions[endpoint] = view_func
-
-    def route(self, rule, **options):
-        """A decorator that is used to register a view function for a
-        given URL rule.  This does the same thing as :meth:`add_url_rule`
-        but is intended for decorator usage::
-
-            @app.route('/')
-            def index():
-                return 'Hello World'
-
-        For more information refer to :ref:`url-route-registrations`.
-
-        :param rule: the URL rule as string
-        :param endpoint: the endpoint for the registered URL rule.  Flask
-                         itself assumes the name of the view function as
-                         endpoint
-        :param options: the options to be forwarded to the underlying
-                        :class:`~werkzeug.routing.Rule` object.  A change
-                        to Werkzeug is handling of method options.  methods
-                        is a list of methods this rule should be limited
-                        to (``GET``, ``POST`` etc.).  By default a rule
-                        just listens for ``GET`` (and implicitly ``HEAD``).
-                        Starting with Flask 0.6, ``OPTIONS`` is implicitly
-                        added and handled by the standard request handling.
-        """
-        def decorator(f):
-            endpoint = options.pop('endpoint', None)
-            self.add_url_rule(rule, endpoint, f, **options)
-            return f
-        return decorator
-
-    @setupmethod
-    def endpoint(self, endpoint):
-        """A decorator to register a function as an endpoint.
-        Example::
-
-            @app.endpoint('example.endpoint')
-            def example():
-                return "example"
-
-        :param endpoint: the name of the endpoint
-        """
-        def decorator(f):
-            self.view_functions[endpoint] = f
-            return f
-        return decorator
-
-    @staticmethod
-    def _get_exc_class_and_code(exc_class_or_code):
-        """Ensure that we register only exceptions as handler keys"""
-        if isinstance(exc_class_or_code, integer_types):
-            exc_class = default_exceptions[exc_class_or_code]
-        else:
-            exc_class = exc_class_or_code
-
-        assert issubclass(exc_class, Exception)
-
-        if issubclass(exc_class, HTTPException):
-            return exc_class, exc_class.code
-        else:
-            return exc_class, None
-
-    @setupmethod
-    def errorhandler(self, code_or_exception):
-        """Register a function to handle errors by code or exception class.
-
-        A decorator that is used to register a function given an
-        error code.  Example::
-
-            @app.errorhandler(404)
-            def page_not_found(error):
-                return 'This page does not exist', 404
-
-        You can also register handlers for arbitrary exceptions::
-
-            @app.errorhandler(DatabaseError)
-            def special_exception_handler(error):
-                return 'Database connection failed', 500
-
-        .. versionadded:: 0.7
-            Use :meth:`register_error_handler` instead of modifying
-            :attr:`error_handler_spec` directly, for application wide error
-            handlers.
-
-        .. versionadded:: 0.7
-           One can now additionally also register custom exception types
-           that do not necessarily have to be a subclass of the
-           :class:`~werkzeug.exceptions.HTTPException` class.
-
-        :param code_or_exception: the code as integer for the handler, or
-                                  an arbitrary exception
-        """
-        def decorator(f):
-            self._register_error_handler(None, code_or_exception, f)
-            return f
-        return decorator
-
-    @setupmethod
-    def register_error_handler(self, code_or_exception, f):
-        """Alternative error attach function to the :meth:`errorhandler`
-        decorator that is more straightforward to use for non decorator
-        usage.
-
-        .. versionadded:: 0.7
-        """
-        self._register_error_handler(None, code_or_exception, f)
-
-    @setupmethod
-    def _register_error_handler(self, key, code_or_exception, f):
-        """
-        :type key: None|str
-        :type code_or_exception: int|T<=Exception
-        :type f: callable
-        """
-        if isinstance(code_or_exception, HTTPException):  # old broken behavior
-            raise ValueError(
-                'Tried to register a handler for an exception instance {0!r}.'
-                ' Handlers can only be registered for exception classes or'
-                ' HTTP error codes.'.format(code_or_exception)
-            )
-
-        try:
-            exc_class, code = self._get_exc_class_and_code(code_or_exception)
-        except KeyError:
-            raise KeyError(
-                "'{0}' is not a recognized HTTP error code. Use a subclass of"
-                " HTTPException with that code instead.".format(code_or_exception)
-            )
-
-        handlers = self.error_handler_spec.setdefault(key, {}).setdefault(code, {})
-        handlers[exc_class] = f
-
-    @setupmethod
-    def template_filter(self, name=None):
-        """A decorator that is used to register custom template filter.
-        You can specify a name for the filter, otherwise the function
-        name will be used. Example::
-
-          @app.template_filter()
-          def reverse(s):
-              return s[::-1]
-
-        :param name: the optional name of the filter, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_template_filter(f, name=name)
-            return f
-        return decorator
-
-    @setupmethod
-    def add_template_filter(self, f, name=None):
-        """Register a custom template filter.  Works exactly like the
-        :meth:`template_filter` decorator.
-
-        :param name: the optional name of the filter, otherwise the
-                     function name will be used.
-        """
-        self.jinja_env.filters[name or f.__name__] = f
-
-    @setupmethod
-    def template_test(self, name=None):
-        """A decorator that is used to register custom template test.
-        You can specify a name for the test, otherwise the function
-        name will be used. Example::
-
-          @app.template_test()
-          def is_prime(n):
-              if n == 2:
-                  return True
-              for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
-                  if n % i == 0:
-                      return False
-              return True
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the test, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_template_test(f, name=name)
-            return f
-        return decorator
-
-    @setupmethod
-    def add_template_test(self, f, name=None):
-        """Register a custom template test.  Works exactly like the
-        :meth:`template_test` decorator.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the test, otherwise the
-                     function name will be used.
-        """
-        self.jinja_env.tests[name or f.__name__] = f
-
-    @setupmethod
-    def template_global(self, name=None):
-        """A decorator that is used to register a custom template global function.
-        You can specify a name for the global function, otherwise the function
-        name will be used. Example::
-
-            @app.template_global()
-            def double(n):
-                return 2 * n
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the global function, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_template_global(f, name=name)
-            return f
-        return decorator
-
-    @setupmethod
-    def add_template_global(self, f, name=None):
-        """Register a custom template global function. Works exactly like the
-        :meth:`template_global` decorator.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the global function, otherwise the
-                     function name will be used.
-        """
-        self.jinja_env.globals[name or f.__name__] = f
-
-    @setupmethod
-    def before_request(self, f):
-        """Registers a function to run before each request.
-
-        For example, this can be used to open a database connection, or to load
-        the logged in user from the session.
-
-        The function will be called without any arguments. If it returns a
-        non-None value, the value is handled as if it was the return value from
-        the view, and further request handling is stopped.
-        """
-        self.before_request_funcs.setdefault(None, []).append(f)
-        return f
-
-    @setupmethod
-    def before_first_request(self, f):
-        """Registers a function to be run before the first request to this
-        instance of the application.
-
-        The function will be called without any arguments and its return
-        value is ignored.
-
-        .. versionadded:: 0.8
-        """
-        self.before_first_request_funcs.append(f)
-        return f
-
-    @setupmethod
-    def after_request(self, f):
-        """Register a function to be run after each request.
-
-        Your function must take one parameter, an instance of
-        :attr:`response_class` and return a new response object or the
-        same (see :meth:`process_response`).
-
-        As of Flask 0.7 this function might not be executed at the end of the
-        request in case an unhandled exception occurred.
-        """
-        self.after_request_funcs.setdefault(None, []).append(f)
-        return f
-
-    @setupmethod
-    def teardown_request(self, f):
-        """Register a function to be run at the end of each request,
-        regardless of whether there was an exception or not.  These functions
-        are executed when the request context is popped, even if not an
-        actual request was performed.
-
-        Example::
-
-            ctx = app.test_request_context()
-            ctx.push()
-            ...
-            ctx.pop()
-
-        When ``ctx.pop()`` is executed in the above example, the teardown
-        functions are called just before the request context moves from the
-        stack of active contexts.  This becomes relevant if you are using
-        such constructs in tests.
-
-        Generally teardown functions must take every necessary step to avoid
-        that they will fail.  If they do execute code that might fail they
-        will have to surround the execution of these code by try/except
-        statements and log occurring errors.
-
-        When a teardown function was called because of an exception it will
-        be passed an error object.
-
-        The return values of teardown functions are ignored.
-
-        .. admonition:: Debug Note
-
-           In debug mode Flask will not tear down a request on an exception
-           immediately.  Instead it will keep it alive so that the interactive
-           debugger can still access it.  This behavior can be controlled
-           by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.
-        """
-        self.teardown_request_funcs.setdefault(None, []).append(f)
-        return f
-
-    @setupmethod
-    def teardown_appcontext(self, f):
-        """Registers a function to be called when the application context
-        ends.  These functions are typically also called when the request
-        context is popped.
-
-        Example::
-
-            ctx = app.app_context()
-            ctx.push()
-            ...
-            ctx.pop()
-
-        When ``ctx.pop()`` is executed in the above example, the teardown
-        functions are called just before the app context moves from the
-        stack of active contexts.  This becomes relevant if you are using
-        such constructs in tests.
-
-        Since a request context typically also manages an application
-        context it would also be called when you pop a request context.
-
-        When a teardown function was called because of an unhandled exception
-        it will be passed an error object. If an :meth:`errorhandler` is
-        registered, it will handle the exception and the teardown will not
-        receive it.
-
-        The return values of teardown functions are ignored.
-
-        .. versionadded:: 0.9
-        """
-        self.teardown_appcontext_funcs.append(f)
-        return f
-
-    @setupmethod
-    def context_processor(self, f):
-        """Registers a template context processor function."""
-        self.template_context_processors[None].append(f)
-        return f
-
-    @setupmethod
-    def shell_context_processor(self, f):
-        """Registers a shell context processor function.
-
-        .. versionadded:: 0.11
-        """
-        self.shell_context_processors.append(f)
-        return f
-
-    @setupmethod
-    def url_value_preprocessor(self, f):
-        """Register a URL value preprocessor function for all view
-        functions in the application. These functions will be called before the
-        :meth:`before_request` functions.
-
-        The function can modify the values captured from the matched url before
-        they are passed to the view. For example, this can be used to pop a
-        common language code value and place it in ``g`` rather than pass it to
-        every view.
-
-        The function is passed the endpoint name and values dict. The return
-        value is ignored.
-        """
-        self.url_value_preprocessors.setdefault(None, []).append(f)
-        return f
-
-    @setupmethod
-    def url_defaults(self, f):
-        """Callback function for URL defaults for all view functions of the
-        application.  It's called with the endpoint and values and should
-        update the values passed in place.
-        """
-        self.url_default_functions.setdefault(None, []).append(f)
-        return f
-
-    def _find_error_handler(self, e):
-        """Return a registered error handler for an exception in this order:
-        blueprint handler for a specific code, app handler for a specific code,
-        blueprint handler for an exception class, app handler for an exception
-        class, or ``None`` if a suitable handler is not found.
-        """
-        exc_class, code = self._get_exc_class_and_code(type(e))
-
-        for name, c in (
-            (request.blueprint, code), (None, code),
-            (request.blueprint, None), (None, None)
-        ):
-            handler_map = self.error_handler_spec.setdefault(name, {}).get(c)
-
-            if not handler_map:
-                continue
-
-            for cls in exc_class.__mro__:
-                handler = handler_map.get(cls)
-
-                if handler is not None:
-                    return handler
-
-    def handle_http_exception(self, e):
-        """Handles an HTTP exception.  By default this will invoke the
-        registered error handlers and fall back to returning the
-        exception as response.
-
-        .. versionadded:: 0.3
-        """
-        # Proxy exceptions don't have error codes.  We want to always return
-        # those unchanged as errors
-        if e.code is None:
-            return e
-
-        handler = self._find_error_handler(e)
-        if handler is None:
-            return e
-        return handler(e)
-
-    def trap_http_exception(self, e):
-        """Checks if an HTTP exception should be trapped or not.  By default
-        this will return ``False`` for all exceptions except for a bad request
-        key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to ``True``.  It
-        also returns ``True`` if ``TRAP_HTTP_EXCEPTIONS`` is set to ``True``.
-
-        This is called for all HTTP exceptions raised by a view function.
-        If it returns ``True`` for any exception the error handler for this
-        exception is not called and it shows up as regular exception in the
-        traceback.  This is helpful for debugging implicitly raised HTTP
-        exceptions.
-
-        .. versionchanged:: 1.0
-            Bad request errors are not trapped by default in debug mode.
-
-        .. versionadded:: 0.8
-        """
-        if self.config['TRAP_HTTP_EXCEPTIONS']:
-            return True
-
-        trap_bad_request = self.config['TRAP_BAD_REQUEST_ERRORS']
-
-        # if unset, trap key errors in debug mode
-        if (
-            trap_bad_request is None and self.debug
-            and isinstance(e, BadRequestKeyError)
-        ):
-            return True
-
-        if trap_bad_request:
-            return isinstance(e, BadRequest)
-
-        return False
-
-    def handle_user_exception(self, e):
-        """This method is called whenever an exception occurs that should be
-        handled.  A special case are
-        :class:`~werkzeug.exception.HTTPException`\s which are forwarded by
-        this function to the :meth:`handle_http_exception` method.  This
-        function will either return a response value or reraise the
-        exception with the same traceback.
-
-        .. versionchanged:: 1.0
-            Key errors raised from request data like ``form`` show the the bad
-            key in debug mode rather than a generic bad request message.
-
-        .. versionadded:: 0.7
-        """
-        exc_type, exc_value, tb = sys.exc_info()
-        assert exc_value is e
-        # ensure not to trash sys.exc_info() at that point in case someone
-        # wants the traceback preserved in handle_http_exception.  Of course
-        # we cannot prevent users from trashing it themselves in a custom
-        # trap_http_exception method so that's their fault then.
-
-        # MultiDict passes the key to the exception, but that's ignored
-        # when generating the response message. Set an informative
-        # description for key errors in debug mode or when trapping errors.
-        if (
-            (self.debug or self.config['TRAP_BAD_REQUEST_ERRORS'])
-            and isinstance(e, BadRequestKeyError)
-            # only set it if it's still the default description
-            and e.description is BadRequestKeyError.description
-        ):
-            e.description = "KeyError: '{0}'".format(*e.args)
-
-        if isinstance(e, HTTPException) and not self.trap_http_exception(e):
-            return self.handle_http_exception(e)
-
-        handler = self._find_error_handler(e)
-
-        if handler is None:
-            reraise(exc_type, exc_value, tb)
-        return handler(e)
-
-    def handle_exception(self, e):
-        """Default exception handling that kicks in when an exception
-        occurs that is not caught.  In debug mode the exception will
-        be re-raised immediately, otherwise it is logged and the handler
-        for a 500 internal server error is used.  If no such handler
-        exists, a default 500 internal server error message is displayed.
-
-        .. versionadded:: 0.3
-        """
-        exc_type, exc_value, tb = sys.exc_info()
-
-        got_request_exception.send(self, exception=e)
-        handler = self._find_error_handler(InternalServerError())
-
-        if self.propagate_exceptions:
-            # if we want to repropagate the exception, we can attempt to
-            # raise it with the whole traceback in case we can do that
-            # (the function was actually called from the except part)
-            # otherwise, we just raise the error again
-            if exc_value is e:
-                reraise(exc_type, exc_value, tb)
-            else:
-                raise e
-
-        self.log_exception((exc_type, exc_value, tb))
-        if handler is None:
-            return InternalServerError()
-        return self.finalize_request(handler(e), from_error_handler=True)
-
-    def log_exception(self, exc_info):
-        """Logs an exception.  This is called by :meth:`handle_exception`
-        if debugging is disabled and right before the handler is called.
-        The default implementation logs the exception as error on the
-        :attr:`logger`.
-
-        .. versionadded:: 0.8
-        """
-        self.logger.error('Exception on %s [%s]' % (
-            request.path,
-            request.method
-        ), exc_info=exc_info)
-
-    def raise_routing_exception(self, request):
-        """Exceptions that are recording during routing are reraised with
-        this method.  During debug we are not reraising redirect requests
-        for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising
-        a different error instead to help debug situations.
-
-        :internal:
-        """
-        if not self.debug \
-           or not isinstance(request.routing_exception, RequestRedirect) \
-           or request.method in ('GET', 'HEAD', 'OPTIONS'):
-            raise request.routing_exception
-
-        from .debughelpers import FormDataRoutingRedirect
-        raise FormDataRoutingRedirect(request)
-
-    def dispatch_request(self):
-        """Does the request dispatching.  Matches the URL and returns the
-        return value of the view or error handler.  This does not have to
-        be a response object.  In order to convert the return value to a
-        proper response object, call :func:`make_response`.
-
-        .. versionchanged:: 0.7
-           This no longer does the exception handling, this code was
-           moved to the new :meth:`full_dispatch_request`.
-        """
-        req = _request_ctx_stack.top.request
-        if req.routing_exception is not None:
-            self.raise_routing_exception(req)
-        rule = req.url_rule
-        # if we provide automatic options for this URL and the
-        # request came with the OPTIONS method, reply automatically
-        if getattr(rule, 'provide_automatic_options', False) \
-           and req.method == 'OPTIONS':
-            return self.make_default_options_response()
-        # otherwise dispatch to the handler for that endpoint
-        return self.view_functions[rule.endpoint](**req.view_args)
-
-    def full_dispatch_request(self):
-        """Dispatches the request and on top of that performs request
-        pre and postprocessing as well as HTTP exception catching and
-        error handling.
-
-        .. versionadded:: 0.7
-        """
-        self.try_trigger_before_first_request_functions()
-        try:
-            request_started.send(self)
-            rv = self.preprocess_request()
-            if rv is None:
-                rv = self.dispatch_request()
-        except Exception as e:
-            rv = self.handle_user_exception(e)
-        return self.finalize_request(rv)
-
-    def finalize_request(self, rv, from_error_handler=False):
-        """Given the return value from a view function this finalizes
-        the request by converting it into a response and invoking the
-        postprocessing functions.  This is invoked for both normal
-        request dispatching as well as error handlers.
-
-        Because this means that it might be called as a result of a
-        failure a special safe mode is available which can be enabled
-        with the `from_error_handler` flag.  If enabled, failures in
-        response processing will be logged and otherwise ignored.
-
-        :internal:
-        """
-        response = self.make_response(rv)
-        try:
-            response = self.process_response(response)
-            request_finished.send(self, response=response)
-        except Exception:
-            if not from_error_handler:
-                raise
-            self.logger.exception('Request finalizing failed with an '
-                                  'error while handling an error')
-        return response
-
-    def try_trigger_before_first_request_functions(self):
-        """Called before each request and will ensure that it triggers
-        the :attr:`before_first_request_funcs` and only exactly once per
-        application instance (which means process usually).
-
-        :internal:
-        """
-        if self._got_first_request:
-            return
-        with self._before_request_lock:
-            if self._got_first_request:
-                return
-            for func in self.before_first_request_funcs:
-                func()
-            self._got_first_request = True
-
-    def make_default_options_response(self):
-        """This method is called to create the default ``OPTIONS`` response.
-        This can be changed through subclassing to change the default
-        behavior of ``OPTIONS`` responses.
-
-        .. versionadded:: 0.7
-        """
-        adapter = _request_ctx_stack.top.url_adapter
-        if hasattr(adapter, 'allowed_methods'):
-            methods = adapter.allowed_methods()
-        else:
-            # fallback for Werkzeug < 0.7
-            methods = []
-            try:
-                adapter.match(method='--')
-            except MethodNotAllowed as e:
-                methods = e.valid_methods
-            except HTTPException as e:
-                pass
-        rv = self.response_class()
-        rv.allow.update(methods)
-        return rv
-
-    def should_ignore_error(self, error):
-        """This is called to figure out if an error should be ignored
-        or not as far as the teardown system is concerned.  If this
-        function returns ``True`` then the teardown handlers will not be
-        passed the error.
-
-        .. versionadded:: 0.10
-        """
-        return False
-
-    def make_response(self, rv):
-        """Convert the return value from a view function to an instance of
-        :attr:`response_class`.
-
-        :param rv: the return value from the view function. The view function
-            must return a response. Returning ``None``, or the view ending
-            without returning, is not allowed. The following types are allowed
-            for ``view_rv``:
-
-            ``str`` (``unicode`` in Python 2)
-                A response object is created with the string encoded to UTF-8
-                as the body.
-
-            ``bytes`` (``str`` in Python 2)
-                A response object is created with the bytes as the body.
-
-            ``tuple``
-                Either ``(body, status, headers)``, ``(body, status)``, or
-                ``(body, headers)``, where ``body`` is any of the other types
-                allowed here, ``status`` is a string or an integer, and
-                ``headers`` is a dictionary or a list of ``(key, value)``
-                tuples. If ``body`` is a :attr:`response_class` instance,
-                ``status`` overwrites the exiting value and ``headers`` are
-                extended.
-
-            :attr:`response_class`
-                The object is returned unchanged.
-
-            other :class:`~werkzeug.wrappers.Response` class
-                The object is coerced to :attr:`response_class`.
-
-            :func:`callable`
-                The function is called as a WSGI application. The result is
-                used to create a response object.
-
-        .. versionchanged:: 0.9
-           Previously a tuple was interpreted as the arguments for the
-           response object.
-        """
-
-        status = headers = None
-
-        # unpack tuple returns
-        if isinstance(rv, tuple):
-            len_rv = len(rv)
-
-            # a 3-tuple is unpacked directly
-            if len_rv == 3:
-                rv, status, headers = rv
-            # decide if a 2-tuple has status or headers
-            elif len_rv == 2:
-                if isinstance(rv[1], (Headers, dict, tuple, list)):
-                    rv, headers = rv
-                else:
-                    rv, status = rv
-            # other sized tuples are not allowed
-            else:
-                raise TypeError(
-                    'The view function did not return a valid response tuple.'
-                    ' The tuple must have the form (body, status, headers),'
-                    ' (body, status), or (body, headers).'
-                )
-
-        # the body must not be None
-        if rv is None:
-            raise TypeError(
-                'The view function did not return a valid response. The'
-                ' function either returned None or ended without a return'
-                ' statement.'
-            )
-
-        # make sure the body is an instance of the response class
-        if not isinstance(rv, self.response_class):
-            if isinstance(rv, (text_type, bytes, bytearray)):
-                # let the response class set the status and headers instead of
-                # waiting to do it manually, so that the class can handle any
-                # special logic
-                rv = self.response_class(rv, status=status, headers=headers)
-                status = headers = None
-            else:
-                # evaluate a WSGI callable, or coerce a different response
-                # class to the correct type
-                try:
-                    rv = self.response_class.force_type(rv, request.environ)
-                except TypeError as e:
-                    new_error = TypeError(
-                        '{e}\nThe view function did not return a valid'
-                        ' response. The return type must be a string, tuple,'
-                        ' Response instance, or WSGI callable, but it was a'
-                        ' {rv.__class__.__name__}.'.format(e=e, rv=rv)
-                    )
-                    reraise(TypeError, new_error, sys.exc_info()[2])
-
-        # prefer the status if it was provided
-        if status is not None:
-            if isinstance(status, (text_type, bytes, bytearray)):
-                rv.status = status
-            else:
-                rv.status_code = status
-
-        # extend existing headers with provided headers
-        if headers:
-            rv.headers.extend(headers)
-
-        return rv
-
-    def create_url_adapter(self, request):
-        """Creates a URL adapter for the given request. The URL adapter
-        is created at a point where the request context is not yet set
-        up so the request is passed explicitly.
-
-        .. versionadded:: 0.6
-
-        .. versionchanged:: 0.9
-           This can now also be called without a request object when the
-           URL adapter is created for the application context.
-
-        .. versionchanged:: 1.0
-            :data:`SERVER_NAME` no longer implicitly enables subdomain
-            matching. Use :attr:`subdomain_matching` instead.
-        """
-        if request is not None:
-            # If subdomain matching is disabled (the default), use the
-            # default subdomain in all cases. This should be the default
-            # in Werkzeug but it currently does not have that feature.
-            subdomain = ((self.url_map.default_subdomain or None)
-                         if not self.subdomain_matching else None)
-            return self.url_map.bind_to_environ(
-                request.environ,
-                server_name=self.config['SERVER_NAME'],
-                subdomain=subdomain)
-        # We need at the very least the server name to be set for this
-        # to work.
-        if self.config['SERVER_NAME'] is not None:
-            return self.url_map.bind(
-                self.config['SERVER_NAME'],
-                script_name=self.config['APPLICATION_ROOT'],
-                url_scheme=self.config['PREFERRED_URL_SCHEME'])
-
-    def inject_url_defaults(self, endpoint, values):
-        """Injects the URL defaults for the given endpoint directly into
-        the values dictionary passed.  This is used internally and
-        automatically called on URL building.
-
-        .. versionadded:: 0.7
-        """
-        funcs = self.url_default_functions.get(None, ())
-        if '.' in endpoint:
-            bp = endpoint.rsplit('.', 1)[0]
-            funcs = chain(funcs, self.url_default_functions.get(bp, ()))
-        for func in funcs:
-            func(endpoint, values)
-
-    def handle_url_build_error(self, error, endpoint, values):
-        """Handle :class:`~werkzeug.routing.BuildError` on :meth:`url_for`.
-        """
-        exc_type, exc_value, tb = sys.exc_info()
-        for handler in self.url_build_error_handlers:
-            try:
-                rv = handler(error, endpoint, values)
-                if rv is not None:
-                    return rv
-            except BuildError as e:
-                # make error available outside except block (py3)
-                error = e
-
-        # At this point we want to reraise the exception.  If the error is
-        # still the same one we can reraise it with the original traceback,
-        # otherwise we raise it from here.
-        if error is exc_value:
-            reraise(exc_type, exc_value, tb)
-        raise error
-
-    def preprocess_request(self):
-        """Called before the request is dispatched. Calls
-        :attr:`url_value_preprocessors` registered with the app and the
-        current blueprint (if any). Then calls :attr:`before_request_funcs`
-        registered with the app and the blueprint.
-
-        If any :meth:`before_request` handler returns a non-None value, the
-        value is handled as if it was the return value from the view, and
-        further request handling is stopped.
-        """
-
-        bp = _request_ctx_stack.top.request.blueprint
-
-        funcs = self.url_value_preprocessors.get(None, ())
-        if bp is not None and bp in self.url_value_preprocessors:
-            funcs = chain(funcs, self.url_value_preprocessors[bp])
-        for func in funcs:
-            func(request.endpoint, request.view_args)
-
-        funcs = self.before_request_funcs.get(None, ())
-        if bp is not None and bp in self.before_request_funcs:
-            funcs = chain(funcs, self.before_request_funcs[bp])
-        for func in funcs:
-            rv = func()
-            if rv is not None:
-                return rv
-
-    def process_response(self, response):
-        """Can be overridden in order to modify the response object
-        before it's sent to the WSGI server.  By default this will
-        call all the :meth:`after_request` decorated functions.
-
-        .. versionchanged:: 0.5
-           As of Flask 0.5 the functions registered for after request
-           execution are called in reverse order of registration.
-
-        :param response: a :attr:`response_class` object.
-        :return: a new response object or the same, has to be an
-                 instance of :attr:`response_class`.
-        """
-        ctx = _request_ctx_stack.top
-        bp = ctx.request.blueprint
-        funcs = ctx._after_request_functions
-        if bp is not None and bp in self.after_request_funcs:
-            funcs = chain(funcs, reversed(self.after_request_funcs[bp]))
-        if None in self.after_request_funcs:
-            funcs = chain(funcs, reversed(self.after_request_funcs[None]))
-        for handler in funcs:
-            response = handler(response)
-        if not self.session_interface.is_null_session(ctx.session):
-            self.session_interface.save_session(self, ctx.session, response)
-        return response
-
-    def do_teardown_request(self, exc=_sentinel):
-        """Called after the request is dispatched and the response is
-        returned, right before the request context is popped.
-
-        This calls all functions decorated with
-        :meth:`teardown_request`, and :meth:`Blueprint.teardown_request`
-        if a blueprint handled the request. Finally, the
-        :data:`request_tearing_down` signal is sent.
-
-        This is called by
-        :meth:`RequestContext.pop() <flask.ctx.RequestContext.pop>`,
-        which may be delayed during testing to maintain access to
-        resources.
-
-        :param exc: An unhandled exception raised while dispatching the
-            request. Detected from the current exception information if
-            not passed. Passed to each teardown function.
-
-        .. versionchanged:: 0.9
-            Added the ``exc`` argument.
-        """
-        if exc is _sentinel:
-            exc = sys.exc_info()[1]
-        funcs = reversed(self.teardown_request_funcs.get(None, ()))
-        bp = _request_ctx_stack.top.request.blueprint
-        if bp is not None and bp in self.teardown_request_funcs:
-            funcs = chain(funcs, reversed(self.teardown_request_funcs[bp]))
-        for func in funcs:
-            func(exc)
-        request_tearing_down.send(self, exc=exc)
-
-    def do_teardown_appcontext(self, exc=_sentinel):
-        """Called right before the application context is popped.
-
-        When handling a request, the application context is popped
-        after the request context. See :meth:`do_teardown_request`.
-
-        This calls all functions decorated with
-        :meth:`teardown_appcontext`. Then the
-        :data:`appcontext_tearing_down` signal is sent.
-
-        This is called by
-        :meth:`AppContext.pop() <flask.ctx.AppContext.pop>`.
-
-        .. versionadded:: 0.9
-        """
-        if exc is _sentinel:
-            exc = sys.exc_info()[1]
-        for func in reversed(self.teardown_appcontext_funcs):
-            func(exc)
-        appcontext_tearing_down.send(self, exc=exc)
-
-    def app_context(self):
-        """Create an :class:`~flask.ctx.AppContext`. Use as a ``with``
-        block to push the context, which will make :data:`current_app`
-        point at this application.
-
-        An application context is automatically pushed by
-        :meth:`RequestContext.push() <flask.ctx.RequestContext.push>`
-        when handling a request, and when running a CLI command. Use
-        this to manually create a context outside of these situations.
-
-        ::
-
-            with app.app_context():
-                init_db()
-
-        See :doc:`/appcontext`.
-
-        .. versionadded:: 0.9
-        """
-        return AppContext(self)
-
-    def request_context(self, environ):
-        """Create a :class:`~flask.ctx.RequestContext` representing a
-        WSGI environment. Use a ``with`` block to push the context,
-        which will make :data:`request` point at this request.
-
-        See :doc:`/reqcontext`.
-
-        Typically you should not call this from your own code. A request
-        context is automatically pushed by the :meth:`wsgi_app` when
-        handling a request. Use :meth:`test_request_context` to create
-        an environment and context instead of this method.
-
-        :param environ: a WSGI environment
-        """
-        return RequestContext(self, environ)
-
-    def test_request_context(self, *args, **kwargs):
-        """Create a :class:`~flask.ctx.RequestContext` for a WSGI
-        environment created from the given values. This is mostly useful
-        during testing, where you may want to run a function that uses
-        request data without dispatching a full request.
-
-        See :doc:`/reqcontext`.
-
-        Use a ``with`` block to push the context, which will make
-        :data:`request` point at the request for the created
-        environment. ::
-
-            with test_request_context(...):
-                generate_report()
-
-        When using the shell, it may be easier to push and pop the
-        context manually to avoid indentation. ::
-
-            ctx = app.test_request_context(...)
-            ctx.push()
-            ...
-            ctx.pop()
-
-        Takes the same arguments as Werkzeug's
-        :class:`~werkzeug.test.EnvironBuilder`, with some defaults from
-        the application. See the linked Werkzeug docs for most of the
-        available arguments. Flask-specific behavior is listed here.
-
-        :param path: URL path being requested.
-        :param base_url: Base URL where the app is being served, which
-            ``path`` is relative to. If not given, built from
-            :data:`PREFERRED_URL_SCHEME`, ``subdomain``,
-            :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
-        :param subdomain: Subdomain name to append to
-            :data:`SERVER_NAME`.
-        :param url_scheme: Scheme to use instead of
-            :data:`PREFERRED_URL_SCHEME`.
-        :param data: The request body, either as a string or a dict of
-            form keys and values.
-        :param json: If given, this is serialized as JSON and passed as
-            ``data``. Also defaults ``content_type`` to
-            ``application/json``.
-        :param args: other positional arguments passed to
-            :class:`~werkzeug.test.EnvironBuilder`.
-        :param kwargs: other keyword arguments passed to
-            :class:`~werkzeug.test.EnvironBuilder`.
-        """
-        from flask.testing import make_test_environ_builder
-
-        builder = make_test_environ_builder(self, *args, **kwargs)
-
-        try:
-            return self.request_context(builder.get_environ())
-        finally:
-            builder.close()
-
-    def wsgi_app(self, environ, start_response):
-        """The actual WSGI application. This is not implemented in
-        :meth:`__call__` so that middlewares can be applied without
-        losing a reference to the app object. Instead of doing this::
-
-            app = MyMiddleware(app)
-
-        It's a better idea to do this instead::
-
-            app.wsgi_app = MyMiddleware(app.wsgi_app)
-
-        Then you still have the original application object around and
-        can continue to call methods on it.
-
-        .. versionchanged:: 0.7
-            Teardown events for the request and app contexts are called
-            even if an unhandled error occurs. Other events may not be
-            called depending on when an error occurs during dispatch.
-            See :ref:`callbacks-and-errors`.
-
-        :param environ: A WSGI environment.
-        :param start_response: A callable accepting a status code,
-            a list of headers, and an optional exception context to
-            start the response.
-        """
-        ctx = self.request_context(environ)
-        error = None
-        try:
-            try:
-                ctx.push()
-                response = self.full_dispatch_request()
-            except Exception as e:
-                error = e
-                response = self.handle_exception(e)
-            except:
-                error = sys.exc_info()[1]
-                raise
-            return response(environ, start_response)
-        finally:
-            if self.should_ignore_error(error):
-                error = None
-            ctx.auto_pop(error)
-
-    def __call__(self, environ, start_response):
-        """The WSGI server calls the Flask application object as the
-        WSGI application. This calls :meth:`wsgi_app` which can be
-        wrapped to applying middleware."""
-        return self.wsgi_app(environ, start_response)
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self.name,
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/blueprints.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/blueprints.py
deleted file mode 100644
index 5ce5561e4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/blueprints.py
+++ /dev/null
@@ -1,448 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.blueprints
-    ~~~~~~~~~~~~~~~~
-
-    Blueprints are the recommended way to implement larger or more
-    pluggable applications in Flask 0.7 and later.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-from functools import update_wrapper
-from werkzeug.urls import url_join
-
-from .helpers import _PackageBoundObject, _endpoint_from_view_func
-
-
-class BlueprintSetupState(object):
-    """Temporary holder object for registering a blueprint with the
-    application.  An instance of this class is created by the
-    :meth:`~flask.Blueprint.make_setup_state` method and later passed
-    to all register callback functions.
-    """
-
-    def __init__(self, blueprint, app, options, first_registration):
-        #: a reference to the current application
-        self.app = app
-
-        #: a reference to the blueprint that created this setup state.
-        self.blueprint = blueprint
-
-        #: a dictionary with all options that were passed to the
-        #: :meth:`~flask.Flask.register_blueprint` method.
-        self.options = options
-
-        #: as blueprints can be registered multiple times with the
-        #: application and not everything wants to be registered
-        #: multiple times on it, this attribute can be used to figure
-        #: out if the blueprint was registered in the past already.
-        self.first_registration = first_registration
-
-        subdomain = self.options.get('subdomain')
-        if subdomain is None:
-            subdomain = self.blueprint.subdomain
-
-        #: The subdomain that the blueprint should be active for, ``None``
-        #: otherwise.
-        self.subdomain = subdomain
-
-        url_prefix = self.options.get('url_prefix')
-        if url_prefix is None:
-            url_prefix = self.blueprint.url_prefix
-        #: The prefix that should be used for all URLs defined on the
-        #: blueprint.
-        self.url_prefix = url_prefix
-
-        #: A dictionary with URL defaults that is added to each and every
-        #: URL that was defined with the blueprint.
-        self.url_defaults = dict(self.blueprint.url_values_defaults)
-        self.url_defaults.update(self.options.get('url_defaults', ()))
-
-    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
-        """A helper method to register a rule (and optionally a view function)
-        to the application.  The endpoint is automatically prefixed with the
-        blueprint's name.
-        """
-        if self.url_prefix is not None:
-            if rule:
-                rule = '/'.join((
-                    self.url_prefix.rstrip('/'), rule.lstrip('/')))
-            else:
-                rule = self.url_prefix
-        options.setdefault('subdomain', self.subdomain)
-        if endpoint is None:
-            endpoint = _endpoint_from_view_func(view_func)
-        defaults = self.url_defaults
-        if 'defaults' in options:
-            defaults = dict(defaults, **options.pop('defaults'))
-        self.app.add_url_rule(rule, '%s.%s' % (self.blueprint.name, endpoint),
-                              view_func, defaults=defaults, **options)
-
-
-class Blueprint(_PackageBoundObject):
-    """Represents a blueprint.  A blueprint is an object that records
-    functions that will be called with the
-    :class:`~flask.blueprints.BlueprintSetupState` later to register functions
-    or other things on the main application.  See :ref:`blueprints` for more
-    information.
-
-    .. versionadded:: 0.7
-    """
-
-    warn_on_modifications = False
-    _got_registered_once = False
-
-    #: Blueprint local JSON decoder class to use.
-    #: Set to ``None`` to use the app's :class:`~flask.app.Flask.json_encoder`.
-    json_encoder = None
-    #: Blueprint local JSON decoder class to use.
-    #: Set to ``None`` to use the app's :class:`~flask.app.Flask.json_decoder`.
-    json_decoder = None
-
-    # TODO remove the next three attrs when Sphinx :inherited-members: works
-    # https://github.com/sphinx-doc/sphinx/issues/741
-
-    #: The name of the package or module that this app belongs to. Do not
-    #: change this once it is set by the constructor.
-    import_name = None
-
-    #: Location of the template files to be added to the template lookup.
-    #: ``None`` if templates should not be added.
-    template_folder = None
-
-    #: Absolute path to the package on the filesystem. Used to look up
-    #: resources contained in the package.
-    root_path = None
-
-    def __init__(self, name, import_name, static_folder=None,
-                 static_url_path=None, template_folder=None,
-                 url_prefix=None, subdomain=None, url_defaults=None,
-                 root_path=None):
-        _PackageBoundObject.__init__(self, import_name, template_folder,
-                                     root_path=root_path)
-        self.name = name
-        self.url_prefix = url_prefix
-        self.subdomain = subdomain
-        self.static_folder = static_folder
-        self.static_url_path = static_url_path
-        self.deferred_functions = []
-        if url_defaults is None:
-            url_defaults = {}
-        self.url_values_defaults = url_defaults
-
-    def record(self, func):
-        """Registers a function that is called when the blueprint is
-        registered on the application.  This function is called with the
-        state as argument as returned by the :meth:`make_setup_state`
-        method.
-        """
-        if self._got_registered_once and self.warn_on_modifications:
-            from warnings import warn
-            warn(Warning('The blueprint was already registered once '
-                         'but is getting modified now.  These changes '
-                         'will not show up.'))
-        self.deferred_functions.append(func)
-
-    def record_once(self, func):
-        """Works like :meth:`record` but wraps the function in another
-        function that will ensure the function is only called once.  If the
-        blueprint is registered a second time on the application, the
-        function passed is not called.
-        """
-        def wrapper(state):
-            if state.first_registration:
-                func(state)
-        return self.record(update_wrapper(wrapper, func))
-
-    def make_setup_state(self, app, options, first_registration=False):
-        """Creates an instance of :meth:`~flask.blueprints.BlueprintSetupState`
-        object that is later passed to the register callback functions.
-        Subclasses can override this to return a subclass of the setup state.
-        """
-        return BlueprintSetupState(self, app, options, first_registration)
-
-    def register(self, app, options, first_registration=False):
-        """Called by :meth:`Flask.register_blueprint` to register all views
-        and callbacks registered on the blueprint with the application. Creates
-        a :class:`.BlueprintSetupState` and calls each :meth:`record` callback
-        with it.
-
-        :param app: The application this blueprint is being registered with.
-        :param options: Keyword arguments forwarded from
-            :meth:`~Flask.register_blueprint`.
-        :param first_registration: Whether this is the first time this
-            blueprint has been registered on the application.
-        """
-        self._got_registered_once = True
-        state = self.make_setup_state(app, options, first_registration)
-
-        if self.has_static_folder:
-            state.add_url_rule(
-                self.static_url_path + '/<path:filename>',
-                view_func=self.send_static_file, endpoint='static'
-            )
-
-        for deferred in self.deferred_functions:
-            deferred(state)
-
-    def route(self, rule, **options):
-        """Like :meth:`Flask.route` but for a blueprint.  The endpoint for the
-        :func:`url_for` function is prefixed with the name of the blueprint.
-        """
-        def decorator(f):
-            endpoint = options.pop("endpoint", f.__name__)
-            self.add_url_rule(rule, endpoint, f, **options)
-            return f
-        return decorator
-
-    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
-        """Like :meth:`Flask.add_url_rule` but for a blueprint.  The endpoint for
-        the :func:`url_for` function is prefixed with the name of the blueprint.
-        """
-        if endpoint:
-            assert '.' not in endpoint, "Blueprint endpoints should not contain dots"
-        if view_func and hasattr(view_func, '__name__'):
-            assert '.' not in view_func.__name__, "Blueprint view function name should not contain dots"
-        self.record(lambda s:
-            s.add_url_rule(rule, endpoint, view_func, **options))
-
-    def endpoint(self, endpoint):
-        """Like :meth:`Flask.endpoint` but for a blueprint.  This does not
-        prefix the endpoint with the blueprint name, this has to be done
-        explicitly by the user of this method.  If the endpoint is prefixed
-        with a `.` it will be registered to the current blueprint, otherwise
-        it's an application independent endpoint.
-        """
-        def decorator(f):
-            def register_endpoint(state):
-                state.app.view_functions[endpoint] = f
-            self.record_once(register_endpoint)
-            return f
-        return decorator
-
-    def app_template_filter(self, name=None):
-        """Register a custom template filter, available application wide.  Like
-        :meth:`Flask.template_filter` but for a blueprint.
-
-        :param name: the optional name of the filter, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_app_template_filter(f, name=name)
-            return f
-        return decorator
-
-    def add_app_template_filter(self, f, name=None):
-        """Register a custom template filter, available application wide.  Like
-        :meth:`Flask.add_template_filter` but for a blueprint.  Works exactly
-        like the :meth:`app_template_filter` decorator.
-
-        :param name: the optional name of the filter, otherwise the
-                     function name will be used.
-        """
-        def register_template(state):
-            state.app.jinja_env.filters[name or f.__name__] = f
-        self.record_once(register_template)
-
-    def app_template_test(self, name=None):
-        """Register a custom template test, available application wide.  Like
-        :meth:`Flask.template_test` but for a blueprint.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the test, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_app_template_test(f, name=name)
-            return f
-        return decorator
-
-    def add_app_template_test(self, f, name=None):
-        """Register a custom template test, available application wide.  Like
-        :meth:`Flask.add_template_test` but for a blueprint.  Works exactly
-        like the :meth:`app_template_test` decorator.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the test, otherwise the
-                     function name will be used.
-        """
-        def register_template(state):
-            state.app.jinja_env.tests[name or f.__name__] = f
-        self.record_once(register_template)
-
-    def app_template_global(self, name=None):
-        """Register a custom template global, available application wide.  Like
-        :meth:`Flask.template_global` but for a blueprint.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the global, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.add_app_template_global(f, name=name)
-            return f
-        return decorator
-
-    def add_app_template_global(self, f, name=None):
-        """Register a custom template global, available application wide.  Like
-        :meth:`Flask.add_template_global` but for a blueprint.  Works exactly
-        like the :meth:`app_template_global` decorator.
-
-        .. versionadded:: 0.10
-
-        :param name: the optional name of the global, otherwise the
-                     function name will be used.
-        """
-        def register_template(state):
-            state.app.jinja_env.globals[name or f.__name__] = f
-        self.record_once(register_template)
-
-    def before_request(self, f):
-        """Like :meth:`Flask.before_request` but for a blueprint.  This function
-        is only executed before each request that is handled by a function of
-        that blueprint.
-        """
-        self.record_once(lambda s: s.app.before_request_funcs
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def before_app_request(self, f):
-        """Like :meth:`Flask.before_request`.  Such a function is executed
-        before each request, even if outside of a blueprint.
-        """
-        self.record_once(lambda s: s.app.before_request_funcs
-            .setdefault(None, []).append(f))
-        return f
-
-    def before_app_first_request(self, f):
-        """Like :meth:`Flask.before_first_request`.  Such a function is
-        executed before the first request to the application.
-        """
-        self.record_once(lambda s: s.app.before_first_request_funcs.append(f))
-        return f
-
-    def after_request(self, f):
-        """Like :meth:`Flask.after_request` but for a blueprint.  This function
-        is only executed after each request that is handled by a function of
-        that blueprint.
-        """
-        self.record_once(lambda s: s.app.after_request_funcs
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def after_app_request(self, f):
-        """Like :meth:`Flask.after_request` but for a blueprint.  Such a function
-        is executed after each request, even if outside of the blueprint.
-        """
-        self.record_once(lambda s: s.app.after_request_funcs
-            .setdefault(None, []).append(f))
-        return f
-
-    def teardown_request(self, f):
-        """Like :meth:`Flask.teardown_request` but for a blueprint.  This
-        function is only executed when tearing down requests handled by a
-        function of that blueprint.  Teardown request functions are executed
-        when the request context is popped, even when no actual request was
-        performed.
-        """
-        self.record_once(lambda s: s.app.teardown_request_funcs
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def teardown_app_request(self, f):
-        """Like :meth:`Flask.teardown_request` but for a blueprint.  Such a
-        function is executed when tearing down each request, even if outside of
-        the blueprint.
-        """
-        self.record_once(lambda s: s.app.teardown_request_funcs
-            .setdefault(None, []).append(f))
-        return f
-
-    def context_processor(self, f):
-        """Like :meth:`Flask.context_processor` but for a blueprint.  This
-        function is only executed for requests handled by a blueprint.
-        """
-        self.record_once(lambda s: s.app.template_context_processors
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def app_context_processor(self, f):
-        """Like :meth:`Flask.context_processor` but for a blueprint.  Such a
-        function is executed each request, even if outside of the blueprint.
-        """
-        self.record_once(lambda s: s.app.template_context_processors
-            .setdefault(None, []).append(f))
-        return f
-
-    def app_errorhandler(self, code):
-        """Like :meth:`Flask.errorhandler` but for a blueprint.  This
-        handler is used for all requests, even if outside of the blueprint.
-        """
-        def decorator(f):
-            self.record_once(lambda s: s.app.errorhandler(code)(f))
-            return f
-        return decorator
-
-    def url_value_preprocessor(self, f):
-        """Registers a function as URL value preprocessor for this
-        blueprint.  It's called before the view functions are called and
-        can modify the url values provided.
-        """
-        self.record_once(lambda s: s.app.url_value_preprocessors
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def url_defaults(self, f):
-        """Callback function for URL defaults for this blueprint.  It's called
-        with the endpoint and values and should update the values passed
-        in place.
-        """
-        self.record_once(lambda s: s.app.url_default_functions
-            .setdefault(self.name, []).append(f))
-        return f
-
-    def app_url_value_preprocessor(self, f):
-        """Same as :meth:`url_value_preprocessor` but application wide.
-        """
-        self.record_once(lambda s: s.app.url_value_preprocessors
-            .setdefault(None, []).append(f))
-        return f
-
-    def app_url_defaults(self, f):
-        """Same as :meth:`url_defaults` but application wide.
-        """
-        self.record_once(lambda s: s.app.url_default_functions
-            .setdefault(None, []).append(f))
-        return f
-
-    def errorhandler(self, code_or_exception):
-        """Registers an error handler that becomes active for this blueprint
-        only.  Please be aware that routing does not happen local to a
-        blueprint so an error handler for 404 usually is not handled by
-        a blueprint unless it is caused inside a view function.  Another
-        special case is the 500 internal server error which is always looked
-        up from the application.
-
-        Otherwise works as the :meth:`~flask.Flask.errorhandler` decorator
-        of the :class:`~flask.Flask` object.
-        """
-        def decorator(f):
-            self.record_once(lambda s: s.app._register_error_handler(
-                self.name, code_or_exception, f))
-            return f
-        return decorator
-
-    def register_error_handler(self, code_or_exception, f):
-        """Non-decorator version of the :meth:`errorhandler` error attach
-        function, akin to the :meth:`~flask.Flask.register_error_handler`
-        application-wide function of the :class:`~flask.Flask` object but
-        for error handlers limited to this blueprint.
-
-        .. versionadded:: 0.11
-        """
-        self.record_once(lambda s: s.app._register_error_handler(
-            self.name, code_or_exception, f))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/cli.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/cli.py
deleted file mode 100644
index efc1733e2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/cli.py
+++ /dev/null
@@ -1,898 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.cli
-    ~~~~~~~~~
-
-    A simple command line application to run flask apps.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import print_function
-
-import ast
-import inspect
-import os
-import re
-import ssl
-import sys
-import traceback
-from functools import update_wrapper
-from operator import attrgetter
-from threading import Lock, Thread
-
-import click
-from werkzeug.utils import import_string
-
-from . import __version__
-from ._compat import getargspec, iteritems, reraise, text_type
-from .globals import current_app
-from .helpers import get_debug_flag, get_env, get_load_dotenv
-
-try:
-    import dotenv
-except ImportError:
-    dotenv = None
-
-
-class NoAppException(click.UsageError):
-    """Raised if an application cannot be found or loaded."""
-
-
-def find_best_app(script_info, module):
-    """Given a module instance this tries to find the best possible
-    application in the module or raises an exception.
-    """
-    from . import Flask
-
-    # Search for the most common names first.
-    for attr_name in ('app', 'application'):
-        app = getattr(module, attr_name, None)
-
-        if isinstance(app, Flask):
-            return app
-
-    # Otherwise find the only object that is a Flask instance.
-    matches = [
-        v for k, v in iteritems(module.__dict__) if isinstance(v, Flask)
-    ]
-
-    if len(matches) == 1:
-        return matches[0]
-    elif len(matches) > 1:
-        raise NoAppException(
-            'Detected multiple Flask applications in module "{module}". Use '
-            '"FLASK_APP={module}:name" to specify the correct '
-            'one.'.format(module=module.__name__)
-        )
-
-    # Search for app factory functions.
-    for attr_name in ('create_app', 'make_app'):
-        app_factory = getattr(module, attr_name, None)
-
-        if inspect.isfunction(app_factory):
-            try:
-                app = call_factory(script_info, app_factory)
-
-                if isinstance(app, Flask):
-                    return app
-            except TypeError:
-                if not _called_with_wrong_args(app_factory):
-                    raise
-                raise NoAppException(
-                    'Detected factory "{factory}" in module "{module}", but '
-                    'could not call it without arguments. Use '
-                    '"FLASK_APP=\'{module}:{factory}(args)\'" to specify '
-                    'arguments.'.format(
-                        factory=attr_name, module=module.__name__
-                    )
-                )
-
-    raise NoAppException(
-        'Failed to find Flask application or factory in module "{module}". '
-        'Use "FLASK_APP={module}:name to specify one.'.format(
-            module=module.__name__
-        )
-    )
-
-
-def call_factory(script_info, app_factory, arguments=()):
-    """Takes an app factory, a ``script_info` object and  optionally a tuple
-    of arguments. Checks for the existence of a script_info argument and calls
-    the app_factory depending on that and the arguments provided.
-    """
-    args_spec = getargspec(app_factory)
-    arg_names = args_spec.args
-    arg_defaults = args_spec.defaults
-
-    if 'script_info' in arg_names:
-        return app_factory(*arguments, script_info=script_info)
-    elif arguments:
-        return app_factory(*arguments)
-    elif not arguments and len(arg_names) == 1 and arg_defaults is None:
-        return app_factory(script_info)
-
-    return app_factory()
-
-
-def _called_with_wrong_args(factory):
-    """Check whether calling a function raised a ``TypeError`` because
-    the call failed or because something in the factory raised the
-    error.
-
-    :param factory: the factory function that was called
-    :return: true if the call failed
-    """
-    tb = sys.exc_info()[2]
-
-    try:
-        while tb is not None:
-            if tb.tb_frame.f_code is factory.__code__:
-                # in the factory, it was called successfully
-                return False
-
-            tb = tb.tb_next
-
-        # didn't reach the factory
-        return True
-    finally:
-        del tb
-
-
-def find_app_by_string(script_info, module, app_name):
-    """Checks if the given string is a variable name or a function. If it is a
-    function, it checks for specified arguments and whether it takes a
-    ``script_info`` argument and calls the function with the appropriate
-    arguments.
-    """
-    from flask import Flask
-    match = re.match(r'^ *([^ ()]+) *(?:\((.*?) *,? *\))? *$', app_name)
-
-    if not match:
-        raise NoAppException(
-            '"{name}" is not a valid variable name or function '
-            'expression.'.format(name=app_name)
-        )
-
-    name, args = match.groups()
-
-    try:
-        attr = getattr(module, name)
-    except AttributeError as e:
-        raise NoAppException(e.args[0])
-
-    if inspect.isfunction(attr):
-        if args:
-            try:
-                args = ast.literal_eval('({args},)'.format(args=args))
-            except (ValueError, SyntaxError)as e:
-                raise NoAppException(
-                    'Could not parse the arguments in '
-                    '"{app_name}".'.format(e=e, app_name=app_name)
-                )
-        else:
-            args = ()
-
-        try:
-            app = call_factory(script_info, attr, args)
-        except TypeError as e:
-            if not _called_with_wrong_args(attr):
-                raise
-
-            raise NoAppException(
-                '{e}\nThe factory "{app_name}" in module "{module}" could not '
-                'be called with the specified arguments.'.format(
-                    e=e, app_name=app_name, module=module.__name__
-                )
-            )
-    else:
-        app = attr
-
-    if isinstance(app, Flask):
-        return app
-
-    raise NoAppException(
-        'A valid Flask application was not obtained from '
-        '"{module}:{app_name}".'.format(
-            module=module.__name__, app_name=app_name
-        )
-    )
-
-
-def prepare_import(path):
-    """Given a filename this will try to calculate the python path, add it
-    to the search path and return the actual module name that is expected.
-    """
-    path = os.path.realpath(path)
-
-    if os.path.splitext(path)[1] == '.py':
-        path = os.path.splitext(path)[0]
-
-    if os.path.basename(path) == '__init__':
-        path = os.path.dirname(path)
-
-    module_name = []
-
-    # move up until outside package structure (no __init__.py)
-    while True:
-        path, name = os.path.split(path)
-        module_name.append(name)
-
-        if not os.path.exists(os.path.join(path, '__init__.py')):
-            break
-
-    if sys.path[0] != path:
-        sys.path.insert(0, path)
-
-    return '.'.join(module_name[::-1])
-
-
-def locate_app(script_info, module_name, app_name, raise_if_not_found=True):
-    __traceback_hide__ = True
-
-    try:
-        __import__(module_name)
-    except ImportError:
-        # Reraise the ImportError if it occurred within the imported module.
-        # Determine this by checking whether the trace has a depth > 1.
-        if sys.exc_info()[-1].tb_next:
-            raise NoAppException(
-                'While importing "{name}", an ImportError was raised:'
-                '\n\n{tb}'.format(name=module_name, tb=traceback.format_exc())
-            )
-        elif raise_if_not_found:
-            raise NoAppException(
-                'Could not import "{name}".'.format(name=module_name)
-            )
-        else:
-            return
-
-    module = sys.modules[module_name]
-
-    if app_name is None:
-        return find_best_app(script_info, module)
-    else:
-        return find_app_by_string(script_info, module, app_name)
-
-
-def get_version(ctx, param, value):
-    if not value or ctx.resilient_parsing:
-        return
-    message = 'Flask %(version)s\nPython %(python_version)s'
-    click.echo(message % {
-        'version': __version__,
-        'python_version': sys.version,
-    }, color=ctx.color)
-    ctx.exit()
-
-
-version_option = click.Option(
-    ['--version'],
-    help='Show the flask version',
-    expose_value=False,
-    callback=get_version,
-    is_flag=True,
-    is_eager=True
-)
-
-
-class DispatchingApp(object):
-    """Special application that dispatches to a Flask application which
-    is imported by name in a background thread.  If an error happens
-    it is recorded and shown as part of the WSGI handling which in case
-    of the Werkzeug debugger means that it shows up in the browser.
-    """
-
-    def __init__(self, loader, use_eager_loading=False):
-        self.loader = loader
-        self._app = None
-        self._lock = Lock()
-        self._bg_loading_exc_info = None
-        if use_eager_loading:
-            self._load_unlocked()
-        else:
-            self._load_in_background()
-
-    def _load_in_background(self):
-        def _load_app():
-            __traceback_hide__ = True
-            with self._lock:
-                try:
-                    self._load_unlocked()
-                except Exception:
-                    self._bg_loading_exc_info = sys.exc_info()
-        t = Thread(target=_load_app, args=())
-        t.start()
-
-    def _flush_bg_loading_exception(self):
-        __traceback_hide__ = True
-        exc_info = self._bg_loading_exc_info
-        if exc_info is not None:
-            self._bg_loading_exc_info = None
-            reraise(*exc_info)
-
-    def _load_unlocked(self):
-        __traceback_hide__ = True
-        self._app = rv = self.loader()
-        self._bg_loading_exc_info = None
-        return rv
-
-    def __call__(self, environ, start_response):
-        __traceback_hide__ = True
-        if self._app is not None:
-            return self._app(environ, start_response)
-        self._flush_bg_loading_exception()
-        with self._lock:
-            if self._app is not None:
-                rv = self._app
-            else:
-                rv = self._load_unlocked()
-            return rv(environ, start_response)
-
-
-class ScriptInfo(object):
-    """Help object to deal with Flask applications.  This is usually not
-    necessary to interface with as it's used internally in the dispatching
-    to click.  In future versions of Flask this object will most likely play
-    a bigger role.  Typically it's created automatically by the
-    :class:`FlaskGroup` but you can also manually create it and pass it
-    onwards as click object.
-    """
-
-    def __init__(self, app_import_path=None, create_app=None):
-        #: Optionally the import path for the Flask application.
-        self.app_import_path = app_import_path or os.environ.get('FLASK_APP')
-        #: Optionally a function that is passed the script info to create
-        #: the instance of the application.
-        self.create_app = create_app
-        #: A dictionary with arbitrary data that can be associated with
-        #: this script info.
-        self.data = {}
-        self._loaded_app = None
-
-    def load_app(self):
-        """Loads the Flask app (if not yet loaded) and returns it.  Calling
-        this multiple times will just result in the already loaded app to
-        be returned.
-        """
-        __traceback_hide__ = True
-
-        if self._loaded_app is not None:
-            return self._loaded_app
-
-        app = None
-
-        if self.create_app is not None:
-            app = call_factory(self, self.create_app)
-        else:
-            if self.app_import_path:
-                path, name = (self.app_import_path.split(':', 1) + [None])[:2]
-                import_name = prepare_import(path)
-                app = locate_app(self, import_name, name)
-            else:
-                for path in ('wsgi.py', 'app.py'):
-                    import_name = prepare_import(path)
-                    app = locate_app(self, import_name, None,
-                                     raise_if_not_found=False)
-
-                    if app:
-                        break
-
-        if not app:
-            raise NoAppException(
-                'Could not locate a Flask application. You did not provide '
-                'the "FLASK_APP" environment variable, and a "wsgi.py" or '
-                '"app.py" module was not found in the current directory.'
-            )
-
-        debug = get_debug_flag()
-
-        # Update the app's debug flag through the descriptor so that other
-        # values repopulate as well.
-        if debug is not None:
-            app.debug = debug
-
-        self._loaded_app = app
-        return app
-
-
-pass_script_info = click.make_pass_decorator(ScriptInfo, ensure=True)
-
-
-def with_appcontext(f):
-    """Wraps a callback so that it's guaranteed to be executed with the
-    script's application context.  If callbacks are registered directly
-    to the ``app.cli`` object then they are wrapped with this function
-    by default unless it's disabled.
-    """
-    @click.pass_context
-    def decorator(__ctx, *args, **kwargs):
-        with __ctx.ensure_object(ScriptInfo).load_app().app_context():
-            return __ctx.invoke(f, *args, **kwargs)
-    return update_wrapper(decorator, f)
-
-
-class AppGroup(click.Group):
-    """This works similar to a regular click :class:`~click.Group` but it
-    changes the behavior of the :meth:`command` decorator so that it
-    automatically wraps the functions in :func:`with_appcontext`.
-
-    Not to be confused with :class:`FlaskGroup`.
-    """
-
-    def command(self, *args, **kwargs):
-        """This works exactly like the method of the same name on a regular
-        :class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
-        unless it's disabled by passing ``with_appcontext=False``.
-        """
-        wrap_for_ctx = kwargs.pop('with_appcontext', True)
-        def decorator(f):
-            if wrap_for_ctx:
-                f = with_appcontext(f)
-            return click.Group.command(self, *args, **kwargs)(f)
-        return decorator
-
-    def group(self, *args, **kwargs):
-        """This works exactly like the method of the same name on a regular
-        :class:`click.Group` but it defaults the group class to
-        :class:`AppGroup`.
-        """
-        kwargs.setdefault('cls', AppGroup)
-        return click.Group.group(self, *args, **kwargs)
-
-
-class FlaskGroup(AppGroup):
-    """Special subclass of the :class:`AppGroup` group that supports
-    loading more commands from the configured Flask app.  Normally a
-    developer does not have to interface with this class but there are
-    some very advanced use cases for which it makes sense to create an
-    instance of this.
-
-    For information as of why this is useful see :ref:`custom-scripts`.
-
-    :param add_default_commands: if this is True then the default run and
-        shell commands wil be added.
-    :param add_version_option: adds the ``--version`` option.
-    :param create_app: an optional callback that is passed the script info and
-        returns the loaded app.
-    :param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
-        files to set environment variables. Will also change the working
-        directory to the directory containing the first file found.
-
-    .. versionchanged:: 1.0
-        If installed, python-dotenv will be used to load environment variables
-        from :file:`.env` and :file:`.flaskenv` files.
-    """
-
-    def __init__(self, add_default_commands=True, create_app=None,
-                 add_version_option=True, load_dotenv=True, **extra):
-        params = list(extra.pop('params', None) or ())
-
-        if add_version_option:
-            params.append(version_option)
-
-        AppGroup.__init__(self, params=params, **extra)
-        self.create_app = create_app
-        self.load_dotenv = load_dotenv
-
-        if add_default_commands:
-            self.add_command(run_command)
-            self.add_command(shell_command)
-            self.add_command(routes_command)
-
-        self._loaded_plugin_commands = False
-
-    def _load_plugin_commands(self):
-        if self._loaded_plugin_commands:
-            return
-        try:
-            import pkg_resources
-        except ImportError:
-            self._loaded_plugin_commands = True
-            return
-
-        for ep in pkg_resources.iter_entry_points('flask.commands'):
-            self.add_command(ep.load(), ep.name)
-        self._loaded_plugin_commands = True
-
-    def get_command(self, ctx, name):
-        self._load_plugin_commands()
-
-        # We load built-in commands first as these should always be the
-        # same no matter what the app does.  If the app does want to
-        # override this it needs to make a custom instance of this group
-        # and not attach the default commands.
-        #
-        # This also means that the script stays functional in case the
-        # application completely fails.
-        rv = AppGroup.get_command(self, ctx, name)
-        if rv is not None:
-            return rv
-
-        info = ctx.ensure_object(ScriptInfo)
-        try:
-            rv = info.load_app().cli.get_command(ctx, name)
-            if rv is not None:
-                return rv
-        except NoAppException:
-            pass
-
-    def list_commands(self, ctx):
-        self._load_plugin_commands()
-
-        # The commands available is the list of both the application (if
-        # available) plus the builtin commands.
-        rv = set(click.Group.list_commands(self, ctx))
-        info = ctx.ensure_object(ScriptInfo)
-        try:
-            rv.update(info.load_app().cli.list_commands(ctx))
-        except Exception:
-            # Here we intentionally swallow all exceptions as we don't
-            # want the help page to break if the app does not exist.
-            # If someone attempts to use the command we try to create
-            # the app again and this will give us the error.
-            # However, we will not do so silently because that would confuse
-            # users.
-            traceback.print_exc()
-        return sorted(rv)
-
-    def main(self, *args, **kwargs):
-        # Set a global flag that indicates that we were invoked from the
-        # command line interface. This is detected by Flask.run to make the
-        # call into a no-op. This is necessary to avoid ugly errors when the
-        # script that is loaded here also attempts to start a server.
-        os.environ['FLASK_RUN_FROM_CLI'] = 'true'
-
-        if get_load_dotenv(self.load_dotenv):
-            load_dotenv()
-
-        obj = kwargs.get('obj')
-
-        if obj is None:
-            obj = ScriptInfo(create_app=self.create_app)
-
-        kwargs['obj'] = obj
-        kwargs.setdefault('auto_envvar_prefix', 'FLASK')
-        return super(FlaskGroup, self).main(*args, **kwargs)
-
-
-def _path_is_ancestor(path, other):
-    """Take ``other`` and remove the length of ``path`` from it. Then join it
-    to ``path``. If it is the original value, ``path`` is an ancestor of
-    ``other``."""
-    return os.path.join(path, other[len(path):].lstrip(os.sep)) == other
-
-
-def load_dotenv(path=None):
-    """Load "dotenv" files in order of precedence to set environment variables.
-
-    If an env var is already set it is not overwritten, so earlier files in the
-    list are preferred over later files.
-
-    Changes the current working directory to the location of the first file
-    found, with the assumption that it is in the top level project directory
-    and will be where the Python path should import local packages from.
-
-    This is a no-op if `python-dotenv`_ is not installed.
-
-    .. _python-dotenv: https://github.com/theskumar/python-dotenv#readme
-
-    :param path: Load the file at this location instead of searching.
-    :return: ``True`` if a file was loaded.
-
-    .. versionadded:: 1.0
-    """
-    if dotenv is None:
-        if path or os.path.exists('.env') or os.path.exists('.flaskenv'):
-            click.secho(
-                ' * Tip: There are .env files present.'
-                ' Do "pip install python-dotenv" to use them.',
-                fg='yellow')
-        return
-
-    if path is not None:
-        return dotenv.load_dotenv(path)
-
-    new_dir = None
-
-    for name in ('.env', '.flaskenv'):
-        path = dotenv.find_dotenv(name, usecwd=True)
-
-        if not path:
-            continue
-
-        if new_dir is None:
-            new_dir = os.path.dirname(path)
-
-        dotenv.load_dotenv(path)
-
-    if new_dir and os.getcwd() != new_dir:
-        os.chdir(new_dir)
-
-    return new_dir is not None  # at least one file was located and loaded
-
-
-def show_server_banner(env, debug, app_import_path, eager_loading):
-    """Show extra startup messages the first time the server is run,
-    ignoring the reloader.
-    """
-    if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
-        return
-
-    if app_import_path is not None:
-        message = ' * Serving Flask app "{0}"'.format(app_import_path)
-
-        if not eager_loading:
-            message += ' (lazy loading)'
-
-        click.echo(message)
-
-    click.echo(' * Environment: {0}'.format(env))
-
-    if env == 'production':
-        click.secho(
-            '   WARNING: Do not use the development server in a production'
-            ' environment.', fg='red')
-        click.secho('   Use a production WSGI server instead.', dim=True)
-
-    if debug is not None:
-        click.echo(' * Debug mode: {0}'.format('on' if debug else 'off'))
-
-
-class CertParamType(click.ParamType):
-    """Click option type for the ``--cert`` option. Allows either an
-    existing file, the string ``'adhoc'``, or an import for a
-    :class:`~ssl.SSLContext` object.
-    """
-
-    name = 'path'
-
-    def __init__(self):
-        self.path_type = click.Path(
-            exists=True, dir_okay=False, resolve_path=True)
-
-    def convert(self, value, param, ctx):
-        try:
-            return self.path_type(value, param, ctx)
-        except click.BadParameter:
-            value = click.STRING(value, param, ctx).lower()
-
-            if value == 'adhoc':
-                try:
-                    import OpenSSL
-                except ImportError:
-                    raise click.BadParameter(
-                        'Using ad-hoc certificates requires pyOpenSSL.',
-                        ctx, param)
-
-                return value
-
-            obj = import_string(value, silent=True)
-
-            if sys.version_info < (2, 7):
-                if obj:
-                    return obj
-            else:
-                if isinstance(obj, ssl.SSLContext):
-                    return obj
-
-            raise
-
-
-def _validate_key(ctx, param, value):
-    """The ``--key`` option must be specified when ``--cert`` is a file.
-    Modifies the ``cert`` param to be a ``(cert, key)`` pair if needed.
-    """
-    cert = ctx.params.get('cert')
-    is_adhoc = cert == 'adhoc'
-
-    if sys.version_info < (2, 7):
-        is_context = cert and not isinstance(cert, (text_type, bytes))
-    else:
-        is_context = isinstance(cert, ssl.SSLContext)
-
-    if value is not None:
-        if is_adhoc:
-            raise click.BadParameter(
-                'When "--cert" is "adhoc", "--key" is not used.',
-                ctx, param)
-
-        if is_context:
-            raise click.BadParameter(
-                'When "--cert" is an SSLContext object, "--key is not used.',
-                ctx, param)
-
-        if not cert:
-            raise click.BadParameter(
-                '"--cert" must also be specified.',
-                ctx, param)
-
-        ctx.params['cert'] = cert, value
-
-    else:
-        if cert and not (is_adhoc or is_context):
-            raise click.BadParameter(
-                'Required when using "--cert".',
-                ctx, param)
-
-    return value
-
-
-@click.command('run', short_help='Runs a development server.')
-@click.option('--host', '-h', default='127.0.0.1',
-              help='The interface to bind to.')
-@click.option('--port', '-p', default=5000,
-              help='The port to bind to.')
-@click.option('--cert', type=CertParamType(),
-              help='Specify a certificate file to use HTTPS.')
-@click.option('--key',
-              type=click.Path(exists=True, dir_okay=False, resolve_path=True),
-              callback=_validate_key, expose_value=False,
-              help='The key file to use when specifying a certificate.')
-@click.option('--reload/--no-reload', default=None,
-              help='Enable or disable the reloader. By default the reloader '
-              'is active if debug is enabled.')
-@click.option('--debugger/--no-debugger', default=None,
-              help='Enable or disable the debugger. By default the debugger '
-              'is active if debug is enabled.')
-@click.option('--eager-loading/--lazy-loader', default=None,
-              help='Enable or disable eager loading. By default eager '
-              'loading is enabled if the reloader is disabled.')
-@click.option('--with-threads/--without-threads', default=True,
-              help='Enable or disable multithreading.')
-@pass_script_info
-def run_command(info, host, port, reload, debugger, eager_loading,
-                with_threads, cert):
-    """Run a local development server.
-
-    This server is for development purposes only. It does not provide
-    the stability, security, or performance of production WSGI servers.
-
-    The reloader and debugger are enabled by default if
-    FLASK_ENV=development or FLASK_DEBUG=1.
-    """
-    debug = get_debug_flag()
-
-    if reload is None:
-        reload = debug
-
-    if debugger is None:
-        debugger = debug
-
-    if eager_loading is None:
-        eager_loading = not reload
-
-    show_server_banner(get_env(), debug, info.app_import_path, eager_loading)
-    app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)
-
-    from werkzeug.serving import run_simple
-    run_simple(host, port, app, use_reloader=reload, use_debugger=debugger,
-               threaded=with_threads, ssl_context=cert)
-
-
-@click.command('shell', short_help='Runs a shell in the app context.')
-@with_appcontext
-def shell_command():
-    """Runs an interactive Python shell in the context of a given
-    Flask application.  The application will populate the default
-    namespace of this shell according to it's configuration.
-
-    This is useful for executing small snippets of management code
-    without having to manually configure the application.
-    """
-    import code
-    from flask.globals import _app_ctx_stack
-    app = _app_ctx_stack.top.app
-    banner = 'Python %s on %s\nApp: %s [%s]\nInstance: %s' % (
-        sys.version,
-        sys.platform,
-        app.import_name,
-        app.env,
-        app.instance_path,
-    )
-    ctx = {}
-
-    # Support the regular Python interpreter startup script if someone
-    # is using it.
-    startup = os.environ.get('PYTHONSTARTUP')
-    if startup and os.path.isfile(startup):
-        with open(startup, 'r') as f:
-            eval(compile(f.read(), startup, 'exec'), ctx)
-
-    ctx.update(app.make_shell_context())
-
-    code.interact(banner=banner, local=ctx)
-
-
-@click.command('routes', short_help='Show the routes for the app.')
-@click.option(
-    '--sort', '-s',
-    type=click.Choice(('endpoint', 'methods', 'rule', 'match')),
-    default='endpoint',
-    help=(
-        'Method to sort routes by. "match" is the order that Flask will match '
-        'routes when dispatching a request.'
-    )
-)
-@click.option(
-    '--all-methods',
-    is_flag=True,
-    help="Show HEAD and OPTIONS methods."
-)
-@with_appcontext
-def routes_command(sort, all_methods):
-    """Show all registered routes with endpoints and methods."""
-
-    rules = list(current_app.url_map.iter_rules())
-    if not rules:
-        click.echo('No routes were registered.')
-        return
-
-    ignored_methods = set(() if all_methods else ('HEAD', 'OPTIONS'))
-
-    if sort in ('endpoint', 'rule'):
-        rules = sorted(rules, key=attrgetter(sort))
-    elif sort == 'methods':
-        rules = sorted(rules, key=lambda rule: sorted(rule.methods))
-
-    rule_methods = [
-        ', '.join(sorted(rule.methods - ignored_methods)) for rule in rules
-    ]
-
-    headers = ('Endpoint', 'Methods', 'Rule')
-    widths = (
-        max(len(rule.endpoint) for rule in rules),
-        max(len(methods) for methods in rule_methods),
-        max(len(rule.rule) for rule in rules),
-    )
-    widths = [max(len(h), w) for h, w in zip(headers, widths)]
-    row = '{{0:<{0}}}  {{1:<{1}}}  {{2:<{2}}}'.format(*widths)
-
-    click.echo(row.format(*headers).strip())
-    click.echo(row.format(*('-' * width for width in widths)))
-
-    for rule, methods in zip(rules, rule_methods):
-        click.echo(row.format(rule.endpoint, methods, rule.rule).rstrip())
-
-
-cli = FlaskGroup(help="""\
-A general utility script for Flask applications.
-
-Provides commands from Flask, extensions, and the application. Loads the
-application defined in the FLASK_APP environment variable, or from a wsgi.py
-file. Setting the FLASK_ENV environment variable to 'development' will enable
-debug mode.
-
-\b
-  {prefix}{cmd} FLASK_APP=hello.py
-  {prefix}{cmd} FLASK_ENV=development
-  {prefix}flask run
-""".format(
-    cmd='export' if os.name == 'posix' else 'set',
-    prefix='$ ' if os.name == 'posix' else '> '
-))
-
-
-def main(as_module=False):
-    args = sys.argv[1:]
-
-    if as_module:
-        this_module = 'flask'
-
-        if sys.version_info < (2, 7):
-            this_module += '.cli'
-
-        name = 'python -m ' + this_module
-
-        # Python rewrites "python -m flask" to the path to the file in argv.
-        # Restore the original command so that the reloader works.
-        sys.argv = ['-m', this_module] + args
-    else:
-        name = None
-
-    cli.main(args=args, prog_name=name)
-
-
-if __name__ == '__main__':
-    main(as_module=True)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/config.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/config.py
deleted file mode 100644
index d6074baa8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/config.py
+++ /dev/null
@@ -1,265 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.config
-    ~~~~~~~~~~~~
-
-    Implements the configuration related objects.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-import types
-import errno
-
-from werkzeug.utils import import_string
-from ._compat import string_types, iteritems
-from . import json
-
-
-class ConfigAttribute(object):
-    """Makes an attribute forward to the config"""
-
-    def __init__(self, name, get_converter=None):
-        self.__name__ = name
-        self.get_converter = get_converter
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        rv = obj.config[self.__name__]
-        if self.get_converter is not None:
-            rv = self.get_converter(rv)
-        return rv
-
-    def __set__(self, obj, value):
-        obj.config[self.__name__] = value
-
-
-class Config(dict):
-    """Works exactly like a dict but provides ways to fill it from files
-    or special dictionaries.  There are two common patterns to populate the
-    config.
-
-    Either you can fill the config from a config file::
-
-        app.config.from_pyfile('yourconfig.cfg')
-
-    Or alternatively you can define the configuration options in the
-    module that calls :meth:`from_object` or provide an import path to
-    a module that should be loaded.  It is also possible to tell it to
-    use the same module and with that provide the configuration values
-    just before the call::
-
-        DEBUG = True
-        SECRET_KEY = 'development key'
-        app.config.from_object(__name__)
-
-    In both cases (loading from any Python file or loading from modules),
-    only uppercase keys are added to the config.  This makes it possible to use
-    lowercase values in the config file for temporary values that are not added
-    to the config or to define the config keys in the same file that implements
-    the application.
-
-    Probably the most interesting way to load configurations is from an
-    environment variable pointing to a file::
-
-        app.config.from_envvar('YOURAPPLICATION_SETTINGS')
-
-    In this case before launching the application you have to set this
-    environment variable to the file you want to use.  On Linux and OS X
-    use the export statement::
-
-        export YOURAPPLICATION_SETTINGS='/path/to/config/file'
-
-    On windows use `set` instead.
-
-    :param root_path: path to which files are read relative from.  When the
-                      config object is created by the application, this is
-                      the application's :attr:`~flask.Flask.root_path`.
-    :param defaults: an optional dictionary of default values
-    """
-
-    def __init__(self, root_path, defaults=None):
-        dict.__init__(self, defaults or {})
-        self.root_path = root_path
-
-    def from_envvar(self, variable_name, silent=False):
-        """Loads a configuration from an environment variable pointing to
-        a configuration file.  This is basically just a shortcut with nicer
-        error messages for this line of code::
-
-            app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
-
-        :param variable_name: name of the environment variable
-        :param silent: set to ``True`` if you want silent failure for missing
-                       files.
-        :return: bool. ``True`` if able to load config, ``False`` otherwise.
-        """
-        rv = os.environ.get(variable_name)
-        if not rv:
-            if silent:
-                return False
-            raise RuntimeError('The environment variable %r is not set '
-                               'and as such configuration could not be '
-                               'loaded.  Set this variable and make it '
-                               'point to a configuration file' %
-                               variable_name)
-        return self.from_pyfile(rv, silent=silent)
-
-    def from_pyfile(self, filename, silent=False):
-        """Updates the values in the config from a Python file.  This function
-        behaves as if the file was imported as module with the
-        :meth:`from_object` function.
-
-        :param filename: the filename of the config.  This can either be an
-                         absolute filename or a filename relative to the
-                         root path.
-        :param silent: set to ``True`` if you want silent failure for missing
-                       files.
-
-        .. versionadded:: 0.7
-           `silent` parameter.
-        """
-        filename = os.path.join(self.root_path, filename)
-        d = types.ModuleType('config')
-        d.__file__ = filename
-        try:
-            with open(filename, mode='rb') as config_file:
-                exec(compile(config_file.read(), filename, 'exec'), d.__dict__)
-        except IOError as e:
-            if silent and e.errno in (
-                errno.ENOENT, errno.EISDIR, errno.ENOTDIR
-            ):
-                return False
-            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
-            raise
-        self.from_object(d)
-        return True
-
-    def from_object(self, obj):
-        """Updates the values from the given object.  An object can be of one
-        of the following two types:
-
-        -   a string: in this case the object with that name will be imported
-        -   an actual object reference: that object is used directly
-
-        Objects are usually either modules or classes. :meth:`from_object`
-        loads only the uppercase attributes of the module/class. A ``dict``
-        object will not work with :meth:`from_object` because the keys of a
-        ``dict`` are not attributes of the ``dict`` class.
-
-        Example of module-based configuration::
-
-            app.config.from_object('yourapplication.default_config')
-            from yourapplication import default_config
-            app.config.from_object(default_config)
-
-        You should not use this function to load the actual configuration but
-        rather configuration defaults.  The actual config should be loaded
-        with :meth:`from_pyfile` and ideally from a location not within the
-        package because the package might be installed system wide.
-
-        See :ref:`config-dev-prod` for an example of class-based configuration
-        using :meth:`from_object`.
-
-        :param obj: an import name or object
-        """
-        if isinstance(obj, string_types):
-            obj = import_string(obj)
-        for key in dir(obj):
-            if key.isupper():
-                self[key] = getattr(obj, key)
-
-    def from_json(self, filename, silent=False):
-        """Updates the values in the config from a JSON file. This function
-        behaves as if the JSON object was a dictionary and passed to the
-        :meth:`from_mapping` function.
-
-        :param filename: the filename of the JSON file.  This can either be an
-                         absolute filename or a filename relative to the
-                         root path.
-        :param silent: set to ``True`` if you want silent failure for missing
-                       files.
-
-        .. versionadded:: 0.11
-        """
-        filename = os.path.join(self.root_path, filename)
-
-        try:
-            with open(filename) as json_file:
-                obj = json.loads(json_file.read())
-        except IOError as e:
-            if silent and e.errno in (errno.ENOENT, errno.EISDIR):
-                return False
-            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
-            raise
-        return self.from_mapping(obj)
-
-    def from_mapping(self, *mapping, **kwargs):
-        """Updates the config like :meth:`update` ignoring items with non-upper
-        keys.
-
-        .. versionadded:: 0.11
-        """
-        mappings = []
-        if len(mapping) == 1:
-            if hasattr(mapping[0], 'items'):
-                mappings.append(mapping[0].items())
-            else:
-                mappings.append(mapping[0])
-        elif len(mapping) > 1:
-            raise TypeError(
-                'expected at most 1 positional argument, got %d' % len(mapping)
-            )
-        mappings.append(kwargs.items())
-        for mapping in mappings:
-            for (key, value) in mapping:
-                if key.isupper():
-                    self[key] = value
-        return True
-
-    def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
-        """Returns a dictionary containing a subset of configuration options
-        that match the specified namespace/prefix. Example usage::
-
-            app.config['IMAGE_STORE_TYPE'] = 'fs'
-            app.config['IMAGE_STORE_PATH'] = '/var/app/images'
-            app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
-            image_store_config = app.config.get_namespace('IMAGE_STORE_')
-
-        The resulting dictionary `image_store_config` would look like::
-
-            {
-                'type': 'fs',
-                'path': '/var/app/images',
-                'base_url': 'http://img.website.com'
-            }
-
-        This is often useful when configuration options map directly to
-        keyword arguments in functions or class constructors.
-
-        :param namespace: a configuration namespace
-        :param lowercase: a flag indicating if the keys of the resulting
-                          dictionary should be lowercase
-        :param trim_namespace: a flag indicating if the keys of the resulting
-                          dictionary should not include the namespace
-
-        .. versionadded:: 0.11
-        """
-        rv = {}
-        for k, v in iteritems(self):
-            if not k.startswith(namespace):
-                continue
-            if trim_namespace:
-                key = k[len(namespace):]
-            else:
-                key = k
-            if lowercase:
-                key = key.lower()
-            rv[key] = v
-        return rv
-
-    def __repr__(self):
-        return '<%s %s>' % (self.__class__.__name__, dict.__repr__(self))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/ctx.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/ctx.py
deleted file mode 100644
index 8472c920c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/ctx.py
+++ /dev/null
@@ -1,457 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.ctx
-    ~~~~~~~~~
-
-    Implements the objects required to keep the context.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import sys
-from functools import update_wrapper
-
-from werkzeug.exceptions import HTTPException
-
-from .globals import _request_ctx_stack, _app_ctx_stack
-from .signals import appcontext_pushed, appcontext_popped
-from ._compat import BROKEN_PYPY_CTXMGR_EXIT, reraise
-
-
-# a singleton sentinel value for parameter defaults
-_sentinel = object()
-
-
-class _AppCtxGlobals(object):
-    """A plain object. Used as a namespace for storing data during an
-    application context.
-
-    Creating an app context automatically creates this object, which is
-    made available as the :data:`g` proxy.
-
-    .. describe:: 'key' in g
-
-        Check whether an attribute is present.
-
-        .. versionadded:: 0.10
-
-    .. describe:: iter(g)
-
-        Return an iterator over the attribute names.
-
-        .. versionadded:: 0.10
-    """
-
-    def get(self, name, default=None):
-        """Get an attribute by name, or a default value. Like
-        :meth:`dict.get`.
-
-        :param name: Name of attribute to get.
-        :param default: Value to return if the attribute is not present.
-
-        .. versionadded:: 0.10
-        """
-        return self.__dict__.get(name, default)
-
-    def pop(self, name, default=_sentinel):
-        """Get and remove an attribute by name. Like :meth:`dict.pop`.
-
-        :param name: Name of attribute to pop.
-        :param default: Value to return if the attribute is not present,
-            instead of raise a ``KeyError``.
-
-        .. versionadded:: 0.11
-        """
-        if default is _sentinel:
-            return self.__dict__.pop(name)
-        else:
-            return self.__dict__.pop(name, default)
-
-    def setdefault(self, name, default=None):
-        """Get the value of an attribute if it is present, otherwise
-        set and return a default value. Like :meth:`dict.setdefault`.
-
-        :param name: Name of attribute to get.
-        :param: default: Value to set and return if the attribute is not
-            present.
-
-        .. versionadded:: 0.11
-        """
-        return self.__dict__.setdefault(name, default)
-
-    def __contains__(self, item):
-        return item in self.__dict__
-
-    def __iter__(self):
-        return iter(self.__dict__)
-
-    def __repr__(self):
-        top = _app_ctx_stack.top
-        if top is not None:
-            return '<flask.g of %r>' % top.app.name
-        return object.__repr__(self)
-
-
-def after_this_request(f):
-    """Executes a function after this request.  This is useful to modify
-    response objects.  The function is passed the response object and has
-    to return the same or a new one.
-
-    Example::
-
-        @app.route('/')
-        def index():
-            @after_this_request
-            def add_header(response):
-                response.headers['X-Foo'] = 'Parachute'
-                return response
-            return 'Hello World!'
-
-    This is more useful if a function other than the view function wants to
-    modify a response.  For instance think of a decorator that wants to add
-    some headers without converting the return value into a response object.
-
-    .. versionadded:: 0.9
-    """
-    _request_ctx_stack.top._after_request_functions.append(f)
-    return f
-
-
-def copy_current_request_context(f):
-    """A helper function that decorates a function to retain the current
-    request context.  This is useful when working with greenlets.  The moment
-    the function is decorated a copy of the request context is created and
-    then pushed when the function is called.
-
-    Example::
-
-        import gevent
-        from flask import copy_current_request_context
-
-        @app.route('/')
-        def index():
-            @copy_current_request_context
-            def do_some_work():
-                # do some work here, it can access flask.request like you
-                # would otherwise in the view function.
-                ...
-            gevent.spawn(do_some_work)
-            return 'Regular response'
-
-    .. versionadded:: 0.10
-    """
-    top = _request_ctx_stack.top
-    if top is None:
-        raise RuntimeError('This decorator can only be used at local scopes '
-            'when a request context is on the stack.  For instance within '
-            'view functions.')
-    reqctx = top.copy()
-    def wrapper(*args, **kwargs):
-        with reqctx:
-            return f(*args, **kwargs)
-    return update_wrapper(wrapper, f)
-
-
-def has_request_context():
-    """If you have code that wants to test if a request context is there or
-    not this function can be used.  For instance, you may want to take advantage
-    of request information if the request object is available, but fail
-    silently if it is unavailable.
-
-    ::
-
-        class User(db.Model):
-
-            def __init__(self, username, remote_addr=None):
-                self.username = username
-                if remote_addr is None and has_request_context():
-                    remote_addr = request.remote_addr
-                self.remote_addr = remote_addr
-
-    Alternatively you can also just test any of the context bound objects
-    (such as :class:`request` or :class:`g` for truthness)::
-
-        class User(db.Model):
-
-            def __init__(self, username, remote_addr=None):
-                self.username = username
-                if remote_addr is None and request:
-                    remote_addr = request.remote_addr
-                self.remote_addr = remote_addr
-
-    .. versionadded:: 0.7
-    """
-    return _request_ctx_stack.top is not None
-
-
-def has_app_context():
-    """Works like :func:`has_request_context` but for the application
-    context.  You can also just do a boolean check on the
-    :data:`current_app` object instead.
-
-    .. versionadded:: 0.9
-    """
-    return _app_ctx_stack.top is not None
-
-
-class AppContext(object):
-    """The application context binds an application object implicitly
-    to the current thread or greenlet, similar to how the
-    :class:`RequestContext` binds request information.  The application
-    context is also implicitly created if a request context is created
-    but the application is not on top of the individual application
-    context.
-    """
-
-    def __init__(self, app):
-        self.app = app
-        self.url_adapter = app.create_url_adapter(None)
-        self.g = app.app_ctx_globals_class()
-
-        # Like request context, app contexts can be pushed multiple times
-        # but there a basic "refcount" is enough to track them.
-        self._refcnt = 0
-
-    def push(self):
-        """Binds the app context to the current context."""
-        self._refcnt += 1
-        if hasattr(sys, 'exc_clear'):
-            sys.exc_clear()
-        _app_ctx_stack.push(self)
-        appcontext_pushed.send(self.app)
-
-    def pop(self, exc=_sentinel):
-        """Pops the app context."""
-        try:
-            self._refcnt -= 1
-            if self._refcnt <= 0:
-                if exc is _sentinel:
-                    exc = sys.exc_info()[1]
-                self.app.do_teardown_appcontext(exc)
-        finally:
-            rv = _app_ctx_stack.pop()
-        assert rv is self, 'Popped wrong app context.  (%r instead of %r)' \
-            % (rv, self)
-        appcontext_popped.send(self.app)
-
-    def __enter__(self):
-        self.push()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.pop(exc_value)
-
-        if BROKEN_PYPY_CTXMGR_EXIT and exc_type is not None:
-            reraise(exc_type, exc_value, tb)
-
-
-class RequestContext(object):
-    """The request context contains all request relevant information.  It is
-    created at the beginning of the request and pushed to the
-    `_request_ctx_stack` and removed at the end of it.  It will create the
-    URL adapter and request object for the WSGI environment provided.
-
-    Do not attempt to use this class directly, instead use
-    :meth:`~flask.Flask.test_request_context` and
-    :meth:`~flask.Flask.request_context` to create this object.
-
-    When the request context is popped, it will evaluate all the
-    functions registered on the application for teardown execution
-    (:meth:`~flask.Flask.teardown_request`).
-
-    The request context is automatically popped at the end of the request
-    for you.  In debug mode the request context is kept around if
-    exceptions happen so that interactive debuggers have a chance to
-    introspect the data.  With 0.4 this can also be forced for requests
-    that did not fail and outside of ``DEBUG`` mode.  By setting
-    ``'flask._preserve_context'`` to ``True`` on the WSGI environment the
-    context will not pop itself at the end of the request.  This is used by
-    the :meth:`~flask.Flask.test_client` for example to implement the
-    deferred cleanup functionality.
-
-    You might find this helpful for unittests where you need the
-    information from the context local around for a little longer.  Make
-    sure to properly :meth:`~werkzeug.LocalStack.pop` the stack yourself in
-    that situation, otherwise your unittests will leak memory.
-    """
-
-    def __init__(self, app, environ, request=None):
-        self.app = app
-        if request is None:
-            request = app.request_class(environ)
-        self.request = request
-        self.url_adapter = app.create_url_adapter(self.request)
-        self.flashes = None
-        self.session = None
-
-        # Request contexts can be pushed multiple times and interleaved with
-        # other request contexts.  Now only if the last level is popped we
-        # get rid of them.  Additionally if an application context is missing
-        # one is created implicitly so for each level we add this information
-        self._implicit_app_ctx_stack = []
-
-        # indicator if the context was preserved.  Next time another context
-        # is pushed the preserved context is popped.
-        self.preserved = False
-
-        # remembers the exception for pop if there is one in case the context
-        # preservation kicks in.
-        self._preserved_exc = None
-
-        # Functions that should be executed after the request on the response
-        # object.  These will be called before the regular "after_request"
-        # functions.
-        self._after_request_functions = []
-
-        self.match_request()
-
-    def _get_g(self):
-        return _app_ctx_stack.top.g
-    def _set_g(self, value):
-        _app_ctx_stack.top.g = value
-    g = property(_get_g, _set_g)
-    del _get_g, _set_g
-
-    def copy(self):
-        """Creates a copy of this request context with the same request object.
-        This can be used to move a request context to a different greenlet.
-        Because the actual request object is the same this cannot be used to
-        move a request context to a different thread unless access to the
-        request object is locked.
-
-        .. versionadded:: 0.10
-        """
-        return self.__class__(self.app,
-            environ=self.request.environ,
-            request=self.request
-        )
-
-    def match_request(self):
-        """Can be overridden by a subclass to hook into the matching
-        of the request.
-        """
-        try:
-            url_rule, self.request.view_args = \
-                self.url_adapter.match(return_rule=True)
-            self.request.url_rule = url_rule
-        except HTTPException as e:
-            self.request.routing_exception = e
-
-    def push(self):
-        """Binds the request context to the current context."""
-        # If an exception occurs in debug mode or if context preservation is
-        # activated under exception situations exactly one context stays
-        # on the stack.  The rationale is that you want to access that
-        # information under debug situations.  However if someone forgets to
-        # pop that context again we want to make sure that on the next push
-        # it's invalidated, otherwise we run at risk that something leaks
-        # memory.  This is usually only a problem in test suite since this
-        # functionality is not active in production environments.
-        top = _request_ctx_stack.top
-        if top is not None and top.preserved:
-            top.pop(top._preserved_exc)
-
-        # Before we push the request context we have to ensure that there
-        # is an application context.
-        app_ctx = _app_ctx_stack.top
-        if app_ctx is None or app_ctx.app != self.app:
-            app_ctx = self.app.app_context()
-            app_ctx.push()
-            self._implicit_app_ctx_stack.append(app_ctx)
-        else:
-            self._implicit_app_ctx_stack.append(None)
-
-        if hasattr(sys, 'exc_clear'):
-            sys.exc_clear()
-
-        _request_ctx_stack.push(self)
-
-        # Open the session at the moment that the request context is available.
-        # This allows a custom open_session method to use the request context.
-        # Only open a new session if this is the first time the request was
-        # pushed, otherwise stream_with_context loses the session.
-        if self.session is None:
-            session_interface = self.app.session_interface
-            self.session = session_interface.open_session(
-                self.app, self.request
-            )
-
-            if self.session is None:
-                self.session = session_interface.make_null_session(self.app)
-
-    def pop(self, exc=_sentinel):
-        """Pops the request context and unbinds it by doing that.  This will
-        also trigger the execution of functions registered by the
-        :meth:`~flask.Flask.teardown_request` decorator.
-
-        .. versionchanged:: 0.9
-           Added the `exc` argument.
-        """
-        app_ctx = self._implicit_app_ctx_stack.pop()
-
-        try:
-            clear_request = False
-            if not self._implicit_app_ctx_stack:
-                self.preserved = False
-                self._preserved_exc = None
-                if exc is _sentinel:
-                    exc = sys.exc_info()[1]
-                self.app.do_teardown_request(exc)
-
-                # If this interpreter supports clearing the exception information
-                # we do that now.  This will only go into effect on Python 2.x,
-                # on 3.x it disappears automatically at the end of the exception
-                # stack.
-                if hasattr(sys, 'exc_clear'):
-                    sys.exc_clear()
-
-                request_close = getattr(self.request, 'close', None)
-                if request_close is not None:
-                    request_close()
-                clear_request = True
-        finally:
-            rv = _request_ctx_stack.pop()
-
-            # get rid of circular dependencies at the end of the request
-            # so that we don't require the GC to be active.
-            if clear_request:
-                rv.request.environ['werkzeug.request'] = None
-
-            # Get rid of the app as well if necessary.
-            if app_ctx is not None:
-                app_ctx.pop(exc)
-
-            assert rv is self, 'Popped wrong request context.  ' \
-                '(%r instead of %r)' % (rv, self)
-
-    def auto_pop(self, exc):
-        if self.request.environ.get('flask._preserve_context') or \
-           (exc is not None and self.app.preserve_context_on_exception):
-            self.preserved = True
-            self._preserved_exc = exc
-        else:
-            self.pop(exc)
-
-    def __enter__(self):
-        self.push()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        # do not pop the request stack if we are in debug mode and an
-        # exception happened.  This will allow the debugger to still
-        # access the request object in the interactive shell.  Furthermore
-        # the context can be force kept alive for the test client.
-        # See flask.testing for how this works.
-        self.auto_pop(exc_value)
-
-        if BROKEN_PYPY_CTXMGR_EXIT and exc_type is not None:
-            reraise(exc_type, exc_value, tb)
-
-    def __repr__(self):
-        return '<%s \'%s\' [%s] of %s>' % (
-            self.__class__.__name__,
-            self.request.url,
-            self.request.method,
-            self.app.name,
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/debughelpers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/debughelpers.py
deleted file mode 100644
index e9765f20d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/debughelpers.py
+++ /dev/null
@@ -1,168 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.debughelpers
-    ~~~~~~~~~~~~~~~~~~
-
-    Various helpers to make the development experience better.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-from warnings import warn
-
-from ._compat import implements_to_string, text_type
-from .app import Flask
-from .blueprints import Blueprint
-from .globals import _request_ctx_stack
-
-
-class UnexpectedUnicodeError(AssertionError, UnicodeError):
-    """Raised in places where we want some better error reporting for
-    unexpected unicode or binary data.
-    """
-
-
-@implements_to_string
-class DebugFilesKeyError(KeyError, AssertionError):
-    """Raised from request.files during debugging.  The idea is that it can
-    provide a better error message than just a generic KeyError/BadRequest.
-    """
-
-    def __init__(self, request, key):
-        form_matches = request.form.getlist(key)
-        buf = ['You tried to access the file "%s" in the request.files '
-               'dictionary but it does not exist.  The mimetype for the request '
-               'is "%s" instead of "multipart/form-data" which means that no '
-               'file contents were transmitted.  To fix this error you should '
-               'provide enctype="multipart/form-data" in your form.' %
-               (key, request.mimetype)]
-        if form_matches:
-            buf.append('\n\nThe browser instead transmitted some file names. '
-                       'This was submitted: %s' % ', '.join('"%s"' % x
-                            for x in form_matches))
-        self.msg = ''.join(buf)
-
-    def __str__(self):
-        return self.msg
-
-
-class FormDataRoutingRedirect(AssertionError):
-    """This exception is raised by Flask in debug mode if it detects a
-    redirect caused by the routing system when the request method is not
-    GET, HEAD or OPTIONS.  Reasoning: form data will be dropped.
-    """
-
-    def __init__(self, request):
-        exc = request.routing_exception
-        buf = ['A request was sent to this URL (%s) but a redirect was '
-               'issued automatically by the routing system to "%s".'
-               % (request.url, exc.new_url)]
-
-        # In case just a slash was appended we can be extra helpful
-        if request.base_url + '/' == exc.new_url.split('?')[0]:
-            buf.append('  The URL was defined with a trailing slash so '
-                       'Flask will automatically redirect to the URL '
-                       'with the trailing slash if it was accessed '
-                       'without one.')
-
-        buf.append('  Make sure to directly send your %s-request to this URL '
-                   'since we can\'t make browsers or HTTP clients redirect '
-                   'with form data reliably or without user interaction.' %
-                   request.method)
-        buf.append('\n\nNote: this exception is only raised in debug mode')
-        AssertionError.__init__(self, ''.join(buf).encode('utf-8'))
-
-
-def attach_enctype_error_multidict(request):
-    """Since Flask 0.8 we're monkeypatching the files object in case a
-    request is detected that does not use multipart form data but the files
-    object is accessed.
-    """
-    oldcls = request.files.__class__
-    class newcls(oldcls):
-        def __getitem__(self, key):
-            try:
-                return oldcls.__getitem__(self, key)
-            except KeyError:
-                if key not in request.form:
-                    raise
-                raise DebugFilesKeyError(request, key)
-    newcls.__name__ = oldcls.__name__
-    newcls.__module__ = oldcls.__module__
-    request.files.__class__ = newcls
-
-
-def _dump_loader_info(loader):
-    yield 'class: %s.%s' % (type(loader).__module__, type(loader).__name__)
-    for key, value in sorted(loader.__dict__.items()):
-        if key.startswith('_'):
-            continue
-        if isinstance(value, (tuple, list)):
-            if not all(isinstance(x, (str, text_type)) for x in value):
-                continue
-            yield '%s:' % key
-            for item in value:
-                yield '  - %s' % item
-            continue
-        elif not isinstance(value, (str, text_type, int, float, bool)):
-            continue
-        yield '%s: %r' % (key, value)
-
-
-def explain_template_loading_attempts(app, template, attempts):
-    """This should help developers understand what failed"""
-    info = ['Locating template "%s":' % template]
-    total_found = 0
-    blueprint = None
-    reqctx = _request_ctx_stack.top
-    if reqctx is not None and reqctx.request.blueprint is not None:
-        blueprint = reqctx.request.blueprint
-
-    for idx, (loader, srcobj, triple) in enumerate(attempts):
-        if isinstance(srcobj, Flask):
-            src_info = 'application "%s"' % srcobj.import_name
-        elif isinstance(srcobj, Blueprint):
-            src_info = 'blueprint "%s" (%s)' % (srcobj.name,
-                                                srcobj.import_name)
-        else:
-            src_info = repr(srcobj)
-
-        info.append('% 5d: trying loader of %s' % (
-            idx + 1, src_info))
-
-        for line in _dump_loader_info(loader):
-            info.append('       %s' % line)
-
-        if triple is None:
-            detail = 'no match'
-        else:
-            detail = 'found (%r)' % (triple[1] or '<string>')
-            total_found += 1
-        info.append('       -> %s' % detail)
-
-    seems_fishy = False
-    if total_found == 0:
-        info.append('Error: the template could not be found.')
-        seems_fishy = True
-    elif total_found > 1:
-        info.append('Warning: multiple loaders returned a match for the template.')
-        seems_fishy = True
-
-    if blueprint is not None and seems_fishy:
-        info.append('  The template was looked up from an endpoint that '
-                    'belongs to the blueprint "%s".' % blueprint)
-        info.append('  Maybe you did not place a template in the right folder?')
-        info.append('  See http://flask.pocoo.org/docs/blueprints/#templates')
-
-    app.logger.info('\n'.join(info))
-
-
-def explain_ignored_app_run():
-    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
-        warn(Warning('Silently ignoring app.run() because the '
-                     'application is run from the flask command line '
-                     'executable.  Consider putting app.run() behind an '
-                     'if __name__ == "__main__" guard to silence this '
-                     'warning.'), stacklevel=3)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/globals.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/globals.py
deleted file mode 100644
index 7d50a6f6d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/globals.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.globals
-    ~~~~~~~~~~~~~
-
-    Defines all the global objects that are proxies to the current
-    active context.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from functools import partial
-from werkzeug.local import LocalStack, LocalProxy
-
-
-_request_ctx_err_msg = '''\
-Working outside of request context.
-
-This typically means that you attempted to use functionality that needed
-an active HTTP request.  Consult the documentation on testing for
-information about how to avoid this problem.\
-'''
-_app_ctx_err_msg = '''\
-Working outside of application context.
-
-This typically means that you attempted to use functionality that needed
-to interface with the current application object in some way. To solve
-this, set up an application context with app.app_context().  See the
-documentation for more information.\
-'''
-
-
-def _lookup_req_object(name):
-    top = _request_ctx_stack.top
-    if top is None:
-        raise RuntimeError(_request_ctx_err_msg)
-    return getattr(top, name)
-
-
-def _lookup_app_object(name):
-    top = _app_ctx_stack.top
-    if top is None:
-        raise RuntimeError(_app_ctx_err_msg)
-    return getattr(top, name)
-
-
-def _find_app():
-    top = _app_ctx_stack.top
-    if top is None:
-        raise RuntimeError(_app_ctx_err_msg)
-    return top.app
-
-
-# context locals
-_request_ctx_stack = LocalStack()
-_app_ctx_stack = LocalStack()
-current_app = LocalProxy(_find_app)
-request = LocalProxy(partial(_lookup_req_object, 'request'))
-session = LocalProxy(partial(_lookup_req_object, 'session'))
-g = LocalProxy(partial(_lookup_app_object, 'g'))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/helpers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/helpers.py
deleted file mode 100644
index df0b91fc5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/helpers.py
+++ /dev/null
@@ -1,1044 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.helpers
-    ~~~~~~~~~~~~~
-
-    Implements various helpers.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-import socket
-import sys
-import pkgutil
-import posixpath
-import mimetypes
-from time import time
-from zlib import adler32
-from threading import RLock
-import unicodedata
-from werkzeug.routing import BuildError
-from functools import update_wrapper
-
-from werkzeug.urls import url_quote
-from werkzeug.datastructures import Headers, Range
-from werkzeug.exceptions import BadRequest, NotFound, \
-    RequestedRangeNotSatisfiable
-
-from werkzeug.wsgi import wrap_file
-from jinja2 import FileSystemLoader
-
-from .signals import message_flashed
-from .globals import session, _request_ctx_stack, _app_ctx_stack, \
-     current_app, request
-from ._compat import string_types, text_type, PY2
-
-# sentinel
-_missing = object()
-
-
-# what separators does this operating system provide that are not a slash?
-# this is used by the send_from_directory function to ensure that nobody is
-# able to access files from outside the filesystem.
-_os_alt_seps = list(sep for sep in [os.path.sep, os.path.altsep]
-                    if sep not in (None, '/'))
-
-
-def get_env():
-    """Get the environment the app is running in, indicated by the
-    :envvar:`FLASK_ENV` environment variable. The default is
-    ``'production'``.
-    """
-    return os.environ.get('FLASK_ENV') or 'production'
-
-
-def get_debug_flag():
-    """Get whether debug mode should be enabled for the app, indicated
-    by the :envvar:`FLASK_DEBUG` environment variable. The default is
-    ``True`` if :func:`.get_env` returns ``'development'``, or ``False``
-    otherwise.
-    """
-    val = os.environ.get('FLASK_DEBUG')
-
-    if not val:
-        return get_env() == 'development'
-
-    return val.lower() not in ('0', 'false', 'no')
-
-
-def get_load_dotenv(default=True):
-    """Get whether the user has disabled loading dotenv files by setting
-    :envvar:`FLASK_SKIP_DOTENV`. The default is ``True``, load the
-    files.
-
-    :param default: What to return if the env var isn't set.
-    """
-    val = os.environ.get('FLASK_SKIP_DOTENV')
-
-    if not val:
-        return default
-
-    return val.lower() in ('0', 'false', 'no')
-
-
-def _endpoint_from_view_func(view_func):
-    """Internal helper that returns the default endpoint for a given
-    function.  This always is the function name.
-    """
-    assert view_func is not None, 'expected view func if endpoint ' \
-                                  'is not provided.'
-    return view_func.__name__
-
-
-def stream_with_context(generator_or_function):
-    """Request contexts disappear when the response is started on the server.
-    This is done for efficiency reasons and to make it less likely to encounter
-    memory leaks with badly written WSGI middlewares.  The downside is that if
-    you are using streamed responses, the generator cannot access request bound
-    information any more.
-
-    This function however can help you keep the context around for longer::
-
-        from flask import stream_with_context, request, Response
-
-        @app.route('/stream')
-        def streamed_response():
-            @stream_with_context
-            def generate():
-                yield 'Hello '
-                yield request.args['name']
-                yield '!'
-            return Response(generate())
-
-    Alternatively it can also be used around a specific generator::
-
-        from flask import stream_with_context, request, Response
-
-        @app.route('/stream')
-        def streamed_response():
-            def generate():
-                yield 'Hello '
-                yield request.args['name']
-                yield '!'
-            return Response(stream_with_context(generate()))
-
-    .. versionadded:: 0.9
-    """
-    try:
-        gen = iter(generator_or_function)
-    except TypeError:
-        def decorator(*args, **kwargs):
-            gen = generator_or_function(*args, **kwargs)
-            return stream_with_context(gen)
-        return update_wrapper(decorator, generator_or_function)
-
-    def generator():
-        ctx = _request_ctx_stack.top
-        if ctx is None:
-            raise RuntimeError('Attempted to stream with context but '
-                'there was no context in the first place to keep around.')
-        with ctx:
-            # Dummy sentinel.  Has to be inside the context block or we're
-            # not actually keeping the context around.
-            yield None
-
-            # The try/finally is here so that if someone passes a WSGI level
-            # iterator in we're still running the cleanup logic.  Generators
-            # don't need that because they are closed on their destruction
-            # automatically.
-            try:
-                for item in gen:
-                    yield item
-            finally:
-                if hasattr(gen, 'close'):
-                    gen.close()
-
-    # The trick is to start the generator.  Then the code execution runs until
-    # the first dummy None is yielded at which point the context was already
-    # pushed.  This item is discarded.  Then when the iteration continues the
-    # real generator is executed.
-    wrapped_g = generator()
-    next(wrapped_g)
-    return wrapped_g
-
-
-def make_response(*args):
-    """Sometimes it is necessary to set additional headers in a view.  Because
-    views do not have to return response objects but can return a value that
-    is converted into a response object by Flask itself, it becomes tricky to
-    add headers to it.  This function can be called instead of using a return
-    and you will get a response object which you can use to attach headers.
-
-    If view looked like this and you want to add a new header::
-
-        def index():
-            return render_template('index.html', foo=42)
-
-    You can now do something like this::
-
-        def index():
-            response = make_response(render_template('index.html', foo=42))
-            response.headers['X-Parachutes'] = 'parachutes are cool'
-            return response
-
-    This function accepts the very same arguments you can return from a
-    view function.  This for example creates a response with a 404 error
-    code::
-
-        response = make_response(render_template('not_found.html'), 404)
-
-    The other use case of this function is to force the return value of a
-    view function into a response which is helpful with view
-    decorators::
-
-        response = make_response(view_function())
-        response.headers['X-Parachutes'] = 'parachutes are cool'
-
-    Internally this function does the following things:
-
-    -   if no arguments are passed, it creates a new response argument
-    -   if one argument is passed, :meth:`flask.Flask.make_response`
-        is invoked with it.
-    -   if more than one argument is passed, the arguments are passed
-        to the :meth:`flask.Flask.make_response` function as tuple.
-
-    .. versionadded:: 0.6
-    """
-    if not args:
-        return current_app.response_class()
-    if len(args) == 1:
-        args = args[0]
-    return current_app.make_response(args)
-
-
-def url_for(endpoint, **values):
-    """Generates a URL to the given endpoint with the method provided.
-
-    Variable arguments that are unknown to the target endpoint are appended
-    to the generated URL as query arguments.  If the value of a query argument
-    is ``None``, the whole pair is skipped.  In case blueprints are active
-    you can shortcut references to the same blueprint by prefixing the
-    local endpoint with a dot (``.``).
-
-    This will reference the index function local to the current blueprint::
-
-        url_for('.index')
-
-    For more information, head over to the :ref:`Quickstart <url-building>`.
-
-    To integrate applications, :class:`Flask` has a hook to intercept URL build
-    errors through :attr:`Flask.url_build_error_handlers`.  The `url_for`
-    function results in a :exc:`~werkzeug.routing.BuildError` when the current
-    app does not have a URL for the given endpoint and values.  When it does, the
-    :data:`~flask.current_app` calls its :attr:`~Flask.url_build_error_handlers` if
-    it is not ``None``, which can return a string to use as the result of
-    `url_for` (instead of `url_for`'s default to raise the
-    :exc:`~werkzeug.routing.BuildError` exception) or re-raise the exception.
-    An example::
-
-        def external_url_handler(error, endpoint, values):
-            "Looks up an external URL when `url_for` cannot build a URL."
-            # This is an example of hooking the build_error_handler.
-            # Here, lookup_url is some utility function you've built
-            # which looks up the endpoint in some external URL registry.
-            url = lookup_url(endpoint, **values)
-            if url is None:
-                # External lookup did not have a URL.
-                # Re-raise the BuildError, in context of original traceback.
-                exc_type, exc_value, tb = sys.exc_info()
-                if exc_value is error:
-                    raise exc_type, exc_value, tb
-                else:
-                    raise error
-            # url_for will use this result, instead of raising BuildError.
-            return url
-
-        app.url_build_error_handlers.append(external_url_handler)
-
-    Here, `error` is the instance of :exc:`~werkzeug.routing.BuildError`, and
-    `endpoint` and `values` are the arguments passed into `url_for`.  Note
-    that this is for building URLs outside the current application, and not for
-    handling 404 NotFound errors.
-
-    .. versionadded:: 0.10
-       The `_scheme` parameter was added.
-
-    .. versionadded:: 0.9
-       The `_anchor` and `_method` parameters were added.
-
-    .. versionadded:: 0.9
-       Calls :meth:`Flask.handle_build_error` on
-       :exc:`~werkzeug.routing.BuildError`.
-
-    :param endpoint: the endpoint of the URL (name of the function)
-    :param values: the variable arguments of the URL rule
-    :param _external: if set to ``True``, an absolute URL is generated. Server
-      address can be changed via ``SERVER_NAME`` configuration variable which
-      defaults to `localhost`.
-    :param _scheme: a string specifying the desired URL scheme. The `_external`
-      parameter must be set to ``True`` or a :exc:`ValueError` is raised. The default
-      behavior uses the same scheme as the current request, or
-      ``PREFERRED_URL_SCHEME`` from the :ref:`app configuration <config>` if no
-      request context is available. As of Werkzeug 0.10, this also can be set
-      to an empty string to build protocol-relative URLs.
-    :param _anchor: if provided this is added as anchor to the URL.
-    :param _method: if provided this explicitly specifies an HTTP method.
-    """
-    appctx = _app_ctx_stack.top
-    reqctx = _request_ctx_stack.top
-
-    if appctx is None:
-        raise RuntimeError(
-            'Attempted to generate a URL without the application context being'
-            ' pushed. This has to be executed when application context is'
-            ' available.'
-        )
-
-    # If request specific information is available we have some extra
-    # features that support "relative" URLs.
-    if reqctx is not None:
-        url_adapter = reqctx.url_adapter
-        blueprint_name = request.blueprint
-
-        if endpoint[:1] == '.':
-            if blueprint_name is not None:
-                endpoint = blueprint_name + endpoint
-            else:
-                endpoint = endpoint[1:]
-
-        external = values.pop('_external', False)
-
-    # Otherwise go with the url adapter from the appctx and make
-    # the URLs external by default.
-    else:
-        url_adapter = appctx.url_adapter
-
-        if url_adapter is None:
-            raise RuntimeError(
-                'Application was not able to create a URL adapter for request'
-                ' independent URL generation. You might be able to fix this by'
-                ' setting the SERVER_NAME config variable.'
-            )
-
-        external = values.pop('_external', True)
-
-    anchor = values.pop('_anchor', None)
-    method = values.pop('_method', None)
-    scheme = values.pop('_scheme', None)
-    appctx.app.inject_url_defaults(endpoint, values)
-
-    # This is not the best way to deal with this but currently the
-    # underlying Werkzeug router does not support overriding the scheme on
-    # a per build call basis.
-    old_scheme = None
-    if scheme is not None:
-        if not external:
-            raise ValueError('When specifying _scheme, _external must be True')
-        old_scheme = url_adapter.url_scheme
-        url_adapter.url_scheme = scheme
-
-    try:
-        try:
-            rv = url_adapter.build(endpoint, values, method=method,
-                                   force_external=external)
-        finally:
-            if old_scheme is not None:
-                url_adapter.url_scheme = old_scheme
-    except BuildError as error:
-        # We need to inject the values again so that the app callback can
-        # deal with that sort of stuff.
-        values['_external'] = external
-        values['_anchor'] = anchor
-        values['_method'] = method
-        values['_scheme'] = scheme
-        return appctx.app.handle_url_build_error(error, endpoint, values)
-
-    if anchor is not None:
-        rv += '#' + url_quote(anchor)
-    return rv
-
-
-def get_template_attribute(template_name, attribute):
-    """Loads a macro (or variable) a template exports.  This can be used to
-    invoke a macro from within Python code.  If you for example have a
-    template named :file:`_cider.html` with the following contents:
-
-    .. sourcecode:: html+jinja
-
-       {% macro hello(name) %}Hello {{ name }}!{% endmacro %}
-
-    You can access this from Python code like this::
-
-        hello = get_template_attribute('_cider.html', 'hello')
-        return hello('World')
-
-    .. versionadded:: 0.2
-
-    :param template_name: the name of the template
-    :param attribute: the name of the variable of macro to access
-    """
-    return getattr(current_app.jinja_env.get_template(template_name).module,
-                   attribute)
-
-
-def flash(message, category='message'):
-    """Flashes a message to the next request.  In order to remove the
-    flashed message from the session and to display it to the user,
-    the template has to call :func:`get_flashed_messages`.
-
-    .. versionchanged:: 0.3
-       `category` parameter added.
-
-    :param message: the message to be flashed.
-    :param category: the category for the message.  The following values
-                     are recommended: ``'message'`` for any kind of message,
-                     ``'error'`` for errors, ``'info'`` for information
-                     messages and ``'warning'`` for warnings.  However any
-                     kind of string can be used as category.
-    """
-    # Original implementation:
-    #
-    #     session.setdefault('_flashes', []).append((category, message))
-    #
-    # This assumed that changes made to mutable structures in the session are
-    # always in sync with the session object, which is not true for session
-    # implementations that use external storage for keeping their keys/values.
-    flashes = session.get('_flashes', [])
-    flashes.append((category, message))
-    session['_flashes'] = flashes
-    message_flashed.send(current_app._get_current_object(),
-                         message=message, category=category)
-
-
-def get_flashed_messages(with_categories=False, category_filter=[]):
-    """Pulls all flashed messages from the session and returns them.
-    Further calls in the same request to the function will return
-    the same messages.  By default just the messages are returned,
-    but when `with_categories` is set to ``True``, the return value will
-    be a list of tuples in the form ``(category, message)`` instead.
-
-    Filter the flashed messages to one or more categories by providing those
-    categories in `category_filter`.  This allows rendering categories in
-    separate html blocks.  The `with_categories` and `category_filter`
-    arguments are distinct:
-
-    * `with_categories` controls whether categories are returned with message
-      text (``True`` gives a tuple, where ``False`` gives just the message text).
-    * `category_filter` filters the messages down to only those matching the
-      provided categories.
-
-    See :ref:`message-flashing-pattern` for examples.
-
-    .. versionchanged:: 0.3
-       `with_categories` parameter added.
-
-    .. versionchanged:: 0.9
-        `category_filter` parameter added.
-
-    :param with_categories: set to ``True`` to also receive categories.
-    :param category_filter: whitelist of categories to limit return values
-    """
-    flashes = _request_ctx_stack.top.flashes
-    if flashes is None:
-        _request_ctx_stack.top.flashes = flashes = session.pop('_flashes') \
-            if '_flashes' in session else []
-    if category_filter:
-        flashes = list(filter(lambda f: f[0] in category_filter, flashes))
-    if not with_categories:
-        return [x[1] for x in flashes]
-    return flashes
-
-
-def send_file(filename_or_fp, mimetype=None, as_attachment=False,
-              attachment_filename=None, add_etags=True,
-              cache_timeout=None, conditional=False, last_modified=None):
-    """Sends the contents of a file to the client.  This will use the
-    most efficient method available and configured.  By default it will
-    try to use the WSGI server's file_wrapper support.  Alternatively
-    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
-    to ``True`` to directly emit an ``X-Sendfile`` header.  This however
-    requires support of the underlying webserver for ``X-Sendfile``.
-
-    By default it will try to guess the mimetype for you, but you can
-    also explicitly provide one.  For extra security you probably want
-    to send certain files as attachment (HTML for instance).  The mimetype
-    guessing requires a `filename` or an `attachment_filename` to be
-    provided.
-
-    ETags will also be attached automatically if a `filename` is provided. You
-    can turn this off by setting `add_etags=False`.
-
-    If `conditional=True` and `filename` is provided, this method will try to
-    upgrade the response stream to support range requests.  This will allow
-    the request to be answered with partial content response.
-
-    Please never pass filenames to this function from user sources;
-    you should use :func:`send_from_directory` instead.
-
-    .. versionadded:: 0.2
-
-    .. versionadded:: 0.5
-       The `add_etags`, `cache_timeout` and `conditional` parameters were
-       added.  The default behavior is now to attach etags.
-
-    .. versionchanged:: 0.7
-       mimetype guessing and etag support for file objects was
-       deprecated because it was unreliable.  Pass a filename if you are
-       able to, otherwise attach an etag yourself.  This functionality
-       will be removed in Flask 1.0
-
-    .. versionchanged:: 0.9
-       cache_timeout pulls its default from application config, when None.
-
-    .. versionchanged:: 0.12
-       The filename is no longer automatically inferred from file objects. If
-       you want to use automatic mimetype and etag support, pass a filepath via
-       `filename_or_fp` or `attachment_filename`.
-
-    .. versionchanged:: 0.12
-       The `attachment_filename` is preferred over `filename` for MIME-type
-       detection.
-
-    .. versionchanged:: 1.0
-        UTF-8 filenames, as specified in `RFC 2231`_, are supported.
-
-    .. _RFC 2231: https://tools.ietf.org/html/rfc2231#section-4
-
-    :param filename_or_fp: the filename of the file to send.
-                           This is relative to the :attr:`~Flask.root_path`
-                           if a relative path is specified.
-                           Alternatively a file object might be provided in
-                           which case ``X-Sendfile`` might not work and fall
-                           back to the traditional method.  Make sure that the
-                           file pointer is positioned at the start of data to
-                           send before calling :func:`send_file`.
-    :param mimetype: the mimetype of the file if provided. If a file path is
-                     given, auto detection happens as fallback, otherwise an
-                     error will be raised.
-    :param as_attachment: set to ``True`` if you want to send this file with
-                          a ``Content-Disposition: attachment`` header.
-    :param attachment_filename: the filename for the attachment if it
-                                differs from the file's filename.
-    :param add_etags: set to ``False`` to disable attaching of etags.
-    :param conditional: set to ``True`` to enable conditional responses.
-
-    :param cache_timeout: the timeout in seconds for the headers. When ``None``
-                          (default), this value is set by
-                          :meth:`~Flask.get_send_file_max_age` of
-                          :data:`~flask.current_app`.
-    :param last_modified: set the ``Last-Modified`` header to this value,
-        a :class:`~datetime.datetime` or timestamp.
-        If a file was passed, this overrides its mtime.
-    """
-    mtime = None
-    fsize = None
-    if isinstance(filename_or_fp, string_types):
-        filename = filename_or_fp
-        if not os.path.isabs(filename):
-            filename = os.path.join(current_app.root_path, filename)
-        file = None
-        if attachment_filename is None:
-            attachment_filename = os.path.basename(filename)
-    else:
-        file = filename_or_fp
-        filename = None
-
-    if mimetype is None:
-        if attachment_filename is not None:
-            mimetype = mimetypes.guess_type(attachment_filename)[0] \
-                or 'application/octet-stream'
-
-        if mimetype is None:
-            raise ValueError(
-                'Unable to infer MIME-type because no filename is available. '
-                'Please set either `attachment_filename`, pass a filepath to '
-                '`filename_or_fp` or set your own MIME-type via `mimetype`.'
-            )
-
-    headers = Headers()
-    if as_attachment:
-        if attachment_filename is None:
-            raise TypeError('filename unavailable, required for '
-                            'sending as attachment')
-
-        try:
-            attachment_filename = attachment_filename.encode('latin-1')
-        except UnicodeEncodeError:
-            filenames = {
-                'filename': unicodedata.normalize(
-                    'NFKD', attachment_filename).encode('latin-1', 'ignore'),
-                'filename*': "UTF-8''%s" % url_quote(attachment_filename),
-            }
-        else:
-            filenames = {'filename': attachment_filename}
-
-        headers.add('Content-Disposition', 'attachment', **filenames)
-
-    if current_app.use_x_sendfile and filename:
-        if file is not None:
-            file.close()
-        headers['X-Sendfile'] = filename
-        fsize = os.path.getsize(filename)
-        headers['Content-Length'] = fsize
-        data = None
-    else:
-        if file is None:
-            file = open(filename, 'rb')
-            mtime = os.path.getmtime(filename)
-            fsize = os.path.getsize(filename)
-            headers['Content-Length'] = fsize
-        data = wrap_file(request.environ, file)
-
-    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
-                                    direct_passthrough=True)
-
-    if last_modified is not None:
-        rv.last_modified = last_modified
-    elif mtime is not None:
-        rv.last_modified = mtime
-
-    rv.cache_control.public = True
-    if cache_timeout is None:
-        cache_timeout = current_app.get_send_file_max_age(filename)
-    if cache_timeout is not None:
-        rv.cache_control.max_age = cache_timeout
-        rv.expires = int(time() + cache_timeout)
-
-    if add_etags and filename is not None:
-        from warnings import warn
-
-        try:
-            rv.set_etag('%s-%s-%s' % (
-                os.path.getmtime(filename),
-                os.path.getsize(filename),
-                adler32(
-                    filename.encode('utf-8') if isinstance(filename, text_type)
-                    else filename
-                ) & 0xffffffff
-            ))
-        except OSError:
-            warn('Access %s failed, maybe it does not exist, so ignore etags in '
-                 'headers' % filename, stacklevel=2)
-
-    if conditional:
-        try:
-            rv = rv.make_conditional(request, accept_ranges=True,
-                                     complete_length=fsize)
-        except RequestedRangeNotSatisfiable:
-            if file is not None:
-                file.close()
-            raise
-        # make sure we don't send x-sendfile for servers that
-        # ignore the 304 status code for x-sendfile.
-        if rv.status_code == 304:
-            rv.headers.pop('x-sendfile', None)
-    return rv
-
-
-def safe_join(directory, *pathnames):
-    """Safely join `directory` and zero or more untrusted `pathnames`
-    components.
-
-    Example usage::
-
-        @app.route('/wiki/<path:filename>')
-        def wiki_page(filename):
-            filename = safe_join(app.config['WIKI_FOLDER'], filename)
-            with open(filename, 'rb') as fd:
-                content = fd.read()  # Read and process the file content...
-
-    :param directory: the trusted base directory.
-    :param pathnames: the untrusted pathnames relative to that directory.
-    :raises: :class:`~werkzeug.exceptions.NotFound` if one or more passed
-            paths fall out of its boundaries.
-    """
-
-    parts = [directory]
-
-    for filename in pathnames:
-        if filename != '':
-            filename = posixpath.normpath(filename)
-
-        if (
-            any(sep in filename for sep in _os_alt_seps)
-            or os.path.isabs(filename)
-            or filename == '..'
-            or filename.startswith('../')
-        ):
-            raise NotFound()
-
-        parts.append(filename)
-
-    return posixpath.join(*parts)
-
-
-def send_from_directory(directory, filename, **options):
-    """Send a file from a given directory with :func:`send_file`.  This
-    is a secure way to quickly expose static files from an upload folder
-    or something similar.
-
-    Example usage::
-
-        @app.route('/uploads/<path:filename>')
-        def download_file(filename):
-            return send_from_directory(app.config['UPLOAD_FOLDER'],
-                                       filename, as_attachment=True)
-
-    .. admonition:: Sending files and Performance
-
-       It is strongly recommended to activate either ``X-Sendfile`` support in
-       your webserver or (if no authentication happens) to tell the webserver
-       to serve files for the given path on its own without calling into the
-       web application for improved performance.
-
-    .. versionadded:: 0.5
-
-    :param directory: the directory where all the files are stored.
-    :param filename: the filename relative to that directory to
-                     download.
-    :param options: optional keyword arguments that are directly
-                    forwarded to :func:`send_file`.
-    """
-    filename = safe_join(directory, filename)
-    if not os.path.isabs(filename):
-        filename = os.path.join(current_app.root_path, filename)
-    try:
-        if not os.path.isfile(filename):
-            raise NotFound()
-    except (TypeError, ValueError):
-        raise BadRequest()
-    options.setdefault('conditional', True)
-    return send_file(filename, **options)
-
-
-def get_root_path(import_name):
-    """Returns the path to a package or cwd if that cannot be found.  This
-    returns the path of a package or the folder that contains a module.
-
-    Not to be confused with the package path returned by :func:`find_package`.
-    """
-    # Module already imported and has a file attribute.  Use that first.
-    mod = sys.modules.get(import_name)
-    if mod is not None and hasattr(mod, '__file__'):
-        return os.path.dirname(os.path.abspath(mod.__file__))
-
-    # Next attempt: check the loader.
-    loader = pkgutil.get_loader(import_name)
-
-    # Loader does not exist or we're referring to an unloaded main module
-    # or a main module without path (interactive sessions), go with the
-    # current working directory.
-    if loader is None or import_name == '__main__':
-        return os.getcwd()
-
-    # For .egg, zipimporter does not have get_filename until Python 2.7.
-    # Some other loaders might exhibit the same behavior.
-    if hasattr(loader, 'get_filename'):
-        filepath = loader.get_filename(import_name)
-    else:
-        # Fall back to imports.
-        __import__(import_name)
-        mod = sys.modules[import_name]
-        filepath = getattr(mod, '__file__', None)
-
-        # If we don't have a filepath it might be because we are a
-        # namespace package.  In this case we pick the root path from the
-        # first module that is contained in our package.
-        if filepath is None:
-            raise RuntimeError('No root path can be found for the provided '
-                               'module "%s".  This can happen because the '
-                               'module came from an import hook that does '
-                               'not provide file name information or because '
-                               'it\'s a namespace package.  In this case '
-                               'the root path needs to be explicitly '
-                               'provided.' % import_name)
-
-    # filepath is import_name.py for a module, or __init__.py for a package.
-    return os.path.dirname(os.path.abspath(filepath))
-
-
-def _matching_loader_thinks_module_is_package(loader, mod_name):
-    """Given the loader that loaded a module and the module this function
-    attempts to figure out if the given module is actually a package.
-    """
-    # If the loader can tell us if something is a package, we can
-    # directly ask the loader.
-    if hasattr(loader, 'is_package'):
-        return loader.is_package(mod_name)
-    # importlib's namespace loaders do not have this functionality but
-    # all the modules it loads are packages, so we can take advantage of
-    # this information.
-    elif (loader.__class__.__module__ == '_frozen_importlib' and
-          loader.__class__.__name__ == 'NamespaceLoader'):
-        return True
-    # Otherwise we need to fail with an error that explains what went
-    # wrong.
-    raise AttributeError(
-        ('%s.is_package() method is missing but is required by Flask of '
-         'PEP 302 import hooks.  If you do not use import hooks and '
-         'you encounter this error please file a bug against Flask.') %
-        loader.__class__.__name__)
-
-
-def find_package(import_name):
-    """Finds a package and returns the prefix (or None if the package is
-    not installed) as well as the folder that contains the package or
-    module as a tuple.  The package path returned is the module that would
-    have to be added to the pythonpath in order to make it possible to
-    import the module.  The prefix is the path below which a UNIX like
-    folder structure exists (lib, share etc.).
-    """
-    root_mod_name = import_name.split('.')[0]
-    loader = pkgutil.get_loader(root_mod_name)
-    if loader is None or import_name == '__main__':
-        # import name is not found, or interactive/main module
-        package_path = os.getcwd()
-    else:
-        # For .egg, zipimporter does not have get_filename until Python 2.7.
-        if hasattr(loader, 'get_filename'):
-            filename = loader.get_filename(root_mod_name)
-        elif hasattr(loader, 'archive'):
-            # zipimporter's loader.archive points to the .egg or .zip
-            # archive filename is dropped in call to dirname below.
-            filename = loader.archive
-        else:
-            # At least one loader is missing both get_filename and archive:
-            # Google App Engine's HardenedModulesHook
-            #
-            # Fall back to imports.
-            __import__(import_name)
-            filename = sys.modules[import_name].__file__
-        package_path = os.path.abspath(os.path.dirname(filename))
-
-        # In case the root module is a package we need to chop of the
-        # rightmost part.  This needs to go through a helper function
-        # because of python 3.3 namespace packages.
-        if _matching_loader_thinks_module_is_package(
-                loader, root_mod_name):
-            package_path = os.path.dirname(package_path)
-
-    site_parent, site_folder = os.path.split(package_path)
-    py_prefix = os.path.abspath(sys.prefix)
-    if package_path.startswith(py_prefix):
-        return py_prefix, package_path
-    elif site_folder.lower() == 'site-packages':
-        parent, folder = os.path.split(site_parent)
-        # Windows like installations
-        if folder.lower() == 'lib':
-            base_dir = parent
-        # UNIX like installations
-        elif os.path.basename(parent).lower() == 'lib':
-            base_dir = os.path.dirname(parent)
-        else:
-            base_dir = site_parent
-        return base_dir, package_path
-    return None, package_path
-
-
-class locked_cached_property(object):
-    """A decorator that converts a function into a lazy property.  The
-    function wrapped is called the first time to retrieve the result
-    and then that calculated result is used the next time you access
-    the value.  Works like the one in Werkzeug but has a lock for
-    thread safety.
-    """
-
-    def __init__(self, func, name=None, doc=None):
-        self.__name__ = name or func.__name__
-        self.__module__ = func.__module__
-        self.__doc__ = doc or func.__doc__
-        self.func = func
-        self.lock = RLock()
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        with self.lock:
-            value = obj.__dict__.get(self.__name__, _missing)
-            if value is _missing:
-                value = self.func(obj)
-                obj.__dict__[self.__name__] = value
-            return value
-
-
-class _PackageBoundObject(object):
-    #: The name of the package or module that this app belongs to. Do not
-    #: change this once it is set by the constructor.
-    import_name = None
-
-    #: Location of the template files to be added to the template lookup.
-    #: ``None`` if templates should not be added.
-    template_folder = None
-
-    #: Absolute path to the package on the filesystem. Used to look up
-    #: resources contained in the package.
-    root_path = None
-
-    def __init__(self, import_name, template_folder=None, root_path=None):
-        self.import_name = import_name
-        self.template_folder = template_folder
-
-        if root_path is None:
-            root_path = get_root_path(self.import_name)
-
-        self.root_path = root_path
-        self._static_folder = None
-        self._static_url_path = None
-
-    def _get_static_folder(self):
-        if self._static_folder is not None:
-            return os.path.join(self.root_path, self._static_folder)
-
-    def _set_static_folder(self, value):
-        self._static_folder = value
-
-    static_folder = property(
-        _get_static_folder, _set_static_folder,
-        doc='The absolute path to the configured static folder.'
-    )
-    del _get_static_folder, _set_static_folder
-
-    def _get_static_url_path(self):
-        if self._static_url_path is not None:
-            return self._static_url_path
-
-        if self.static_folder is not None:
-            return '/' + os.path.basename(self.static_folder)
-
-    def _set_static_url_path(self, value):
-        self._static_url_path = value
-
-    static_url_path = property(
-        _get_static_url_path, _set_static_url_path,
-        doc='The URL prefix that the static route will be registered for.'
-    )
-    del _get_static_url_path, _set_static_url_path
-
-    @property
-    def has_static_folder(self):
-        """This is ``True`` if the package bound object's container has a
-        folder for static files.
-
-        .. versionadded:: 0.5
-        """
-        return self.static_folder is not None
-
-    @locked_cached_property
-    def jinja_loader(self):
-        """The Jinja loader for this package bound object.
-
-        .. versionadded:: 0.5
-        """
-        if self.template_folder is not None:
-            return FileSystemLoader(os.path.join(self.root_path,
-                                                 self.template_folder))
-
-    def get_send_file_max_age(self, filename):
-        """Provides default cache_timeout for the :func:`send_file` functions.
-
-        By default, this function returns ``SEND_FILE_MAX_AGE_DEFAULT`` from
-        the configuration of :data:`~flask.current_app`.
-
-        Static file functions such as :func:`send_from_directory` use this
-        function, and :func:`send_file` calls this function on
-        :data:`~flask.current_app` when the given cache_timeout is ``None``. If a
-        cache_timeout is given in :func:`send_file`, that timeout is used;
-        otherwise, this method is called.
-
-        This allows subclasses to change the behavior when sending files based
-        on the filename.  For example, to set the cache timeout for .js files
-        to 60 seconds::
-
-            class MyFlask(flask.Flask):
-                def get_send_file_max_age(self, name):
-                    if name.lower().endswith('.js'):
-                        return 60
-                    return flask.Flask.get_send_file_max_age(self, name)
-
-        .. versionadded:: 0.9
-        """
-        return total_seconds(current_app.send_file_max_age_default)
-
-    def send_static_file(self, filename):
-        """Function used internally to send static files from the static
-        folder to the browser.
-
-        .. versionadded:: 0.5
-        """
-        if not self.has_static_folder:
-            raise RuntimeError('No static folder for this object')
-        # Ensure get_send_file_max_age is called in all cases.
-        # Here, we ensure get_send_file_max_age is called for Blueprints.
-        cache_timeout = self.get_send_file_max_age(filename)
-        return send_from_directory(self.static_folder, filename,
-                                   cache_timeout=cache_timeout)
-
-    def open_resource(self, resource, mode='rb'):
-        """Opens a resource from the application's resource folder.  To see
-        how this works, consider the following folder structure::
-
-            /myapplication.py
-            /schema.sql
-            /static
-                /style.css
-            /templates
-                /layout.html
-                /index.html
-
-        If you want to open the :file:`schema.sql` file you would do the
-        following::
-
-            with app.open_resource('schema.sql') as f:
-                contents = f.read()
-                do_something_with(contents)
-
-        :param resource: the name of the resource.  To access resources within
-                         subfolders use forward slashes as separator.
-        :param mode: resource file opening mode, default is 'rb'.
-        """
-        if mode not in ('r', 'rb'):
-            raise ValueError('Resources can only be opened for reading')
-        return open(os.path.join(self.root_path, resource), mode)
-
-
-def total_seconds(td):
-    """Returns the total seconds from a timedelta object.
-
-    :param timedelta td: the timedelta to be converted in seconds
-
-    :returns: number of seconds
-    :rtype: int
-    """
-    return td.days * 60 * 60 * 24 + td.seconds
-
-
-def is_ip(value):
-    """Determine if the given string is an IP address.
-
-    Python 2 on Windows doesn't provide ``inet_pton``, so this only
-    checks IPv4 addresses in that environment.
-
-    :param value: value to check
-    :type value: str
-
-    :return: True if string is an IP address
-    :rtype: bool
-    """
-    if PY2 and os.name == 'nt':
-        try:
-            socket.inet_aton(value)
-            return True
-        except socket.error:
-            return False
-
-    for family in (socket.AF_INET, socket.AF_INET6):
-        try:
-            socket.inet_pton(family, value)
-        except socket.error:
-            pass
-        else:
-            return True
-
-    return False
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__init__.py
deleted file mode 100644
index fbe6b92f0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__init__.py
+++ /dev/null
@@ -1,327 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-flask.json
-~~~~~~~~~~
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-import codecs
-import io
-import uuid
-from datetime import date, datetime
-from flask.globals import current_app, request
-from flask._compat import text_type, PY2
-
-from werkzeug.http import http_date
-from jinja2 import Markup
-
-# Use the same json implementation as itsdangerous on which we
-# depend anyways.
-from itsdangerous import json as _json
-
-
-# Figure out if simplejson escapes slashes.  This behavior was changed
-# from one version to another without reason.
-_slash_escape = '\\/' not in _json.dumps('/')
-
-
-__all__ = ['dump', 'dumps', 'load', 'loads', 'htmlsafe_dump',
-           'htmlsafe_dumps', 'JSONDecoder', 'JSONEncoder',
-           'jsonify']
-
-
-def _wrap_reader_for_text(fp, encoding):
-    if isinstance(fp.read(0), bytes):
-        fp = io.TextIOWrapper(io.BufferedReader(fp), encoding)
-    return fp
-
-
-def _wrap_writer_for_text(fp, encoding):
-    try:
-        fp.write('')
-    except TypeError:
-        fp = io.TextIOWrapper(fp, encoding)
-    return fp
-
-
-class JSONEncoder(_json.JSONEncoder):
-    """The default Flask JSON encoder.  This one extends the default simplejson
-    encoder by also supporting ``datetime`` objects, ``UUID`` as well as
-    ``Markup`` objects which are serialized as RFC 822 datetime strings (same
-    as the HTTP date format).  In order to support more data types override the
-    :meth:`default` method.
-    """
-
-    def default(self, o):
-        """Implement this method in a subclass such that it returns a
-        serializable object for ``o``, or calls the base implementation (to
-        raise a :exc:`TypeError`).
-
-        For example, to support arbitrary iterators, you could implement
-        default like this::
-
-            def default(self, o):
-                try:
-                    iterable = iter(o)
-                except TypeError:
-                    pass
-                else:
-                    return list(iterable)
-                return JSONEncoder.default(self, o)
-        """
-        if isinstance(o, datetime):
-            return http_date(o.utctimetuple())
-        if isinstance(o, date):
-            return http_date(o.timetuple())
-        if isinstance(o, uuid.UUID):
-            return str(o)
-        if hasattr(o, '__html__'):
-            return text_type(o.__html__())
-        return _json.JSONEncoder.default(self, o)
-
-
-class JSONDecoder(_json.JSONDecoder):
-    """The default JSON decoder.  This one does not change the behavior from
-    the default simplejson decoder.  Consult the :mod:`json` documentation
-    for more information.  This decoder is not only used for the load
-    functions of this module but also :attr:`~flask.Request`.
-    """
-
-
-def _dump_arg_defaults(kwargs):
-    """Inject default arguments for dump functions."""
-    if current_app:
-        bp = current_app.blueprints.get(request.blueprint) if request else None
-        kwargs.setdefault(
-            'cls',
-            bp.json_encoder if bp and bp.json_encoder
-                else current_app.json_encoder
-        )
-
-        if not current_app.config['JSON_AS_ASCII']:
-            kwargs.setdefault('ensure_ascii', False)
-
-        kwargs.setdefault('sort_keys', current_app.config['JSON_SORT_KEYS'])
-    else:
-        kwargs.setdefault('sort_keys', True)
-        kwargs.setdefault('cls', JSONEncoder)
-
-
-def _load_arg_defaults(kwargs):
-    """Inject default arguments for load functions."""
-    if current_app:
-        bp = current_app.blueprints.get(request.blueprint) if request else None
-        kwargs.setdefault(
-            'cls',
-            bp.json_decoder if bp and bp.json_decoder
-                else current_app.json_decoder
-        )
-    else:
-        kwargs.setdefault('cls', JSONDecoder)
-
-
-def detect_encoding(data):
-    """Detect which UTF codec was used to encode the given bytes.
-
-    The latest JSON standard (:rfc:`8259`) suggests that only UTF-8 is
-    accepted. Older documents allowed 8, 16, or 32. 16 and 32 can be big
-    or little endian. Some editors or libraries may prepend a BOM.
-
-    :param data: Bytes in unknown UTF encoding.
-    :return: UTF encoding name
-    """
-    head = data[:4]
-
-    if head[:3] == codecs.BOM_UTF8:
-        return 'utf-8-sig'
-
-    if b'\x00' not in head:
-        return 'utf-8'
-
-    if head in (codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE):
-        return 'utf-32'
-
-    if head[:2] in (codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE):
-        return 'utf-16'
-
-    if len(head) == 4:
-        if head[:3] == b'\x00\x00\x00':
-            return 'utf-32-be'
-
-        if head[::2] == b'\x00\x00':
-            return 'utf-16-be'
-
-        if head[1:] == b'\x00\x00\x00':
-            return 'utf-32-le'
-
-        if head[1::2] == b'\x00\x00':
-            return 'utf-16-le'
-
-    if len(head) == 2:
-        return 'utf-16-be' if head.startswith(b'\x00') else 'utf-16-le'
-
-    return 'utf-8'
-
-
-def dumps(obj, **kwargs):
-    """Serialize ``obj`` to a JSON formatted ``str`` by using the application's
-    configured encoder (:attr:`~flask.Flask.json_encoder`) if there is an
-    application on the stack.
-
-    This function can return ``unicode`` strings or ascii-only bytestrings by
-    default which coerce into unicode strings automatically.  That behavior by
-    default is controlled by the ``JSON_AS_ASCII`` configuration variable
-    and can be overridden by the simplejson ``ensure_ascii`` parameter.
-    """
-    _dump_arg_defaults(kwargs)
-    encoding = kwargs.pop('encoding', None)
-    rv = _json.dumps(obj, **kwargs)
-    if encoding is not None and isinstance(rv, text_type):
-        rv = rv.encode(encoding)
-    return rv
-
-
-def dump(obj, fp, **kwargs):
-    """Like :func:`dumps` but writes into a file object."""
-    _dump_arg_defaults(kwargs)
-    encoding = kwargs.pop('encoding', None)
-    if encoding is not None:
-        fp = _wrap_writer_for_text(fp, encoding)
-    _json.dump(obj, fp, **kwargs)
-
-
-def loads(s, **kwargs):
-    """Unserialize a JSON object from a string ``s`` by using the application's
-    configured decoder (:attr:`~flask.Flask.json_decoder`) if there is an
-    application on the stack.
-    """
-    _load_arg_defaults(kwargs)
-    if isinstance(s, bytes):
-        encoding = kwargs.pop('encoding', None)
-        if encoding is None:
-            encoding = detect_encoding(s)
-        s = s.decode(encoding)
-    return _json.loads(s, **kwargs)
-
-
-def load(fp, **kwargs):
-    """Like :func:`loads` but reads from a file object.
-    """
-    _load_arg_defaults(kwargs)
-    if not PY2:
-        fp = _wrap_reader_for_text(fp, kwargs.pop('encoding', None) or 'utf-8')
-    return _json.load(fp, **kwargs)
-
-
-def htmlsafe_dumps(obj, **kwargs):
-    """Works exactly like :func:`dumps` but is safe for use in ``<script>``
-    tags.  It accepts the same arguments and returns a JSON string.  Note that
-    this is available in templates through the ``|tojson`` filter which will
-    also mark the result as safe.  Due to how this function escapes certain
-    characters this is safe even if used outside of ``<script>`` tags.
-
-    The following characters are escaped in strings:
-
-    -   ``<``
-    -   ``>``
-    -   ``&``
-    -   ``'``
-
-    This makes it safe to embed such strings in any place in HTML with the
-    notable exception of double quoted attributes.  In that case single
-    quote your attributes or HTML escape it in addition.
-
-    .. versionchanged:: 0.10
-       This function's return value is now always safe for HTML usage, even
-       if outside of script tags or if used in XHTML.  This rule does not
-       hold true when using this function in HTML attributes that are double
-       quoted.  Always single quote attributes if you use the ``|tojson``
-       filter.  Alternatively use ``|tojson|forceescape``.
-    """
-    rv = dumps(obj, **kwargs) \
-        .replace(u'<', u'\\u003c') \
-        .replace(u'>', u'\\u003e') \
-        .replace(u'&', u'\\u0026') \
-        .replace(u"'", u'\\u0027')
-    if not _slash_escape:
-        rv = rv.replace('\\/', '/')
-    return rv
-
-
-def htmlsafe_dump(obj, fp, **kwargs):
-    """Like :func:`htmlsafe_dumps` but writes into a file object."""
-    fp.write(text_type(htmlsafe_dumps(obj, **kwargs)))
-
-
-def jsonify(*args, **kwargs):
-    """This function wraps :func:`dumps` to add a few enhancements that make
-    life easier.  It turns the JSON output into a :class:`~flask.Response`
-    object with the :mimetype:`application/json` mimetype.  For convenience, it
-    also converts multiple arguments into an array or multiple keyword arguments
-    into a dict.  This means that both ``jsonify(1,2,3)`` and
-    ``jsonify([1,2,3])`` serialize to ``[1,2,3]``.
-
-    For clarity, the JSON serialization behavior has the following differences
-    from :func:`dumps`:
-
-    1. Single argument: Passed straight through to :func:`dumps`.
-    2. Multiple arguments: Converted to an array before being passed to
-       :func:`dumps`.
-    3. Multiple keyword arguments: Converted to a dict before being passed to
-       :func:`dumps`.
-    4. Both args and kwargs: Behavior undefined and will throw an exception.
-
-    Example usage::
-
-        from flask import jsonify
-
-        @app.route('/_get_current_user')
-        def get_current_user():
-            return jsonify(username=g.user.username,
-                           email=g.user.email,
-                           id=g.user.id)
-
-    This will send a JSON response like this to the browser::
-
-        {
-            "username": "admin",
-            "email": "admin@localhost",
-            "id": 42
-        }
-
-
-    .. versionchanged:: 0.11
-       Added support for serializing top-level arrays. This introduces a
-       security risk in ancient browsers. See :ref:`json-security` for details.
-
-    This function's response will be pretty printed if the
-    ``JSONIFY_PRETTYPRINT_REGULAR`` config parameter is set to True or the
-    Flask app is running in debug mode. Compressed (not pretty) formatting
-    currently means no indents and no spaces after separators.
-
-    .. versionadded:: 0.2
-    """
-
-    indent = None
-    separators = (',', ':')
-
-    if current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] or current_app.debug:
-        indent = 2
-        separators = (', ', ': ')
-
-    if args and kwargs:
-        raise TypeError('jsonify() behavior undefined when passed both args and kwargs')
-    elif len(args) == 1:  # single args are passed directly to dumps()
-        data = args[0]
-    else:
-        data = args or kwargs
-
-    return current_app.response_class(
-        dumps(data, indent=indent, separators=separators) + '\n',
-        mimetype=current_app.config['JSONIFY_MIMETYPE']
-    )
-
-
-def tojson_filter(obj, **kwargs):
-    return Markup(htmlsafe_dumps(obj, **kwargs))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index e9f303b6f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/tag.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/tag.cpython-35.pyc
deleted file mode 100644
index 1aadea80f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/__pycache__/tag.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/tag.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/tag.py
deleted file mode 100644
index 11c966c58..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/json/tag.py
+++ /dev/null
@@ -1,300 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Tagged JSON
-~~~~~~~~~~~
-
-A compact representation for lossless serialization of non-standard JSON types.
-:class:`~flask.sessions.SecureCookieSessionInterface` uses this to serialize
-the session data, but it may be useful in other places. It can be extended to
-support other types.
-
-.. autoclass:: TaggedJSONSerializer
-    :members:
-
-.. autoclass:: JSONTag
-    :members:
-
-Let's seen an example that adds support for :class:`~collections.OrderedDict`.
-Dicts don't have an order in Python or JSON, so to handle this we will dump
-the items as a list of ``[key, value]`` pairs. Subclass :class:`JSONTag` and
-give it the new key ``' od'`` to identify the type. The session serializer
-processes dicts first, so insert the new tag at the front of the order since
-``OrderedDict`` must be processed before ``dict``. ::
-
-    from flask.json.tag import JSONTag
-
-    class TagOrderedDict(JSONTag):
-        __slots__ = ('serializer',)
-        key = ' od'
-
-        def check(self, value):
-            return isinstance(value, OrderedDict)
-
-        def to_json(self, value):
-            return [[k, self.serializer.tag(v)] for k, v in iteritems(value)]
-
-        def to_python(self, value):
-            return OrderedDict(value)
-
-    app.session_interface.serializer.register(TagOrderedDict, index=0)
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-
-from base64 import b64decode, b64encode
-from datetime import datetime
-from uuid import UUID
-
-from jinja2 import Markup
-from werkzeug.http import http_date, parse_date
-
-from flask._compat import iteritems, text_type
-from flask.json import dumps, loads
-
-
-class JSONTag(object):
-    """Base class for defining type tags for :class:`TaggedJSONSerializer`."""
-
-    __slots__ = ('serializer',)
-
-    #: The tag to mark the serialized object with. If ``None``, this tag is
-    #: only used as an intermediate step during tagging.
-    key = None
-
-    def __init__(self, serializer):
-        """Create a tagger for the given serializer."""
-        self.serializer = serializer
-
-    def check(self, value):
-        """Check if the given value should be tagged by this tag."""
-        raise NotImplementedError
-
-    def to_json(self, value):
-        """Convert the Python object to an object that is a valid JSON type.
-        The tag will be added later."""
-        raise NotImplementedError
-
-    def to_python(self, value):
-        """Convert the JSON representation back to the correct type. The tag
-        will already be removed."""
-        raise NotImplementedError
-
-    def tag(self, value):
-        """Convert the value to a valid JSON type and add the tag structure
-        around it."""
-        return {self.key: self.to_json(value)}
-
-
-class TagDict(JSONTag):
-    """Tag for 1-item dicts whose only key matches a registered tag.
-
-    Internally, the dict key is suffixed with `__`, and the suffix is removed
-    when deserializing.
-    """
-
-    __slots__ = ()
-    key = ' di'
-
-    def check(self, value):
-        return (
-            isinstance(value, dict)
-            and len(value) == 1
-            and next(iter(value)) in self.serializer.tags
-        )
-
-    def to_json(self, value):
-        key = next(iter(value))
-        return {key + '__': self.serializer.tag(value[key])}
-
-    def to_python(self, value):
-        key = next(iter(value))
-        return {key[:-2]: value[key]}
-
-
-class PassDict(JSONTag):
-    __slots__ = ()
-
-    def check(self, value):
-        return isinstance(value, dict)
-
-    def to_json(self, value):
-        # JSON objects may only have string keys, so don't bother tagging the
-        # key here.
-        return dict((k, self.serializer.tag(v)) for k, v in iteritems(value))
-
-    tag = to_json
-
-
-class TagTuple(JSONTag):
-    __slots__ = ()
-    key = ' t'
-
-    def check(self, value):
-        return isinstance(value, tuple)
-
-    def to_json(self, value):
-        return [self.serializer.tag(item) for item in value]
-
-    def to_python(self, value):
-        return tuple(value)
-
-
-class PassList(JSONTag):
-    __slots__ = ()
-
-    def check(self, value):
-        return isinstance(value, list)
-
-    def to_json(self, value):
-        return [self.serializer.tag(item) for item in value]
-
-    tag = to_json
-
-
-class TagBytes(JSONTag):
-    __slots__ = ()
-    key = ' b'
-
-    def check(self, value):
-        return isinstance(value, bytes)
-
-    def to_json(self, value):
-        return b64encode(value).decode('ascii')
-
-    def to_python(self, value):
-        return b64decode(value)
-
-
-class TagMarkup(JSONTag):
-    """Serialize anything matching the :class:`~flask.Markup` API by
-    having a ``__html__`` method to the result of that method. Always
-    deserializes to an instance of :class:`~flask.Markup`."""
-
-    __slots__ = ()
-    key = ' m'
-
-    def check(self, value):
-        return callable(getattr(value, '__html__', None))
-
-    def to_json(self, value):
-        return text_type(value.__html__())
-
-    def to_python(self, value):
-        return Markup(value)
-
-
-class TagUUID(JSONTag):
-    __slots__ = ()
-    key = ' u'
-
-    def check(self, value):
-        return isinstance(value, UUID)
-
-    def to_json(self, value):
-        return value.hex
-
-    def to_python(self, value):
-        return UUID(value)
-
-
-class TagDateTime(JSONTag):
-    __slots__ = ()
-    key = ' d'
-
-    def check(self, value):
-        return isinstance(value, datetime)
-
-    def to_json(self, value):
-        return http_date(value)
-
-    def to_python(self, value):
-        return parse_date(value)
-
-
-class TaggedJSONSerializer(object):
-    """Serializer that uses a tag system to compactly represent objects that
-    are not JSON types. Passed as the intermediate serializer to
-    :class:`itsdangerous.Serializer`.
-
-    The following extra types are supported:
-
-    * :class:`dict`
-    * :class:`tuple`
-    * :class:`bytes`
-    * :class:`~flask.Markup`
-    * :class:`~uuid.UUID`
-    * :class:`~datetime.datetime`
-    """
-
-    __slots__ = ('tags', 'order')
-
-    #: Tag classes to bind when creating the serializer. Other tags can be
-    #: added later using :meth:`~register`.
-    default_tags = [
-        TagDict, PassDict, TagTuple, PassList, TagBytes, TagMarkup, TagUUID,
-        TagDateTime,
-    ]
-
-    def __init__(self):
-        self.tags = {}
-        self.order = []
-
-        for cls in self.default_tags:
-            self.register(cls)
-
-    def register(self, tag_class, force=False, index=None):
-        """Register a new tag with this serializer.
-
-        :param tag_class: tag class to register. Will be instantiated with this
-            serializer instance.
-        :param force: overwrite an existing tag. If false (default), a
-            :exc:`KeyError` is raised.
-        :param index: index to insert the new tag in the tag order. Useful when
-            the new tag is a special case of an existing tag. If ``None``
-            (default), the tag is appended to the end of the order.
-
-        :raise KeyError: if the tag key is already registered and ``force`` is
-            not true.
-        """
-        tag = tag_class(self)
-        key = tag.key
-
-        if key is not None:
-            if not force and key in self.tags:
-                raise KeyError("Tag '{0}' is already registered.".format(key))
-
-            self.tags[key] = tag
-
-        if index is None:
-            self.order.append(tag)
-        else:
-            self.order.insert(index, tag)
-
-    def tag(self, value):
-        """Convert a value to a tagged representation if necessary."""
-        for tag in self.order:
-            if tag.check(value):
-                return tag.tag(value)
-
-        return value
-
-    def untag(self, value):
-        """Convert a tagged representation back to the original type."""
-        if len(value) != 1:
-            return value
-
-        key = next(iter(value))
-
-        if key not in self.tags:
-            return value
-
-        return self.tags[key].to_python(value[key])
-
-    def dumps(self, value):
-        """Tag the value and dump it to a compact JSON string."""
-        return dumps(self.tag(value), separators=(',', ':'))
-
-    def loads(self, value):
-        """Load data from a JSON string and deserialized any tagged objects."""
-        return loads(value, object_hook=self.untag)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/logging.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/logging.py
deleted file mode 100644
index 389c2c22e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/logging.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-flask.logging
-~~~~~~~~~~~~~
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import absolute_import
-
-import logging
-import sys
-
-from werkzeug.local import LocalProxy
-
-from .globals import request
-
-
-@LocalProxy
-def wsgi_errors_stream():
-    """Find the most appropriate error stream for the application. If a request
-    is active, log to ``wsgi.errors``, otherwise use ``sys.stderr``.
-
-    If you configure your own :class:`logging.StreamHandler`, you may want to
-    use this for the stream. If you are using file or dict configuration and
-    can't import this directly, you can refer to it as
-    ``ext://flask.logging.wsgi_errors_stream``.
-    """
-    return request.environ['wsgi.errors'] if request else sys.stderr
-
-
-def has_level_handler(logger):
-    """Check if there is a handler in the logging chain that will handle the
-    given logger's :meth:`effective level <~logging.Logger.getEffectiveLevel>`.
-    """
-    level = logger.getEffectiveLevel()
-    current = logger
-
-    while current:
-        if any(handler.level <= level for handler in current.handlers):
-            return True
-
-        if not current.propagate:
-            break
-
-        current = current.parent
-
-    return False
-
-
-#: Log messages to :func:`~flask.logging.wsgi_errors_stream` with the format
-#: ``[%(asctime)s] %(levelname)s in %(module)s: %(message)s``.
-default_handler = logging.StreamHandler(wsgi_errors_stream)
-default_handler.setFormatter(logging.Formatter(
-    '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
-))
-
-
-def create_logger(app):
-    """Get the ``'flask.app'`` logger and configure it if needed.
-
-    When :attr:`~flask.Flask.debug` is enabled, set the logger level to
-    :data:`logging.DEBUG` if it is not set.
-
-    If there is no handler for the logger's effective level, add a
-    :class:`~logging.StreamHandler` for
-    :func:`~flask.logging.wsgi_errors_stream` with a basic format.
-    """
-    logger = logging.getLogger('flask.app')
-
-    if app.debug and logger.level == logging.NOTSET:
-        logger.setLevel(logging.DEBUG)
-
-    if not has_level_handler(logger):
-        logger.addHandler(default_handler)
-
-    return logger
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/sessions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/sessions.py
deleted file mode 100644
index ec4253d55..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/sessions.py
+++ /dev/null
@@ -1,385 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.sessions
-    ~~~~~~~~~~~~~~
-
-    Implements cookie based sessions based on itsdangerous.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import hashlib
-import warnings
-from collections import MutableMapping
-from datetime import datetime
-
-from itsdangerous import BadSignature, URLSafeTimedSerializer
-from werkzeug.datastructures import CallbackDict
-
-from flask.helpers import is_ip, total_seconds
-from flask.json.tag import TaggedJSONSerializer
-
-
-class SessionMixin(MutableMapping):
-    """Expands a basic dictionary with session attributes."""
-
-    @property
-    def permanent(self):
-        """This reflects the ``'_permanent'`` key in the dict."""
-        return self.get('_permanent', False)
-
-    @permanent.setter
-    def permanent(self, value):
-        self['_permanent'] = bool(value)
-
-    #: Some implementations can detect whether a session is newly
-    #: created, but that is not guaranteed. Use with caution. The mixin
-    # default is hard-coded ``False``.
-    new = False
-
-    #: Some implementations can detect changes to the session and set
-    #: this when that happens. The mixin default is hard coded to
-    #: ``True``.
-    modified = True
-
-    #: Some implementations can detect when session data is read or
-    #: written and set this when that happens. The mixin default is hard
-    #: coded to ``True``.
-    accessed = True
-
-
-class SecureCookieSession(CallbackDict, SessionMixin):
-    """Base class for sessions based on signed cookies.
-
-    This session backend will set the :attr:`modified` and
-    :attr:`accessed` attributes. It cannot reliably track whether a
-    session is new (vs. empty), so :attr:`new` remains hard coded to
-    ``False``.
-    """
-
-    #: When data is changed, this is set to ``True``. Only the session
-    #: dictionary itself is tracked; if the session contains mutable
-    #: data (for example a nested dict) then this must be set to
-    #: ``True`` manually when modifying that data. The session cookie
-    #: will only be written to the response if this is ``True``.
-    modified = False
-
-    #: When data is read or written, this is set to ``True``. Used by
-    # :class:`.SecureCookieSessionInterface` to add a ``Vary: Cookie``
-    #: header, which allows caching proxies to cache different pages for
-    #: different users.
-    accessed = False
-
-    def __init__(self, initial=None):
-        def on_update(self):
-            self.modified = True
-            self.accessed = True
-
-        super(SecureCookieSession, self).__init__(initial, on_update)
-
-    def __getitem__(self, key):
-        self.accessed = True
-        return super(SecureCookieSession, self).__getitem__(key)
-
-    def get(self, key, default=None):
-        self.accessed = True
-        return super(SecureCookieSession, self).get(key, default)
-
-    def setdefault(self, key, default=None):
-        self.accessed = True
-        return super(SecureCookieSession, self).setdefault(key, default)
-
-
-class NullSession(SecureCookieSession):
-    """Class used to generate nicer error messages if sessions are not
-    available.  Will still allow read-only access to the empty session
-    but fail on setting.
-    """
-
-    def _fail(self, *args, **kwargs):
-        raise RuntimeError('The session is unavailable because no secret '
-                           'key was set.  Set the secret_key on the '
-                           'application to something unique and secret.')
-    __setitem__ = __delitem__ = clear = pop = popitem = \
-        update = setdefault = _fail
-    del _fail
-
-
-class SessionInterface(object):
-    """The basic interface you have to implement in order to replace the
-    default session interface which uses werkzeug's securecookie
-    implementation.  The only methods you have to implement are
-    :meth:`open_session` and :meth:`save_session`, the others have
-    useful defaults which you don't need to change.
-
-    The session object returned by the :meth:`open_session` method has to
-    provide a dictionary like interface plus the properties and methods
-    from the :class:`SessionMixin`.  We recommend just subclassing a dict
-    and adding that mixin::
-
-        class Session(dict, SessionMixin):
-            pass
-
-    If :meth:`open_session` returns ``None`` Flask will call into
-    :meth:`make_null_session` to create a session that acts as replacement
-    if the session support cannot work because some requirement is not
-    fulfilled.  The default :class:`NullSession` class that is created
-    will complain that the secret key was not set.
-
-    To replace the session interface on an application all you have to do
-    is to assign :attr:`flask.Flask.session_interface`::
-
-        app = Flask(__name__)
-        app.session_interface = MySessionInterface()
-
-    .. versionadded:: 0.8
-    """
-
-    #: :meth:`make_null_session` will look here for the class that should
-    #: be created when a null session is requested.  Likewise the
-    #: :meth:`is_null_session` method will perform a typecheck against
-    #: this type.
-    null_session_class = NullSession
-
-    #: A flag that indicates if the session interface is pickle based.
-    #: This can be used by Flask extensions to make a decision in regards
-    #: to how to deal with the session object.
-    #:
-    #: .. versionadded:: 0.10
-    pickle_based = False
-
-    def make_null_session(self, app):
-        """Creates a null session which acts as a replacement object if the
-        real session support could not be loaded due to a configuration
-        error.  This mainly aids the user experience because the job of the
-        null session is to still support lookup without complaining but
-        modifications are answered with a helpful error message of what
-        failed.
-
-        This creates an instance of :attr:`null_session_class` by default.
-        """
-        return self.null_session_class()
-
-    def is_null_session(self, obj):
-        """Checks if a given object is a null session.  Null sessions are
-        not asked to be saved.
-
-        This checks if the object is an instance of :attr:`null_session_class`
-        by default.
-        """
-        return isinstance(obj, self.null_session_class)
-
-    def get_cookie_domain(self, app):
-        """Returns the domain that should be set for the session cookie.
-
-        Uses ``SESSION_COOKIE_DOMAIN`` if it is configured, otherwise
-        falls back to detecting the domain based on ``SERVER_NAME``.
-
-        Once detected (or if not set at all), ``SESSION_COOKIE_DOMAIN`` is
-        updated to avoid re-running the logic.
-        """
-
-        rv = app.config['SESSION_COOKIE_DOMAIN']
-
-        # set explicitly, or cached from SERVER_NAME detection
-        # if False, return None
-        if rv is not None:
-            return rv if rv else None
-
-        rv = app.config['SERVER_NAME']
-
-        # server name not set, cache False to return none next time
-        if not rv:
-            app.config['SESSION_COOKIE_DOMAIN'] = False
-            return None
-
-        # chop off the port which is usually not supported by browsers
-        # remove any leading '.' since we'll add that later
-        rv = rv.rsplit(':', 1)[0].lstrip('.')
-
-        if '.' not in rv:
-            # Chrome doesn't allow names without a '.'
-            # this should only come up with localhost
-            # hack around this by not setting the name, and show a warning
-            warnings.warn(
-                '"{rv}" is not a valid cookie domain, it must contain a ".".'
-                ' Add an entry to your hosts file, for example'
-                ' "{rv}.localdomain", and use that instead.'.format(rv=rv)
-            )
-            app.config['SESSION_COOKIE_DOMAIN'] = False
-            return None
-
-        ip = is_ip(rv)
-
-        if ip:
-            warnings.warn(
-                'The session cookie domain is an IP address. This may not work'
-                ' as intended in some browsers. Add an entry to your hosts'
-                ' file, for example "localhost.localdomain", and use that'
-                ' instead.'
-            )
-
-        # if this is not an ip and app is mounted at the root, allow subdomain
-        # matching by adding a '.' prefix
-        if self.get_cookie_path(app) == '/' and not ip:
-            rv = '.' + rv
-
-        app.config['SESSION_COOKIE_DOMAIN'] = rv
-        return rv
-
-    def get_cookie_path(self, app):
-        """Returns the path for which the cookie should be valid.  The
-        default implementation uses the value from the ``SESSION_COOKIE_PATH``
-        config var if it's set, and falls back to ``APPLICATION_ROOT`` or
-        uses ``/`` if it's ``None``.
-        """
-        return app.config['SESSION_COOKIE_PATH'] \
-               or app.config['APPLICATION_ROOT']
-
-    def get_cookie_httponly(self, app):
-        """Returns True if the session cookie should be httponly.  This
-        currently just returns the value of the ``SESSION_COOKIE_HTTPONLY``
-        config var.
-        """
-        return app.config['SESSION_COOKIE_HTTPONLY']
-
-    def get_cookie_secure(self, app):
-        """Returns True if the cookie should be secure.  This currently
-        just returns the value of the ``SESSION_COOKIE_SECURE`` setting.
-        """
-        return app.config['SESSION_COOKIE_SECURE']
-
-    def get_cookie_samesite(self, app):
-        """Return ``'Strict'`` or ``'Lax'`` if the cookie should use the
-        ``SameSite`` attribute. This currently just returns the value of
-        the :data:`SESSION_COOKIE_SAMESITE` setting.
-        """
-        return app.config['SESSION_COOKIE_SAMESITE']
-
-    def get_expiration_time(self, app, session):
-        """A helper method that returns an expiration date for the session
-        or ``None`` if the session is linked to the browser session.  The
-        default implementation returns now + the permanent session
-        lifetime configured on the application.
-        """
-        if session.permanent:
-            return datetime.utcnow() + app.permanent_session_lifetime
-
-    def should_set_cookie(self, app, session):
-        """Used by session backends to determine if a ``Set-Cookie`` header
-        should be set for this session cookie for this response. If the session
-        has been modified, the cookie is set. If the session is permanent and
-        the ``SESSION_REFRESH_EACH_REQUEST`` config is true, the cookie is
-        always set.
-
-        This check is usually skipped if the session was deleted.
-
-        .. versionadded:: 0.11
-        """
-
-        return session.modified or (
-            session.permanent and app.config['SESSION_REFRESH_EACH_REQUEST']
-        )
-
-    def open_session(self, app, request):
-        """This method has to be implemented and must either return ``None``
-        in case the loading failed because of a configuration error or an
-        instance of a session object which implements a dictionary like
-        interface + the methods and attributes on :class:`SessionMixin`.
-        """
-        raise NotImplementedError()
-
-    def save_session(self, app, session, response):
-        """This is called for actual sessions returned by :meth:`open_session`
-        at the end of the request.  This is still called during a request
-        context so if you absolutely need access to the request you can do
-        that.
-        """
-        raise NotImplementedError()
-
-
-session_json_serializer = TaggedJSONSerializer()
-
-
-class SecureCookieSessionInterface(SessionInterface):
-    """The default session interface that stores sessions in signed cookies
-    through the :mod:`itsdangerous` module.
-    """
-    #: the salt that should be applied on top of the secret key for the
-    #: signing of cookie based sessions.
-    salt = 'cookie-session'
-    #: the hash function to use for the signature.  The default is sha1
-    digest_method = staticmethod(hashlib.sha1)
-    #: the name of the itsdangerous supported key derivation.  The default
-    #: is hmac.
-    key_derivation = 'hmac'
-    #: A python serializer for the payload.  The default is a compact
-    #: JSON derived serializer with support for some extra Python types
-    #: such as datetime objects or tuples.
-    serializer = session_json_serializer
-    session_class = SecureCookieSession
-
-    def get_signing_serializer(self, app):
-        if not app.secret_key:
-            return None
-        signer_kwargs = dict(
-            key_derivation=self.key_derivation,
-            digest_method=self.digest_method
-        )
-        return URLSafeTimedSerializer(app.secret_key, salt=self.salt,
-                                      serializer=self.serializer,
-                                      signer_kwargs=signer_kwargs)
-
-    def open_session(self, app, request):
-        s = self.get_signing_serializer(app)
-        if s is None:
-            return None
-        val = request.cookies.get(app.session_cookie_name)
-        if not val:
-            return self.session_class()
-        max_age = total_seconds(app.permanent_session_lifetime)
-        try:
-            data = s.loads(val, max_age=max_age)
-            return self.session_class(data)
-        except BadSignature:
-            return self.session_class()
-
-    def save_session(self, app, session, response):
-        domain = self.get_cookie_domain(app)
-        path = self.get_cookie_path(app)
-
-        # If the session is modified to be empty, remove the cookie.
-        # If the session is empty, return without setting the cookie.
-        if not session:
-            if session.modified:
-                response.delete_cookie(
-                    app.session_cookie_name,
-                    domain=domain,
-                    path=path
-                )
-
-            return
-
-        # Add a "Vary: Cookie" header if the session was accessed at all.
-        if session.accessed:
-            response.vary.add('Cookie')
-
-        if not self.should_set_cookie(app, session):
-            return
-
-        httponly = self.get_cookie_httponly(app)
-        secure = self.get_cookie_secure(app)
-        samesite = self.get_cookie_samesite(app)
-        expires = self.get_expiration_time(app, session)
-        val = self.get_signing_serializer(app).dumps(dict(session))
-        response.set_cookie(
-            app.session_cookie_name,
-            val,
-            expires=expires,
-            httponly=httponly,
-            domain=domain,
-            path=path,
-            secure=secure,
-            samesite=samesite
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/signals.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/signals.py
deleted file mode 100644
index 18f263072..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/signals.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.signals
-    ~~~~~~~~~~~~~
-
-    Implements signals based on blinker if available, otherwise
-    falls silently back to a noop.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-signals_available = False
-try:
-    from blinker import Namespace
-    signals_available = True
-except ImportError:
-    class Namespace(object):
-        def signal(self, name, doc=None):
-            return _FakeSignal(name, doc)
-
-    class _FakeSignal(object):
-        """If blinker is unavailable, create a fake class with the same
-        interface that allows sending of signals but will fail with an
-        error on anything else.  Instead of doing anything on send, it
-        will just ignore the arguments and do nothing instead.
-        """
-
-        def __init__(self, name, doc=None):
-            self.name = name
-            self.__doc__ = doc
-        def _fail(self, *args, **kwargs):
-            raise RuntimeError('signalling support is unavailable '
-                               'because the blinker library is '
-                               'not installed.')
-        send = lambda *a, **kw: None
-        connect = disconnect = has_receivers_for = receivers_for = \
-            temporarily_connected_to = connected_to = _fail
-        del _fail
-
-# The namespace for code signals.  If you are not Flask code, do
-# not put signals in here.  Create your own namespace instead.
-_signals = Namespace()
-
-
-# Core signals.  For usage examples grep the source code or consult
-# the API documentation in docs/api.rst as well as docs/signals.rst
-template_rendered = _signals.signal('template-rendered')
-before_render_template = _signals.signal('before-render-template')
-request_started = _signals.signal('request-started')
-request_finished = _signals.signal('request-finished')
-request_tearing_down = _signals.signal('request-tearing-down')
-got_request_exception = _signals.signal('got-request-exception')
-appcontext_tearing_down = _signals.signal('appcontext-tearing-down')
-appcontext_pushed = _signals.signal('appcontext-pushed')
-appcontext_popped = _signals.signal('appcontext-popped')
-message_flashed = _signals.signal('message-flashed')
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/templating.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/templating.py
deleted file mode 100644
index 024020086..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/templating.py
+++ /dev/null
@@ -1,150 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.templating
-    ~~~~~~~~~~~~~~~~
-
-    Implements the bridge to Jinja2.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from jinja2 import BaseLoader, Environment as BaseEnvironment, \
-     TemplateNotFound
-
-from .globals import _request_ctx_stack, _app_ctx_stack
-from .signals import template_rendered, before_render_template
-
-
-def _default_template_ctx_processor():
-    """Default template context processor.  Injects `request`,
-    `session` and `g`.
-    """
-    reqctx = _request_ctx_stack.top
-    appctx = _app_ctx_stack.top
-    rv = {}
-    if appctx is not None:
-        rv['g'] = appctx.g
-    if reqctx is not None:
-        rv['request'] = reqctx.request
-        rv['session'] = reqctx.session
-    return rv
-
-
-class Environment(BaseEnvironment):
-    """Works like a regular Jinja2 environment but has some additional
-    knowledge of how Flask's blueprint works so that it can prepend the
-    name of the blueprint to referenced templates if necessary.
-    """
-
-    def __init__(self, app, **options):
-        if 'loader' not in options:
-            options['loader'] = app.create_global_jinja_loader()
-        BaseEnvironment.__init__(self, **options)
-        self.app = app
-
-
-class DispatchingJinjaLoader(BaseLoader):
-    """A loader that looks for templates in the application and all
-    the blueprint folders.
-    """
-
-    def __init__(self, app):
-        self.app = app
-
-    def get_source(self, environment, template):
-        if self.app.config['EXPLAIN_TEMPLATE_LOADING']:
-            return self._get_source_explained(environment, template)
-        return self._get_source_fast(environment, template)
-
-    def _get_source_explained(self, environment, template):
-        attempts = []
-        trv = None
-
-        for srcobj, loader in self._iter_loaders(template):
-            try:
-                rv = loader.get_source(environment, template)
-                if trv is None:
-                    trv = rv
-            except TemplateNotFound:
-                rv = None
-            attempts.append((loader, srcobj, rv))
-
-        from .debughelpers import explain_template_loading_attempts
-        explain_template_loading_attempts(self.app, template, attempts)
-
-        if trv is not None:
-            return trv
-        raise TemplateNotFound(template)
-
-    def _get_source_fast(self, environment, template):
-        for srcobj, loader in self._iter_loaders(template):
-            try:
-                return loader.get_source(environment, template)
-            except TemplateNotFound:
-                continue
-        raise TemplateNotFound(template)
-
-    def _iter_loaders(self, template):
-        loader = self.app.jinja_loader
-        if loader is not None:
-            yield self.app, loader
-
-        for blueprint in self.app.iter_blueprints():
-            loader = blueprint.jinja_loader
-            if loader is not None:
-                yield blueprint, loader
-
-    def list_templates(self):
-        result = set()
-        loader = self.app.jinja_loader
-        if loader is not None:
-            result.update(loader.list_templates())
-
-        for blueprint in self.app.iter_blueprints():
-            loader = blueprint.jinja_loader
-            if loader is not None:
-                for template in loader.list_templates():
-                    result.add(template)
-
-        return list(result)
-
-
-def _render(template, context, app):
-    """Renders the template and fires the signal"""
-
-    before_render_template.send(app, template=template, context=context)
-    rv = template.render(context)
-    template_rendered.send(app, template=template, context=context)
-    return rv
-
-
-def render_template(template_name_or_list, **context):
-    """Renders a template from the template folder with the given
-    context.
-
-    :param template_name_or_list: the name of the template to be
-                                  rendered, or an iterable with template names
-                                  the first one existing will be rendered
-    :param context: the variables that should be available in the
-                    context of the template.
-    """
-    ctx = _app_ctx_stack.top
-    ctx.app.update_template_context(context)
-    return _render(ctx.app.jinja_env.get_or_select_template(template_name_or_list),
-                   context, ctx.app)
-
-
-def render_template_string(source, **context):
-    """Renders a template from the given template source string
-    with the given context. Template variables will be autoescaped.
-
-    :param source: the source code of the template to be
-                   rendered
-    :param context: the variables that should be available in the
-                    context of the template.
-    """
-    ctx = _app_ctx_stack.top
-    ctx.app.update_template_context(context)
-    return _render(ctx.app.jinja_env.from_string(source),
-                   context, ctx.app)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/testing.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/testing.py
deleted file mode 100644
index 4bf0ebc12..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/testing.py
+++ /dev/null
@@ -1,250 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.testing
-    ~~~~~~~~~~~~~
-
-    Implements test support helpers.  This module is lazily imported
-    and usually not used in production environments.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import werkzeug
-from contextlib import contextmanager
-
-from click.testing import CliRunner
-from flask.cli import ScriptInfo
-from werkzeug.test import Client, EnvironBuilder
-from flask import _request_ctx_stack
-from flask.json import dumps as json_dumps
-from werkzeug.urls import url_parse
-
-
-def make_test_environ_builder(
-    app, path='/', base_url=None, subdomain=None, url_scheme=None,
-    *args, **kwargs
-):
-    """Create a :class:`~werkzeug.test.EnvironBuilder`, taking some
-    defaults from the application.
-
-    :param app: The Flask application to configure the environment from.
-    :param path: URL path being requested.
-    :param base_url: Base URL where the app is being served, which
-        ``path`` is relative to. If not given, built from
-        :data:`PREFERRED_URL_SCHEME`, ``subdomain``,
-        :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
-    :param subdomain: Subdomain name to append to :data:`SERVER_NAME`.
-    :param url_scheme: Scheme to use instead of
-        :data:`PREFERRED_URL_SCHEME`.
-    :param json: If given, this is serialized as JSON and passed as
-        ``data``. Also defaults ``content_type`` to
-        ``application/json``.
-    :param args: other positional arguments passed to
-        :class:`~werkzeug.test.EnvironBuilder`.
-    :param kwargs: other keyword arguments passed to
-        :class:`~werkzeug.test.EnvironBuilder`.
-    """
-
-    assert (
-        not (base_url or subdomain or url_scheme)
-        or (base_url is not None) != bool(subdomain or url_scheme)
-    ), 'Cannot pass "subdomain" or "url_scheme" with "base_url".'
-
-    if base_url is None:
-        http_host = app.config.get('SERVER_NAME') or 'localhost'
-        app_root = app.config['APPLICATION_ROOT']
-
-        if subdomain:
-            http_host = '{0}.{1}'.format(subdomain, http_host)
-
-        if url_scheme is None:
-            url_scheme = app.config['PREFERRED_URL_SCHEME']
-
-        url = url_parse(path)
-        base_url = '{scheme}://{netloc}/{path}'.format(
-            scheme=url.scheme or url_scheme,
-            netloc=url.netloc or http_host,
-            path=app_root.lstrip('/')
-        )
-        path = url.path
-
-        if url.query:
-            sep = b'?' if isinstance(url.query, bytes) else '?'
-            path += sep + url.query
-
-    if 'json' in kwargs:
-        assert 'data' not in kwargs, (
-            "Client cannot provide both 'json' and 'data'."
-        )
-
-        # push a context so flask.json can use app's json attributes
-        with app.app_context():
-            kwargs['data'] = json_dumps(kwargs.pop('json'))
-
-        if 'content_type' not in kwargs:
-            kwargs['content_type'] = 'application/json'
-
-    return EnvironBuilder(path, base_url, *args, **kwargs)
-
-
-class FlaskClient(Client):
-    """Works like a regular Werkzeug test client but has some knowledge about
-    how Flask works to defer the cleanup of the request context stack to the
-    end of a ``with`` body when used in a ``with`` statement.  For general
-    information about how to use this class refer to
-    :class:`werkzeug.test.Client`.
-
-    .. versionchanged:: 0.12
-       `app.test_client()` includes preset default environment, which can be
-       set after instantiation of the `app.test_client()` object in
-       `client.environ_base`.
-
-    Basic usage is outlined in the :ref:`testing` chapter.
-    """
-
-    preserve_context = False
-
-    def __init__(self, *args, **kwargs):
-        super(FlaskClient, self).__init__(*args, **kwargs)
-        self.environ_base = {
-            "REMOTE_ADDR": "127.0.0.1",
-            "HTTP_USER_AGENT": "werkzeug/" + werkzeug.__version__
-        }
-
-    @contextmanager
-    def session_transaction(self, *args, **kwargs):
-        """When used in combination with a ``with`` statement this opens a
-        session transaction.  This can be used to modify the session that
-        the test client uses.  Once the ``with`` block is left the session is
-        stored back.
-
-        ::
-
-            with client.session_transaction() as session:
-                session['value'] = 42
-
-        Internally this is implemented by going through a temporary test
-        request context and since session handling could depend on
-        request variables this function accepts the same arguments as
-        :meth:`~flask.Flask.test_request_context` which are directly
-        passed through.
-        """
-        if self.cookie_jar is None:
-            raise RuntimeError('Session transactions only make sense '
-                               'with cookies enabled.')
-        app = self.application
-        environ_overrides = kwargs.setdefault('environ_overrides', {})
-        self.cookie_jar.inject_wsgi(environ_overrides)
-        outer_reqctx = _request_ctx_stack.top
-        with app.test_request_context(*args, **kwargs) as c:
-            session_interface = app.session_interface
-            sess = session_interface.open_session(app, c.request)
-            if sess is None:
-                raise RuntimeError('Session backend did not open a session. '
-                                   'Check the configuration')
-
-            # Since we have to open a new request context for the session
-            # handling we want to make sure that we hide out own context
-            # from the caller.  By pushing the original request context
-            # (or None) on top of this and popping it we get exactly that
-            # behavior.  It's important to not use the push and pop
-            # methods of the actual request context object since that would
-            # mean that cleanup handlers are called
-            _request_ctx_stack.push(outer_reqctx)
-            try:
-                yield sess
-            finally:
-                _request_ctx_stack.pop()
-
-            resp = app.response_class()
-            if not session_interface.is_null_session(sess):
-                session_interface.save_session(app, sess, resp)
-            headers = resp.get_wsgi_headers(c.request.environ)
-            self.cookie_jar.extract_wsgi(c.request.environ, headers)
-
-    def open(self, *args, **kwargs):
-        as_tuple = kwargs.pop('as_tuple', False)
-        buffered = kwargs.pop('buffered', False)
-        follow_redirects = kwargs.pop('follow_redirects', False)
-
-        if (
-            not kwargs and len(args) == 1
-            and isinstance(args[0], (EnvironBuilder, dict))
-        ):
-            environ = self.environ_base.copy()
-
-            if isinstance(args[0], EnvironBuilder):
-                environ.update(args[0].get_environ())
-            else:
-                environ.update(args[0])
-
-            environ['flask._preserve_context'] = self.preserve_context
-        else:
-            kwargs.setdefault('environ_overrides', {}) \
-                ['flask._preserve_context'] = self.preserve_context
-            kwargs.setdefault('environ_base', self.environ_base)
-            builder = make_test_environ_builder(
-                self.application, *args, **kwargs
-            )
-
-            try:
-                environ = builder.get_environ()
-            finally:
-                builder.close()
-
-        return Client.open(
-            self, environ,
-            as_tuple=as_tuple,
-            buffered=buffered,
-            follow_redirects=follow_redirects
-        )
-
-    def __enter__(self):
-        if self.preserve_context:
-            raise RuntimeError('Cannot nest client invocations')
-        self.preserve_context = True
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.preserve_context = False
-
-        # on exit we want to clean up earlier.  Normally the request context
-        # stays preserved until the next request in the same thread comes
-        # in.  See RequestGlobals.push() for the general behavior.
-        top = _request_ctx_stack.top
-        if top is not None and top.preserved:
-            top.pop()
-
-
-class FlaskCliRunner(CliRunner):
-    """A :class:`~click.testing.CliRunner` for testing a Flask app's
-    CLI commands. Typically created using
-    :meth:`~flask.Flask.test_cli_runner`. See :ref:`testing-cli`.
-    """
-    def __init__(self, app, **kwargs):
-        self.app = app
-        super(FlaskCliRunner, self).__init__(**kwargs)
-
-    def invoke(self, cli=None, args=None, **kwargs):
-        """Invokes a CLI command in an isolated environment. See
-        :meth:`CliRunner.invoke <click.testing.CliRunner.invoke>` for
-        full method documentation. See :ref:`testing-cli` for examples.
-
-        If the ``obj`` argument is not given, passes an instance of
-        :class:`~flask.cli.ScriptInfo` that knows how to load the Flask
-        app being tested.
-
-        :param cli: Command object to invoke. Default is the app's
-            :attr:`~flask.app.Flask.cli` group.
-        :param args: List of strings to invoke the command with.
-
-        :return: a :class:`~click.testing.Result` object.
-        """
-        if cli is None:
-            cli = self.app.cli
-
-        if 'obj' not in kwargs:
-            kwargs['obj'] = ScriptInfo(create_app=lambda: self.app)
-
-        return super(FlaskCliRunner, self).invoke(cli, args, **kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/views.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/views.py
deleted file mode 100644
index 1f2c997b4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/views.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.views
-    ~~~~~~~~~~~
-
-    This module provides class-based views inspired by the ones in Django.
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from .globals import request
-from ._compat import with_metaclass
-
-
-http_method_funcs = frozenset(['get', 'post', 'head', 'options',
-                               'delete', 'put', 'trace', 'patch'])
-
-
-class View(object):
-    """Alternative way to use view functions.  A subclass has to implement
-    :meth:`dispatch_request` which is called with the view arguments from
-    the URL routing system.  If :attr:`methods` is provided the methods
-    do not have to be passed to the :meth:`~flask.Flask.add_url_rule`
-    method explicitly::
-
-        class MyView(View):
-            methods = ['GET']
-
-            def dispatch_request(self, name):
-                return 'Hello %s!' % name
-
-        app.add_url_rule('/hello/<name>', view_func=MyView.as_view('myview'))
-
-    When you want to decorate a pluggable view you will have to either do that
-    when the view function is created (by wrapping the return value of
-    :meth:`as_view`) or you can use the :attr:`decorators` attribute::
-
-        class SecretView(View):
-            methods = ['GET']
-            decorators = [superuser_required]
-
-            def dispatch_request(self):
-                ...
-
-    The decorators stored in the decorators list are applied one after another
-    when the view function is created.  Note that you can *not* use the class
-    based decorators since those would decorate the view class and not the
-    generated view function!
-    """
-
-    #: A list of methods this view can handle.
-    methods = None
-
-    #: Setting this disables or force-enables the automatic options handling.
-    provide_automatic_options = None
-
-    #: The canonical way to decorate class-based views is to decorate the
-    #: return value of as_view().  However since this moves parts of the
-    #: logic from the class declaration to the place where it's hooked
-    #: into the routing system.
-    #:
-    #: You can place one or more decorators in this list and whenever the
-    #: view function is created the result is automatically decorated.
-    #:
-    #: .. versionadded:: 0.8
-    decorators = ()
-
-    def dispatch_request(self):
-        """Subclasses have to override this method to implement the
-        actual view function code.  This method is called with all
-        the arguments from the URL rule.
-        """
-        raise NotImplementedError()
-
-    @classmethod
-    def as_view(cls, name, *class_args, **class_kwargs):
-        """Converts the class into an actual view function that can be used
-        with the routing system.  Internally this generates a function on the
-        fly which will instantiate the :class:`View` on each request and call
-        the :meth:`dispatch_request` method on it.
-
-        The arguments passed to :meth:`as_view` are forwarded to the
-        constructor of the class.
-        """
-        def view(*args, **kwargs):
-            self = view.view_class(*class_args, **class_kwargs)
-            return self.dispatch_request(*args, **kwargs)
-
-        if cls.decorators:
-            view.__name__ = name
-            view.__module__ = cls.__module__
-            for decorator in cls.decorators:
-                view = decorator(view)
-
-        # We attach the view class to the view function for two reasons:
-        # first of all it allows us to easily figure out what class-based
-        # view this thing came from, secondly it's also used for instantiating
-        # the view class so you can actually replace it with something else
-        # for testing purposes and debugging.
-        view.view_class = cls
-        view.__name__ = name
-        view.__doc__ = cls.__doc__
-        view.__module__ = cls.__module__
-        view.methods = cls.methods
-        view.provide_automatic_options = cls.provide_automatic_options
-        return view
-
-
-class MethodViewType(type):
-    """Metaclass for :class:`MethodView` that determines what methods the view
-    defines.
-    """
-
-    def __init__(cls, name, bases, d):
-        super(MethodViewType, cls).__init__(name, bases, d)
-
-        if 'methods' not in d:
-            methods = set()
-
-            for key in http_method_funcs:
-                if hasattr(cls, key):
-                    methods.add(key.upper())
-
-            # If we have no method at all in there we don't want to add a
-            # method list. This is for instance the case for the base class
-            # or another subclass of a base method view that does not introduce
-            # new methods.
-            if methods:
-                cls.methods = methods
-
-
-class MethodView(with_metaclass(MethodViewType, View)):
-    """A class-based view that dispatches request methods to the corresponding
-    class methods. For example, if you implement a ``get`` method, it will be
-    used to handle ``GET`` requests. ::
-
-        class CounterAPI(MethodView):
-            def get(self):
-                return session.get('counter', 0)
-
-            def post(self):
-                session['counter'] = session.get('counter', 0) + 1
-                return 'OK'
-
-        app.add_url_rule('/counter', view_func=CounterAPI.as_view('counter'))
-    """
-
-    def dispatch_request(self, *args, **kwargs):
-        meth = getattr(self, request.method.lower(), None)
-
-        # If the request method is HEAD and we don't have a handler for it
-        # retry with GET.
-        if meth is None and request.method == 'HEAD':
-            meth = getattr(self, 'get', None)
-
-        assert meth is not None, 'Unimplemented method %r' % request.method
-        return meth(*args, **kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/wrappers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/wrappers.py
deleted file mode 100644
index 12eff2c7e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/flask/wrappers.py
+++ /dev/null
@@ -1,216 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    flask.wrappers
-    ~~~~~~~~~~~~~~
-
-    Implements the WSGI wrappers (request and response).
-
-    :copyright: © 2010 by the Pallets team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from werkzeug.exceptions import BadRequest
-from werkzeug.wrappers import Request as RequestBase, Response as ResponseBase
-
-from flask import json
-from flask.globals import current_app
-
-
-class JSONMixin(object):
-    """Common mixin for both request and response objects to provide JSON
-    parsing capabilities.
-
-    .. versionadded:: 1.0
-    """
-
-    _cached_json = (Ellipsis, Ellipsis)
-
-    @property
-    def is_json(self):
-        """Check if the mimetype indicates JSON data, either
-        :mimetype:`application/json` or :mimetype:`application/*+json`.
-
-        .. versionadded:: 0.11
-        """
-        mt = self.mimetype
-        return (
-            mt == 'application/json'
-            or (mt.startswith('application/')) and mt.endswith('+json')
-        )
-
-    @property
-    def json(self):
-        """This will contain the parsed JSON data if the mimetype indicates
-        JSON (:mimetype:`application/json`, see :meth:`is_json`), otherwise it
-        will be ``None``.
-        """
-        return self.get_json()
-
-    def _get_data_for_json(self, cache):
-        return self.get_data(cache=cache)
-
-    def get_json(self, force=False, silent=False, cache=True):
-        """Parse and return the data as JSON. If the mimetype does not
-        indicate JSON (:mimetype:`application/json`, see
-        :meth:`is_json`), this returns ``None`` unless ``force`` is
-        true. If parsing fails, :meth:`on_json_loading_failed` is called
-        and its return value is used as the return value.
-
-        :param force: Ignore the mimetype and always try to parse JSON.
-        :param silent: Silence parsing errors and return ``None``
-            instead.
-        :param cache: Store the parsed JSON to return for subsequent
-            calls.
-        """
-        if cache and self._cached_json[silent] is not Ellipsis:
-            return self._cached_json[silent]
-
-        if not (force or self.is_json):
-            return None
-
-        data = self._get_data_for_json(cache=cache)
-
-        try:
-            rv = json.loads(data)
-        except ValueError as e:
-            if silent:
-                rv = None
-                if cache:
-                    normal_rv, _ = self._cached_json
-                    self._cached_json = (normal_rv, rv)
-            else:
-                rv = self.on_json_loading_failed(e)
-                if cache:
-                    _, silent_rv = self._cached_json
-                    self._cached_json = (rv, silent_rv)
-        else:
-            if cache:
-                self._cached_json = (rv, rv)
-
-        return rv
-
-    def on_json_loading_failed(self, e):
-        """Called if :meth:`get_json` parsing fails and isn't silenced. If
-        this method returns a value, it is used as the return value for
-        :meth:`get_json`. The default implementation raises a
-        :class:`BadRequest` exception.
-
-        .. versionchanged:: 0.10
-           Raise a :exc:`BadRequest` error instead of returning an error
-           message as JSON. If you want that behavior you can add it by
-           subclassing.
-
-        .. versionadded:: 0.8
-        """
-        if current_app is not None and current_app.debug:
-            raise BadRequest('Failed to decode JSON object: {0}'.format(e))
-
-        raise BadRequest()
-
-
-class Request(RequestBase, JSONMixin):
-    """The request object used by default in Flask.  Remembers the
-    matched endpoint and view arguments.
-
-    It is what ends up as :class:`~flask.request`.  If you want to replace
-    the request object used you can subclass this and set
-    :attr:`~flask.Flask.request_class` to your subclass.
-
-    The request object is a :class:`~werkzeug.wrappers.Request` subclass and
-    provides all of the attributes Werkzeug defines plus a few Flask
-    specific ones.
-    """
-
-    #: The internal URL rule that matched the request.  This can be
-    #: useful to inspect which methods are allowed for the URL from
-    #: a before/after handler (``request.url_rule.methods``) etc.
-    #: Though if the request's method was invalid for the URL rule,
-    #: the valid list is available in ``routing_exception.valid_methods``
-    #: instead (an attribute of the Werkzeug exception :exc:`~werkzeug.exceptions.MethodNotAllowed`)
-    #: because the request was never internally bound.
-    #:
-    #: .. versionadded:: 0.6
-    url_rule = None
-
-    #: A dict of view arguments that matched the request.  If an exception
-    #: happened when matching, this will be ``None``.
-    view_args = None
-
-    #: If matching the URL failed, this is the exception that will be
-    #: raised / was raised as part of the request handling.  This is
-    #: usually a :exc:`~werkzeug.exceptions.NotFound` exception or
-    #: something similar.
-    routing_exception = None
-
-    @property
-    def max_content_length(self):
-        """Read-only view of the ``MAX_CONTENT_LENGTH`` config key."""
-        if current_app:
-            return current_app.config['MAX_CONTENT_LENGTH']
-
-    @property
-    def endpoint(self):
-        """The endpoint that matched the request.  This in combination with
-        :attr:`view_args` can be used to reconstruct the same or a
-        modified URL.  If an exception happened when matching, this will
-        be ``None``.
-        """
-        if self.url_rule is not None:
-            return self.url_rule.endpoint
-
-    @property
-    def blueprint(self):
-        """The name of the current blueprint"""
-        if self.url_rule and '.' in self.url_rule.endpoint:
-            return self.url_rule.endpoint.rsplit('.', 1)[0]
-
-    def _load_form_data(self):
-        RequestBase._load_form_data(self)
-
-        # In debug mode we're replacing the files multidict with an ad-hoc
-        # subclass that raises a different error for key errors.
-        if (
-            current_app
-            and current_app.debug
-            and self.mimetype != 'multipart/form-data'
-            and not self.files
-        ):
-            from .debughelpers import attach_enctype_error_multidict
-            attach_enctype_error_multidict(self)
-
-
-class Response(ResponseBase, JSONMixin):
-    """The response object that is used by default in Flask.  Works like the
-    response object from Werkzeug but is set to have an HTML mimetype by
-    default.  Quite often you don't have to create this object yourself because
-    :meth:`~flask.Flask.make_response` will take care of that for you.
-
-    If you want to replace the response object used you can subclass this and
-    set :attr:`~flask.Flask.response_class` to your subclass.
-
-    .. versionchanged:: 1.0
-        JSON support is added to the response, like the request. This is useful
-        when testing to get the test client response data as JSON.
-
-    .. versionchanged:: 1.0
-
-        Added :attr:`max_cookie_size`.
-    """
-
-    default_mimetype = 'text/html'
-
-    def _get_data_for_json(self, cache):
-        return self.get_data()
-
-    @property
-    def max_cookie_size(self):
-        """Read-only view of the :data:`MAX_COOKIE_SIZE` config key.
-
-        See :attr:`~werkzeug.wrappers.BaseResponse.max_cookie_size` in
-        Werkzeug's docs.
-        """
-        if current_app:
-            return current_app.config['MAX_COOKIE_SIZE']
-
-        # return Werkzeug's default when not in an app context
-        return super(Response, self).max_cookie_size
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/LICENSE.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/LICENSE.txt
deleted file mode 100644
index 65865a92a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/LICENSE.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-2009-2018 (c) Benoît Chesneau <benoitc@e-engura.org>
-2009-2015 (c) Paul J. Davis <paul.joseph.davis@gmail.com>
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/METADATA
deleted file mode 100644
index 148e50000..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/METADATA
+++ /dev/null
@@ -1,111 +0,0 @@
-Metadata-Version: 2.1
-Name: gunicorn
-Version: 19.9.0
-Summary: WSGI HTTP Server for UNIX
-Home-page: http://gunicorn.org
-Author: Benoit Chesneau
-Author-email: benoitc@e-engura.com
-License: MIT
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Other Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: POSIX
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.2
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Topic :: Internet
-Classifier: Topic :: Utilities
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Requires-Python: >=2.6, !=3.0.*, !=3.1.*
-Provides-Extra: tornado
-Provides-Extra: gthread
-Provides-Extra: eventlet
-Provides-Extra: gevent
-Provides-Extra: eventlet
-Requires-Dist: eventlet (>=0.9.7); extra == 'eventlet'
-Provides-Extra: gevent
-Requires-Dist: gevent (>=0.13); extra == 'gevent'
-Provides-Extra: gthread
-Provides-Extra: tornado
-Requires-Dist: tornado (>=0.2); extra == 'tornado'
-
-Gunicorn
---------
-
-.. image:: https://img.shields.io/pypi/v/gunicorn.svg?style=flat
-    :alt: PyPI version
-    :target: https://pypi.python.org/pypi/gunicorn
-
-.. image:: https://img.shields.io/pypi/pyversions/gunicorn.svg
-    :alt: Supported Python versions
-    :target: https://pypi.python.org/pypi/gunicorn
-
-.. image:: https://travis-ci.org/benoitc/gunicorn.svg?branch=master
-    :alt: Build Status
-    :target: https://travis-ci.org/benoitc/gunicorn
-
-Gunicorn 'Green Unicorn' is a Python WSGI HTTP Server for UNIX. It's a pre-fork
-worker model ported from Ruby's Unicorn_ project. The Gunicorn server is broadly
-compatible with various web frameworks, simply implemented, light on server
-resource usage, and fairly speedy.
-
-Feel free to join us in `#gunicorn`_ on Freenode_.
-
-Documentation
--------------
-
-The documentation is hosted at http://docs.gunicorn.org.
-
-Installation
-------------
-
-Gunicorn requires **Python 2.x >= 2.6** or **Python 3.x >= 3.2**.
-
-Install from PyPI::
-
-    $ pip install gunicorn
-
-
-Usage
------
-
-Basic usage::
-
-    $ gunicorn [OPTIONS] APP_MODULE
-
-Where ``APP_MODULE`` is of the pattern ``$(MODULE_NAME):$(VARIABLE_NAME)``. The
-module name can be a full dotted path. The variable name refers to a WSGI
-callable that should be found in the specified module.
-
-Example with test app::
-
-    $ cd examples
-    $ gunicorn --workers=2 test:app
-
-
-License
--------
-
-Gunicorn is released under the MIT License. See the LICENSE_ file for more
-details.
-
-.. _Unicorn: https://bogomips.org/unicorn/
-.. _`#gunicorn`: https://webchat.freenode.net/?channels=gunicorn
-.. _Freenode: https://freenode.net/
-.. _LICENSE: https://github.com/benoitc/gunicorn/blob/master/LICENSE
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/RECORD
deleted file mode 100644
index dad3bb11c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/RECORD
+++ /dev/null
@@ -1,89 +0,0 @@
-gunicorn/__init__.py,sha256=kRm2HQJytwQi-xmyUfM0cOMyls23DfFDgGFbGI2Gj68,255
-gunicorn/_compat.py,sha256=5cXb6vMfVzInDq-AHNyZfsK-UG5NetDn62nPfqylHSU,9355
-gunicorn/arbiter.py,sha256=AbJNSFnTmx9Qd-vZAqEH3y5fz8ydPmyli_BERNIwdyE,20158
-gunicorn/argparse_compat.py,sha256=gsHDGwo4BSJWHdiaEXy0Emr96NKC0LDYmK5nB7PE8Qc,87791
-gunicorn/config.py,sha256=wYeAJFMweU3FXNF4BdfgZzPC94vUXUnuYgI6lNk-5_U,53420
-gunicorn/debug.py,sha256=UUw-eteLEm_OQ98D6K3XtDjx4Dya2H35zdiu8z7F7uc,2289
-gunicorn/errors.py,sha256=JlDBjag90gMiRwLHG3xzEJzDOntSl1iM32R277-U6j0,919
-gunicorn/glogging.py,sha256=bvnX-sky6HgqJor2JZ9VKZZzT4uh_yOgknkYegB7D7Y,15581
-gunicorn/pidfile.py,sha256=_69tsfF1aHklrMrJe2sHERovMduRByVTv99my7yQ874,2357
-gunicorn/reloader.py,sha256=CPNfYAAvJHazX3NAM7qysSRt0fpiHBGPqBlB0tYKhxs,3839
-gunicorn/selectors.py,sha256=14_UESrpE3AQKXWKeeAUG9vBTzJ0yTYDGtEo6xOtlDY,18997
-gunicorn/six.py,sha256=6N-6RCENPfBtMpN5UmgDfDKmJebbbuPu_Dk3Zf8ngww,27344
-gunicorn/sock.py,sha256=gX2FsdsOGMCtSHbDXn7lsiYYYRc3roQklIJLip1oZQo,6019
-gunicorn/systemd.py,sha256=ffhv17cdv-hDeFAJi1eAVtJskkVciV6cQU75Q2oplqg,1362
-gunicorn/util.py,sha256=Ns_a8Pf7MkaEi0KbV3GsP9aVQ2a_S45EjSE6Iyg2tYU,16229
-gunicorn/app/__init__.py,sha256=GuqstqdkizeV4HRbd8aGMBn0Q8IDOyRU1wMMNqNe5GY,127
-gunicorn/app/base.py,sha256=LKxyziLMPNlK3qm6dPMieELBqfLfmwBFnn9SB-KBogE,6652
-gunicorn/app/pasterapp.py,sha256=AGzZnUpcpw8O8KrizxTgdJBZ4lQdrHgsV0gdx7FVTs8,6046
-gunicorn/app/wsgiapp.py,sha256=ny71qjegQHl_bGMjNfq_aemPrmGEpH2bMRIdph6bj4Q,1870
-gunicorn/http/__init__.py,sha256=b4TF3x5F0VYOPTOeNYwRGR1EYHBaPMhZRMoNeuD5-n0,277
-gunicorn/http/_sendfile.py,sha256=Eqd-s3HlvLuyfGjqaH_Jk72cAtEV8hQv5tb1M1AqcBU,2217
-gunicorn/http/body.py,sha256=MmlZpj_6oRPj3oPVSMQZr0X3KH6ikntxDnVcLgfekZs,7345
-gunicorn/http/errors.py,sha256=sNjF2lm4m2qyZ9l95_U33FRxPXpxXzjnZyYqWS-hxd4,2850
-gunicorn/http/message.py,sha256=G5po0upwbrTyIggb_IEAItIjSi_aDoWYLPQ62o8pOI4,12257
-gunicorn/http/parser.py,sha256=IRMvp0veP4wL8Z4vgNV72CPydCNPdNNIy9u-DlDvvSo,1294
-gunicorn/http/unreader.py,sha256=s4kDW5euiJPsDuHzCqFXUtHCApqIxpShb9dtAyjJw9Y,2019
-gunicorn/http/wsgi.py,sha256=SETzcFoLggub2aMuGduTVELBwJGg9YvvDbkiFbugkwU,12856
-gunicorn/instrument/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gunicorn/instrument/statsd.py,sha256=5xueDuTZMFtmS8ayGT4sU_OyB9qkEv4Agk-eJwAmhJM,4434
-gunicorn/workers/__init__.py,sha256=arPaAM8HxcK39L2dmDzmMhpK9bsyLOJymuCcBz_qqw0,774
-gunicorn/workers/_gaiohttp.py,sha256=llho90CjwpeAB9ehrYeGmD9VZZAPdcNpVwnrBA3GEZA,5079
-gunicorn/workers/base.py,sha256=nzo4KfCQkO3Y2HKuKVk-xInZUiYay_A5B9e_9NVXU28,9121
-gunicorn/workers/base_async.py,sha256=54VkS3S_wrFD7v3jInhFfkeBhaPnV5UN-cu-i5MoXkc,5575
-gunicorn/workers/gaiohttp.py,sha256=3rhXky6APkhI0D9nwXlogLo_Jd9v98CiEuCy9inzCU4,823
-gunicorn/workers/geventlet.py,sha256=mE-Zw3zh8lOZVaprXcfaoBMmwKeDj6sZzdjmgIsvHXw,4258
-gunicorn/workers/ggevent.py,sha256=OV5KCJ3qlJP5E46sjyWQKGbQ5xGR2SOrZlEtLhIB89s,7412
-gunicorn/workers/gthread.py,sha256=HIoWuylHZfH1wlSh4eZ8wxo1kQ5abvdUaFfKfIsgQvI,12009
-gunicorn/workers/gtornado.py,sha256=LtBWnEX7MNpeGX-YmlBoV1_OOhjkdytFmt1pzOlRPZk,5044
-gunicorn/workers/sync.py,sha256=_vd1JATNLG4MgJppNJG5KWBIzLGYqRzhEAQVz9H11LI,7153
-gunicorn/workers/workertmp.py,sha256=6QINPBrriLvezgkC_hclOOeXLi_owMt_SOA5KPEIN-A,1459
-gunicorn-19.9.0.dist-info/LICENSE.txt,sha256=eJ_hG5Lhyr-890S1_MOSyb1cZ5hgOk6J-SW2M3mE0d8,1136
-gunicorn-19.9.0.dist-info/METADATA,sha256=SBjzTcJcbKUR9ev_rvypyWJYU0qgHvm8KzgfG6FtniE,3388
-gunicorn-19.9.0.dist-info/RECORD,,
-gunicorn-19.9.0.dist-info/WHEEL,sha256=gduuPyBvFJQSQ0zdyxF7k0zynDXbIbvg5ZBHoXum5uk,110
-gunicorn-19.9.0.dist-info/entry_points.txt,sha256=XeFINKRdSUKwJwaVSolO24PuV_YeO71IMF-rOra5JO8,184
-gunicorn-19.9.0.dist-info/top_level.txt,sha256=cdMaa2yhxb8do-WioY9qRHUCfwf55YztjwQCncaInoE,9
-../../../bin/gunicorn,sha256=v6clpHxpH3v-pvwYhoxp68OLRQqcku8N4bZBXFPTm54,258
-../../../bin/gunicorn_paster,sha256=GjXnuZdTey4e_Ry9s58urtc9n9dquNDiYUzP4-4zqSU,260
-gunicorn-19.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-gunicorn/__pycache__/reloader.cpython-35.pyc,,
-gunicorn/app/__pycache__/base.cpython-35.pyc,,
-gunicorn/__pycache__/errors.cpython-35.pyc,,
-gunicorn/workers/__pycache__/gaiohttp.cpython-35.pyc,,
-gunicorn/__pycache__/pidfile.cpython-35.pyc,,
-gunicorn/http/__pycache__/body.cpython-35.pyc,,
-gunicorn/__pycache__/config.cpython-35.pyc,,
-gunicorn/http/__pycache__/parser.cpython-35.pyc,,
-gunicorn/__pycache__/debug.cpython-35.pyc,,
-gunicorn/instrument/__pycache__/__init__.cpython-35.pyc,,
-gunicorn/__pycache__/sock.cpython-35.pyc,,
-gunicorn/http/__pycache__/wsgi.cpython-35.pyc,,
-gunicorn/http/__pycache__/__init__.cpython-35.pyc,,
-gunicorn/__pycache__/util.cpython-35.pyc,,
-gunicorn/workers/__pycache__/base_async.cpython-35.pyc,,
-gunicorn/workers/__pycache__/geventlet.cpython-35.pyc,,
-gunicorn/__pycache__/selectors.cpython-35.pyc,,
-gunicorn/http/__pycache__/unreader.cpython-35.pyc,,
-gunicorn/workers/__pycache__/__init__.cpython-35.pyc,,
-gunicorn/workers/__pycache__/_gaiohttp.cpython-35.pyc,,
-gunicorn/__pycache__/__init__.cpython-35.pyc,,
-gunicorn/__pycache__/glogging.cpython-35.pyc,,
-gunicorn/workers/__pycache__/ggevent.cpython-35.pyc,,
-gunicorn/workers/__pycache__/gthread.cpython-35.pyc,,
-gunicorn/workers/__pycache__/gtornado.cpython-35.pyc,,
-gunicorn/workers/__pycache__/workertmp.cpython-35.pyc,,
-gunicorn/http/__pycache__/_sendfile.cpython-35.pyc,,
-gunicorn/__pycache__/argparse_compat.cpython-35.pyc,,
-gunicorn/__pycache__/_compat.cpython-35.pyc,,
-gunicorn/http/__pycache__/errors.cpython-35.pyc,,
-gunicorn/__pycache__/arbiter.cpython-35.pyc,,
-gunicorn/app/__pycache__/pasterapp.cpython-35.pyc,,
-gunicorn/__pycache__/six.cpython-35.pyc,,
-gunicorn/__pycache__/systemd.cpython-35.pyc,,
-gunicorn/workers/__pycache__/sync.cpython-35.pyc,,
-gunicorn/instrument/__pycache__/statsd.cpython-35.pyc,,
-gunicorn/http/__pycache__/message.cpython-35.pyc,,
-gunicorn/workers/__pycache__/base.cpython-35.pyc,,
-gunicorn/app/__pycache__/wsgiapp.cpython-35.pyc,,
-gunicorn/app/__pycache__/__init__.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/WHEEL
deleted file mode 100644
index 1316c41d0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.31.1)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/entry_points.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/entry_points.txt
deleted file mode 100644
index d5b5aa1d6..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/entry_points.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-
-    [console_scripts]
-    gunicorn=gunicorn.app.wsgiapp:run
-    gunicorn_paster=gunicorn.app.pasterapp:run
-
-    [paste.server_runner]
-    main=gunicorn.app.pasterapp:paste_server
-    
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/top_level.txt
deleted file mode 100644
index 8f22dccf9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn-19.9.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-gunicorn
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__init__.py
deleted file mode 100644
index 78204797b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-version_info = (19, 9, 0)
-__version__ = ".".join([str(v) for v in version_info])
-SERVER_SOFTWARE = "gunicorn/%s" % __version__
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a9481b748..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 614991109..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/arbiter.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/arbiter.cpython-35.pyc
deleted file mode 100644
index e11c5c627..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/arbiter.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/argparse_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/argparse_compat.cpython-35.pyc
deleted file mode 100644
index 46022aba5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/argparse_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/config.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/config.cpython-35.pyc
deleted file mode 100644
index 90d02ceb3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/config.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/debug.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/debug.cpython-35.pyc
deleted file mode 100644
index bec4972e2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/debug.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/errors.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/errors.cpython-35.pyc
deleted file mode 100644
index 86fd2142b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/errors.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/glogging.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/glogging.cpython-35.pyc
deleted file mode 100644
index 5a923b05f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/glogging.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/pidfile.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/pidfile.cpython-35.pyc
deleted file mode 100644
index bbc5282e9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/pidfile.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/reloader.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/reloader.cpython-35.pyc
deleted file mode 100644
index 3dd7e8d90..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/reloader.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/selectors.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/selectors.cpython-35.pyc
deleted file mode 100644
index 7625c6bd2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/selectors.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/six.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/six.cpython-35.pyc
deleted file mode 100644
index 028b75804..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/six.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/sock.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/sock.cpython-35.pyc
deleted file mode 100644
index e22b2d359..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/sock.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/systemd.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/systemd.cpython-35.pyc
deleted file mode 100644
index 93e8f9a93..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/systemd.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/util.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/util.cpython-35.pyc
deleted file mode 100644
index 48b3260b9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/__pycache__/util.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/_compat.py
deleted file mode 100644
index 39dbfdfc5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/_compat.py
+++ /dev/null
@@ -1,298 +0,0 @@
-import sys
-
-from gunicorn import six
-
-PY26 = (sys.version_info[:2] == (2, 6))
-PY33 = (sys.version_info >= (3, 3))
-
-
-def _check_if_pyc(fname):
-    """Return True if the extension is .pyc, False if .py
-    and None if otherwise"""
-    from imp import find_module
-    from os.path import realpath, dirname, basename, splitext
-
-    # Normalize the file-path for the find_module()
-    filepath = realpath(fname)
-    dirpath = dirname(filepath)
-    module_name = splitext(basename(filepath))[0]
-
-    # Validate and fetch
-    try:
-        fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath])
-    except ImportError:
-        raise IOError("Cannot find config file. "
-                      "Path maybe incorrect! : {0}".format(filepath))
-    return pytype, fileobj, fullpath
-
-
-def _get_codeobj(pyfile):
-    """ Returns the code object, given a python file """
-    from imp import PY_COMPILED, PY_SOURCE
-
-    result, fileobj, fullpath = _check_if_pyc(pyfile)
-
-    # WARNING:
-    # fp.read() can blowup if the module is extremely large file.
-    # Lookout for overflow errors.
-    try:
-        data = fileobj.read()
-    finally:
-        fileobj.close()
-
-    # This is a .pyc file. Treat accordingly.
-    if result is PY_COMPILED:
-        # .pyc format is as follows:
-        # 0 - 4 bytes: Magic number, which changes with each create of .pyc file.
-        #              First 2 bytes change with each marshal of .pyc file. Last 2 bytes is "\r\n".
-        # 4 - 8 bytes: Datetime value, when the .py was last changed.
-        # 8 - EOF: Marshalled code object data.
-        # So to get code object, just read the 8th byte onwards till EOF, and
-        # UN-marshal it.
-        import marshal
-        code_obj = marshal.loads(data[8:])
-
-    elif result is PY_SOURCE:
-        # This is a .py file.
-        code_obj = compile(data, fullpath, 'exec')
-
-    else:
-        # Unsupported extension
-        raise Exception("Input file is unknown format: {0}".format(fullpath))
-
-    # Return code object
-    return code_obj
-
-if six.PY3:
-    def execfile_(fname, *args):
-        if fname.endswith(".pyc"):
-            code = _get_codeobj(fname)
-        else:
-            code = compile(open(fname, 'rb').read(), fname, 'exec')
-        return six.exec_(code, *args)
-
-    def bytes_to_str(b):
-        if isinstance(b, six.text_type):
-            return b
-        return str(b, 'latin1')
-
-    import urllib.parse
-
-    def unquote_to_wsgi_str(string):
-        return _unquote_to_bytes(string).decode('latin-1')
-
-    _unquote_to_bytes = urllib.parse.unquote_to_bytes
-
-else:
-    def execfile_(fname, *args):
-        """ Overriding PY2 execfile() implementation to support .pyc files """
-        if fname.endswith(".pyc"):
-            return six.exec_(_get_codeobj(fname), *args)
-        return execfile(fname, *args)
-
-    def bytes_to_str(s):
-        if isinstance(s, unicode):
-            return s.encode('utf-8')
-        return s
-
-    import urllib
-    unquote_to_wsgi_str = urllib.unquote
-
-
-# The following code adapted from trollius.py33_exceptions
-def _wrap_error(exc, mapping, key):
-    if key not in mapping:
-        return
-    new_err_cls = mapping[key]
-    new_err = new_err_cls(*exc.args)
-
-    # raise a new exception with the original traceback
-    six.reraise(new_err_cls, new_err,
-                exc.__traceback__ if hasattr(exc, '__traceback__') else sys.exc_info()[2])
-
-if PY33:
-    import builtins
-
-    BlockingIOError = builtins.BlockingIOError
-    BrokenPipeError = builtins.BrokenPipeError
-    ChildProcessError = builtins.ChildProcessError
-    ConnectionRefusedError = builtins.ConnectionRefusedError
-    ConnectionResetError = builtins.ConnectionResetError
-    InterruptedError = builtins.InterruptedError
-    ConnectionAbortedError = builtins.ConnectionAbortedError
-    PermissionError = builtins.PermissionError
-    FileNotFoundError = builtins.FileNotFoundError
-    ProcessLookupError = builtins.ProcessLookupError
-
-    def wrap_error(func, *args, **kw):
-        return func(*args, **kw)
-else:
-    import errno
-    import select
-    import socket
-
-    class BlockingIOError(OSError):
-        pass
-
-    class BrokenPipeError(OSError):
-        pass
-
-    class ChildProcessError(OSError):
-        pass
-
-    class ConnectionRefusedError(OSError):
-        pass
-
-    class InterruptedError(OSError):
-        pass
-
-    class ConnectionResetError(OSError):
-        pass
-
-    class ConnectionAbortedError(OSError):
-        pass
-
-    class PermissionError(OSError):
-        pass
-
-    class FileNotFoundError(OSError):
-        pass
-
-    class ProcessLookupError(OSError):
-        pass
-
-    _MAP_ERRNO = {
-        errno.EACCES: PermissionError,
-        errno.EAGAIN: BlockingIOError,
-        errno.EALREADY: BlockingIOError,
-        errno.ECHILD: ChildProcessError,
-        errno.ECONNABORTED: ConnectionAbortedError,
-        errno.ECONNREFUSED: ConnectionRefusedError,
-        errno.ECONNRESET: ConnectionResetError,
-        errno.EINPROGRESS: BlockingIOError,
-        errno.EINTR: InterruptedError,
-        errno.ENOENT: FileNotFoundError,
-        errno.EPERM: PermissionError,
-        errno.EPIPE: BrokenPipeError,
-        errno.ESHUTDOWN: BrokenPipeError,
-        errno.EWOULDBLOCK: BlockingIOError,
-        errno.ESRCH: ProcessLookupError,
-    }
-
-    def wrap_error(func, *args, **kw):
-        """
-        Wrap socket.error, IOError, OSError, select.error to raise new specialized
-        exceptions of Python 3.3 like InterruptedError (PEP 3151).
-        """
-        try:
-            return func(*args, **kw)
-        except (socket.error, IOError, OSError) as exc:
-            if hasattr(exc, 'winerror'):
-                _wrap_error(exc, _MAP_ERRNO, exc.winerror)
-                # _MAP_ERRNO does not contain all Windows errors.
-                # For some errors like "file not found", exc.errno should
-                # be used (ex: ENOENT).
-            _wrap_error(exc, _MAP_ERRNO, exc.errno)
-            raise
-        except select.error as exc:
-            if exc.args:
-                _wrap_error(exc, _MAP_ERRNO, exc.args[0])
-            raise
-
-if PY26:
-    from urlparse import (
-        _parse_cache, MAX_CACHE_SIZE, clear_cache, _splitnetloc, SplitResult,
-        scheme_chars,
-    )
-
-    def urlsplit(url, scheme='', allow_fragments=True):
-        """Parse a URL into 5 components:
-        <scheme>://<netloc>/<path>?<query>#<fragment>
-        Return a 5-tuple: (scheme, netloc, path, query, fragment).
-        Note that we don't break the components up in smaller bits
-        (e.g. netloc is a single string) and we don't expand % escapes."""
-        allow_fragments = bool(allow_fragments)
-        key = url, scheme, allow_fragments, type(url), type(scheme)
-        cached = _parse_cache.get(key, None)
-        if cached:
-            return cached
-        if len(_parse_cache) >= MAX_CACHE_SIZE: # avoid runaway growth
-            clear_cache()
-        netloc = query = fragment = ''
-        i = url.find(':')
-        if i > 0:
-            if url[:i] == 'http': # optimize the common case
-                scheme = url[:i].lower()
-                url = url[i+1:]
-                if url[:2] == '//':
-                    netloc, url = _splitnetloc(url, 2)
-                    if (('[' in netloc and ']' not in netloc) or
-                            (']' in netloc and '[' not in netloc)):
-                        raise ValueError("Invalid IPv6 URL")
-                if allow_fragments and '#' in url:
-                    url, fragment = url.split('#', 1)
-                if '?' in url:
-                    url, query = url.split('?', 1)
-                v = SplitResult(scheme, netloc, url, query, fragment)
-                _parse_cache[key] = v
-                return v
-            for c in url[:i]:
-                if c not in scheme_chars:
-                    break
-            else:
-                # make sure "url" is not actually a port number (in which case
-                # "scheme" is really part of the path)
-                rest = url[i+1:]
-                if not rest or any(c not in '0123456789' for c in rest):
-                    # not a port number
-                    scheme, url = url[:i].lower(), rest
-
-        if url[:2] == '//':
-            netloc, url = _splitnetloc(url, 2)
-            if (('[' in netloc and ']' not in netloc) or
-                    (']' in netloc and '[' not in netloc)):
-                raise ValueError("Invalid IPv6 URL")
-        if allow_fragments and '#' in url:
-            url, fragment = url.split('#', 1)
-        if '?' in url:
-            url, query = url.split('?', 1)
-        v = SplitResult(scheme, netloc, url, query, fragment)
-        _parse_cache[key] = v
-        return v
-
-else:
-    from gunicorn.six.moves.urllib.parse import urlsplit
-
-
-import inspect
-
-if hasattr(inspect, 'signature'):
-    positionals = (
-        inspect.Parameter.POSITIONAL_ONLY,
-        inspect.Parameter.POSITIONAL_OR_KEYWORD,
-    )
-
-    def get_arity(f):
-        sig = inspect.signature(f)
-        arity = 0
-
-        for param in sig.parameters.values():
-            if param.kind in positionals:
-                arity += 1
-
-        return arity
-else:
-    def get_arity(f):
-        return len(inspect.getargspec(f)[0])
-
-
-try:
-    import html
-
-    def html_escape(s):
-        return html.escape(s)
-except ImportError:
-    import cgi
-
-    def html_escape(s):
-        return cgi.escape(s, quote=True)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__init__.py
deleted file mode 100644
index 87f06117b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 7148dd169..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/base.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/base.cpython-35.pyc
deleted file mode 100644
index 18c9c4a1a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/base.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/pasterapp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/pasterapp.cpython-35.pyc
deleted file mode 100644
index d48b79cf5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/pasterapp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-35.pyc
deleted file mode 100644
index 7e11481ce..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/__pycache__/wsgiapp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/base.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/base.py
deleted file mode 100644
index e468c9562..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/base.py
+++ /dev/null
@@ -1,223 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-from __future__ import print_function
-
-import os
-import sys
-import traceback
-
-from gunicorn._compat import execfile_
-from gunicorn import util
-from gunicorn.arbiter import Arbiter
-from gunicorn.config import Config, get_default_config_file
-from gunicorn import debug
-
-class BaseApplication(object):
-    """
-    An application interface for configuring and loading
-    the various necessities for any given web framework.
-    """
-    def __init__(self, usage=None, prog=None):
-        self.usage = usage
-        self.cfg = None
-        self.callable = None
-        self.prog = prog
-        self.logger = None
-        self.do_load_config()
-
-    def do_load_config(self):
-        """
-        Loads the configuration
-        """
-        try:
-            self.load_default_config()
-            self.load_config()
-        except Exception as e:
-            print("\nError: %s" % str(e), file=sys.stderr)
-            sys.stderr.flush()
-            sys.exit(1)
-
-    def load_default_config(self):
-        # init configuration
-        self.cfg = Config(self.usage, prog=self.prog)
-
-    def init(self, parser, opts, args):
-        raise NotImplementedError
-
-    def load(self):
-        raise NotImplementedError
-
-    def load_config(self):
-        """
-        This method is used to load the configuration from one or several input(s).
-        Custom Command line, configuration file.
-        You have to override this method in your class.
-        """
-        raise NotImplementedError
-
-    def reload(self):
-        self.do_load_config()
-        if self.cfg.spew:
-            debug.spew()
-
-    def wsgi(self):
-        if self.callable is None:
-            self.callable = self.load()
-        return self.callable
-
-    def run(self):
-        try:
-            Arbiter(self).run()
-        except RuntimeError as e:
-            print("\nError: %s\n" % e, file=sys.stderr)
-            sys.stderr.flush()
-            sys.exit(1)
-
-
-class Application(BaseApplication):
-
-    # 'init' and 'load' methods are implemented by WSGIApplication.
-    # pylint: disable=abstract-method
-
-    def chdir(self):
-        # chdir to the configured path before loading,
-        # default is the current dir
-        os.chdir(self.cfg.chdir)
-
-        # add the path to sys.path
-        if self.cfg.chdir not in sys.path:
-            sys.path.insert(0, self.cfg.chdir)
-
-    def get_config_from_filename(self, filename):
-
-        if not os.path.exists(filename):
-            raise RuntimeError("%r doesn't exist" % filename)
-
-        cfg = {
-            "__builtins__": __builtins__,
-            "__name__": "__config__",
-            "__file__": filename,
-            "__doc__": None,
-            "__package__": None
-        }
-        try:
-            execfile_(filename, cfg, cfg)
-        except Exception:
-            print("Failed to read config file: %s" % filename, file=sys.stderr)
-            traceback.print_exc()
-            sys.stderr.flush()
-            sys.exit(1)
-
-        return cfg
-
-    def get_config_from_module_name(self, module_name):
-        return vars(util.import_module(module_name))
-
-    def load_config_from_module_name_or_filename(self, location):
-        """
-        Loads the configuration file: the file is a python file, otherwise raise an RuntimeError
-        Exception or stop the process if the configuration file contains a syntax error.
-        """
-
-        if location.startswith("python:"):
-            module_name = location[len("python:"):]
-            cfg = self.get_config_from_module_name(module_name)
-        else:
-            if location.startswith("file:"):
-                filename = location[len("file:"):]
-            else:
-                filename = location
-            cfg = self.get_config_from_filename(filename)
-
-        for k, v in cfg.items():
-            # Ignore unknown names
-            if k not in self.cfg.settings:
-                continue
-            try:
-                self.cfg.set(k.lower(), v)
-            except:
-                print("Invalid value for %s: %s\n" % (k, v), file=sys.stderr)
-                sys.stderr.flush()
-                raise
-
-        return cfg
-
-    def load_config_from_file(self, filename):
-        return self.load_config_from_module_name_or_filename(location=filename)
-
-    def load_config(self):
-        # parse console args
-        parser = self.cfg.parser()
-        args = parser.parse_args()
-
-        # optional settings from apps
-        cfg = self.init(parser, args, args.args)
-
-        # set up import paths and follow symlinks
-        self.chdir()
-
-        # Load up the any app specific configuration
-        if cfg:
-            for k, v in cfg.items():
-                self.cfg.set(k.lower(), v)
-
-        env_args = parser.parse_args(self.cfg.get_cmd_args_from_env())
-
-        if args.config:
-            self.load_config_from_file(args.config)
-        elif env_args.config:
-            self.load_config_from_file(env_args.config)
-        else:
-            default_config = get_default_config_file()
-            if default_config is not None:
-                self.load_config_from_file(default_config)
-
-        # Load up environment configuration
-        for k, v in vars(env_args).items():
-            if v is None:
-                continue
-            if k == "args":
-                continue
-            self.cfg.set(k.lower(), v)
-
-        # Lastly, update the configuration with any command line settings.
-        for k, v in vars(args).items():
-            if v is None:
-                continue
-            if k == "args":
-                continue
-            self.cfg.set(k.lower(), v)
-
-        # current directory might be changed by the config now
-        # set up import paths and follow symlinks
-        self.chdir()
-
-    def run(self):
-        if self.cfg.check_config:
-            try:
-                self.load()
-            except:
-                msg = "\nError while loading the application:\n"
-                print(msg, file=sys.stderr)
-                traceback.print_exc()
-                sys.stderr.flush()
-                sys.exit(1)
-            sys.exit(0)
-
-        if self.cfg.spew:
-            debug.spew()
-
-        if self.cfg.daemon:
-            util.daemonize(self.cfg.enable_stdio_inheritance)
-
-        # set python paths
-        if self.cfg.pythonpath:
-            paths = self.cfg.pythonpath.split(",")
-            for path in paths:
-                pythonpath = os.path.abspath(path)
-                if pythonpath not in sys.path:
-                    sys.path.insert(0, pythonpath)
-
-        super(Application, self).run()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/pasterapp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/pasterapp.py
deleted file mode 100644
index dbcd339dc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/pasterapp.py
+++ /dev/null
@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-from __future__ import print_function
-
-# pylint: skip-file
-
-import os
-import pkg_resources
-import sys
-
-try:
-    import configparser as ConfigParser
-except ImportError:
-    import ConfigParser
-
-from paste.deploy import loadapp, loadwsgi
-SERVER = loadwsgi.SERVER
-
-from gunicorn.app.base import Application
-from gunicorn.config import Config, get_default_config_file
-from gunicorn import util
-
-
-def _has_logging_config(paste_file):
-    cfg_parser = ConfigParser.ConfigParser()
-    cfg_parser.read([paste_file])
-    return cfg_parser.has_section('loggers')
-
-
-def paste_config(gconfig, config_url, relative_to, global_conf=None):
-    # add entry to pkg_resources
-    sys.path.insert(0, relative_to)
-    pkg_resources.working_set.add_entry(relative_to)
-
-    config_url = config_url.split('#')[0]
-    cx = loadwsgi.loadcontext(SERVER, config_url, relative_to=relative_to,
-                              global_conf=global_conf)
-    gc, lc = cx.global_conf.copy(), cx.local_conf.copy()
-    cfg = {}
-
-    host, port = lc.pop('host', ''), lc.pop('port', '')
-    if host and port:
-        cfg['bind'] = '%s:%s' % (host, port)
-    elif host:
-        cfg['bind'] = host.split(',')
-
-    cfg['default_proc_name'] = gc.get('__file__')
-
-    # init logging configuration
-    config_file = config_url.split(':')[1]
-    if _has_logging_config(config_file):
-        cfg.setdefault('logconfig', config_file)
-
-    for k, v in gc.items():
-        if k not in gconfig.settings:
-            continue
-        cfg[k] = v
-
-    for k, v in lc.items():
-        if k not in gconfig.settings:
-            continue
-        cfg[k] = v
-
-    return cfg
-
-
-def load_pasteapp(config_url, relative_to, global_conf=None):
-    return loadapp(config_url, relative_to=relative_to,
-            global_conf=global_conf)
-
-class PasterBaseApplication(Application):
-    gcfg = None
-
-    def app_config(self):
-        return paste_config(self.cfg, self.cfgurl, self.relpath,
-                global_conf=self.gcfg)
-
-    def load_config(self):
-        super(PasterBaseApplication, self).load_config()
-
-        # reload logging conf
-        if hasattr(self, "cfgfname"):
-            parser = ConfigParser.ConfigParser()
-            parser.read([self.cfgfname])
-            if parser.has_section('loggers'):
-                from logging.config import fileConfig
-                config_file = os.path.abspath(self.cfgfname)
-                fileConfig(config_file, dict(__file__=config_file,
-                                             here=os.path.dirname(config_file)))
-
-
-class PasterApplication(PasterBaseApplication):
-
-    def init(self, parser, opts, args):
-        if len(args) != 1:
-            parser.error("No application name specified.")
-
-        cwd = util.getcwd()
-        cfgfname = os.path.normpath(os.path.join(cwd, args[0]))
-        cfgfname = os.path.abspath(cfgfname)
-        if not os.path.exists(cfgfname):
-            parser.error("Config file not found: %s" % cfgfname)
-
-        self.cfgurl = 'config:%s' % cfgfname
-        self.relpath = os.path.dirname(cfgfname)
-        self.cfgfname = cfgfname
-
-        sys.path.insert(0, self.relpath)
-        pkg_resources.working_set.add_entry(self.relpath)
-
-        return self.app_config()
-
-    def load(self):
-        # chdir to the configured path before loading,
-        # default is the current dir
-        os.chdir(self.cfg.chdir)
-
-        return load_pasteapp(self.cfgurl, self.relpath, global_conf=self.gcfg)
-
-
-class PasterServerApplication(PasterBaseApplication):
-
-    def __init__(self, app, gcfg=None, host="127.0.0.1", port=None, **kwargs):
-        # pylint: disable=super-init-not-called
-        self.cfg = Config()
-        self.gcfg = gcfg  # need to hold this for app_config
-        self.app = app
-        self.callable = None
-
-        gcfg = gcfg or {}
-        cfgfname = gcfg.get("__file__")
-        if cfgfname is not None:
-            self.cfgurl = 'config:%s' % cfgfname
-            self.relpath = os.path.dirname(cfgfname)
-            self.cfgfname = cfgfname
-
-        cfg = kwargs.copy()
-
-        if port and not host.startswith("unix:"):
-            bind = "%s:%s" % (host, port)
-        else:
-            bind = host
-        cfg["bind"] = bind.split(',')
-
-        if gcfg:
-            for k, v in gcfg.items():
-                cfg[k] = v
-            cfg["default_proc_name"] = cfg['__file__']
-
-        try:
-            for k, v in cfg.items():
-                if k.lower() in self.cfg.settings and v is not None:
-                    self.cfg.set(k.lower(), v)
-        except Exception as e:
-            print("\nConfig error: %s" % str(e), file=sys.stderr)
-            sys.stderr.flush()
-            sys.exit(1)
-
-        if cfg.get("config"):
-            self.load_config_from_file(cfg["config"])
-        else:
-            default_config = get_default_config_file()
-            if default_config is not None:
-                self.load_config_from_file(default_config)
-
-    def load(self):
-        return self.app
-
-
-def run():
-    """\
-    The ``gunicorn_paster`` command for launching Paster compatible
-    applications like Pylons or Turbogears2
-    """
-    util.warn("""This command is deprecated.
-
-    You should now use the `--paste` option. Ex.:
-
-        gunicorn --paste development.ini
-    """)
-
-    from gunicorn.app.pasterapp import PasterApplication
-    PasterApplication("%(prog)s [OPTIONS] pasteconfig.ini").run()
-
-
-def paste_server(app, gcfg=None, host="127.0.0.1", port=None, **kwargs):
-    """\
-    A paster server.
-
-    Then entry point in your paster ini file should looks like this:
-
-    [server:main]
-    use = egg:gunicorn#main
-    host = 127.0.0.1
-    port = 5000
-
-    """
-
-    util.warn("""This command is deprecated.
-
-    You should now use the `--paste` option. Ex.:
-
-        gunicorn --paste development.ini
-    """)
-
-    from gunicorn.app.pasterapp import PasterServerApplication
-    PasterServerApplication(app, gcfg=gcfg, host=host, port=port, **kwargs).run()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/wsgiapp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/wsgiapp.py
deleted file mode 100644
index 2205944cd..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/app/wsgiapp.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import os
-
-from gunicorn.errors import ConfigError
-from gunicorn.app.base import Application
-from gunicorn import util
-
-
-class WSGIApplication(Application):
-    def init(self, parser, opts, args):
-        if opts.paste:
-            app_name = 'main'
-            path = opts.paste
-            if '#' in path:
-                path, app_name = path.split('#')
-            path = os.path.abspath(os.path.normpath(
-                os.path.join(util.getcwd(), path)))
-
-            if not os.path.exists(path):
-                raise ConfigError("%r not found" % path)
-
-            # paste application, load the config
-            self.cfgurl = 'config:%s#%s' % (path, app_name)
-            self.relpath = os.path.dirname(path)
-
-            from .pasterapp import paste_config
-            return paste_config(self.cfg, self.cfgurl, self.relpath)
-
-        if len(args) < 1:
-            parser.error("No application module specified.")
-
-        self.cfg.set("default_proc_name", args[0])
-        self.app_uri = args[0]
-
-    def load_wsgiapp(self):
-        # load the app
-        return util.import_app(self.app_uri)
-
-    def load_pasteapp(self):
-        # load the paste app
-        from .pasterapp import load_pasteapp
-        return load_pasteapp(self.cfgurl, self.relpath, global_conf=self.cfg.paste_global_conf)
-
-    def load(self):
-        if self.cfg.paste is not None:
-            return self.load_pasteapp()
-        else:
-            return self.load_wsgiapp()
-
-
-def run():
-    """\
-    The ``gunicorn`` command line runner for launching Gunicorn with
-    generic WSGI applications.
-    """
-    from gunicorn.app.wsgiapp import WSGIApplication
-    WSGIApplication("%(prog)s [OPTIONS] [APP_MODULE]").run()
-
-
-if __name__ == '__main__':
-    run()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/arbiter.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/arbiter.py
deleted file mode 100644
index 083ee6a05..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/arbiter.py
+++ /dev/null
@@ -1,646 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-from __future__ import print_function
-
-import errno
-import os
-import random
-import select
-import signal
-import sys
-import time
-import traceback
-
-from gunicorn.errors import HaltServer, AppImportError
-from gunicorn.pidfile import Pidfile
-from gunicorn import sock, systemd, util
-
-from gunicorn import __version__, SERVER_SOFTWARE
-
-
-class Arbiter(object):
-    """
-    Arbiter maintain the workers processes alive. It launches or
-    kills them if needed. It also manages application reloading
-    via SIGHUP/USR2.
-    """
-
-    # A flag indicating if a worker failed to
-    # to boot. If a worker process exist with
-    # this error code, the arbiter will terminate.
-    WORKER_BOOT_ERROR = 3
-
-    # A flag indicating if an application failed to be loaded
-    APP_LOAD_ERROR = 4
-
-    START_CTX = {}
-
-    LISTENERS = []
-    WORKERS = {}
-    PIPE = []
-
-    # I love dynamic languages
-    SIG_QUEUE = []
-    SIGNALS = [getattr(signal, "SIG%s" % x)
-               for x in "HUP QUIT INT TERM TTIN TTOU USR1 USR2 WINCH".split()]
-    SIG_NAMES = dict(
-        (getattr(signal, name), name[3:].lower()) for name in dir(signal)
-        if name[:3] == "SIG" and name[3] != "_"
-    )
-
-    def __init__(self, app):
-        os.environ["SERVER_SOFTWARE"] = SERVER_SOFTWARE
-
-        self._num_workers = None
-        self._last_logged_active_worker_count = None
-        self.log = None
-
-        self.setup(app)
-
-        self.pidfile = None
-        self.systemd = False
-        self.worker_age = 0
-        self.reexec_pid = 0
-        self.master_pid = 0
-        self.master_name = "Master"
-
-        cwd = util.getcwd()
-
-        args = sys.argv[:]
-        args.insert(0, sys.executable)
-
-        # init start context
-        self.START_CTX = {
-            "args": args,
-            "cwd": cwd,
-            0: sys.executable
-        }
-
-    def _get_num_workers(self):
-        return self._num_workers
-
-    def _set_num_workers(self, value):
-        old_value = self._num_workers
-        self._num_workers = value
-        self.cfg.nworkers_changed(self, value, old_value)
-    num_workers = property(_get_num_workers, _set_num_workers)
-
-    def setup(self, app):
-        self.app = app
-        self.cfg = app.cfg
-
-        if self.log is None:
-            self.log = self.cfg.logger_class(app.cfg)
-
-        # reopen files
-        if 'GUNICORN_FD' in os.environ:
-            self.log.reopen_files()
-
-        self.worker_class = self.cfg.worker_class
-        self.address = self.cfg.address
-        self.num_workers = self.cfg.workers
-        self.timeout = self.cfg.timeout
-        self.proc_name = self.cfg.proc_name
-
-        self.log.debug('Current configuration:\n{0}'.format(
-            '\n'.join(
-                '  {0}: {1}'.format(config, value.value)
-                for config, value
-                in sorted(self.cfg.settings.items(),
-                          key=lambda setting: setting[1]))))
-
-        # set enviroment' variables
-        if self.cfg.env:
-            for k, v in self.cfg.env.items():
-                os.environ[k] = v
-
-        if self.cfg.preload_app:
-            self.app.wsgi()
-
-    def start(self):
-        """\
-        Initialize the arbiter. Start listening and set pidfile if needed.
-        """
-        self.log.info("Starting gunicorn %s", __version__)
-
-        if 'GUNICORN_PID' in os.environ:
-            self.master_pid = int(os.environ.get('GUNICORN_PID'))
-            self.proc_name = self.proc_name + ".2"
-            self.master_name = "Master.2"
-
-        self.pid = os.getpid()
-        if self.cfg.pidfile is not None:
-            pidname = self.cfg.pidfile
-            if self.master_pid != 0:
-                pidname += ".2"
-            self.pidfile = Pidfile(pidname)
-            self.pidfile.create(self.pid)
-        self.cfg.on_starting(self)
-
-        self.init_signals()
-
-        if not self.LISTENERS:
-            fds = None
-            listen_fds = systemd.listen_fds()
-            if listen_fds:
-                self.systemd = True
-                fds = range(systemd.SD_LISTEN_FDS_START,
-                            systemd.SD_LISTEN_FDS_START + listen_fds)
-
-            elif self.master_pid:
-                fds = []
-                for fd in os.environ.pop('GUNICORN_FD').split(','):
-                    fds.append(int(fd))
-
-            self.LISTENERS = sock.create_sockets(self.cfg, self.log, fds)
-
-        listeners_str = ",".join([str(l) for l in self.LISTENERS])
-        self.log.debug("Arbiter booted")
-        self.log.info("Listening at: %s (%s)", listeners_str, self.pid)
-        self.log.info("Using worker: %s", self.cfg.worker_class_str)
-
-        # check worker class requirements
-        if hasattr(self.worker_class, "check_config"):
-            self.worker_class.check_config(self.cfg, self.log)
-
-        self.cfg.when_ready(self)
-
-    def init_signals(self):
-        """\
-        Initialize master signal handling. Most of the signals
-        are queued. Child signals only wake up the master.
-        """
-        # close old PIPE
-        for p in self.PIPE:
-            os.close(p)
-
-        # initialize the pipe
-        self.PIPE = pair = os.pipe()
-        for p in pair:
-            util.set_non_blocking(p)
-            util.close_on_exec(p)
-
-        self.log.close_on_exec()
-
-        # initialize all signals
-        for s in self.SIGNALS:
-            signal.signal(s, self.signal)
-        signal.signal(signal.SIGCHLD, self.handle_chld)
-
-    def signal(self, sig, frame):
-        if len(self.SIG_QUEUE) < 5:
-            self.SIG_QUEUE.append(sig)
-            self.wakeup()
-
-    def run(self):
-        "Main master loop."
-        self.start()
-        util._setproctitle("master [%s]" % self.proc_name)
-
-        try:
-            self.manage_workers()
-
-            while True:
-                self.maybe_promote_master()
-
-                sig = self.SIG_QUEUE.pop(0) if self.SIG_QUEUE else None
-                if sig is None:
-                    self.sleep()
-                    self.murder_workers()
-                    self.manage_workers()
-                    continue
-
-                if sig not in self.SIG_NAMES:
-                    self.log.info("Ignoring unknown signal: %s", sig)
-                    continue
-
-                signame = self.SIG_NAMES.get(sig)
-                handler = getattr(self, "handle_%s" % signame, None)
-                if not handler:
-                    self.log.error("Unhandled signal: %s", signame)
-                    continue
-                self.log.info("Handling signal: %s", signame)
-                handler()
-                self.wakeup()
-        except StopIteration:
-            self.halt()
-        except KeyboardInterrupt:
-            self.halt()
-        except HaltServer as inst:
-            self.halt(reason=inst.reason, exit_status=inst.exit_status)
-        except SystemExit:
-            raise
-        except Exception:
-            self.log.info("Unhandled exception in main loop",
-                          exc_info=True)
-            self.stop(False)
-            if self.pidfile is not None:
-                self.pidfile.unlink()
-            sys.exit(-1)
-
-    def handle_chld(self, sig, frame):
-        "SIGCHLD handling"
-        self.reap_workers()
-        self.wakeup()
-
-    def handle_hup(self):
-        """\
-        HUP handling.
-        - Reload configuration
-        - Start the new worker processes with a new configuration
-        - Gracefully shutdown the old worker processes
-        """
-        self.log.info("Hang up: %s", self.master_name)
-        self.reload()
-
-    def handle_term(self):
-        "SIGTERM handling"
-        raise StopIteration
-
-    def handle_int(self):
-        "SIGINT handling"
-        self.stop(False)
-        raise StopIteration
-
-    def handle_quit(self):
-        "SIGQUIT handling"
-        self.stop(False)
-        raise StopIteration
-
-    def handle_ttin(self):
-        """\
-        SIGTTIN handling.
-        Increases the number of workers by one.
-        """
-        self.num_workers += 1
-        self.manage_workers()
-
-    def handle_ttou(self):
-        """\
-        SIGTTOU handling.
-        Decreases the number of workers by one.
-        """
-        if self.num_workers <= 1:
-            return
-        self.num_workers -= 1
-        self.manage_workers()
-
-    def handle_usr1(self):
-        """\
-        SIGUSR1 handling.
-        Kill all workers by sending them a SIGUSR1
-        """
-        self.log.reopen_files()
-        self.kill_workers(signal.SIGUSR1)
-
-    def handle_usr2(self):
-        """\
-        SIGUSR2 handling.
-        Creates a new master/worker set as a slave of the current
-        master without affecting old workers. Use this to do live
-        deployment with the ability to backout a change.
-        """
-        self.reexec()
-
-    def handle_winch(self):
-        """SIGWINCH handling"""
-        if self.cfg.daemon:
-            self.log.info("graceful stop of workers")
-            self.num_workers = 0
-            self.kill_workers(signal.SIGTERM)
-        else:
-            self.log.debug("SIGWINCH ignored. Not daemonized")
-
-    def maybe_promote_master(self):
-        if self.master_pid == 0:
-            return
-
-        if self.master_pid != os.getppid():
-            self.log.info("Master has been promoted.")
-            # reset master infos
-            self.master_name = "Master"
-            self.master_pid = 0
-            self.proc_name = self.cfg.proc_name
-            del os.environ['GUNICORN_PID']
-            # rename the pidfile
-            if self.pidfile is not None:
-                self.pidfile.rename(self.cfg.pidfile)
-            # reset proctitle
-            util._setproctitle("master [%s]" % self.proc_name)
-
-    def wakeup(self):
-        """\
-        Wake up the arbiter by writing to the PIPE
-        """
-        try:
-            os.write(self.PIPE[1], b'.')
-        except IOError as e:
-            if e.errno not in [errno.EAGAIN, errno.EINTR]:
-                raise
-
-    def halt(self, reason=None, exit_status=0):
-        """ halt arbiter """
-        self.stop()
-        self.log.info("Shutting down: %s", self.master_name)
-        if reason is not None:
-            self.log.info("Reason: %s", reason)
-        if self.pidfile is not None:
-            self.pidfile.unlink()
-        self.cfg.on_exit(self)
-        sys.exit(exit_status)
-
-    def sleep(self):
-        """\
-        Sleep until PIPE is readable or we timeout.
-        A readable PIPE means a signal occurred.
-        """
-        try:
-            ready = select.select([self.PIPE[0]], [], [], 1.0)
-            if not ready[0]:
-                return
-            while os.read(self.PIPE[0], 1):
-                pass
-        except (select.error, OSError) as e:
-            # TODO: select.error is a subclass of OSError since Python 3.3.
-            error_number = getattr(e, 'errno', e.args[0])
-            if error_number not in [errno.EAGAIN, errno.EINTR]:
-                raise
-        except KeyboardInterrupt:
-            sys.exit()
-
-    def stop(self, graceful=True):
-        """\
-        Stop workers
-
-        :attr graceful: boolean, If True (the default) workers will be
-        killed gracefully  (ie. trying to wait for the current connection)
-        """
-
-        unlink = self.reexec_pid == self.master_pid == 0 and not self.systemd
-        sock.close_sockets(self.LISTENERS, unlink)
-
-        self.LISTENERS = []
-        sig = signal.SIGTERM
-        if not graceful:
-            sig = signal.SIGQUIT
-        limit = time.time() + self.cfg.graceful_timeout
-        # instruct the workers to exit
-        self.kill_workers(sig)
-        # wait until the graceful timeout
-        while self.WORKERS and time.time() < limit:
-            time.sleep(0.1)
-
-        self.kill_workers(signal.SIGKILL)
-
-    def reexec(self):
-        """\
-        Relaunch the master and workers.
-        """
-        if self.reexec_pid != 0:
-            self.log.warning("USR2 signal ignored. Child exists.")
-            return
-
-        if self.master_pid != 0:
-            self.log.warning("USR2 signal ignored. Parent exists.")
-            return
-
-        master_pid = os.getpid()
-        self.reexec_pid = os.fork()
-        if self.reexec_pid != 0:
-            return
-
-        self.cfg.pre_exec(self)
-
-        environ = self.cfg.env_orig.copy()
-        environ['GUNICORN_PID'] = str(master_pid)
-
-        if self.systemd:
-            environ['LISTEN_PID'] = str(os.getpid())
-            environ['LISTEN_FDS'] = str(len(self.LISTENERS))
-        else:
-            environ['GUNICORN_FD'] = ','.join(
-                str(l.fileno()) for l in self.LISTENERS)
-
-        os.chdir(self.START_CTX['cwd'])
-
-        # exec the process using the original environment
-        os.execvpe(self.START_CTX[0], self.START_CTX['args'], environ)
-
-    def reload(self):
-        old_address = self.cfg.address
-
-        # reset old environment
-        for k in self.cfg.env:
-            if k in self.cfg.env_orig:
-                # reset the key to the value it had before
-                # we launched gunicorn
-                os.environ[k] = self.cfg.env_orig[k]
-            else:
-                # delete the value set by gunicorn
-                try:
-                    del os.environ[k]
-                except KeyError:
-                    pass
-
-        # reload conf
-        self.app.reload()
-        self.setup(self.app)
-
-        # reopen log files
-        self.log.reopen_files()
-
-        # do we need to change listener ?
-        if old_address != self.cfg.address:
-            # close all listeners
-            for l in self.LISTENERS:
-                l.close()
-            # init new listeners
-            self.LISTENERS = sock.create_sockets(self.cfg, self.log)
-            listeners_str = ",".join([str(l) for l in self.LISTENERS])
-            self.log.info("Listening at: %s", listeners_str)
-
-        # do some actions on reload
-        self.cfg.on_reload(self)
-
-        # unlink pidfile
-        if self.pidfile is not None:
-            self.pidfile.unlink()
-
-        # create new pidfile
-        if self.cfg.pidfile is not None:
-            self.pidfile = Pidfile(self.cfg.pidfile)
-            self.pidfile.create(self.pid)
-
-        # set new proc_name
-        util._setproctitle("master [%s]" % self.proc_name)
-
-        # spawn new workers
-        for _ in range(self.cfg.workers):
-            self.spawn_worker()
-
-        # manage workers
-        self.manage_workers()
-
-    def murder_workers(self):
-        """\
-        Kill unused/idle workers
-        """
-        if not self.timeout:
-            return
-        workers = list(self.WORKERS.items())
-        for (pid, worker) in workers:
-            try:
-                if time.time() - worker.tmp.last_update() <= self.timeout:
-                    continue
-            except (OSError, ValueError):
-                continue
-
-            if not worker.aborted:
-                self.log.critical("WORKER TIMEOUT (pid:%s)", pid)
-                worker.aborted = True
-                self.kill_worker(pid, signal.SIGABRT)
-            else:
-                self.kill_worker(pid, signal.SIGKILL)
-
-    def reap_workers(self):
-        """\
-        Reap workers to avoid zombie processes
-        """
-        try:
-            while True:
-                wpid, status = os.waitpid(-1, os.WNOHANG)
-                if not wpid:
-                    break
-                if self.reexec_pid == wpid:
-                    self.reexec_pid = 0
-                else:
-                    # A worker was terminated. If the termination reason was
-                    # that it could not boot, we'll shut it down to avoid
-                    # infinite start/stop cycles.
-                    exitcode = status >> 8
-                    if exitcode == self.WORKER_BOOT_ERROR:
-                        reason = "Worker failed to boot."
-                        raise HaltServer(reason, self.WORKER_BOOT_ERROR)
-                    if exitcode == self.APP_LOAD_ERROR:
-                        reason = "App failed to load."
-                        raise HaltServer(reason, self.APP_LOAD_ERROR)
-
-                    worker = self.WORKERS.pop(wpid, None)
-                    if not worker:
-                        continue
-                    worker.tmp.close()
-                    self.cfg.child_exit(self, worker)
-        except OSError as e:
-            if e.errno != errno.ECHILD:
-                raise
-
-    def manage_workers(self):
-        """\
-        Maintain the number of workers by spawning or killing
-        as required.
-        """
-        if len(self.WORKERS.keys()) < self.num_workers:
-            self.spawn_workers()
-
-        workers = self.WORKERS.items()
-        workers = sorted(workers, key=lambda w: w[1].age)
-        while len(workers) > self.num_workers:
-            (pid, _) = workers.pop(0)
-            self.kill_worker(pid, signal.SIGTERM)
-
-        active_worker_count = len(workers)
-        if self._last_logged_active_worker_count != active_worker_count:
-            self._last_logged_active_worker_count = active_worker_count
-            self.log.debug("{0} workers".format(active_worker_count),
-                           extra={"metric": "gunicorn.workers",
-                                  "value": active_worker_count,
-                                  "mtype": "gauge"})
-
-    def spawn_worker(self):
-        self.worker_age += 1
-        worker = self.worker_class(self.worker_age, self.pid, self.LISTENERS,
-                                   self.app, self.timeout / 2.0,
-                                   self.cfg, self.log)
-        self.cfg.pre_fork(self, worker)
-        pid = os.fork()
-        if pid != 0:
-            worker.pid = pid
-            self.WORKERS[pid] = worker
-            return pid
-
-        # Do not inherit the temporary files of other workers
-        for sibling in self.WORKERS.values():
-            sibling.tmp.close()
-
-        # Process Child
-        worker.pid = os.getpid()
-        try:
-            util._setproctitle("worker [%s]" % self.proc_name)
-            self.log.info("Booting worker with pid: %s", worker.pid)
-            self.cfg.post_fork(self, worker)
-            worker.init_process()
-            sys.exit(0)
-        except SystemExit:
-            raise
-        except AppImportError as e:
-            self.log.debug("Exception while loading the application",
-                           exc_info=True)
-            print("%s" % e, file=sys.stderr)
-            sys.stderr.flush()
-            sys.exit(self.APP_LOAD_ERROR)
-        except:
-            self.log.exception("Exception in worker process")
-            if not worker.booted:
-                sys.exit(self.WORKER_BOOT_ERROR)
-            sys.exit(-1)
-        finally:
-            self.log.info("Worker exiting (pid: %s)", worker.pid)
-            try:
-                worker.tmp.close()
-                self.cfg.worker_exit(self, worker)
-            except:
-                self.log.warning("Exception during worker exit:\n%s",
-                                  traceback.format_exc())
-
-    def spawn_workers(self):
-        """\
-        Spawn new workers as needed.
-
-        This is where a worker process leaves the main loop
-        of the master process.
-        """
-
-        for _ in range(self.num_workers - len(self.WORKERS.keys())):
-            self.spawn_worker()
-            time.sleep(0.1 * random.random())
-
-    def kill_workers(self, sig):
-        """\
-        Kill all workers with the signal `sig`
-        :attr sig: `signal.SIG*` value
-        """
-        worker_pids = list(self.WORKERS.keys())
-        for pid in worker_pids:
-            self.kill_worker(pid, sig)
-
-    def kill_worker(self, pid, sig):
-        """\
-        Kill a worker
-
-        :attr pid: int, worker pid
-        :attr sig: `signal.SIG*` value
-         """
-        try:
-            os.kill(pid, sig)
-        except OSError as e:
-            if e.errno == errno.ESRCH:
-                try:
-                    worker = self.WORKERS.pop(pid)
-                    worker.tmp.close()
-                    self.cfg.worker_exit(self, worker)
-                    return
-                except (KeyError, OSError):
-                    return
-            raise
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/argparse_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/argparse_compat.py
deleted file mode 100644
index 32d948c03..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/argparse_compat.py
+++ /dev/null
@@ -1,2362 +0,0 @@
-# Author: Steven J. Bethard <steven.bethard@gmail.com>.
-
-"""Command-line parsing library
-
-This module is an optparse-inspired command-line parsing library that:
-
-    - handles both optional and positional arguments
-    - produces highly informative usage messages
-    - supports parsers that dispatch to sub-parsers
-
-The following is a simple usage example that sums integers from the
-command-line and writes the result to a file::
-
-    parser = argparse.ArgumentParser(
-        description='sum the integers at the command line')
-    parser.add_argument(
-        'integers', metavar='int', nargs='+', type=int,
-        help='an integer to be summed')
-    parser.add_argument(
-        '--log', default=sys.stdout, type=argparse.FileType('w'),
-        help='the file where the sum should be written')
-    args = parser.parse_args()
-    args.log.write('%s' % sum(args.integers))
-    args.log.close()
-
-The module contains the following public classes:
-
-    - ArgumentParser -- The main entry point for command-line parsing. As the
-        example above shows, the add_argument() method is used to populate
-        the parser with actions for optional and positional arguments. Then
-        the parse_args() method is invoked to convert the args at the
-        command-line into an object with attributes.
-
-    - ArgumentError -- The exception raised by ArgumentParser objects when
-        there are errors with the parser's actions. Errors raised while
-        parsing the command-line are caught by ArgumentParser and emitted
-        as command-line messages.
-
-    - FileType -- A factory for defining types of files to be created. As the
-        example above shows, instances of FileType are typically passed as
-        the type= argument of add_argument() calls.
-
-    - Action -- The base class for parser actions. Typically actions are
-        selected by passing strings like 'store_true' or 'append_const' to
-        the action= argument of add_argument(). However, for greater
-        customization of ArgumentParser actions, subclasses of Action may
-        be defined and passed as the action= argument.
-
-    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
-        ArgumentDefaultsHelpFormatter -- Formatter classes which
-        may be passed as the formatter_class= argument to the
-        ArgumentParser constructor. HelpFormatter is the default,
-        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
-        not to change the formatting for help text, and
-        ArgumentDefaultsHelpFormatter adds information about argument defaults
-        to the help.
-
-All other classes in this module are considered implementation details.
-(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
-considered public as object names -- the API of the formatter objects is
-still considered an implementation detail.)
-"""
-
-__version__ = '1.2.1'
-__all__ = [
-    'ArgumentParser',
-    'ArgumentError',
-    'ArgumentTypeError',
-    'FileType',
-    'HelpFormatter',
-    'ArgumentDefaultsHelpFormatter',
-    'RawDescriptionHelpFormatter',
-    'RawTextHelpFormatter',
-    'Namespace',
-    'Action',
-    'ONE_OR_MORE',
-    'OPTIONAL',
-    'PARSER',
-    'REMAINDER',
-    'SUPPRESS',
-    'ZERO_OR_MORE',
-]
-
-
-import copy as _copy
-import os as _os
-import re as _re
-import sys as _sys
-import textwrap as _textwrap
-
-from gettext import gettext as _
-
-try:
-    set
-except NameError:
-    # for python < 2.4 compatibility (sets module is there since 2.3):
-    from sets import Set as set
-
-try:
-    basestring
-except NameError:
-    basestring = str
-
-try:
-    sorted
-except NameError:
-    # for python < 2.4 compatibility:
-    def sorted(iterable, reverse=False):
-        result = list(iterable)
-        result.sort()
-        if reverse:
-            result.reverse()
-        return result
-
-
-def _callable(obj):
-    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
-
-
-SUPPRESS = '==SUPPRESS=='
-
-OPTIONAL = '?'
-ZERO_OR_MORE = '*'
-ONE_OR_MORE = '+'
-PARSER = 'A...'
-REMAINDER = '...'
-_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
-
-# =============================
-# Utility functions and classes
-# =============================
-
-class _AttributeHolder(object):
-    """Abstract base class that provides __repr__.
-
-    The __repr__ method returns a string in the format::
-        ClassName(attr=name, attr=name, ...)
-    The attributes are determined either by a class-level attribute,
-    '_kwarg_names', or by inspecting the instance __dict__.
-    """
-
-    def __repr__(self):
-        type_name = type(self).__name__
-        arg_strings = []
-        for arg in self._get_args():
-            arg_strings.append(repr(arg))
-        for name, value in self._get_kwargs():
-            arg_strings.append('%s=%r' % (name, value))
-        return '%s(%s)' % (type_name, ', '.join(arg_strings))
-
-    def _get_kwargs(self):
-        return sorted(self.__dict__.items())
-
-    def _get_args(self):
-        return []
-
-
-def _ensure_value(namespace, name, value):
-    if getattr(namespace, name, None) is None:
-        setattr(namespace, name, value)
-    return getattr(namespace, name)
-
-
-# ===============
-# Formatting Help
-# ===============
-
-class HelpFormatter(object):
-    """Formatter for generating usage messages and argument help strings.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def __init__(self,
-                 prog,
-                 indent_increment=2,
-                 max_help_position=24,
-                 width=None):
-
-        # default setting for width
-        if width is None:
-            try:
-                width = int(_os.environ['COLUMNS'])
-            except (KeyError, ValueError):
-                width = 80
-            width -= 2
-
-        self._prog = prog
-        self._indent_increment = indent_increment
-        self._max_help_position = max_help_position
-        self._width = width
-
-        self._current_indent = 0
-        self._level = 0
-        self._action_max_length = 0
-
-        self._root_section = self._Section(self, None)
-        self._current_section = self._root_section
-
-        self._whitespace_matcher = _re.compile(r'\s+')
-        self._long_break_matcher = _re.compile(r'\n\n\n+')
-
-    # ===============================
-    # Section and indentation methods
-    # ===============================
-    def _indent(self):
-        self._current_indent += self._indent_increment
-        self._level += 1
-
-    def _dedent(self):
-        self._current_indent -= self._indent_increment
-        assert self._current_indent >= 0, 'Indent decreased below 0.'
-        self._level -= 1
-
-    class _Section(object):
-
-        def __init__(self, formatter, parent, heading=None):
-            self.formatter = formatter
-            self.parent = parent
-            self.heading = heading
-            self.items = []
-
-        def format_help(self):
-            # format the indented section
-            if self.parent is not None:
-                self.formatter._indent()
-            join = self.formatter._join_parts
-            for func, args in self.items:
-                func(*args)
-            item_help = join([func(*args) for func, args in self.items])
-            if self.parent is not None:
-                self.formatter._dedent()
-
-            # return nothing if the section was empty
-            if not item_help:
-                return ''
-
-            # add the heading if the section was non-empty
-            if self.heading is not SUPPRESS and self.heading is not None:
-                current_indent = self.formatter._current_indent
-                heading = '%*s%s:\n' % (current_indent, '', self.heading)
-            else:
-                heading = ''
-
-            # join the section-initial newline, the heading and the help
-            return join(['\n', heading, item_help, '\n'])
-
-    def _add_item(self, func, args):
-        self._current_section.items.append((func, args))
-
-    # ========================
-    # Message building methods
-    # ========================
-    def start_section(self, heading):
-        self._indent()
-        section = self._Section(self, self._current_section, heading)
-        self._add_item(section.format_help, [])
-        self._current_section = section
-
-    def end_section(self):
-        self._current_section = self._current_section.parent
-        self._dedent()
-
-    def add_text(self, text):
-        if text is not SUPPRESS and text is not None:
-            self._add_item(self._format_text, [text])
-
-    def add_usage(self, usage, actions, groups, prefix=None):
-        if usage is not SUPPRESS:
-            args = usage, actions, groups, prefix
-            self._add_item(self._format_usage, args)
-
-    def add_argument(self, action):
-        if action.help is not SUPPRESS:
-
-            # find all invocations
-            get_invocation = self._format_action_invocation
-            invocations = [get_invocation(action)]
-            for subaction in self._iter_indented_subactions(action):
-                invocations.append(get_invocation(subaction))
-
-            # update the maximum item length
-            invocation_length = max([len(s) for s in invocations])
-            action_length = invocation_length + self._current_indent
-            self._action_max_length = max(self._action_max_length,
-                                          action_length)
-
-            # add the item to the list
-            self._add_item(self._format_action, [action])
-
-    def add_arguments(self, actions):
-        for action in actions:
-            self.add_argument(action)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_help(self):
-        help = self._root_section.format_help()
-        if help:
-            help = self._long_break_matcher.sub('\n\n', help)
-            help = help.strip('\n') + '\n'
-        return help
-
-    def _join_parts(self, part_strings):
-        return ''.join([part
-                        for part in part_strings
-                        if part and part is not SUPPRESS])
-
-    def _format_usage(self, usage, actions, groups, prefix):
-        if prefix is None:
-            prefix = _('usage: ')
-
-        # if usage is specified, use that
-        if usage is not None:
-            usage = usage % dict(prog=self._prog)
-
-        # if no optionals or positionals are available, usage is just prog
-        elif usage is None and not actions:
-            usage = '%(prog)s' % dict(prog=self._prog)
-
-        # if optionals and positionals are available, calculate usage
-        elif usage is None:
-            prog = '%(prog)s' % dict(prog=self._prog)
-
-            # split optionals from positionals
-            optionals = []
-            positionals = []
-            for action in actions:
-                if action.option_strings:
-                    optionals.append(action)
-                else:
-                    positionals.append(action)
-
-            # build full usage string
-            format = self._format_actions_usage
-            action_usage = format(optionals + positionals, groups)
-            usage = ' '.join([s for s in [prog, action_usage] if s])
-
-            # wrap the usage parts if it's too long
-            text_width = self._width - self._current_indent
-            if len(prefix) + len(usage) > text_width:
-
-                # break usage into wrappable parts
-                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
-                opt_usage = format(optionals, groups)
-                pos_usage = format(positionals, groups)
-                opt_parts = _re.findall(part_regexp, opt_usage)
-                pos_parts = _re.findall(part_regexp, pos_usage)
-                assert ' '.join(opt_parts) == opt_usage
-                assert ' '.join(pos_parts) == pos_usage
-
-                # helper for wrapping lines
-                def get_lines(parts, indent, prefix=None):
-                    lines = []
-                    line = []
-                    if prefix is not None:
-                        line_len = len(prefix) - 1
-                    else:
-                        line_len = len(indent) - 1
-                    for part in parts:
-                        if line_len + 1 + len(part) > text_width:
-                            lines.append(indent + ' '.join(line))
-                            line = []
-                            line_len = len(indent) - 1
-                        line.append(part)
-                        line_len += len(part) + 1
-                    if line:
-                        lines.append(indent + ' '.join(line))
-                    if prefix is not None:
-                        lines[0] = lines[0][len(indent):]
-                    return lines
-
-                # if prog is short, follow it with optionals or positionals
-                if len(prefix) + len(prog) <= 0.75 * text_width:
-                    indent = ' ' * (len(prefix) + len(prog) + 1)
-                    if opt_parts:
-                        lines = get_lines([prog] + opt_parts, indent, prefix)
-                        lines.extend(get_lines(pos_parts, indent))
-                    elif pos_parts:
-                        lines = get_lines([prog] + pos_parts, indent, prefix)
-                    else:
-                        lines = [prog]
-
-                # if prog is long, put it on its own line
-                else:
-                    indent = ' ' * len(prefix)
-                    parts = opt_parts + pos_parts
-                    lines = get_lines(parts, indent)
-                    if len(lines) > 1:
-                        lines = []
-                        lines.extend(get_lines(opt_parts, indent))
-                        lines.extend(get_lines(pos_parts, indent))
-                    lines = [prog] + lines
-
-                # join lines into usage
-                usage = '\n'.join(lines)
-
-        # prefix with 'usage:'
-        return '%s%s\n\n' % (prefix, usage)
-
-    def _format_actions_usage(self, actions, groups):
-        # find group indices and identify actions in groups
-        group_actions = set()
-        inserts = {}
-        for group in groups:
-            try:
-                start = actions.index(group._group_actions[0])
-            except ValueError:
-                continue
-            else:
-                end = start + len(group._group_actions)
-                if actions[start:end] == group._group_actions:
-                    for action in group._group_actions:
-                        group_actions.add(action)
-                    if not group.required:
-                        if start in inserts:
-                            inserts[start] += ' ['
-                        else:
-                            inserts[start] = '['
-                        inserts[end] = ']'
-                    else:
-                        if start in inserts:
-                            inserts[start] += ' ('
-                        else:
-                            inserts[start] = '('
-                        inserts[end] = ')'
-                    for i in range(start + 1, end):
-                        inserts[i] = '|'
-
-        # collect all actions format strings
-        parts = []
-        for i, action in enumerate(actions):
-
-            # suppressed arguments are marked with None
-            # remove | separators for suppressed arguments
-            if action.help is SUPPRESS:
-                parts.append(None)
-                if inserts.get(i) == '|':
-                    inserts.pop(i)
-                elif inserts.get(i + 1) == '|':
-                    inserts.pop(i + 1)
-
-            # produce all arg strings
-            elif not action.option_strings:
-                part = self._format_args(action, action.dest)
-
-                # if it's in a group, strip the outer []
-                if action in group_actions:
-                    if part[0] == '[' and part[-1] == ']':
-                        part = part[1:-1]
-
-                # add the action string to the list
-                parts.append(part)
-
-            # produce the first way to invoke the option in brackets
-            else:
-                option_string = action.option_strings[0]
-
-                # if the Optional doesn't take a value, format is:
-                #    -s or --long
-                if action.nargs == 0:
-                    part = '%s' % option_string
-
-                # if the Optional takes a value, format is:
-                #    -s ARGS or --long ARGS
-                else:
-                    default = action.dest.upper()
-                    args_string = self._format_args(action, default)
-                    part = '%s %s' % (option_string, args_string)
-
-                # make it look optional if it's not required or in a group
-                if not action.required and action not in group_actions:
-                    part = '[%s]' % part
-
-                # add the action string to the list
-                parts.append(part)
-
-        # insert things at the necessary indices
-        for i in sorted(inserts, reverse=True):
-            parts[i:i] = [inserts[i]]
-
-        # join all the action items with spaces
-        text = ' '.join([item for item in parts if item is not None])
-
-        # clean up separators for mutually exclusive groups
-        open = r'[\[(]'
-        close = r'[\])]'
-        text = _re.sub(r'(%s) ' % open, r'\1', text)
-        text = _re.sub(r' (%s)' % close, r'\1', text)
-        text = _re.sub(r'%s *%s' % (open, close), r'', text)
-        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
-        text = text.strip()
-
-        # return the text
-        return text
-
-    def _format_text(self, text):
-        if '%(prog)' in text:
-            text = text % dict(prog=self._prog)
-        text_width = self._width - self._current_indent
-        indent = ' ' * self._current_indent
-        return self._fill_text(text, text_width, indent) + '\n\n'
-
-    def _format_action(self, action):
-        # determine the required width and the entry label
-        help_position = min(self._action_max_length + 2,
-                            self._max_help_position)
-        help_width = self._width - help_position
-        action_width = help_position - self._current_indent - 2
-        action_header = self._format_action_invocation(action)
-
-        # ho nelp; start on same line and add a final newline
-        if not action.help:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-
-        # short action name; start on the same line and pad two spaces
-        elif len(action_header) <= action_width:
-            tup = self._current_indent, '', action_width, action_header
-            action_header = '%*s%-*s  ' % tup
-            indent_first = 0
-
-        # long action name; start on the next line
-        else:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-            indent_first = help_position
-
-        # collect the pieces of the action help
-        parts = [action_header]
-
-        # if there was help for the action, add lines of help text
-        if action.help:
-            help_text = self._expand_help(action)
-            help_lines = self._split_lines(help_text, help_width)
-            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
-            for line in help_lines[1:]:
-                parts.append('%*s%s\n' % (help_position, '', line))
-
-        # or add a newline if the description doesn't end with one
-        elif not action_header.endswith('\n'):
-            parts.append('\n')
-
-        # if there are any sub-actions, add their help as well
-        for subaction in self._iter_indented_subactions(action):
-            parts.append(self._format_action(subaction))
-
-        # return a single string
-        return self._join_parts(parts)
-
-    def _format_action_invocation(self, action):
-        if not action.option_strings:
-            metavar, = self._metavar_formatter(action, action.dest)(1)
-            return metavar
-
-        else:
-            parts = []
-
-            # if the Optional doesn't take a value, format is:
-            #    -s, --long
-            if action.nargs == 0:
-                parts.extend(action.option_strings)
-
-            # if the Optional takes a value, format is:
-            #    -s ARGS, --long ARGS
-            else:
-                default = action.dest.upper()
-                args_string = self._format_args(action, default)
-                for option_string in action.option_strings:
-                    parts.append('%s %s' % (option_string, args_string))
-
-            return ', '.join(parts)
-
-    def _metavar_formatter(self, action, default_metavar):
-        if action.metavar is not None:
-            result = action.metavar
-        elif action.choices is not None:
-            choice_strs = [str(choice) for choice in action.choices]
-            result = '{%s}' % ','.join(choice_strs)
-        else:
-            result = default_metavar
-
-        def format(tuple_size):
-            if isinstance(result, tuple):
-                return result
-            else:
-                return (result, ) * tuple_size
-        return format
-
-    def _format_args(self, action, default_metavar):
-        get_metavar = self._metavar_formatter(action, default_metavar)
-        if action.nargs is None:
-            result = '%s' % get_metavar(1)
-        elif action.nargs == OPTIONAL:
-            result = '[%s]' % get_metavar(1)
-        elif action.nargs == ZERO_OR_MORE:
-            result = '[%s [%s ...]]' % get_metavar(2)
-        elif action.nargs == ONE_OR_MORE:
-            result = '%s [%s ...]' % get_metavar(2)
-        elif action.nargs == REMAINDER:
-            result = '...'
-        elif action.nargs == PARSER:
-            result = '%s ...' % get_metavar(1)
-        else:
-            formats = ['%s' for _ in range(action.nargs)]
-            result = ' '.join(formats) % get_metavar(action.nargs)
-        return result
-
-    def _expand_help(self, action):
-        params = dict(vars(action), prog=self._prog)
-        for name in list(params):
-            if params[name] is SUPPRESS:
-                del params[name]
-        for name in list(params):
-            if hasattr(params[name], '__name__'):
-                params[name] = params[name].__name__
-        if params.get('choices') is not None:
-            choices_str = ', '.join([str(c) for c in params['choices']])
-            params['choices'] = choices_str
-        return self._get_help_string(action) % params
-
-    def _iter_indented_subactions(self, action):
-        try:
-            get_subactions = action._get_subactions
-        except AttributeError:
-            pass
-        else:
-            self._indent()
-            for subaction in get_subactions():
-                yield subaction
-            self._dedent()
-
-    def _split_lines(self, text, width):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.wrap(text, width)
-
-    def _fill_text(self, text, width, indent):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.fill(text, width, initial_indent=indent,
-                                           subsequent_indent=indent)
-
-    def _get_help_string(self, action):
-        return action.help
-
-
-class RawDescriptionHelpFormatter(HelpFormatter):
-    """Help message formatter which retains any formatting in descriptions.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _fill_text(self, text, width, indent):
-        return ''.join([indent + line for line in text.splitlines(True)])
-
-
-class RawTextHelpFormatter(RawDescriptionHelpFormatter):
-    """Help message formatter which retains formatting of all help text.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _split_lines(self, text, width):
-        return text.splitlines()
-
-
-class ArgumentDefaultsHelpFormatter(HelpFormatter):
-    """Help message formatter which adds default values to argument help.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _get_help_string(self, action):
-        help = action.help
-        if '%(default)' not in action.help:
-            if action.default is not SUPPRESS:
-                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
-                if action.option_strings or action.nargs in defaulting_nargs:
-                    help += ' (default: %(default)s)'
-        return help
-
-
-# =====================
-# Options and Arguments
-# =====================
-
-def _get_action_name(argument):
-    if argument is None:
-        return None
-    elif argument.option_strings:
-        return  '/'.join(argument.option_strings)
-    elif argument.metavar not in (None, SUPPRESS):
-        return argument.metavar
-    elif argument.dest not in (None, SUPPRESS):
-        return argument.dest
-    else:
-        return None
-
-
-class ArgumentError(Exception):
-    """An error from creating or using an argument (optional or positional).
-
-    The string value of this exception is the message, augmented with
-    information about the argument that caused it.
-    """
-
-    def __init__(self, argument, message):
-        self.argument_name = _get_action_name(argument)
-        self.message = message
-
-    def __str__(self):
-        if self.argument_name is None:
-            format = '%(message)s'
-        else:
-            format = 'argument %(argument_name)s: %(message)s'
-        return format % dict(message=self.message,
-                             argument_name=self.argument_name)
-
-
-class ArgumentTypeError(Exception):
-    """An error from trying to convert a command line string to a type."""
-    pass
-
-
-# ==============
-# Action classes
-# ==============
-
-class Action(_AttributeHolder):
-    """Information about how to convert command line strings to Python objects.
-
-    Action objects are used by an ArgumentParser to represent the information
-    needed to parse a single argument from one or more strings from the
-    command line. The keyword arguments to the Action constructor are also
-    all attributes of Action instances.
-
-    Keyword Arguments:
-
-        - option_strings -- A list of command-line option strings which
-            should be associated with this action.
-
-        - dest -- The name of the attribute to hold the created object(s)
-
-        - nargs -- The number of command-line arguments that should be
-            consumed. By default, one argument will be consumed and a single
-            value will be produced.  Other values include:
-                - N (an integer) consumes N arguments (and produces a list)
-                - '?' consumes zero or one arguments
-                - '*' consumes zero or more arguments (and produces a list)
-                - '+' consumes one or more arguments (and produces a list)
-            Note that the difference between the default and nargs=1 is that
-            with the default, a single value will be produced, while with
-            nargs=1, a list containing a single value will be produced.
-
-        - const -- The value to be produced if the option is specified and the
-            option uses an action that takes no values.
-
-        - default -- The value to be produced if the option is not specified.
-
-        - type -- The type which the command-line arguments should be converted
-            to, should be one of 'string', 'int', 'float', 'complex' or a
-            callable object that accepts a single string argument. If None,
-            'string' is assumed.
-
-        - choices -- A container of values that should be allowed. If not None,
-            after a command-line argument has been converted to the appropriate
-            type, an exception will be raised if it is not a member of this
-            collection.
-
-        - required -- True if the action must always be specified at the
-            command line. This is only meaningful for optional command-line
-            arguments.
-
-        - help -- The help string describing the argument.
-
-        - metavar -- The name to be used for the option's argument with the
-            help string. If None, the 'dest' value will be used as the name.
-    """
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        self.option_strings = option_strings
-        self.dest = dest
-        self.nargs = nargs
-        self.const = const
-        self.default = default
-        self.type = type
-        self.choices = choices
-        self.required = required
-        self.help = help
-        self.metavar = metavar
-
-    def _get_kwargs(self):
-        names = [
-            'option_strings',
-            'dest',
-            'nargs',
-            'const',
-            'default',
-            'type',
-            'choices',
-            'help',
-            'metavar',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        raise NotImplementedError(_('.__call__() not defined'))
-
-
-class _StoreAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for store actions must be > 0; if you '
-                             'have nothing to store, actions such as store '
-                             'true or store const may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_StoreAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, values)
-
-
-class _StoreConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_StoreConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, self.const)
-
-
-class _StoreTrueAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=False,
-                 required=False,
-                 help=None):
-        super(_StoreTrueAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=True,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _StoreFalseAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=True,
-                 required=False,
-                 help=None):
-        super(_StoreFalseAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=False,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _AppendAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for append actions must be > 0; if arg '
-                             'strings are not supplying the value to append, '
-                             'the append const action may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_AppendAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(values)
-        setattr(namespace, self.dest, items)
-
-
-class _AppendConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_AppendConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(self.const)
-        setattr(namespace, self.dest, items)
-
-
-class _CountAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=None,
-                 required=False,
-                 help=None):
-        super(_CountAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        new_count = _ensure_value(namespace, self.dest, 0) + 1
-        setattr(namespace, self.dest, new_count)
-
-
-class _HelpAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help=None):
-        super(_HelpAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser.print_help()
-        parser.exit()
-
-
-class _VersionAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 version=None,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help="show program's version number and exit"):
-        super(_VersionAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-        self.version = version
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        version = self.version
-        if version is None:
-            version = parser.version
-        formatter = parser._get_formatter()
-        formatter.add_text(version)
-        parser.exit(message=formatter.format_help())
-
-
-class _SubParsersAction(Action):
-
-    class _ChoicesPseudoAction(Action):
-
-        def __init__(self, name, help):
-            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
-            sup.__init__(option_strings=[], dest=name, help=help)
-
-    def __init__(self,
-                 option_strings,
-                 prog,
-                 parser_class,
-                 dest=SUPPRESS,
-                 help=None,
-                 metavar=None):
-
-        self._prog_prefix = prog
-        self._parser_class = parser_class
-        self._name_parser_map = {}
-        self._choices_actions = []
-
-        super(_SubParsersAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=PARSER,
-            choices=self._name_parser_map,
-            help=help,
-            metavar=metavar)
-
-    def add_parser(self, name, **kwargs):
-        # set prog from the existing prefix
-        if kwargs.get('prog') is None:
-            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
-
-        # create a pseudo-action to hold the choice help
-        if 'help' in kwargs:
-            help = kwargs.pop('help')
-            choice_action = self._ChoicesPseudoAction(name, help)
-            self._choices_actions.append(choice_action)
-
-        # create the parser and add it to the map
-        parser = self._parser_class(**kwargs)
-        self._name_parser_map[name] = parser
-        return parser
-
-    def _get_subactions(self):
-        return self._choices_actions
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser_name = values[0]
-        arg_strings = values[1:]
-
-        # set the parser name if requested
-        if self.dest is not SUPPRESS:
-            setattr(namespace, self.dest, parser_name)
-
-        # select the parser
-        try:
-            parser = self._name_parser_map[parser_name]
-        except KeyError:
-            tup = parser_name, ', '.join(self._name_parser_map)
-            msg = _('unknown parser %r (choices: %s)' % tup)
-            raise ArgumentError(self, msg)
-
-        # parse all the remaining options into the namespace
-        # store any unrecognized options on the object, so that the top
-        # level parser can decide what to do with them
-        namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
-        if arg_strings:
-            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
-            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
-
-
-# ==============
-# Type classes
-# ==============
-
-class FileType(object):
-    """Factory for creating file object types
-
-    Instances of FileType are typically passed as type= arguments to the
-    ArgumentParser add_argument() method.
-
-    Keyword Arguments:
-        - mode -- A string indicating how the file is to be opened. Accepts the
-            same values as the builtin open() function.
-        - bufsize -- The file's desired buffer size. Accepts the same values as
-            the builtin open() function.
-    """
-
-    def __init__(self, mode='r', bufsize=None):
-        self._mode = mode
-        self._bufsize = bufsize
-
-    def __call__(self, string):
-        # the special argument "-" means sys.std{in,out}
-        if string == '-':
-            if 'r' in self._mode:
-                return _sys.stdin
-            elif 'w' in self._mode:
-                return _sys.stdout
-            else:
-                msg = _('argument "-" with mode %r' % self._mode)
-                raise ValueError(msg)
-
-        # all other arguments are used as file names
-        if self._bufsize:
-            return open(string, self._mode, self._bufsize)
-        else:
-            return open(string, self._mode)
-
-    def __repr__(self):
-        args = [self._mode, self._bufsize]
-        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
-        return '%s(%s)' % (type(self).__name__, args_str)
-
-# ===========================
-# Optional and Positional Parsing
-# ===========================
-
-class Namespace(_AttributeHolder):
-    """Simple object for storing attributes.
-
-    Implements equality by attribute names and values, and provides a simple
-    string representation.
-    """
-
-    def __init__(self, **kwargs):
-        for name in kwargs:
-            setattr(self, name, kwargs[name])
-
-    __hash__ = None
-
-    def __eq__(self, other):
-        return vars(self) == vars(other)
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-
-class _ActionsContainer(object):
-
-    def __init__(self,
-                 description,
-                 prefix_chars,
-                 argument_default,
-                 conflict_handler):
-        super(_ActionsContainer, self).__init__()
-
-        self.description = description
-        self.argument_default = argument_default
-        self.prefix_chars = prefix_chars
-        self.conflict_handler = conflict_handler
-
-        # set up registries
-        self._registries = {}
-
-        # register actions
-        self.register('action', None, _StoreAction)
-        self.register('action', 'store', _StoreAction)
-        self.register('action', 'store_const', _StoreConstAction)
-        self.register('action', 'store_true', _StoreTrueAction)
-        self.register('action', 'store_false', _StoreFalseAction)
-        self.register('action', 'append', _AppendAction)
-        self.register('action', 'append_const', _AppendConstAction)
-        self.register('action', 'count', _CountAction)
-        self.register('action', 'help', _HelpAction)
-        self.register('action', 'version', _VersionAction)
-        self.register('action', 'parsers', _SubParsersAction)
-
-        # raise an exception if the conflict handler is invalid
-        self._get_handler()
-
-        # action storage
-        self._actions = []
-        self._option_string_actions = {}
-
-        # groups
-        self._action_groups = []
-        self._mutually_exclusive_groups = []
-
-        # defaults storage
-        self._defaults = {}
-
-        # determines whether an "option" looks like a negative number
-        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
-
-        # whether or not there are any optionals that look like negative
-        # numbers -- uses a list so it can be shared and edited
-        self._has_negative_number_optionals = []
-
-    # ====================
-    # Registration methods
-    # ====================
-    def register(self, registry_name, value, object):
-        registry = self._registries.setdefault(registry_name, {})
-        registry[value] = object
-
-    def _registry_get(self, registry_name, value, default=None):
-        return self._registries[registry_name].get(value, default)
-
-    # ==================================
-    # Namespace default accessor methods
-    # ==================================
-    def set_defaults(self, **kwargs):
-        self._defaults.update(kwargs)
-
-        # if these defaults match any existing arguments, replace
-        # the previous default on the object with the new one
-        for action in self._actions:
-            if action.dest in kwargs:
-                action.default = kwargs[action.dest]
-
-    def get_default(self, dest):
-        for action in self._actions:
-            if action.dest == dest and action.default is not None:
-                return action.default
-        return self._defaults.get(dest, None)
-
-
-    # =======================
-    # Adding argument actions
-    # =======================
-    def add_argument(self, *args, **kwargs):
-        """
-        add_argument(dest, ..., name=value, ...)
-        add_argument(option_string, option_string, ..., name=value, ...)
-        """
-
-        # if no positional args are supplied or only one is supplied and
-        # it doesn't look like an option string, parse a positional
-        # argument
-        chars = self.prefix_chars
-        if not args or len(args) == 1 and args[0][0] not in chars:
-            if args and 'dest' in kwargs:
-                raise ValueError('dest supplied twice for positional argument')
-            kwargs = self._get_positional_kwargs(*args, **kwargs)
-
-        # otherwise, we're adding an optional argument
-        else:
-            kwargs = self._get_optional_kwargs(*args, **kwargs)
-
-        # if no default was supplied, use the parser-level default
-        if 'default' not in kwargs:
-            dest = kwargs['dest']
-            if dest in self._defaults:
-                kwargs['default'] = self._defaults[dest]
-            elif self.argument_default is not None:
-                kwargs['default'] = self.argument_default
-
-        # create the action object, and add it to the parser
-        action_class = self._pop_action_class(kwargs)
-        if not _callable(action_class):
-            raise ValueError('unknown action "%s"' % action_class)
-        action = action_class(**kwargs)
-
-        # raise an error if the action type is not callable
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            raise ValueError('%r is not callable' % type_func)
-
-        return self._add_action(action)
-
-    def add_argument_group(self, *args, **kwargs):
-        group = _ArgumentGroup(self, *args, **kwargs)
-        self._action_groups.append(group)
-        return group
-
-    def add_mutually_exclusive_group(self, **kwargs):
-        group = _MutuallyExclusiveGroup(self, **kwargs)
-        self._mutually_exclusive_groups.append(group)
-        return group
-
-    def _add_action(self, action):
-        # resolve any conflicts
-        self._check_conflict(action)
-
-        # add to actions list
-        self._actions.append(action)
-        action.container = self
-
-        # index the action by any option strings it has
-        for option_string in action.option_strings:
-            self._option_string_actions[option_string] = action
-
-        # set the flag if any option strings look like negative numbers
-        for option_string in action.option_strings:
-            if self._negative_number_matcher.match(option_string):
-                if not self._has_negative_number_optionals:
-                    self._has_negative_number_optionals.append(True)
-
-        # return the created action
-        return action
-
-    def _remove_action(self, action):
-        self._actions.remove(action)
-
-    def _add_container_actions(self, container):
-        # collect groups by titles
-        title_group_map = {}
-        for group in self._action_groups:
-            if group.title in title_group_map:
-                msg = _('cannot merge actions - two groups are named %r')
-                raise ValueError(msg % (group.title))
-            title_group_map[group.title] = group
-
-        # map each action to its group
-        group_map = {}
-        for group in container._action_groups:
-
-            # if a group with the title exists, use that, otherwise
-            # create a new group matching the container's group
-            if group.title not in title_group_map:
-                title_group_map[group.title] = self.add_argument_group(
-                    title=group.title,
-                    description=group.description,
-                    conflict_handler=group.conflict_handler)
-
-            # map the actions to their new group
-            for action in group._group_actions:
-                group_map[action] = title_group_map[group.title]
-
-        # add container's mutually exclusive groups
-        # NOTE: if add_mutually_exclusive_group ever gains title= and
-        # description= then this code will need to be expanded as above
-        for group in container._mutually_exclusive_groups:
-            mutex_group = self.add_mutually_exclusive_group(
-                required=group.required)
-
-            # map the actions to their new mutex group
-            for action in group._group_actions:
-                group_map[action] = mutex_group
-
-        # add all actions to this container or their group
-        for action in container._actions:
-            group_map.get(action, self)._add_action(action)
-
-    def _get_positional_kwargs(self, dest, **kwargs):
-        # make sure required is not specified
-        if 'required' in kwargs:
-            msg = _("'required' is an invalid argument for positionals")
-            raise TypeError(msg)
-
-        # mark positional arguments as required if at least one is
-        # always required
-        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
-            kwargs['required'] = True
-        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
-            kwargs['required'] = True
-
-        # return the keyword arguments with no option strings
-        return dict(kwargs, dest=dest, option_strings=[])
-
-    def _get_optional_kwargs(self, *args, **kwargs):
-        # determine short and long option strings
-        option_strings = []
-        long_option_strings = []
-        for option_string in args:
-            # error on strings that don't start with an appropriate prefix
-            if not option_string[0] in self.prefix_chars:
-                msg = _('invalid option string %r: '
-                        'must start with a character %r')
-                tup = option_string, self.prefix_chars
-                raise ValueError(msg % tup)
-
-            # strings starting with two prefix characters are long options
-            option_strings.append(option_string)
-            if option_string[0] in self.prefix_chars:
-                if len(option_string) > 1:
-                    if option_string[1] in self.prefix_chars:
-                        long_option_strings.append(option_string)
-
-        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
-        dest = kwargs.pop('dest', None)
-        if dest is None:
-            if long_option_strings:
-                dest_option_string = long_option_strings[0]
-            else:
-                dest_option_string = option_strings[0]
-            dest = dest_option_string.lstrip(self.prefix_chars)
-            if not dest:
-                msg = _('dest= is required for options like %r')
-                raise ValueError(msg % option_string)
-            dest = dest.replace('-', '_')
-
-        # return the updated keyword arguments
-        return dict(kwargs, dest=dest, option_strings=option_strings)
-
-    def _pop_action_class(self, kwargs, default=None):
-        action = kwargs.pop('action', default)
-        return self._registry_get('action', action, action)
-
-    def _get_handler(self):
-        # determine function from conflict handler string
-        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
-        try:
-            return getattr(self, handler_func_name)
-        except AttributeError:
-            msg = _('invalid conflict_resolution value: %r')
-            raise ValueError(msg % self.conflict_handler)
-
-    def _check_conflict(self, action):
-
-        # find all options that conflict with this option
-        confl_optionals = []
-        for option_string in action.option_strings:
-            if option_string in self._option_string_actions:
-                confl_optional = self._option_string_actions[option_string]
-                confl_optionals.append((option_string, confl_optional))
-
-        # resolve any conflicts
-        if confl_optionals:
-            conflict_handler = self._get_handler()
-            conflict_handler(action, confl_optionals)
-
-    def _handle_conflict_error(self, action, conflicting_actions):
-        message = _('conflicting option string(s): %s')
-        conflict_string = ', '.join([option_string
-                                     for option_string, action
-                                     in conflicting_actions])
-        raise ArgumentError(action, message % conflict_string)
-
-    def _handle_conflict_resolve(self, action, conflicting_actions):
-
-        # remove all conflicting options
-        for option_string, action in conflicting_actions:
-
-            # remove the conflicting option
-            action.option_strings.remove(option_string)
-            self._option_string_actions.pop(option_string, None)
-
-            # if the option now has no option string, remove it from the
-            # container holding it
-            if not action.option_strings:
-                action.container._remove_action(action)
-
-
-class _ArgumentGroup(_ActionsContainer):
-
-    def __init__(self, container, title=None, description=None, **kwargs):
-        # add any missing keyword arguments by checking the container
-        update = kwargs.setdefault
-        update('conflict_handler', container.conflict_handler)
-        update('prefix_chars', container.prefix_chars)
-        update('argument_default', container.argument_default)
-        super_init = super(_ArgumentGroup, self).__init__
-        super_init(description=description, **kwargs)
-
-        # group attributes
-        self.title = title
-        self._group_actions = []
-
-        # share most attributes with the container
-        self._registries = container._registries
-        self._actions = container._actions
-        self._option_string_actions = container._option_string_actions
-        self._defaults = container._defaults
-        self._has_negative_number_optionals = \
-            container._has_negative_number_optionals
-
-    def _add_action(self, action):
-        action = super(_ArgumentGroup, self)._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        super(_ArgumentGroup, self)._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class _MutuallyExclusiveGroup(_ArgumentGroup):
-
-    def __init__(self, container, required=False):
-        super(_MutuallyExclusiveGroup, self).__init__(container)
-        self.required = required
-        self._container = container
-
-    def _add_action(self, action):
-        if action.required:
-            msg = _('mutually exclusive arguments must be optional')
-            raise ValueError(msg)
-        action = self._container._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        self._container._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class ArgumentParser(_AttributeHolder, _ActionsContainer):
-    """Object for parsing command line strings into Python objects.
-
-    Keyword Arguments:
-        - prog -- The name of the program (default: sys.argv[0])
-        - usage -- A usage message (default: auto-generated from arguments)
-        - description -- A description of what the program does
-        - epilog -- Text following the argument descriptions
-        - parents -- Parsers whose arguments should be copied into this one
-        - formatter_class -- HelpFormatter class for printing help messages
-        - prefix_chars -- Characters that prefix optional arguments
-        - fromfile_prefix_chars -- Characters that prefix files containing
-            additional arguments
-        - argument_default -- The default value for all arguments
-        - conflict_handler -- String indicating how to handle conflicts
-        - add_help -- Add a -h/-help option
-    """
-
-    def __init__(self,
-                 prog=None,
-                 usage=None,
-                 description=None,
-                 epilog=None,
-                 version=None,
-                 parents=[],
-                 formatter_class=HelpFormatter,
-                 prefix_chars='-',
-                 fromfile_prefix_chars=None,
-                 argument_default=None,
-                 conflict_handler='error',
-                 add_help=True):
-
-        if version is not None:
-            import warnings
-            warnings.warn(
-                """The "version" argument to ArgumentParser is deprecated. """
-                """Please use """
-                """"add_argument(..., action='version', version="N", ...)" """
-                """instead""", DeprecationWarning)
-
-        superinit = super(ArgumentParser, self).__init__
-        superinit(description=description,
-                  prefix_chars=prefix_chars,
-                  argument_default=argument_default,
-                  conflict_handler=conflict_handler)
-
-        # default setting for prog
-        if prog is None:
-            prog = _os.path.basename(_sys.argv[0])
-
-        self.prog = prog
-        self.usage = usage
-        self.epilog = epilog
-        self.version = version
-        self.formatter_class = formatter_class
-        self.fromfile_prefix_chars = fromfile_prefix_chars
-        self.add_help = add_help
-
-        add_group = self.add_argument_group
-        self._positionals = add_group(_('positional arguments'))
-        self._optionals = add_group(_('optional arguments'))
-        self._subparsers = None
-
-        # register types
-        def identity(string):
-            return string
-        self.register('type', None, identity)
-
-        # add help and version arguments if necessary
-        # (using explicit default to override global argument_default)
-        if '-' in prefix_chars:
-            default_prefix = '-'
-        else:
-            default_prefix = prefix_chars[0]
-        if self.add_help:
-            self.add_argument(
-                default_prefix+'h', default_prefix*2+'help',
-                action='help', default=SUPPRESS,
-                help=_('show this help message and exit'))
-        if self.version:
-            self.add_argument(
-                default_prefix+'v', default_prefix*2+'version',
-                action='version', default=SUPPRESS,
-                version=self.version,
-                help=_("show program's version number and exit"))
-
-        # add parent arguments and defaults
-        for parent in parents:
-            self._add_container_actions(parent)
-            try:
-                defaults = parent._defaults
-            except AttributeError:
-                pass
-            else:
-                self._defaults.update(defaults)
-
-    # =======================
-    # Pretty __repr__ methods
-    # =======================
-    def _get_kwargs(self):
-        names = [
-            'prog',
-            'usage',
-            'description',
-            'version',
-            'formatter_class',
-            'conflict_handler',
-            'add_help',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    # ==================================
-    # Optional/Positional adding methods
-    # ==================================
-    def add_subparsers(self, **kwargs):
-        if self._subparsers is not None:
-            self.error(_('cannot have multiple subparser arguments'))
-
-        # add the parser class to the arguments if it's not present
-        kwargs.setdefault('parser_class', type(self))
-
-        if 'title' in kwargs or 'description' in kwargs:
-            title = _(kwargs.pop('title', 'subcommands'))
-            description = _(kwargs.pop('description', None))
-            self._subparsers = self.add_argument_group(title, description)
-        else:
-            self._subparsers = self._positionals
-
-        # prog defaults to the usage message of this parser, skipping
-        # optional arguments and with no "usage:" prefix
-        if kwargs.get('prog') is None:
-            formatter = self._get_formatter()
-            positionals = self._get_positional_actions()
-            groups = self._mutually_exclusive_groups
-            formatter.add_usage(self.usage, positionals, groups, '')
-            kwargs['prog'] = formatter.format_help().strip()
-
-        # create the parsers action and add it to the positionals list
-        parsers_class = self._pop_action_class(kwargs, 'parsers')
-        action = parsers_class(option_strings=[], **kwargs)
-        self._subparsers._add_action(action)
-
-        # return the created parsers action
-        return action
-
-    def _add_action(self, action):
-        if action.option_strings:
-            self._optionals._add_action(action)
-        else:
-            self._positionals._add_action(action)
-        return action
-
-    def _get_optional_actions(self):
-        return [action
-                for action in self._actions
-                if action.option_strings]
-
-    def _get_positional_actions(self):
-        return [action
-                for action in self._actions
-                if not action.option_strings]
-
-    # =====================================
-    # Command line argument parsing methods
-    # =====================================
-    def parse_args(self, args=None, namespace=None):
-        args, argv = self.parse_known_args(args, namespace)
-        if argv:
-            msg = _('unrecognized arguments: %s')
-            self.error(msg % ' '.join(argv))
-        return args
-
-    def parse_known_args(self, args=None, namespace=None):
-        # args default to the system args
-        if args is None:
-            args = _sys.argv[1:]
-
-        # default Namespace built from parser defaults
-        if namespace is None:
-            namespace = Namespace()
-
-        # add any action defaults that aren't present
-        for action in self._actions:
-            if action.dest is not SUPPRESS:
-                if not hasattr(namespace, action.dest):
-                    if action.default is not SUPPRESS:
-                        default = action.default
-                        if isinstance(action.default, basestring):
-                            default = self._get_value(action, default)
-                        setattr(namespace, action.dest, default)
-
-        # add any parser defaults that aren't present
-        for dest in self._defaults:
-            if not hasattr(namespace, dest):
-                setattr(namespace, dest, self._defaults[dest])
-
-        # parse the arguments and exit if there are any errors
-        try:
-            namespace, args = self._parse_known_args(args, namespace)
-            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
-                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
-                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
-            return namespace, args
-        except ArgumentError:
-            err = _sys.exc_info()[1]
-            self.error(str(err))
-
-    def _parse_known_args(self, arg_strings, namespace):
-        # replace arg strings that are file references
-        if self.fromfile_prefix_chars is not None:
-            arg_strings = self._read_args_from_files(arg_strings)
-
-        # map all mutually exclusive arguments to the other arguments
-        # they can't occur with
-        action_conflicts = {}
-        for mutex_group in self._mutually_exclusive_groups:
-            group_actions = mutex_group._group_actions
-            for i, mutex_action in enumerate(mutex_group._group_actions):
-                conflicts = action_conflicts.setdefault(mutex_action, [])
-                conflicts.extend(group_actions[:i])
-                conflicts.extend(group_actions[i + 1:])
-
-        # find all option indices, and determine the arg_string_pattern
-        # which has an 'O' if there is an option at an index,
-        # an 'A' if there is an argument, or a '-' if there is a '--'
-        option_string_indices = {}
-        arg_string_pattern_parts = []
-        arg_strings_iter = iter(arg_strings)
-        for i, arg_string in enumerate(arg_strings_iter):
-
-            # all args after -- are non-options
-            if arg_string == '--':
-                arg_string_pattern_parts.append('-')
-                for arg_string in arg_strings_iter:
-                    arg_string_pattern_parts.append('A')
-
-            # otherwise, add the arg to the arg strings
-            # and note the index if it was an option
-            else:
-                option_tuple = self._parse_optional(arg_string)
-                if option_tuple is None:
-                    pattern = 'A'
-                else:
-                    option_string_indices[i] = option_tuple
-                    pattern = 'O'
-                arg_string_pattern_parts.append(pattern)
-
-        # join the pieces together to form the pattern
-        arg_strings_pattern = ''.join(arg_string_pattern_parts)
-
-        # converts arg strings to the appropriate and then takes the action
-        seen_actions = set()
-        seen_non_default_actions = set()
-
-        def take_action(action, argument_strings, option_string=None):
-            seen_actions.add(action)
-            argument_values = self._get_values(action, argument_strings)
-
-            # error if this argument is not allowed with other previously
-            # seen arguments, assuming that actions that use the default
-            # value don't really count as "present"
-            if argument_values is not action.default:
-                seen_non_default_actions.add(action)
-                for conflict_action in action_conflicts.get(action, []):
-                    if conflict_action in seen_non_default_actions:
-                        msg = _('not allowed with argument %s')
-                        action_name = _get_action_name(conflict_action)
-                        raise ArgumentError(action, msg % action_name)
-
-            # take the action if we didn't receive a SUPPRESS value
-            # (e.g. from a default)
-            if argument_values is not SUPPRESS:
-                action(self, namespace, argument_values, option_string)
-
-        # function to convert arg_strings into an optional action
-        def consume_optional(start_index):
-
-            # get the optional identified at this index
-            option_tuple = option_string_indices[start_index]
-            action, option_string, explicit_arg = option_tuple
-
-            # identify additional optionals in the same arg string
-            # (e.g. -xyz is the same as -x -y -z if no args are required)
-            match_argument = self._match_argument
-            action_tuples = []
-            while True:
-
-                # if we found no optional action, skip it
-                if action is None:
-                    extras.append(arg_strings[start_index])
-                    return start_index + 1
-
-                # if there is an explicit argument, try to match the
-                # optional's string arguments to only this
-                if explicit_arg is not None:
-                    arg_count = match_argument(action, 'A')
-
-                    # if the action is a single-dash option and takes no
-                    # arguments, try to parse more single-dash options out
-                    # of the tail of the option string
-                    chars = self.prefix_chars
-                    if arg_count == 0 and option_string[1] not in chars:
-                        action_tuples.append((action, [], option_string))
-                        char = option_string[0]
-                        option_string = char + explicit_arg[0]
-                        new_explicit_arg = explicit_arg[1:] or None
-                        optionals_map = self._option_string_actions
-                        if option_string in optionals_map:
-                            action = optionals_map[option_string]
-                            explicit_arg = new_explicit_arg
-                        else:
-                            msg = _('ignored explicit argument %r')
-                            raise ArgumentError(action, msg % explicit_arg)
-
-                    # if the action expect exactly one argument, we've
-                    # successfully matched the option; exit the loop
-                    elif arg_count == 1:
-                        stop = start_index + 1
-                        args = [explicit_arg]
-                        action_tuples.append((action, args, option_string))
-                        break
-
-                    # error if a double-dash option did not use the
-                    # explicit argument
-                    else:
-                        msg = _('ignored explicit argument %r')
-                        raise ArgumentError(action, msg % explicit_arg)
-
-                # if there is no explicit argument, try to match the
-                # optional's string arguments with the following strings
-                # if successful, exit the loop
-                else:
-                    start = start_index + 1
-                    selected_patterns = arg_strings_pattern[start:]
-                    arg_count = match_argument(action, selected_patterns)
-                    stop = start + arg_count
-                    args = arg_strings[start:stop]
-                    action_tuples.append((action, args, option_string))
-                    break
-
-            # add the Optional to the list and return the index at which
-            # the Optional's string args stopped
-            assert action_tuples
-            for action, args, option_string in action_tuples:
-                take_action(action, args, option_string)
-            return stop
-
-        # the list of Positionals left to be parsed; this is modified
-        # by consume_positionals()
-        positionals = self._get_positional_actions()
-
-        # function to convert arg_strings into positional actions
-        def consume_positionals(start_index):
-            # match as many Positionals as possible
-            match_partial = self._match_arguments_partial
-            selected_pattern = arg_strings_pattern[start_index:]
-            arg_counts = match_partial(positionals, selected_pattern)
-
-            # slice off the appropriate arg strings for each Positional
-            # and add the Positional and its args to the list
-            for action, arg_count in zip(positionals, arg_counts):
-                args = arg_strings[start_index: start_index + arg_count]
-                start_index += arg_count
-                take_action(action, args)
-
-            # slice off the Positionals that we just parsed and return the
-            # index at which the Positionals' string args stopped
-            positionals[:] = positionals[len(arg_counts):]
-            return start_index
-
-        # consume Positionals and Optionals alternately, until we have
-        # passed the last option string
-        extras = []
-        start_index = 0
-        if option_string_indices:
-            max_option_string_index = max(option_string_indices)
-        else:
-            max_option_string_index = -1
-        while start_index <= max_option_string_index:
-
-            # consume any Positionals preceding the next option
-            next_option_string_index = min([
-                index
-                for index in option_string_indices
-                if index >= start_index])
-            if start_index != next_option_string_index:
-                positionals_end_index = consume_positionals(start_index)
-
-                # only try to parse the next optional if we didn't consume
-                # the option string during the positionals parsing
-                if positionals_end_index > start_index:
-                    start_index = positionals_end_index
-                    continue
-                else:
-                    start_index = positionals_end_index
-
-            # if we consumed all the positionals we could and we're not
-            # at the index of an option string, there were extra arguments
-            if start_index not in option_string_indices:
-                strings = arg_strings[start_index:next_option_string_index]
-                extras.extend(strings)
-                start_index = next_option_string_index
-
-            # consume the next optional and any arguments for it
-            start_index = consume_optional(start_index)
-
-        # consume any positionals following the last Optional
-        stop_index = consume_positionals(start_index)
-
-        # if we didn't consume all the argument strings, there were extras
-        extras.extend(arg_strings[stop_index:])
-
-        # if we didn't use all the Positional objects, there were too few
-        # arg strings supplied.
-        if positionals:
-            self.error(_('too few arguments'))
-
-        # make sure all required actions were present
-        for action in self._actions:
-            if action.required:
-                if action not in seen_actions:
-                    name = _get_action_name(action)
-                    self.error(_('argument %s is required') % name)
-
-        # make sure all required groups had one option present
-        for group in self._mutually_exclusive_groups:
-            if group.required:
-                for action in group._group_actions:
-                    if action in seen_non_default_actions:
-                        break
-
-                # if no actions were used, report the error
-                else:
-                    names = [_get_action_name(action)
-                             for action in group._group_actions
-                             if action.help is not SUPPRESS]
-                    msg = _('one of the arguments %s is required')
-                    self.error(msg % ' '.join(names))
-
-        # return the updated namespace and the extra arguments
-        return namespace, extras
-
-    def _read_args_from_files(self, arg_strings):
-        # expand arguments referencing files
-        new_arg_strings = []
-        for arg_string in arg_strings:
-
-            # for regular arguments, just add them back into the list
-            if arg_string[0] not in self.fromfile_prefix_chars:
-                new_arg_strings.append(arg_string)
-
-            # replace arguments referencing files with the file content
-            else:
-                try:
-                    args_file = open(arg_string[1:])
-                    try:
-                        arg_strings = []
-                        for arg_line in args_file.read().splitlines():
-                            for arg in self.convert_arg_line_to_args(arg_line):
-                                arg_strings.append(arg)
-                        arg_strings = self._read_args_from_files(arg_strings)
-                        new_arg_strings.extend(arg_strings)
-                    finally:
-                        args_file.close()
-                except IOError:
-                    err = _sys.exc_info()[1]
-                    self.error(str(err))
-
-        # return the modified argument list
-        return new_arg_strings
-
-    def convert_arg_line_to_args(self, arg_line):
-        return [arg_line]
-
-    def _match_argument(self, action, arg_strings_pattern):
-        # match the pattern for this action to the arg strings
-        nargs_pattern = self._get_nargs_pattern(action)
-        match = _re.match(nargs_pattern, arg_strings_pattern)
-
-        # raise an exception if we weren't able to find a match
-        if match is None:
-            nargs_errors = {
-                None: _('expected one argument'),
-                OPTIONAL: _('expected at most one argument'),
-                ONE_OR_MORE: _('expected at least one argument'),
-            }
-            default = _('expected %s argument(s)') % action.nargs
-            msg = nargs_errors.get(action.nargs, default)
-            raise ArgumentError(action, msg)
-
-        # return the number of arguments matched
-        return len(match.group(1))
-
-    def _match_arguments_partial(self, actions, arg_strings_pattern):
-        # progressively shorten the actions list by slicing off the
-        # final actions until we find a match
-        result = []
-        for i in range(len(actions), 0, -1):
-            actions_slice = actions[:i]
-            pattern = ''.join([self._get_nargs_pattern(action)
-                               for action in actions_slice])
-            match = _re.match(pattern, arg_strings_pattern)
-            if match is not None:
-                result.extend([len(string) for string in match.groups()])
-                break
-
-        # return the list of arg string counts
-        return result
-
-    def _parse_optional(self, arg_string):
-        # if it's an empty string, it was meant to be a positional
-        if not arg_string:
-            return None
-
-        # if it doesn't start with a prefix, it was meant to be positional
-        if not arg_string[0] in self.prefix_chars:
-            return None
-
-        # if the option string is present in the parser, return the action
-        if arg_string in self._option_string_actions:
-            action = self._option_string_actions[arg_string]
-            return action, arg_string, None
-
-        # if it's just a single character, it was meant to be positional
-        if len(arg_string) == 1:
-            return None
-
-        # if the option string before the "=" is present, return the action
-        if '=' in arg_string:
-            option_string, explicit_arg = arg_string.split('=', 1)
-            if option_string in self._option_string_actions:
-                action = self._option_string_actions[option_string]
-                return action, option_string, explicit_arg
-
-        # search through all possible prefixes of the option string
-        # and all actions in the parser for possible interpretations
-        option_tuples = self._get_option_tuples(arg_string)
-
-        # if multiple actions match, the option string was ambiguous
-        if len(option_tuples) > 1:
-            options = ', '.join([option_string
-                for action, option_string, explicit_arg in option_tuples])
-            tup = arg_string, options
-            self.error(_('ambiguous option: %s could match %s') % tup)
-
-        # if exactly one action matched, this segmentation is good,
-        # so return the parsed action
-        elif len(option_tuples) == 1:
-            option_tuple, = option_tuples
-            return option_tuple
-
-        # if it was not found as an option, but it looks like a negative
-        # number, it was meant to be positional
-        # unless there are negative-number-like options
-        if self._negative_number_matcher.match(arg_string):
-            if not self._has_negative_number_optionals:
-                return None
-
-        # if it contains a space, it was meant to be a positional
-        if ' ' in arg_string:
-            return None
-
-        # it was meant to be an optional but there is no such option
-        # in this parser (though it might be a valid option in a subparser)
-        return None, arg_string, None
-
-    def _get_option_tuples(self, option_string):
-        result = []
-
-        # option strings starting with two prefix characters are only
-        # split at the '='
-        chars = self.prefix_chars
-        if option_string[0] in chars and option_string[1] in chars:
-            if '=' in option_string:
-                option_prefix, explicit_arg = option_string.split('=', 1)
-            else:
-                option_prefix = option_string
-                explicit_arg = None
-            for option_string in self._option_string_actions:
-                if option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # single character options can be concatenated with their arguments
-        # but multiple character options always have to have their argument
-        # separate
-        elif option_string[0] in chars and option_string[1] not in chars:
-            option_prefix = option_string
-            explicit_arg = None
-            short_option_prefix = option_string[:2]
-            short_explicit_arg = option_string[2:]
-
-            for option_string in self._option_string_actions:
-                if option_string == short_option_prefix:
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, short_explicit_arg
-                    result.append(tup)
-                elif option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # shouldn't ever get here
-        else:
-            self.error(_('unexpected option string: %s') % option_string)
-
-        # return the collected option tuples
-        return result
-
-    def _get_nargs_pattern(self, action):
-        # in all examples below, we have to allow for '--' args
-        # which are represented as '-' in the pattern
-        nargs = action.nargs
-
-        # the default (None) is assumed to be a single argument
-        if nargs is None:
-            nargs_pattern = '(-*A-*)'
-
-        # allow zero or one arguments
-        elif nargs == OPTIONAL:
-            nargs_pattern = '(-*A?-*)'
-
-        # allow zero or more arguments
-        elif nargs == ZERO_OR_MORE:
-            nargs_pattern = '(-*[A-]*)'
-
-        # allow one or more arguments
-        elif nargs == ONE_OR_MORE:
-            nargs_pattern = '(-*A[A-]*)'
-
-        # allow any number of options or arguments
-        elif nargs == REMAINDER:
-            nargs_pattern = '([-AO]*)'
-
-        # allow one argument followed by any number of options or arguments
-        elif nargs == PARSER:
-            nargs_pattern = '(-*A[-AO]*)'
-
-        # all others should be integers
-        else:
-            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
-
-        # if this is an optional action, -- is not allowed
-        if action.option_strings:
-            nargs_pattern = nargs_pattern.replace('-*', '')
-            nargs_pattern = nargs_pattern.replace('-', '')
-
-        # return the pattern
-        return nargs_pattern
-
-    # ========================
-    # Value conversion methods
-    # ========================
-    def _get_values(self, action, arg_strings):
-        # for everything but PARSER args, strip out '--'
-        if action.nargs not in [PARSER, REMAINDER]:
-            arg_strings = [s for s in arg_strings if s != '--']
-
-        # optional argument produces a default when not present
-        if not arg_strings and action.nargs == OPTIONAL:
-            if action.option_strings:
-                value = action.const
-            else:
-                value = action.default
-            if isinstance(value, basestring):
-                value = self._get_value(action, value)
-                self._check_value(action, value)
-
-        # when nargs='*' on a positional, if there were no command-line
-        # args, use the default if it is anything other than None
-        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
-              not action.option_strings):
-            if action.default is not None:
-                value = action.default
-            else:
-                value = arg_strings
-            self._check_value(action, value)
-
-        # single argument or optional argument produces a single value
-        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
-            arg_string, = arg_strings
-            value = self._get_value(action, arg_string)
-            self._check_value(action, value)
-
-        # REMAINDER arguments convert all values, checking none
-        elif action.nargs == REMAINDER:
-            value = [self._get_value(action, v) for v in arg_strings]
-
-        # PARSER arguments convert all values, but check only the first
-        elif action.nargs == PARSER:
-            value = [self._get_value(action, v) for v in arg_strings]
-            self._check_value(action, value[0])
-
-        # all other types of nargs produce a list
-        else:
-            value = [self._get_value(action, v) for v in arg_strings]
-            for v in value:
-                self._check_value(action, v)
-
-        # return the converted value
-        return value
-
-    def _get_value(self, action, arg_string):
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            msg = _('%r is not callable')
-            raise ArgumentError(action, msg % type_func)
-
-        # convert the value to the appropriate type
-        try:
-            result = type_func(arg_string)
-
-        # ArgumentTypeErrors indicate errors
-        except ArgumentTypeError:
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = str(_sys.exc_info()[1])
-            raise ArgumentError(action, msg)
-
-        # TypeErrors or ValueErrors also indicate errors
-        except (TypeError, ValueError):
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = _('invalid %s value: %r')
-            raise ArgumentError(action, msg % (name, arg_string))
-
-        # return the converted value
-        return result
-
-    def _check_value(self, action, value):
-        # converted value must be one of the choices (if specified)
-        if action.choices is not None and value not in action.choices:
-            tup = value, ', '.join(map(repr, action.choices))
-            msg = _('invalid choice: %r (choose from %s)') % tup
-            raise ArgumentError(action, msg)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_usage(self):
-        formatter = self._get_formatter()
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-        return formatter.format_help()
-
-    def format_help(self):
-        formatter = self._get_formatter()
-
-        # usage
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-
-        # description
-        formatter.add_text(self.description)
-
-        # positionals, optionals and user-defined groups
-        for action_group in self._action_groups:
-            formatter.start_section(action_group.title)
-            formatter.add_text(action_group.description)
-            formatter.add_arguments(action_group._group_actions)
-            formatter.end_section()
-
-        # epilog
-        formatter.add_text(self.epilog)
-
-        # determine help from format above
-        return formatter.format_help()
-
-    def format_version(self):
-        import warnings
-        warnings.warn(
-            'The format_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        formatter = self._get_formatter()
-        formatter.add_text(self.version)
-        return formatter.format_help()
-
-    def _get_formatter(self):
-        return self.formatter_class(prog=self.prog)
-
-    # =====================
-    # Help-printing methods
-    # =====================
-    def print_usage(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_usage(), file)
-
-    def print_help(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_help(), file)
-
-    def print_version(self, file=None):
-        import warnings
-        warnings.warn(
-            'The print_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        self._print_message(self.format_version(), file)
-
-    def _print_message(self, message, file=None):
-        if message:
-            if file is None:
-                file = _sys.stderr
-            file.write(message)
-
-    # ===============
-    # Exiting methods
-    # ===============
-    def exit(self, status=0, message=None):
-        if message:
-            self._print_message(message, _sys.stderr)
-        _sys.exit(status)
-
-    def error(self, message):
-        """error(message: string)
-
-        Prints a usage message incorporating the message to stderr and
-        exits.
-
-        If you override this in a subclass, it should not return -- it
-        should either exit or raise an exception.
-        """
-        self.print_usage(_sys.stderr)
-        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/config.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/config.py
deleted file mode 100644
index aa978949d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/config.py
+++ /dev/null
@@ -1,1950 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-# Please remember to run "make -C docs html" after update "desc" attributes.
-
-import copy
-import grp
-import inspect
-try:
-    import argparse
-except ImportError:  # python 2.6
-    from . import argparse_compat as argparse
-import os
-import pwd
-import re
-import ssl
-import sys
-import textwrap
-import shlex
-
-from gunicorn import __version__
-from gunicorn import _compat
-from gunicorn.errors import ConfigError
-from gunicorn.reloader import reloader_engines
-from gunicorn import six
-from gunicorn import util
-
-KNOWN_SETTINGS = []
-PLATFORM = sys.platform
-
-
-def make_settings(ignore=None):
-    settings = {}
-    ignore = ignore or ()
-    for s in KNOWN_SETTINGS:
-        setting = s()
-        if setting.name in ignore:
-            continue
-        settings[setting.name] = setting.copy()
-    return settings
-
-
-def auto_int(_, x):
-    # for compatible with octal numbers in python3
-    if re.match(r'0(\d)', x, re.IGNORECASE):
-        x = x.replace('0', '0o', 1)
-    return int(x, 0)
-
-
-class Config(object):
-
-    def __init__(self, usage=None, prog=None):
-        self.settings = make_settings()
-        self.usage = usage
-        self.prog = prog or os.path.basename(sys.argv[0])
-        self.env_orig = os.environ.copy()
-
-    def __getattr__(self, name):
-        if name not in self.settings:
-            raise AttributeError("No configuration setting for: %s" % name)
-        return self.settings[name].get()
-
-    def __setattr__(self, name, value):
-        if name != "settings" and name in self.settings:
-            raise AttributeError("Invalid access!")
-        super(Config, self).__setattr__(name, value)
-
-    def set(self, name, value):
-        if name not in self.settings:
-            raise AttributeError("No configuration setting for: %s" % name)
-        self.settings[name].set(value)
-
-    def get_cmd_args_from_env(self):
-        if 'GUNICORN_CMD_ARGS' in self.env_orig:
-            return shlex.split(self.env_orig['GUNICORN_CMD_ARGS'])
-        return []
-
-    def parser(self):
-        kwargs = {
-            "usage": self.usage,
-            "prog": self.prog
-        }
-        parser = argparse.ArgumentParser(**kwargs)
-        parser.add_argument("-v", "--version",
-                action="version", default=argparse.SUPPRESS,
-                version="%(prog)s (version " + __version__ + ")\n",
-                help="show program's version number and exit")
-        parser.add_argument("args", nargs="*", help=argparse.SUPPRESS)
-
-        keys = sorted(self.settings, key=self.settings.__getitem__)
-        for k in keys:
-            self.settings[k].add_option(parser)
-
-        return parser
-
-    @property
-    def worker_class_str(self):
-        uri = self.settings['worker_class'].get()
-
-        ## are we using a threaded worker?
-        is_sync = uri.endswith('SyncWorker') or uri == 'sync'
-        if is_sync and self.threads > 1:
-            return "threads"
-        return uri
-
-    @property
-    def worker_class(self):
-        uri = self.settings['worker_class'].get()
-
-        ## are we using a threaded worker?
-        is_sync = uri.endswith('SyncWorker') or uri == 'sync'
-        if is_sync and self.threads > 1:
-            uri = "gunicorn.workers.gthread.ThreadWorker"
-
-        worker_class = util.load_class(uri)
-        if hasattr(worker_class, "setup"):
-            worker_class.setup()
-        return worker_class
-
-    @property
-    def address(self):
-        s = self.settings['bind'].get()
-        return [util.parse_address(_compat.bytes_to_str(bind)) for bind in s]
-
-    @property
-    def uid(self):
-        return self.settings['user'].get()
-
-    @property
-    def gid(self):
-        return self.settings['group'].get()
-
-    @property
-    def proc_name(self):
-        pn = self.settings['proc_name'].get()
-        if pn is not None:
-            return pn
-        else:
-            return self.settings['default_proc_name'].get()
-
-    @property
-    def logger_class(self):
-        uri = self.settings['logger_class'].get()
-        if uri == "simple":
-            # support the default
-            uri = LoggerClass.default
-
-        # if default logger is in use, and statsd is on, automagically switch
-        # to the statsd logger
-        if uri == LoggerClass.default:
-            if 'statsd_host' in self.settings and self.settings['statsd_host'].value is not None:
-                uri = "gunicorn.instrument.statsd.Statsd"
-
-        logger_class = util.load_class(
-            uri,
-            default="gunicorn.glogging.Logger",
-            section="gunicorn.loggers")
-
-        if hasattr(logger_class, "install"):
-            logger_class.install()
-        return logger_class
-
-    @property
-    def is_ssl(self):
-        return self.certfile or self.keyfile
-
-    @property
-    def ssl_options(self):
-        opts = {}
-        for name, value in self.settings.items():
-            if value.section == 'SSL':
-                opts[name] = value.get()
-        return opts
-
-    @property
-    def env(self):
-        raw_env = self.settings['raw_env'].get()
-        env = {}
-
-        if not raw_env:
-            return env
-
-        for e in raw_env:
-            s = _compat.bytes_to_str(e)
-            try:
-                k, v = s.split('=', 1)
-            except ValueError:
-                raise RuntimeError("environment setting %r invalid" % s)
-
-            env[k] = v
-
-        return env
-
-    @property
-    def sendfile(self):
-        if self.settings['sendfile'].get() is not None:
-            return False
-
-        if 'SENDFILE' in os.environ:
-            sendfile = os.environ['SENDFILE'].lower()
-            return sendfile in ['y', '1', 'yes', 'true']
-
-        return True
-
-    @property
-    def reuse_port(self):
-        return self.settings['reuse_port'].get()
-
-    @property
-    def paste_global_conf(self):
-        raw_global_conf = self.settings['raw_paste_global_conf'].get()
-        if raw_global_conf is None:
-            return None
-
-        global_conf = {}
-        for e in raw_global_conf:
-            s = _compat.bytes_to_str(e)
-            try:
-                k, v = re.split(r'(?<!\\)=', s, 1)
-            except ValueError:
-                raise RuntimeError("environment setting %r invalid" % s)
-            k = k.replace('\\=', '=')
-            v = v.replace('\\=', '=')
-            global_conf[k] = v
-
-        return global_conf
-
-
-class SettingMeta(type):
-    def __new__(cls, name, bases, attrs):
-        super_new = super(SettingMeta, cls).__new__
-        parents = [b for b in bases if isinstance(b, SettingMeta)]
-        if not parents:
-            return super_new(cls, name, bases, attrs)
-
-        attrs["order"] = len(KNOWN_SETTINGS)
-        attrs["validator"] = staticmethod(attrs["validator"])
-
-        new_class = super_new(cls, name, bases, attrs)
-        new_class.fmt_desc(attrs.get("desc", ""))
-        KNOWN_SETTINGS.append(new_class)
-        return new_class
-
-    def fmt_desc(cls, desc):
-        desc = textwrap.dedent(desc).strip()
-        setattr(cls, "desc", desc)
-        setattr(cls, "short", desc.splitlines()[0])
-
-
-class Setting(object):
-    name = None
-    value = None
-    section = None
-    cli = None
-    validator = None
-    type = None
-    meta = None
-    action = None
-    default = None
-    short = None
-    desc = None
-    nargs = None
-    const = None
-
-    def __init__(self):
-        if self.default is not None:
-            self.set(self.default)
-
-    def add_option(self, parser):
-        if not self.cli:
-            return
-        args = tuple(self.cli)
-
-        help_txt = "%s [%s]" % (self.short, self.default)
-        help_txt = help_txt.replace("%", "%%")
-
-        kwargs = {
-            "dest": self.name,
-            "action": self.action or "store",
-            "type": self.type or str,
-            "default": None,
-            "help": help_txt
-        }
-
-        if self.meta is not None:
-            kwargs['metavar'] = self.meta
-
-        if kwargs["action"] != "store":
-            kwargs.pop("type")
-
-        if self.nargs is not None:
-            kwargs["nargs"] = self.nargs
-
-        if self.const is not None:
-            kwargs["const"] = self.const
-
-        parser.add_argument(*args, **kwargs)
-
-    def copy(self):
-        return copy.copy(self)
-
-    def get(self):
-        return self.value
-
-    def set(self, val):
-        if not six.callable(self.validator):
-            raise TypeError('Invalid validator: %s' % self.name)
-        self.value = self.validator(val)
-
-    def __lt__(self, other):
-        return (self.section == other.section and
-                self.order < other.order)
-    __cmp__ = __lt__
-
-Setting = SettingMeta('Setting', (Setting,), {})
-
-
-def validate_bool(val):
-    if val is None:
-        return
-
-    if isinstance(val, bool):
-        return val
-    if not isinstance(val, six.string_types):
-        raise TypeError("Invalid type for casting: %s" % val)
-    if val.lower().strip() == "true":
-        return True
-    elif val.lower().strip() == "false":
-        return False
-    else:
-        raise ValueError("Invalid boolean: %s" % val)
-
-
-def validate_dict(val):
-    if not isinstance(val, dict):
-        raise TypeError("Value is not a dictionary: %s " % val)
-    return val
-
-
-def validate_pos_int(val):
-    if not isinstance(val, six.integer_types):
-        val = int(val, 0)
-    else:
-        # Booleans are ints!
-        val = int(val)
-    if val < 0:
-        raise ValueError("Value must be positive: %s" % val)
-    return val
-
-
-def validate_string(val):
-    if val is None:
-        return None
-    if not isinstance(val, six.string_types):
-        raise TypeError("Not a string: %s" % val)
-    return val.strip()
-
-
-def validate_file_exists(val):
-    if val is None:
-        return None
-    if not os.path.exists(val):
-        raise ValueError("File %s does not exists." % val)
-    return val
-
-
-def validate_list_string(val):
-    if not val:
-        return []
-
-    # legacy syntax
-    if isinstance(val, six.string_types):
-        val = [val]
-
-    return [validate_string(v) for v in val]
-
-
-def validate_list_of_existing_files(val):
-    return [validate_file_exists(v) for v in validate_list_string(val)]
-
-
-def validate_string_to_list(val):
-    val = validate_string(val)
-
-    if not val:
-        return []
-
-    return [v.strip() for v in val.split(",") if v]
-
-
-def validate_class(val):
-    if inspect.isfunction(val) or inspect.ismethod(val):
-        val = val()
-    if inspect.isclass(val):
-        return val
-    return validate_string(val)
-
-
-def validate_callable(arity):
-    def _validate_callable(val):
-        if isinstance(val, six.string_types):
-            try:
-                mod_name, obj_name = val.rsplit(".", 1)
-            except ValueError:
-                raise TypeError("Value '%s' is not import string. "
-                                "Format: module[.submodules...].object" % val)
-            try:
-                mod = __import__(mod_name, fromlist=[obj_name])
-                val = getattr(mod, obj_name)
-            except ImportError as e:
-                raise TypeError(str(e))
-            except AttributeError:
-                raise TypeError("Can not load '%s' from '%s'"
-                    "" % (obj_name, mod_name))
-        if not six.callable(val):
-            raise TypeError("Value is not six.callable: %s" % val)
-        if arity != -1 and arity != _compat.get_arity(val):
-            raise TypeError("Value must have an arity of: %s" % arity)
-        return val
-    return _validate_callable
-
-
-def validate_user(val):
-    if val is None:
-        return os.geteuid()
-    if isinstance(val, int):
-        return val
-    elif val.isdigit():
-        return int(val)
-    else:
-        try:
-            return pwd.getpwnam(val).pw_uid
-        except KeyError:
-            raise ConfigError("No such user: '%s'" % val)
-
-
-def validate_group(val):
-    if val is None:
-        return os.getegid()
-
-    if isinstance(val, int):
-        return val
-    elif val.isdigit():
-        return int(val)
-    else:
-        try:
-            return grp.getgrnam(val).gr_gid
-        except KeyError:
-            raise ConfigError("No such group: '%s'" % val)
-
-
-def validate_post_request(val):
-    val = validate_callable(-1)(val)
-
-    largs = _compat.get_arity(val)
-    if largs == 4:
-        return val
-    elif largs == 3:
-        return lambda worker, req, env, _r: val(worker, req, env)
-    elif largs == 2:
-        return lambda worker, req, _e, _r: val(worker, req)
-    else:
-        raise TypeError("Value must have an arity of: 4")
-
-
-def validate_chdir(val):
-    # valid if the value is a string
-    val = validate_string(val)
-
-    # transform relative paths
-    path = os.path.abspath(os.path.normpath(os.path.join(util.getcwd(), val)))
-
-    # test if the path exists
-    if not os.path.exists(path):
-        raise ConfigError("can't chdir to %r" % val)
-
-    return path
-
-
-def validate_hostport(val):
-    val = validate_string(val)
-    if val is None:
-        return None
-    elements = val.split(":")
-    if len(elements) == 2:
-        return (elements[0], int(elements[1]))
-    else:
-        raise TypeError("Value must consist of: hostname:port")
-
-
-def validate_reload_engine(val):
-    if val not in reloader_engines:
-        raise ConfigError("Invalid reload_engine: %r" % val)
-
-    return val
-
-
-def get_default_config_file():
-    config_path = os.path.join(os.path.abspath(os.getcwd()),
-            'gunicorn.conf.py')
-    if os.path.exists(config_path):
-        return config_path
-    return None
-
-
-class ConfigFile(Setting):
-    name = "config"
-    section = "Config File"
-    cli = ["-c", "--config"]
-    meta = "CONFIG"
-    validator = validate_string
-    default = None
-    desc = """\
-        The Gunicorn config file.
-
-        A string of the form ``PATH``, ``file:PATH``, or ``python:MODULE_NAME``.
-
-        Only has an effect when specified on the command line or as part of an
-        application specific configuration.
-
-        .. versionchanged:: 19.4
-           Loading the config from a Python module requires the ``python:``
-           prefix.
-        """
-
-class Bind(Setting):
-    name = "bind"
-    action = "append"
-    section = "Server Socket"
-    cli = ["-b", "--bind"]
-    meta = "ADDRESS"
-    validator = validate_list_string
-
-    if 'PORT' in os.environ:
-        default = ['0.0.0.0:{0}'.format(os.environ.get('PORT'))]
-    else:
-        default = ['127.0.0.1:8000']
-
-    desc = """\
-        The socket to bind.
-
-        A string of the form: ``HOST``, ``HOST:PORT``, ``unix:PATH``. An IP is
-        a valid ``HOST``.
-
-        Multiple addresses can be bound. ex.::
-
-            $ gunicorn -b 127.0.0.1:8000 -b [::1]:8000 test:app
-
-        will bind the `test:app` application on localhost both on ipv6
-        and ipv4 interfaces.
-        """
-
-
-class Backlog(Setting):
-    name = "backlog"
-    section = "Server Socket"
-    cli = ["--backlog"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 2048
-    desc = """\
-        The maximum number of pending connections.
-
-        This refers to the number of clients that can be waiting to be served.
-        Exceeding this number results in the client getting an error when
-        attempting to connect. It should only affect servers under significant
-        load.
-
-        Must be a positive integer. Generally set in the 64-2048 range.
-        """
-
-
-class Workers(Setting):
-    name = "workers"
-    section = "Worker Processes"
-    cli = ["-w", "--workers"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = int(os.environ.get("WEB_CONCURRENCY", 1))
-    desc = """\
-        The number of worker processes for handling requests.
-
-        A positive integer generally in the ``2-4 x $(NUM_CORES)`` range.
-        You'll want to vary this a bit to find the best for your particular
-        application's work load.
-
-        By default, the value of the ``WEB_CONCURRENCY`` environment variable.
-        If it is not defined, the default is ``1``.
-        """
-
-
-class WorkerClass(Setting):
-    name = "worker_class"
-    section = "Worker Processes"
-    cli = ["-k", "--worker-class"]
-    meta = "STRING"
-    validator = validate_class
-    default = "sync"
-    desc = """\
-        The type of workers to use.
-
-        The default class (``sync``) should handle most "normal" types of
-        workloads. You'll want to read :doc:`design` for information on when
-        you might want to choose one of the other worker classes. Required
-        libraries may be installed using setuptools' ``extra_require`` feature.
-
-        A string referring to one of the following bundled classes:
-
-        * ``sync``
-        * ``eventlet`` - Requires eventlet >= 0.9.7 (or install it via 
-          ``pip install gunicorn[eventlet]``)
-        * ``gevent``   - Requires gevent >= 0.13 (or install it via 
-          ``pip install gunicorn[gevent]``)
-        * ``tornado``  - Requires tornado >= 0.2 (or install it via 
-          ``pip install gunicorn[tornado]``)
-        * ``gthread``  - Python 2 requires the futures package to be installed
-          (or install it via ``pip install gunicorn[gthread]``)
-        * ``gaiohttp`` - Deprecated.
-
-        Optionally, you can provide your own worker by giving Gunicorn a
-        Python path to a subclass of ``gunicorn.workers.base.Worker``.
-        This alternative syntax will load the gevent class:
-        ``gunicorn.workers.ggevent.GeventWorker``.
-
-        .. deprecated:: 19.8
-           The ``gaiohttp`` worker is deprecated. Please use
-           ``aiohttp.worker.GunicornWebWorker`` instead. See
-           :ref:`asyncio-workers` for more information on how to use it.
-        """
-
-class WorkerThreads(Setting):
-    name = "threads"
-    section = "Worker Processes"
-    cli = ["--threads"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 1
-    desc = """\
-        The number of worker threads for handling requests.
-
-        Run each worker with the specified number of threads.
-
-        A positive integer generally in the ``2-4 x $(NUM_CORES)`` range.
-        You'll want to vary this a bit to find the best for your particular
-        application's work load.
-
-        If it is not defined, the default is ``1``.
-
-        This setting only affects the Gthread worker type.
-        
-        .. note::
-           If you try to use the ``sync`` worker type and set the ``threads``
-           setting to more than 1, the ``gthread`` worker type will be used
-           instead.
-        """
-
-
-class WorkerConnections(Setting):
-    name = "worker_connections"
-    section = "Worker Processes"
-    cli = ["--worker-connections"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 1000
-    desc = """\
-        The maximum number of simultaneous clients.
-
-        This setting only affects the Eventlet and Gevent worker types.
-        """
-
-
-class MaxRequests(Setting):
-    name = "max_requests"
-    section = "Worker Processes"
-    cli = ["--max-requests"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 0
-    desc = """\
-        The maximum number of requests a worker will process before restarting.
-
-        Any value greater than zero will limit the number of requests a work
-        will process before automatically restarting. This is a simple method
-        to help limit the damage of memory leaks.
-
-        If this is set to zero (the default) then the automatic worker
-        restarts are disabled.
-        """
-
-
-class MaxRequestsJitter(Setting):
-    name = "max_requests_jitter"
-    section = "Worker Processes"
-    cli = ["--max-requests-jitter"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 0
-    desc = """\
-        The maximum jitter to add to the *max_requests* setting.
-
-        The jitter causes the restart per worker to be randomized by
-        ``randint(0, max_requests_jitter)``. This is intended to stagger worker
-        restarts to avoid all workers restarting at the same time.
-
-        .. versionadded:: 19.2
-        """
-
-
-class Timeout(Setting):
-    name = "timeout"
-    section = "Worker Processes"
-    cli = ["-t", "--timeout"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 30
-    desc = """\
-        Workers silent for more than this many seconds are killed and restarted.
-
-        Generally set to thirty seconds. Only set this noticeably higher if
-        you're sure of the repercussions for sync workers. For the non sync
-        workers it just means that the worker process is still communicating and
-        is not tied to the length of time required to handle a single request.
-        """
-
-
-class GracefulTimeout(Setting):
-    name = "graceful_timeout"
-    section = "Worker Processes"
-    cli = ["--graceful-timeout"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 30
-    desc = """\
-        Timeout for graceful workers restart.
-
-        After receiving a restart signal, workers have this much time to finish
-        serving requests. Workers still alive after the timeout (starting from
-        the receipt of the restart signal) are force killed.
-        """
-
-
-class Keepalive(Setting):
-    name = "keepalive"
-    section = "Worker Processes"
-    cli = ["--keep-alive"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 2
-    desc = """\
-        The number of seconds to wait for requests on a Keep-Alive connection.
-
-        Generally set in the 1-5 seconds range for servers with direct connection
-        to the client (e.g. when you don't have separate load balancer). When
-        Gunicorn is deployed behind a load balancer, it often makes sense to
-        set this to a higher value.
-
-        .. note::
-           ``sync`` worker does not support persistent connections and will
-           ignore this option.
-        """
-
-
-class LimitRequestLine(Setting):
-    name = "limit_request_line"
-    section = "Security"
-    cli = ["--limit-request-line"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 4094
-    desc = """\
-        The maximum size of HTTP request line in bytes.
-
-        This parameter is used to limit the allowed size of a client's
-        HTTP request-line. Since the request-line consists of the HTTP
-        method, URI, and protocol version, this directive places a
-        restriction on the length of a request-URI allowed for a request
-        on the server. A server needs this value to be large enough to
-        hold any of its resource names, including any information that
-        might be passed in the query part of a GET request. Value is a number
-        from 0 (unlimited) to 8190.
-
-        This parameter can be used to prevent any DDOS attack.
-        """
-
-
-class LimitRequestFields(Setting):
-    name = "limit_request_fields"
-    section = "Security"
-    cli = ["--limit-request-fields"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 100
-    desc = """\
-        Limit the number of HTTP headers fields in a request.
-
-        This parameter is used to limit the number of headers in a request to
-        prevent DDOS attack. Used with the *limit_request_field_size* it allows
-        more safety. By default this value is 100 and can't be larger than
-        32768.
-        """
-
-
-class LimitRequestFieldSize(Setting):
-    name = "limit_request_field_size"
-    section = "Security"
-    cli = ["--limit-request-field_size"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = int
-    default = 8190
-    desc = """\
-        Limit the allowed size of an HTTP request header field.
-
-        Value is a positive number or 0. Setting it to 0 will allow unlimited
-        header field sizes.
-
-        .. warning::
-           Setting this parameter to a very high or unlimited value can open
-           up for DDOS attacks.
-        """
-
-
-class Reload(Setting):
-    name = "reload"
-    section = 'Debugging'
-    cli = ['--reload']
-    validator = validate_bool
-    action = 'store_true'
-    default = False
-
-    desc = '''\
-        Restart workers when code changes.
-
-        This setting is intended for development. It will cause workers to be
-        restarted whenever application code changes.
-
-        The reloader is incompatible with application preloading. When using a
-        paste configuration be sure that the server block does not import any
-        application code or the reload will not work as designed.
-
-        The default behavior is to attempt inotify with a fallback to file
-        system polling. Generally, inotify should be preferred if available
-        because it consumes less system resources.
-
-        .. note::
-           In order to use the inotify reloader, you must have the ``inotify``
-           package installed.
-        '''
-
-
-class ReloadEngine(Setting):
-    name = "reload_engine"
-    section = "Debugging"
-    cli = ["--reload-engine"]
-    meta = "STRING"
-    validator = validate_reload_engine
-    default = "auto"
-    desc = """\
-        The implementation that should be used to power :ref:`reload`.
-
-        Valid engines are:
-
-        * 'auto'
-        * 'poll'
-        * 'inotify' (requires inotify)
-
-        .. versionadded:: 19.7
-        """
-
-
-class ReloadExtraFiles(Setting):
-    name = "reload_extra_files"
-    action = "append"
-    section = "Debugging"
-    cli = ["--reload-extra-file"]
-    meta = "FILES"
-    validator = validate_list_of_existing_files
-    default = []
-    desc = """\
-        Extends :ref:`reload` option to also watch and reload on additional files
-        (e.g., templates, configurations, specifications, etc.).
-
-        .. versionadded:: 19.8
-        """
-
-
-class Spew(Setting):
-    name = "spew"
-    section = "Debugging"
-    cli = ["--spew"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-    desc = """\
-        Install a trace function that spews every line executed by the server.
-
-        This is the nuclear option.
-        """
-
-
-class ConfigCheck(Setting):
-    name = "check_config"
-    section = "Debugging"
-    cli = ["--check-config"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-    desc = """\
-        Check the configuration.
-        """
-
-
-class PreloadApp(Setting):
-    name = "preload_app"
-    section = "Server Mechanics"
-    cli = ["--preload"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-    desc = """\
-        Load application code before the worker processes are forked.
-
-        By preloading an application you can save some RAM resources as well as
-        speed up server boot times. Although, if you defer application loading
-        to each worker process, you can reload your application code easily by
-        restarting workers.
-        """
-
-
-class Sendfile(Setting):
-    name = "sendfile"
-    section = "Server Mechanics"
-    cli = ["--no-sendfile"]
-    validator = validate_bool
-    action = "store_const"
-    const = False
-
-    desc = """\
-        Disables the use of ``sendfile()``.
-
-        If not set, the value of the ``SENDFILE`` environment variable is used
-        to enable or disable its usage.
-
-        .. versionadded:: 19.2
-        .. versionchanged:: 19.4
-           Swapped ``--sendfile`` with ``--no-sendfile`` to actually allow
-           disabling.
-        .. versionchanged:: 19.6
-           added support for the ``SENDFILE`` environment variable
-        """
-
-
-class ReusePort(Setting):
-    name = "reuse_port"
-    section = "Server Mechanics"
-    cli = ["--reuse-port"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-
-    desc = """\
-        Set the ``SO_REUSEPORT`` flag on the listening socket.
-
-        .. versionadded:: 19.8
-        """
-
-
-class Chdir(Setting):
-    name = "chdir"
-    section = "Server Mechanics"
-    cli = ["--chdir"]
-    validator = validate_chdir
-    default = util.getcwd()
-    desc = """\
-        Chdir to specified directory before apps loading.
-        """
-
-
-class Daemon(Setting):
-    name = "daemon"
-    section = "Server Mechanics"
-    cli = ["-D", "--daemon"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-    desc = """\
-        Daemonize the Gunicorn process.
-
-        Detaches the server from the controlling terminal and enters the
-        background.
-        """
-
-class Env(Setting):
-    name = "raw_env"
-    action = "append"
-    section = "Server Mechanics"
-    cli = ["-e", "--env"]
-    meta = "ENV"
-    validator = validate_list_string
-    default = []
-
-    desc = """\
-        Set environment variable (key=value).
-
-        Pass variables to the execution environment. Ex.::
-
-            $ gunicorn -b 127.0.0.1:8000 --env FOO=1 test:app
-
-        and test for the foo variable environment in your application.
-        """
-
-
-class Pidfile(Setting):
-    name = "pidfile"
-    section = "Server Mechanics"
-    cli = ["-p", "--pid"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-        A filename to use for the PID file.
-
-        If not set, no PID file will be written.
-        """
-
-class WorkerTmpDir(Setting):
-    name = "worker_tmp_dir"
-    section = "Server Mechanics"
-    cli = ["--worker-tmp-dir"]
-    meta = "DIR"
-    validator = validate_string
-    default = None
-    desc = """\
-        A directory to use for the worker heartbeat temporary file.
-
-        If not set, the default temporary directory will be used.
-
-        .. note::
-           The current heartbeat system involves calling ``os.fchmod`` on
-           temporary file handlers and may block a worker for arbitrary time
-           if the directory is on a disk-backed filesystem.
-
-           See :ref:`blocking-os-fchmod` for more detailed information
-           and a solution for avoiding this problem.
-        """
-
-
-class User(Setting):
-    name = "user"
-    section = "Server Mechanics"
-    cli = ["-u", "--user"]
-    meta = "USER"
-    validator = validate_user
-    default = os.geteuid()
-    desc = """\
-        Switch worker processes to run as this user.
-
-        A valid user id (as an integer) or the name of a user that can be
-        retrieved with a call to ``pwd.getpwnam(value)`` or ``None`` to not
-        change the worker process user.
-        """
-
-
-class Group(Setting):
-    name = "group"
-    section = "Server Mechanics"
-    cli = ["-g", "--group"]
-    meta = "GROUP"
-    validator = validate_group
-    default = os.getegid()
-    desc = """\
-        Switch worker process to run as this group.
-
-        A valid group id (as an integer) or the name of a user that can be
-        retrieved with a call to ``pwd.getgrnam(value)`` or ``None`` to not
-        change the worker processes group.
-        """
-
-class Umask(Setting):
-    name = "umask"
-    section = "Server Mechanics"
-    cli = ["-m", "--umask"]
-    meta = "INT"
-    validator = validate_pos_int
-    type = auto_int
-    default = 0
-    desc = """\
-        A bit mask for the file mode on files written by Gunicorn.
-
-        Note that this affects unix socket permissions.
-
-        A valid value for the ``os.umask(mode)`` call or a string compatible
-        with ``int(value, 0)`` (``0`` means Python guesses the base, so values
-        like ``0``, ``0xFF``, ``0022`` are valid for decimal, hex, and octal
-        representations)
-        """
-
-
-class Initgroups(Setting):
-    name = "initgroups"
-    section = "Server Mechanics"
-    cli = ["--initgroups"]
-    validator = validate_bool
-    action = 'store_true'
-    default = False
-
-    desc = """\
-        If true, set the worker process's group access list with all of the
-        groups of which the specified username is a member, plus the specified
-        group id.
-
-        .. versionadded:: 19.7
-        """
-
-
-class TmpUploadDir(Setting):
-    name = "tmp_upload_dir"
-    section = "Server Mechanics"
-    meta = "DIR"
-    validator = validate_string
-    default = None
-    desc = """\
-        Directory to store temporary request data as they are read.
-
-        This may disappear in the near future.
-
-        This path should be writable by the process permissions set for Gunicorn
-        workers. If not specified, Gunicorn will choose a system generated
-        temporary directory.
-        """
-
-
-class SecureSchemeHeader(Setting):
-    name = "secure_scheme_headers"
-    section = "Server Mechanics"
-    validator = validate_dict
-    default = {
-        "X-FORWARDED-PROTOCOL": "ssl",
-        "X-FORWARDED-PROTO": "https",
-        "X-FORWARDED-SSL": "on"
-    }
-    desc = """\
-
-        A dictionary containing headers and values that the front-end proxy
-        uses to indicate HTTPS requests. These tell Gunicorn to set
-        ``wsgi.url_scheme`` to ``https``, so your application can tell that the
-        request is secure.
-
-        The dictionary should map upper-case header names to exact string
-        values. The value comparisons are case-sensitive, unlike the header
-        names, so make sure they're exactly what your front-end proxy sends
-        when handling HTTPS requests.
-
-        It is important that your front-end proxy configuration ensures that
-        the headers defined here can not be passed directly from the client.
-        """
-
-
-class ForwardedAllowIPS(Setting):
-    name = "forwarded_allow_ips"
-    section = "Server Mechanics"
-    cli = ["--forwarded-allow-ips"]
-    meta = "STRING"
-    validator = validate_string_to_list
-    default = os.environ.get("FORWARDED_ALLOW_IPS", "127.0.0.1")
-    desc = """\
-        Front-end's IPs from which allowed to handle set secure headers.
-        (comma separate).
-
-        Set to ``*`` to disable checking of Front-end IPs (useful for setups
-        where you don't know in advance the IP address of Front-end, but
-        you still trust the environment).
-
-        By default, the value of the ``FORWARDED_ALLOW_IPS`` environment
-        variable. If it is not defined, the default is ``"127.0.0.1"``.
-        """
-
-
-class AccessLog(Setting):
-    name = "accesslog"
-    section = "Logging"
-    cli = ["--access-logfile"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-        The Access log file to write to.
-
-        ``'-'`` means log to stdout.
-        """
-
-class DisableRedirectAccessToSyslog(Setting):
-    name = "disable_redirect_access_to_syslog"
-    section = "Logging"
-    cli = ["--disable-redirect-access-to-syslog"]
-    validator = validate_bool
-    action = 'store_true'
-    default = False
-    desc = """\
-    Disable redirect access logs to syslog.
-
-    .. versionadded:: 19.8
-    """
-
-
-class AccessLogFormat(Setting):
-    name = "access_log_format"
-    section = "Logging"
-    cli = ["--access-logformat"]
-    meta = "STRING"
-    validator = validate_string
-    default = '%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'
-    desc = """\
-        The access log format.
-
-        ===========  ===========
-        Identifier   Description
-        ===========  ===========
-        h            remote address
-        l            ``'-'``
-        u            user name
-        t            date of the request
-        r            status line (e.g. ``GET / HTTP/1.1``)
-        m            request method
-        U            URL path without query string
-        q            query string
-        H            protocol
-        s            status
-        B            response length
-        b            response length or ``'-'`` (CLF format)
-        f            referer
-        a            user agent
-        T            request time in seconds
-        D            request time in microseconds
-        L            request time in decimal seconds
-        p            process ID
-        {Header}i    request header
-        {Header}o    response header
-        {Variable}e  environment variable
-        ===========  ===========
-        """
-
-
-class ErrorLog(Setting):
-    name = "errorlog"
-    section = "Logging"
-    cli = ["--error-logfile", "--log-file"]
-    meta = "FILE"
-    validator = validate_string
-    default = '-'
-    desc = """\
-        The Error log file to write to.
-
-        Using ``'-'`` for FILE makes gunicorn log to stderr.
-
-        .. versionchanged:: 19.2
-           Log to stderr by default.
-
-        """
-
-
-class Loglevel(Setting):
-    name = "loglevel"
-    section = "Logging"
-    cli = ["--log-level"]
-    meta = "LEVEL"
-    validator = validate_string
-    default = "info"
-    desc = """\
-        The granularity of Error log outputs.
-
-        Valid level names are:
-
-        * debug
-        * info
-        * warning
-        * error
-        * critical
-        """
-
-
-class CaptureOutput(Setting):
-    name = "capture_output"
-    section = "Logging"
-    cli = ["--capture-output"]
-    validator = validate_bool
-    action = 'store_true'
-    default = False
-    desc = """\
-        Redirect stdout/stderr to specified file in :ref:`errorlog`.
-
-        .. versionadded:: 19.6
-        """
-
-
-class LoggerClass(Setting):
-    name = "logger_class"
-    section = "Logging"
-    cli = ["--logger-class"]
-    meta = "STRING"
-    validator = validate_class
-    default = "gunicorn.glogging.Logger"
-    desc = """\
-        The logger you want to use to log events in Gunicorn.
-
-        The default class (``gunicorn.glogging.Logger``) handle most of
-        normal usages in logging. It provides error and access logging.
-
-        You can provide your own logger by giving Gunicorn a
-        Python path to a subclass like ``gunicorn.glogging.Logger``.
-        """
-
-
-class LogConfig(Setting):
-    name = "logconfig"
-    section = "Logging"
-    cli = ["--log-config"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-    The log config file to use.
-    Gunicorn uses the standard Python logging module's Configuration
-    file format.
-    """
-
-
-class LogConfigDict(Setting):
-    name = "logconfig_dict"
-    section = "Logging"
-    cli = ["--log-config-dict"]
-    validator = validate_dict
-    default = {}
-    desc = """\
-    The log config dictionary to use, using the standard Python
-    logging module's dictionary configuration format. This option
-    takes precedence over the :ref:`logconfig` option, which uses the
-    older file configuration format.
-
-    Format: https://docs.python.org/3/library/logging.config.html#logging.config.dictConfig
-
-    .. versionadded:: 19.8
-    """
-
-
-class SyslogTo(Setting):
-    name = "syslog_addr"
-    section = "Logging"
-    cli = ["--log-syslog-to"]
-    meta = "SYSLOG_ADDR"
-    validator = validate_string
-
-    if PLATFORM == "darwin":
-        default = "unix:///var/run/syslog"
-    elif PLATFORM in ('freebsd', 'dragonfly', ):
-        default = "unix:///var/run/log"
-    elif PLATFORM == "openbsd":
-        default = "unix:///dev/log"
-    else:
-        default = "udp://localhost:514"
-
-    desc = """\
-    Address to send syslog messages.
-
-    Address is a string of the form:
-
-    * ``unix://PATH#TYPE`` : for unix domain socket. ``TYPE`` can be ``stream``
-      for the stream driver or ``dgram`` for the dgram driver.
-      ``stream`` is the default.
-    * ``udp://HOST:PORT`` : for UDP sockets
-    * ``tcp://HOST:PORT`` : for TCP sockets
-
-    """
-
-
-class Syslog(Setting):
-    name = "syslog"
-    section = "Logging"
-    cli = ["--log-syslog"]
-    validator = validate_bool
-    action = 'store_true'
-    default = False
-    desc = """\
-    Send *Gunicorn* logs to syslog.
-
-    .. versionchanged:: 19.8
-       You can now disable sending access logs by using the
-       :ref:`disable-redirect-access-to-syslog` setting.
-    """
-
-
-class SyslogPrefix(Setting):
-    name = "syslog_prefix"
-    section = "Logging"
-    cli = ["--log-syslog-prefix"]
-    meta = "SYSLOG_PREFIX"
-    validator = validate_string
-    default = None
-    desc = """\
-    Makes Gunicorn use the parameter as program-name in the syslog entries.
-
-    All entries will be prefixed by ``gunicorn.<prefix>``. By default the
-    program name is the name of the process.
-    """
-
-
-class SyslogFacility(Setting):
-    name = "syslog_facility"
-    section = "Logging"
-    cli = ["--log-syslog-facility"]
-    meta = "SYSLOG_FACILITY"
-    validator = validate_string
-    default = "user"
-    desc = """\
-    Syslog facility name
-    """
-
-
-class EnableStdioInheritance(Setting):
-    name = "enable_stdio_inheritance"
-    section = "Logging"
-    cli = ["-R", "--enable-stdio-inheritance"]
-    validator = validate_bool
-    default = False
-    action = "store_true"
-    desc = """\
-    Enable stdio inheritance.
-
-    Enable inheritance for stdio file descriptors in daemon mode.
-
-    Note: To disable the Python stdout buffering, you can to set the user
-    environment variable ``PYTHONUNBUFFERED`` .
-    """
-
-
-# statsD monitoring
-class StatsdHost(Setting):
-    name = "statsd_host"
-    section = "Logging"
-    cli = ["--statsd-host"]
-    meta = "STATSD_ADDR"
-    default = None
-    validator = validate_hostport
-    desc = """\
-    ``host:port`` of the statsd server to log to.
-
-    .. versionadded:: 19.1
-    """
-
-class StatsdPrefix(Setting):
-    name = "statsd_prefix"
-    section = "Logging"
-    cli = ["--statsd-prefix"]
-    meta = "STATSD_PREFIX"
-    default = ""
-    validator = validate_string
-    desc = """\
-    Prefix to use when emitting statsd metrics (a trailing ``.`` is added,
-    if not provided).
-
-    .. versionadded:: 19.2
-    """
-
-
-class Procname(Setting):
-    name = "proc_name"
-    section = "Process Naming"
-    cli = ["-n", "--name"]
-    meta = "STRING"
-    validator = validate_string
-    default = None
-    desc = """\
-        A base to use with setproctitle for process naming.
-
-        This affects things like ``ps`` and ``top``. If you're going to be
-        running more than one instance of Gunicorn you'll probably want to set a
-        name to tell them apart. This requires that you install the setproctitle
-        module.
-
-        If not set, the *default_proc_name* setting will be used.
-        """
-
-
-class DefaultProcName(Setting):
-    name = "default_proc_name"
-    section = "Process Naming"
-    validator = validate_string
-    default = "gunicorn"
-    desc = """\
-        Internal setting that is adjusted for each type of application.
-        """
-
-
-class PythonPath(Setting):
-    name = "pythonpath"
-    section = "Server Mechanics"
-    cli = ["--pythonpath"]
-    meta = "STRING"
-    validator = validate_string
-    default = None
-    desc = """\
-        A comma-separated list of directories to add to the Python path.
-
-        e.g.
-        ``'/home/djangoprojects/myproject,/home/python/mylibrary'``.
-        """
-
-
-class Paste(Setting):
-    name = "paste"
-    section = "Server Mechanics"
-    cli = ["--paste", "--paster"]
-    meta = "STRING"
-    validator = validate_string
-    default = None
-    desc = """\
-        Load a PasteDeploy config file. The argument may contain a ``#``
-        symbol followed by the name of an app section from the config file,
-        e.g. ``production.ini#admin``.
-
-        At this time, using alternate server blocks is not supported. Use the
-        command line arguments to control server configuration instead.
-        """
-
-
-class OnStarting(Setting):
-    name = "on_starting"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def on_starting(server):
-        pass
-    default = staticmethod(on_starting)
-    desc = """\
-        Called just before the master process is initialized.
-
-        The callable needs to accept a single instance variable for the Arbiter.
-        """
-
-
-class OnReload(Setting):
-    name = "on_reload"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def on_reload(server):
-        pass
-    default = staticmethod(on_reload)
-    desc = """\
-        Called to recycle workers during a reload via SIGHUP.
-
-        The callable needs to accept a single instance variable for the Arbiter.
-        """
-
-
-class WhenReady(Setting):
-    name = "when_ready"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def when_ready(server):
-        pass
-    default = staticmethod(when_ready)
-    desc = """\
-        Called just after the server is started.
-
-        The callable needs to accept a single instance variable for the Arbiter.
-        """
-
-
-class Prefork(Setting):
-    name = "pre_fork"
-    section = "Server Hooks"
-    validator = validate_callable(2)
-    type = six.callable
-
-    def pre_fork(server, worker):
-        pass
-    default = staticmethod(pre_fork)
-    desc = """\
-        Called just before a worker is forked.
-
-        The callable needs to accept two instance variables for the Arbiter and
-        new Worker.
-        """
-
-
-class Postfork(Setting):
-    name = "post_fork"
-    section = "Server Hooks"
-    validator = validate_callable(2)
-    type = six.callable
-
-    def post_fork(server, worker):
-        pass
-    default = staticmethod(post_fork)
-    desc = """\
-        Called just after a worker has been forked.
-
-        The callable needs to accept two instance variables for the Arbiter and
-        new Worker.
-        """
-
-
-class PostWorkerInit(Setting):
-    name = "post_worker_init"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def post_worker_init(worker):
-        pass
-
-    default = staticmethod(post_worker_init)
-    desc = """\
-        Called just after a worker has initialized the application.
-
-        The callable needs to accept one instance variable for the initialized
-        Worker.
-        """
-
-class WorkerInt(Setting):
-    name = "worker_int"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def worker_int(worker):
-        pass
-
-    default = staticmethod(worker_int)
-    desc = """\
-        Called just after a worker exited on SIGINT or SIGQUIT.
-
-        The callable needs to accept one instance variable for the initialized
-        Worker.
-        """
-
-
-class WorkerAbort(Setting):
-    name = "worker_abort"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def worker_abort(worker):
-        pass
-
-    default = staticmethod(worker_abort)
-    desc = """\
-        Called when a worker received the SIGABRT signal.
-
-        This call generally happens on timeout.
-
-        The callable needs to accept one instance variable for the initialized
-        Worker.
-        """
-
-
-class PreExec(Setting):
-    name = "pre_exec"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-    type = six.callable
-
-    def pre_exec(server):
-        pass
-    default = staticmethod(pre_exec)
-    desc = """\
-        Called just before a new master process is forked.
-
-        The callable needs to accept a single instance variable for the Arbiter.
-        """
-
-
-class PreRequest(Setting):
-    name = "pre_request"
-    section = "Server Hooks"
-    validator = validate_callable(2)
-    type = six.callable
-
-    def pre_request(worker, req):
-        worker.log.debug("%s %s" % (req.method, req.path))
-    default = staticmethod(pre_request)
-    desc = """\
-        Called just before a worker processes the request.
-
-        The callable needs to accept two instance variables for the Worker and
-        the Request.
-        """
-
-
-class PostRequest(Setting):
-    name = "post_request"
-    section = "Server Hooks"
-    validator = validate_post_request
-    type = six.callable
-
-    def post_request(worker, req, environ, resp):
-        pass
-    default = staticmethod(post_request)
-    desc = """\
-        Called after a worker processes the request.
-
-        The callable needs to accept two instance variables for the Worker and
-        the Request.
-        """
-
-
-class ChildExit(Setting):
-    name = "child_exit"
-    section = "Server Hooks"
-    validator = validate_callable(2)
-    type = six.callable
-
-    def child_exit(server, worker):
-        pass
-    default = staticmethod(child_exit)
-    desc = """\
-        Called just after a worker has been exited, in the master process.
-
-        The callable needs to accept two instance variables for the Arbiter and
-        the just-exited Worker.
-
-        .. versionadded:: 19.7
-        """
-
-
-class WorkerExit(Setting):
-    name = "worker_exit"
-    section = "Server Hooks"
-    validator = validate_callable(2)
-    type = six.callable
-
-    def worker_exit(server, worker):
-        pass
-    default = staticmethod(worker_exit)
-    desc = """\
-        Called just after a worker has been exited, in the worker process.
-
-        The callable needs to accept two instance variables for the Arbiter and
-        the just-exited Worker.
-        """
-
-
-class NumWorkersChanged(Setting):
-    name = "nworkers_changed"
-    section = "Server Hooks"
-    validator = validate_callable(3)
-    type = six.callable
-
-    def nworkers_changed(server, new_value, old_value):
-        pass
-    default = staticmethod(nworkers_changed)
-    desc = """\
-        Called just after *num_workers* has been changed.
-
-        The callable needs to accept an instance variable of the Arbiter and
-        two integers of number of workers after and before change.
-
-        If the number of workers is set for the first time, *old_value* would
-        be ``None``.
-        """
-
-class OnExit(Setting):
-    name = "on_exit"
-    section = "Server Hooks"
-    validator = validate_callable(1)
-
-    def on_exit(server):
-        pass
-
-    default = staticmethod(on_exit)
-    desc = """\
-        Called just before exiting Gunicorn.
-
-        The callable needs to accept a single instance variable for the Arbiter.
-        """
-
-
-class ProxyProtocol(Setting):
-    name = "proxy_protocol"
-    section = "Server Mechanics"
-    cli = ["--proxy-protocol"]
-    validator = validate_bool
-    default = False
-    action = "store_true"
-    desc = """\
-        Enable detect PROXY protocol (PROXY mode).
-
-        Allow using HTTP and Proxy together. It may be useful for work with
-        stunnel as HTTPS frontend and Gunicorn as HTTP server.
-
-        PROXY protocol: http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt
-
-        Example for stunnel config::
-
-            [https]
-            protocol = proxy
-            accept  = 443
-            connect = 80
-            cert = /etc/ssl/certs/stunnel.pem
-            key = /etc/ssl/certs/stunnel.key
-        """
-
-
-class ProxyAllowFrom(Setting):
-    name = "proxy_allow_ips"
-    section = "Server Mechanics"
-    cli = ["--proxy-allow-from"]
-    validator = validate_string_to_list
-    default = "127.0.0.1"
-    desc = """\
-        Front-end's IPs from which allowed accept proxy requests (comma separate).
-
-        Set to ``*`` to disable checking of Front-end IPs (useful for setups
-        where you don't know in advance the IP address of Front-end, but
-        you still trust the environment)
-        """
-
-
-class KeyFile(Setting):
-    name = "keyfile"
-    section = "SSL"
-    cli = ["--keyfile"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-    SSL key file
-    """
-
-
-class CertFile(Setting):
-    name = "certfile"
-    section = "SSL"
-    cli = ["--certfile"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-    SSL certificate file
-    """
-
-class SSLVersion(Setting):
-    name = "ssl_version"
-    section = "SSL"
-    cli = ["--ssl-version"]
-    validator = validate_pos_int
-    default = ssl.PROTOCOL_SSLv23
-    desc = """\
-    SSL version to use (see stdlib ssl module's)
-
-    .. versionchanged:: 19.7
-       The default value has been changed from ``ssl.PROTOCOL_TLSv1`` to
-       ``ssl.PROTOCOL_SSLv23``.
-    """
-
-class CertReqs(Setting):
-    name = "cert_reqs"
-    section = "SSL"
-    cli = ["--cert-reqs"]
-    validator = validate_pos_int
-    default = ssl.CERT_NONE
-    desc = """\
-    Whether client certificate is required (see stdlib ssl module's)
-    """
-
-class CACerts(Setting):
-    name = "ca_certs"
-    section = "SSL"
-    cli = ["--ca-certs"]
-    meta = "FILE"
-    validator = validate_string
-    default = None
-    desc = """\
-    CA certificates file
-    """
-
-class SuppressRaggedEOFs(Setting):
-    name = "suppress_ragged_eofs"
-    section = "SSL"
-    cli = ["--suppress-ragged-eofs"]
-    action = "store_true"
-    default = True
-    validator = validate_bool
-    desc = """\
-    Suppress ragged EOFs (see stdlib ssl module's)
-    """
-
-class DoHandshakeOnConnect(Setting):
-    name = "do_handshake_on_connect"
-    section = "SSL"
-    cli = ["--do-handshake-on-connect"]
-    validator = validate_bool
-    action = "store_true"
-    default = False
-    desc = """\
-    Whether to perform SSL handshake on socket connect (see stdlib ssl module's)
-    """
-
-
-if sys.version_info >= (2, 7):
-    class Ciphers(Setting):
-        name = "ciphers"
-        section = "SSL"
-        cli = ["--ciphers"]
-        validator = validate_string
-        default = 'TLSv1'
-        desc = """\
-        Ciphers to use (see stdlib ssl module's)
-        """
-
-
-class PasteGlobalConf(Setting):
-    name = "raw_paste_global_conf"
-    action = "append"
-    section = "Server Mechanics"
-    cli = ["--paste-global"]
-    meta = "CONF"
-    validator = validate_list_string
-    default = []
-
-    desc = """\
-        Set a PasteDeploy global config variable in ``key=value`` form.
-
-        The option can be specified multiple times.
-
-        The variables are passed to the the PasteDeploy entrypoint. Example::
-
-            $ gunicorn -b 127.0.0.1:8000 --paste development.ini --paste-global FOO=1 --paste-global BAR=2
-
-        .. versionadded:: 19.7
-        """
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/debug.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/debug.py
deleted file mode 100644
index 996fe1b4b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/debug.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-"""The debug module contains utilities and functions for better
-debugging Gunicorn."""
-
-import sys
-import linecache
-import re
-import inspect
-
-__all__ = ['spew', 'unspew']
-
-_token_spliter = re.compile(r'\W+')
-
-
-class Spew(object):
-
-    def __init__(self, trace_names=None, show_values=True):
-        self.trace_names = trace_names
-        self.show_values = show_values
-
-    def __call__(self, frame, event, arg):
-        if event == 'line':
-            lineno = frame.f_lineno
-            if '__file__' in frame.f_globals:
-                filename = frame.f_globals['__file__']
-                if (filename.endswith('.pyc') or
-                    filename.endswith('.pyo')):
-                    filename = filename[:-1]
-                name = frame.f_globals['__name__']
-                line = linecache.getline(filename, lineno)
-            else:
-                name = '[unknown]'
-                try:
-                    src = inspect.getsourcelines(frame)
-                    line = src[lineno]
-                except IOError:
-                    line = 'Unknown code named [%s].  VM instruction #%d' % (
-                        frame.f_code.co_name, frame.f_lasti)
-            if self.trace_names is None or name in self.trace_names:
-                print('%s:%s: %s' % (name, lineno, line.rstrip()))
-                if not self.show_values:
-                    return self
-                details = []
-                tokens = _token_spliter.split(line)
-                for tok in tokens:
-                    if tok in frame.f_globals:
-                        details.append('%s=%r' % (tok, frame.f_globals[tok]))
-                    if tok in frame.f_locals:
-                        details.append('%s=%r' % (tok, frame.f_locals[tok]))
-                if details:
-                    print("\t%s" % ' '.join(details))
-        return self
-
-
-def spew(trace_names=None, show_values=False):
-    """Install a trace hook which writes incredibly detailed logs
-    about what code is being executed to stdout.
-    """
-    sys.settrace(Spew(trace_names, show_values))
-
-
-def unspew():
-    """Remove the trace hook installed by spew.
-    """
-    sys.settrace(None)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/errors.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/errors.py
deleted file mode 100644
index 727d336ad..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/errors.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-# We don't need to call super() in __init__ methods of our
-# BaseException and Exception classes because we also define
-# our own __str__ methods so there is no need to pass 'message'
-# to the base class to get a meaningful output from 'str(exc)'.
-# pylint: disable=super-init-not-called
-
-
-# we inherit from BaseException here to make sure to not be caught
-# at application level
-class HaltServer(BaseException):
-    def __init__(self, reason, exit_status=1):
-        self.reason = reason
-        self.exit_status = exit_status
-
-    def __str__(self):
-        return "<HaltServer %r %d>" % (self.reason, self.exit_status)
-
-
-class ConfigError(Exception):
-    """ Exception raised on config error """
-
-
-class AppImportError(Exception):
-    """ Exception raised when loading an application """
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/glogging.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/glogging.py
deleted file mode 100644
index 041a74d50..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/glogging.py
+++ /dev/null
@@ -1,478 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import base64
-import binascii
-import time
-import logging
-logging.Logger.manager.emittedNoHandlerWarning = 1
-from logging.config import fileConfig
-try:
-    from logging.config import dictConfig
-except ImportError:
-    # python 2.6
-    dictConfig = None
-import os
-import socket
-import sys
-import threading
-import traceback
-
-from gunicorn import util
-from gunicorn.six import PY3, string_types
-
-
-# syslog facility codes
-SYSLOG_FACILITIES = {
-        "auth":     4,
-        "authpriv": 10,
-        "cron":     9,
-        "daemon":   3,
-        "ftp":      11,
-        "kern":     0,
-        "lpr":      6,
-        "mail":     2,
-        "news":     7,
-        "security": 4,  #  DEPRECATED
-        "syslog":   5,
-        "user":     1,
-        "uucp":     8,
-        "local0":   16,
-        "local1":   17,
-        "local2":   18,
-        "local3":   19,
-        "local4":   20,
-        "local5":   21,
-        "local6":   22,
-        "local7":   23
-        }
-
-
-CONFIG_DEFAULTS = dict(
-        version=1,
-        disable_existing_loggers=False,
-
-        loggers={
-            "root": {"level": "INFO", "handlers": ["console"]},
-            "gunicorn.error": {
-                "level": "INFO",
-                "handlers": ["error_console"],
-                "propagate": True,
-                "qualname": "gunicorn.error"
-            },
-
-            "gunicorn.access": {
-                "level": "INFO",
-                "handlers": ["console"],
-                "propagate": True,
-                "qualname": "gunicorn.access"
-            }
-        },
-        handlers={
-            "console": {
-                "class": "logging.StreamHandler",
-                "formatter": "generic",
-                "stream": "ext://sys.stdout"
-            },
-            "error_console": {
-                "class": "logging.StreamHandler",
-                "formatter": "generic",
-                "stream": "ext://sys.stderr"
-            },
-        },
-        formatters={
-            "generic": {
-                "format": "%(asctime)s [%(process)d] [%(levelname)s] %(message)s",
-                "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
-                "class": "logging.Formatter"
-            }
-        }
-)
-
-
-def loggers():
-    """ get list of all loggers """
-    root = logging.root
-    existing = root.manager.loggerDict.keys()
-    return [logging.getLogger(name) for name in existing]
-
-
-class SafeAtoms(dict):
-
-    def __init__(self, atoms):
-        dict.__init__(self)
-        for key, value in atoms.items():
-            if isinstance(value, string_types):
-                self[key] = value.replace('"', '\\"')
-            else:
-                self[key] = value
-
-    def __getitem__(self, k):
-        if k.startswith("{"):
-            kl = k.lower()
-            if kl in self:
-                return super(SafeAtoms, self).__getitem__(kl)
-            else:
-                return "-"
-        if k in self:
-            return super(SafeAtoms, self).__getitem__(k)
-        else:
-            return '-'
-
-
-def parse_syslog_address(addr):
-
-    # unix domain socket type depends on backend
-    # SysLogHandler will try both when given None
-    if addr.startswith("unix://"):
-        sock_type = None
-
-        # set socket type only if explicitly requested
-        parts = addr.split("#", 1)
-        if len(parts) == 2:
-            addr = parts[0]
-            if parts[1] == "dgram":
-                sock_type = socket.SOCK_DGRAM
-
-        return (sock_type, addr.split("unix://")[1])
-
-    if addr.startswith("udp://"):
-        addr = addr.split("udp://")[1]
-        socktype = socket.SOCK_DGRAM
-    elif addr.startswith("tcp://"):
-        addr = addr.split("tcp://")[1]
-        socktype = socket.SOCK_STREAM
-    else:
-        raise RuntimeError("invalid syslog address")
-
-    if '[' in addr and ']' in addr:
-        host = addr.split(']')[0][1:].lower()
-    elif ':' in addr:
-        host = addr.split(':')[0].lower()
-    elif addr == "":
-        host = "localhost"
-    else:
-        host = addr.lower()
-
-    addr = addr.split(']')[-1]
-    if ":" in addr:
-        port = addr.split(':', 1)[1]
-        if not port.isdigit():
-            raise RuntimeError("%r is not a valid port number." % port)
-        port = int(port)
-    else:
-        port = 514
-
-    return (socktype, (host, port))
-
-
-class Logger(object):
-
-    LOG_LEVELS = {
-        "critical": logging.CRITICAL,
-        "error": logging.ERROR,
-        "warning": logging.WARNING,
-        "info": logging.INFO,
-        "debug": logging.DEBUG
-    }
-    loglevel = logging.INFO
-
-    error_fmt = r"%(asctime)s [%(process)d] [%(levelname)s] %(message)s"
-    datefmt = r"[%Y-%m-%d %H:%M:%S %z]"
-
-    access_fmt = "%(message)s"
-    syslog_fmt = "[%(process)d] %(message)s"
-
-    atoms_wrapper_class = SafeAtoms
-
-    def __init__(self, cfg):
-        self.error_log = logging.getLogger("gunicorn.error")
-        self.error_log.propagate = False
-        self.access_log = logging.getLogger("gunicorn.access")
-        self.access_log.propagate = False
-        self.error_handlers = []
-        self.access_handlers = []
-        self.logfile = None
-        self.lock = threading.Lock()
-        self.cfg = cfg
-        self.setup(cfg)
-
-    def setup(self, cfg):
-        self.loglevel = self.LOG_LEVELS.get(cfg.loglevel.lower(), logging.INFO)
-        self.error_log.setLevel(self.loglevel)
-        self.access_log.setLevel(logging.INFO)
-
-        # set gunicorn.error handler
-        if self.cfg.capture_output and cfg.errorlog != "-":
-            for stream in sys.stdout, sys.stderr:
-                stream.flush()
-
-            self.logfile = open(cfg.errorlog, 'a+')
-            os.dup2(self.logfile.fileno(), sys.stdout.fileno())
-            os.dup2(self.logfile.fileno(), sys.stderr.fileno())
-
-        self._set_handler(self.error_log, cfg.errorlog,
-                          logging.Formatter(self.error_fmt, self.datefmt))
-
-        # set gunicorn.access handler
-        if cfg.accesslog is not None:
-            self._set_handler(self.access_log, cfg.accesslog,
-                fmt=logging.Formatter(self.access_fmt), stream=sys.stdout)
-
-        # set syslog handler
-        if cfg.syslog:
-            self._set_syslog_handler(
-                self.error_log, cfg, self.syslog_fmt, "error"
-            )
-            if not cfg.disable_redirect_access_to_syslog:
-                self._set_syslog_handler(
-                    self.access_log, cfg, self.syslog_fmt, "access"
-                )
-
-        if dictConfig is None and cfg.logconfig_dict:
-            util.warn("Dictionary-based log configuration requires "
-                      "Python 2.7 or above.")
-
-        if dictConfig and cfg.logconfig_dict:
-            config = CONFIG_DEFAULTS.copy()
-            config.update(cfg.logconfig_dict)
-            try:
-                dictConfig(config)
-            except (
-                    AttributeError,
-                    ImportError,
-                    ValueError,
-                    TypeError
-            ) as exc:
-                raise RuntimeError(str(exc))
-        elif cfg.logconfig:
-            if os.path.exists(cfg.logconfig):
-                defaults = CONFIG_DEFAULTS.copy()
-                defaults['__file__'] = cfg.logconfig
-                defaults['here'] = os.path.dirname(cfg.logconfig)
-                fileConfig(cfg.logconfig, defaults=defaults,
-                           disable_existing_loggers=False)
-            else:
-                msg = "Error: log config '%s' not found"
-                raise RuntimeError(msg % cfg.logconfig)
-
-    def critical(self, msg, *args, **kwargs):
-        self.error_log.critical(msg, *args, **kwargs)
-
-    def error(self, msg, *args, **kwargs):
-        self.error_log.error(msg, *args, **kwargs)
-
-    def warning(self, msg, *args, **kwargs):
-        self.error_log.warning(msg, *args, **kwargs)
-
-    def info(self, msg, *args, **kwargs):
-        self.error_log.info(msg, *args, **kwargs)
-
-    def debug(self, msg, *args, **kwargs):
-        self.error_log.debug(msg, *args, **kwargs)
-
-    def exception(self, msg, *args, **kwargs):
-        self.error_log.exception(msg, *args, **kwargs)
-
-    def log(self, lvl, msg, *args, **kwargs):
-        if isinstance(lvl, string_types):
-            lvl = self.LOG_LEVELS.get(lvl.lower(), logging.INFO)
-        self.error_log.log(lvl, msg, *args, **kwargs)
-
-    def atoms(self, resp, req, environ, request_time):
-        """ Gets atoms for log formating.
-        """
-        status = resp.status
-        if isinstance(status, str):
-            status = status.split(None, 1)[0]
-        atoms = {
-            'h': environ.get('REMOTE_ADDR', '-'),
-            'l': '-',
-            'u': self._get_user(environ) or '-',
-            't': self.now(),
-            'r': "%s %s %s" % (environ['REQUEST_METHOD'],
-                environ['RAW_URI'], environ["SERVER_PROTOCOL"]),
-            's': status,
-            'm': environ.get('REQUEST_METHOD'),
-            'U': environ.get('PATH_INFO'),
-            'q': environ.get('QUERY_STRING'),
-            'H': environ.get('SERVER_PROTOCOL'),
-            'b': getattr(resp, 'sent', None) is not None and str(resp.sent) or '-',
-            'B': getattr(resp, 'sent', None),
-            'f': environ.get('HTTP_REFERER', '-'),
-            'a': environ.get('HTTP_USER_AGENT', '-'),
-            'T': request_time.seconds,
-            'D': (request_time.seconds*1000000) + request_time.microseconds,
-            'L': "%d.%06d" % (request_time.seconds, request_time.microseconds),
-            'p': "<%s>" % os.getpid()
-        }
-
-        # add request headers
-        if hasattr(req, 'headers'):
-            req_headers = req.headers
-        else:
-            req_headers = req
-
-        if hasattr(req_headers, "items"):
-            req_headers = req_headers.items()
-
-        atoms.update(dict([("{%s}i" % k.lower(), v) for k, v in req_headers]))
-
-        resp_headers = resp.headers
-        if hasattr(resp_headers, "items"):
-            resp_headers = resp_headers.items()
-
-        # add response headers
-        atoms.update(dict([("{%s}o" % k.lower(), v) for k, v in resp_headers]))
-
-        # add environ variables
-        environ_variables = environ.items()
-        atoms.update(dict([("{%s}e" % k.lower(), v) for k, v in environ_variables]))
-
-        return atoms
-
-    def access(self, resp, req, environ, request_time):
-        """ See http://httpd.apache.org/docs/2.0/logs.html#combined
-        for format details
-        """
-
-        if not (self.cfg.accesslog or self.cfg.logconfig or
-           self.cfg.logconfig_dict or
-           (self.cfg.syslog and not self.cfg.disable_redirect_access_to_syslog)):
-            return
-
-        # wrap atoms:
-        # - make sure atoms will be test case insensitively
-        # - if atom doesn't exist replace it by '-'
-        safe_atoms = self.atoms_wrapper_class(self.atoms(resp, req, environ,
-            request_time))
-
-        try:
-            self.access_log.info(self.cfg.access_log_format, safe_atoms)
-        except:
-            self.error(traceback.format_exc())
-
-    def now(self):
-        """ return date in Apache Common Log Format """
-        return time.strftime('[%d/%b/%Y:%H:%M:%S %z]')
-
-    def reopen_files(self):
-        if self.cfg.capture_output and self.cfg.errorlog != "-":
-            for stream in sys.stdout, sys.stderr:
-                stream.flush()
-
-            with self.lock:
-                if self.logfile is not None:
-                    self.logfile.close()
-                self.logfile = open(self.cfg.errorlog, 'a+')
-                os.dup2(self.logfile.fileno(), sys.stdout.fileno())
-                os.dup2(self.logfile.fileno(), sys.stderr.fileno())
-
-
-        for log in loggers():
-            for handler in log.handlers:
-                if isinstance(handler, logging.FileHandler):
-                    handler.acquire()
-                    try:
-                        if handler.stream:
-                            handler.close()
-                            handler.stream = handler._open()
-                    finally:
-                        handler.release()
-
-    def close_on_exec(self):
-        for log in loggers():
-            for handler in log.handlers:
-                if isinstance(handler, logging.FileHandler):
-                    handler.acquire()
-                    try:
-                        if handler.stream:
-                            util.close_on_exec(handler.stream.fileno())
-                    finally:
-                        handler.release()
-
-    def _get_gunicorn_handler(self, log):
-        for h in log.handlers:
-            if getattr(h, "_gunicorn", False):
-                return h
-
-    def _set_handler(self, log, output, fmt, stream=None):
-        # remove previous gunicorn log handler
-        h = self._get_gunicorn_handler(log)
-        if h:
-            log.handlers.remove(h)
-
-        if output is not None:
-            if output == "-":
-                h = logging.StreamHandler(stream)
-            else:
-                util.check_is_writeable(output)
-                h = logging.FileHandler(output)
-                # make sure the user can reopen the file
-                try:
-                    os.chown(h.baseFilename, self.cfg.user, self.cfg.group)
-                except OSError:
-                    # it's probably OK there, we assume the user has given
-                    # /dev/null as a parameter.
-                    pass
-
-            h.setFormatter(fmt)
-            h._gunicorn = True
-            log.addHandler(h)
-
-    def _set_syslog_handler(self, log, cfg, fmt, name):
-        # setup format
-        if not cfg.syslog_prefix:
-            prefix = cfg.proc_name.replace(":", ".")
-        else:
-            prefix = cfg.syslog_prefix
-
-        prefix = "gunicorn.%s.%s" % (prefix, name)
-
-        # set format
-        fmt = logging.Formatter(r"%s: %s" % (prefix, fmt))
-
-        # syslog facility
-        try:
-            facility = SYSLOG_FACILITIES[cfg.syslog_facility.lower()]
-        except KeyError:
-            raise RuntimeError("unknown facility name")
-
-        # parse syslog address
-        socktype, addr = parse_syslog_address(cfg.syslog_addr)
-
-        # finally setup the syslog handler
-        if sys.version_info >= (2, 7):
-            h = logging.handlers.SysLogHandler(address=addr,
-                    facility=facility, socktype=socktype)
-        else:
-            # socktype is only supported in 2.7 and sup
-            # fix issue #541
-            h = logging.handlers.SysLogHandler(address=addr,
-                    facility=facility)
-
-        h.setFormatter(fmt)
-        h._gunicorn = True
-        log.addHandler(h)
-
-    def _get_user(self, environ):
-        user = None
-        http_auth = environ.get("HTTP_AUTHORIZATION")
-        if http_auth and http_auth.startswith('Basic'):
-            auth = http_auth.split(" ", 1)
-            if len(auth) == 2:
-                try:
-                    # b64decode doesn't accept unicode in Python < 3.3
-                    # so we need to convert it to a byte string
-                    auth = base64.b64decode(auth[1].strip().encode('utf-8'))
-                    if PY3:  # b64decode returns a byte string in Python 3
-                        auth = auth.decode('utf-8')
-                    auth = auth.split(":", 1)
-                except (TypeError, binascii.Error, UnicodeDecodeError) as exc:
-                    self.debug("Couldn't get username: %s", exc)
-                    return user
-                if len(auth) == 2:
-                    user = auth[0]
-        return user
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__init__.py
deleted file mode 100644
index 1da6f3ec1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from gunicorn.http.message import Message, Request
-from gunicorn.http.parser import RequestParser
-
-__all__ = ['Message', 'Request', 'RequestParser']
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index e186c8b64..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/_sendfile.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/_sendfile.cpython-35.pyc
deleted file mode 100644
index 0b1675a8e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/_sendfile.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/body.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/body.cpython-35.pyc
deleted file mode 100644
index fcc2a4c37..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/body.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/errors.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/errors.cpython-35.pyc
deleted file mode 100644
index 5086b901f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/errors.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/message.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/message.cpython-35.pyc
deleted file mode 100644
index 57d9cfc3e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/message.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/parser.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/parser.cpython-35.pyc
deleted file mode 100644
index 8a3261b5c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/parser.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/unreader.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/unreader.cpython-35.pyc
deleted file mode 100644
index 94eb225ba..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/unreader.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/wsgi.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/wsgi.cpython-35.pyc
deleted file mode 100644
index abe553e65..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/__pycache__/wsgi.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/_sendfile.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/_sendfile.py
deleted file mode 100644
index 1764cb325..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/_sendfile.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import errno
-import os
-import sys
-
-try:
-    import ctypes
-    import ctypes.util
-except MemoryError:
-    # selinux execmem denial
-    # https://bugzilla.redhat.com/show_bug.cgi?id=488396
-    raise ImportError
-
-SUPPORTED_PLATFORMS = (
-    'darwin',
-    'freebsd',
-    'dragonfly',
-    'linux2')
-
-if sys.platform not in SUPPORTED_PLATFORMS:
-    raise ImportError("sendfile isn't supported on this platform")
-
-_libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True)
-_sendfile = _libc.sendfile
-
-
-def sendfile(fdout, fdin, offset, nbytes):
-    if sys.platform == 'darwin':
-        _sendfile.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_uint64,
-                              ctypes.POINTER(ctypes.c_uint64), ctypes.c_voidp,
-                              ctypes.c_int]
-        _nbytes = ctypes.c_uint64(nbytes)
-        result = _sendfile(fdin, fdout, offset, _nbytes, None, 0)
-
-        if result == -1:
-            e = ctypes.get_errno()
-            if e == errno.EAGAIN and _nbytes.value is not None:
-                return _nbytes.value
-            raise OSError(e, os.strerror(e))
-        return _nbytes.value
-    elif sys.platform in ('freebsd', 'dragonfly',):
-        _sendfile.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_uint64,
-                              ctypes.c_uint64, ctypes.c_voidp,
-                              ctypes.POINTER(ctypes.c_uint64), ctypes.c_int]
-        _sbytes = ctypes.c_uint64()
-        result = _sendfile(fdin, fdout, offset, nbytes, None, _sbytes, 0)
-        if result == -1:
-            e = ctypes.get_errno()
-            if e == errno.EAGAIN and _sbytes.value is not None:
-                return _sbytes.value
-            raise OSError(e, os.strerror(e))
-        return _sbytes.value
-
-    else:
-        _sendfile.argtypes = [ctypes.c_int, ctypes.c_int,
-                ctypes.POINTER(ctypes.c_uint64), ctypes.c_size_t]
-
-        _offset = ctypes.c_uint64(offset)
-        sent = _sendfile(fdout, fdin, _offset, nbytes)
-        if sent == -1:
-            e = ctypes.get_errno()
-            raise OSError(e, os.strerror(e))
-        return sent
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/body.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/body.py
deleted file mode 100644
index fb8633ed2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/body.py
+++ /dev/null
@@ -1,259 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from gunicorn.http.errors import (NoMoreData, ChunkMissingTerminator,
-        InvalidChunkSize)
-from gunicorn import six
-
-
-class ChunkedReader(object):
-    def __init__(self, req, unreader):
-        self.req = req
-        self.parser = self.parse_chunked(unreader)
-        self.buf = six.BytesIO()
-
-    def read(self, size):
-        if not isinstance(size, six.integer_types):
-            raise TypeError("size must be an integral type")
-        if size < 0:
-            raise ValueError("Size must be positive.")
-        if size == 0:
-            return b""
-
-        if self.parser:
-            while self.buf.tell() < size:
-                try:
-                    self.buf.write(six.next(self.parser))
-                except StopIteration:
-                    self.parser = None
-                    break
-
-        data = self.buf.getvalue()
-        ret, rest = data[:size], data[size:]
-        self.buf = six.BytesIO()
-        self.buf.write(rest)
-        return ret
-
-    def parse_trailers(self, unreader, data):
-        buf = six.BytesIO()
-        buf.write(data)
-
-        idx = buf.getvalue().find(b"\r\n\r\n")
-        done = buf.getvalue()[:2] == b"\r\n"
-        while idx < 0 and not done:
-            self.get_data(unreader, buf)
-            idx = buf.getvalue().find(b"\r\n\r\n")
-            done = buf.getvalue()[:2] == b"\r\n"
-        if done:
-            unreader.unread(buf.getvalue()[2:])
-            return b""
-        self.req.trailers = self.req.parse_headers(buf.getvalue()[:idx])
-        unreader.unread(buf.getvalue()[idx + 4:])
-
-    def parse_chunked(self, unreader):
-        (size, rest) = self.parse_chunk_size(unreader)
-        while size > 0:
-            while size > len(rest):
-                size -= len(rest)
-                yield rest
-                rest = unreader.read()
-                if not rest:
-                    raise NoMoreData()
-            yield rest[:size]
-            # Remove \r\n after chunk
-            rest = rest[size:]
-            while len(rest) < 2:
-                rest += unreader.read()
-            if rest[:2] != b'\r\n':
-                raise ChunkMissingTerminator(rest[:2])
-            (size, rest) = self.parse_chunk_size(unreader, data=rest[2:])
-
-    def parse_chunk_size(self, unreader, data=None):
-        buf = six.BytesIO()
-        if data is not None:
-            buf.write(data)
-
-        idx = buf.getvalue().find(b"\r\n")
-        while idx < 0:
-            self.get_data(unreader, buf)
-            idx = buf.getvalue().find(b"\r\n")
-
-        data = buf.getvalue()
-        line, rest_chunk = data[:idx], data[idx + 2:]
-
-        chunk_size = line.split(b";", 1)[0].strip()
-        try:
-            chunk_size = int(chunk_size, 16)
-        except ValueError:
-            raise InvalidChunkSize(chunk_size)
-
-        if chunk_size == 0:
-            try:
-                self.parse_trailers(unreader, rest_chunk)
-            except NoMoreData:
-                pass
-            return (0, None)
-        return (chunk_size, rest_chunk)
-
-    def get_data(self, unreader, buf):
-        data = unreader.read()
-        if not data:
-            raise NoMoreData()
-        buf.write(data)
-
-
-class LengthReader(object):
-    def __init__(self, unreader, length):
-        self.unreader = unreader
-        self.length = length
-
-    def read(self, size):
-        if not isinstance(size, six.integer_types):
-            raise TypeError("size must be an integral type")
-
-        size = min(self.length, size)
-        if size < 0:
-            raise ValueError("Size must be positive.")
-        if size == 0:
-            return b""
-
-        buf = six.BytesIO()
-        data = self.unreader.read()
-        while data:
-            buf.write(data)
-            if buf.tell() >= size:
-                break
-            data = self.unreader.read()
-
-        buf = buf.getvalue()
-        ret, rest = buf[:size], buf[size:]
-        self.unreader.unread(rest)
-        self.length -= size
-        return ret
-
-
-class EOFReader(object):
-    def __init__(self, unreader):
-        self.unreader = unreader
-        self.buf = six.BytesIO()
-        self.finished = False
-
-    def read(self, size):
-        if not isinstance(size, six.integer_types):
-            raise TypeError("size must be an integral type")
-        if size < 0:
-            raise ValueError("Size must be positive.")
-        if size == 0:
-            return b""
-
-        if self.finished:
-            data = self.buf.getvalue()
-            ret, rest = data[:size], data[size:]
-            self.buf = six.BytesIO()
-            self.buf.write(rest)
-            return ret
-
-        data = self.unreader.read()
-        while data:
-            self.buf.write(data)
-            if self.buf.tell() > size:
-                break
-            data = self.unreader.read()
-
-        if not data:
-            self.finished = True
-
-        data = self.buf.getvalue()
-        ret, rest = data[:size], data[size:]
-        self.buf = six.BytesIO()
-        self.buf.write(rest)
-        return ret
-
-
-class Body(object):
-    def __init__(self, reader):
-        self.reader = reader
-        self.buf = six.BytesIO()
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        ret = self.readline()
-        if not ret:
-            raise StopIteration()
-        return ret
-    next = __next__
-
-    def getsize(self, size):
-        if size is None:
-            return six.MAXSIZE
-        elif not isinstance(size, six.integer_types):
-            raise TypeError("size must be an integral type")
-        elif size < 0:
-            return six.MAXSIZE
-        return size
-
-    def read(self, size=None):
-        size = self.getsize(size)
-        if size == 0:
-            return b""
-
-        if size < self.buf.tell():
-            data = self.buf.getvalue()
-            ret, rest = data[:size], data[size:]
-            self.buf = six.BytesIO()
-            self.buf.write(rest)
-            return ret
-
-        while size > self.buf.tell():
-            data = self.reader.read(1024)
-            if not data:
-                break
-            self.buf.write(data)
-
-        data = self.buf.getvalue()
-        ret, rest = data[:size], data[size:]
-        self.buf = six.BytesIO()
-        self.buf.write(rest)
-        return ret
-
-    def readline(self, size=None):
-        size = self.getsize(size)
-        if size == 0:
-            return b""
-
-        data = self.buf.getvalue()
-        self.buf = six.BytesIO()
-
-        ret = []
-        while 1:
-            idx = data.find(b"\n", 0, size)
-            idx = idx + 1 if idx >= 0 else size if len(data) >= size else 0
-            if idx:
-                ret.append(data[:idx])
-                self.buf.write(data[idx:])
-                break
-
-            ret.append(data)
-            size -= len(data)
-            data = self.reader.read(min(1024, size))
-            if not data:
-                break
-
-        return b"".join(ret)
-
-    def readlines(self, size=None):
-        ret = []
-        data = self.read()
-        while data:
-            pos = data.find(b"\n")
-            if pos < 0:
-                ret.append(data)
-                data = b""
-            else:
-                line, data = data[:pos + 1], data[pos + 1:]
-                ret.append(line)
-        return ret
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/errors.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/errors.py
deleted file mode 100644
index 7839ef05a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/errors.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-# We don't need to call super() in __init__ methods of our
-# BaseException and Exception classes because we also define
-# our own __str__ methods so there is no need to pass 'message'
-# to the base class to get a meaningful output from 'str(exc)'.
-# pylint: disable=super-init-not-called
-
-
-class ParseException(Exception):
-    pass
-
-
-class NoMoreData(IOError):
-    def __init__(self, buf=None):
-        self.buf = buf
-
-    def __str__(self):
-        return "No more data after: %r" % self.buf
-
-
-class InvalidRequestLine(ParseException):
-    def __init__(self, req):
-        self.req = req
-        self.code = 400
-
-    def __str__(self):
-        return "Invalid HTTP request line: %r" % self.req
-
-
-class InvalidRequestMethod(ParseException):
-    def __init__(self, method):
-        self.method = method
-
-    def __str__(self):
-        return "Invalid HTTP method: %r" % self.method
-
-
-class InvalidHTTPVersion(ParseException):
-    def __init__(self, version):
-        self.version = version
-
-    def __str__(self):
-        return "Invalid HTTP Version: %r" % self.version
-
-
-class InvalidHeader(ParseException):
-    def __init__(self, hdr, req=None):
-        self.hdr = hdr
-        self.req = req
-
-    def __str__(self):
-        return "Invalid HTTP Header: %r" % self.hdr
-
-
-class InvalidHeaderName(ParseException):
-    def __init__(self, hdr):
-        self.hdr = hdr
-
-    def __str__(self):
-        return "Invalid HTTP header name: %r" % self.hdr
-
-
-class InvalidChunkSize(IOError):
-    def __init__(self, data):
-        self.data = data
-
-    def __str__(self):
-        return "Invalid chunk size: %r" % self.data
-
-
-class ChunkMissingTerminator(IOError):
-    def __init__(self, term):
-        self.term = term
-
-    def __str__(self):
-        return "Invalid chunk terminator is not '\\r\\n': %r" % self.term
-
-
-class LimitRequestLine(ParseException):
-    def __init__(self, size, max_size):
-        self.size = size
-        self.max_size = max_size
-
-    def __str__(self):
-        return "Request Line is too large (%s > %s)" % (self.size, self.max_size)
-
-
-class LimitRequestHeaders(ParseException):
-    def __init__(self, msg):
-        self.msg = msg
-
-    def __str__(self):
-        return self.msg
-
-
-class InvalidProxyLine(ParseException):
-    def __init__(self, line):
-        self.line = line
-        self.code = 400
-
-    def __str__(self):
-        return "Invalid PROXY line: %r" % self.line
-
-
-class ForbiddenProxyRequest(ParseException):
-    def __init__(self, host):
-        self.host = host
-        self.code = 403
-
-    def __str__(self):
-        return "Proxy request from %r not allowed" % self.host
-
-
-class InvalidSchemeHeaders(ParseException):
-    def __str__(self):
-        return "Contradictory scheme headers"
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/message.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/message.py
deleted file mode 100644
index 2700b3213..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/message.py
+++ /dev/null
@@ -1,363 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import re
-import socket
-from errno import ENOTCONN
-
-from gunicorn._compat import bytes_to_str
-from gunicorn.http.unreader import SocketUnreader
-from gunicorn.http.body import ChunkedReader, LengthReader, EOFReader, Body
-from gunicorn.http.errors import (InvalidHeader, InvalidHeaderName, NoMoreData,
-    InvalidRequestLine, InvalidRequestMethod, InvalidHTTPVersion,
-    LimitRequestLine, LimitRequestHeaders)
-from gunicorn.http.errors import InvalidProxyLine, ForbiddenProxyRequest
-from gunicorn.http.errors import InvalidSchemeHeaders
-from gunicorn.six import BytesIO, string_types
-from gunicorn.util import split_request_uri
-
-MAX_REQUEST_LINE = 8190
-MAX_HEADERS = 32768
-DEFAULT_MAX_HEADERFIELD_SIZE = 8190
-
-HEADER_RE = re.compile(r"[\x00-\x1F\x7F()<>@,;:\[\]={} \t\\\"]")
-METH_RE = re.compile(r"[A-Z0-9$-_.]{3,20}")
-VERSION_RE = re.compile(r"HTTP/(\d+)\.(\d+)")
-
-
-class Message(object):
-    def __init__(self, cfg, unreader):
-        self.cfg = cfg
-        self.unreader = unreader
-        self.version = None
-        self.headers = []
-        self.trailers = []
-        self.body = None
-        self.scheme = "https" if cfg.is_ssl else "http"
-
-        # set headers limits
-        self.limit_request_fields = cfg.limit_request_fields
-        if (self.limit_request_fields <= 0
-            or self.limit_request_fields > MAX_HEADERS):
-            self.limit_request_fields = MAX_HEADERS
-        self.limit_request_field_size = cfg.limit_request_field_size
-        if self.limit_request_field_size < 0:
-            self.limit_request_field_size = DEFAULT_MAX_HEADERFIELD_SIZE
-
-        # set max header buffer size
-        max_header_field_size = self.limit_request_field_size or DEFAULT_MAX_HEADERFIELD_SIZE
-        self.max_buffer_headers = self.limit_request_fields * \
-            (max_header_field_size + 2) + 4
-
-        unused = self.parse(self.unreader)
-        self.unreader.unread(unused)
-        self.set_body_reader()
-
-    def parse(self, unreader):
-        raise NotImplementedError()
-
-    def parse_headers(self, data):
-        cfg = self.cfg
-        headers = []
-
-        # Split lines on \r\n keeping the \r\n on each line
-        lines = [bytes_to_str(line) + "\r\n" for line in data.split(b"\r\n")]
-
-        # handle scheme headers
-        scheme_header = False
-        secure_scheme_headers = {}
-        if '*' in cfg.forwarded_allow_ips:
-            secure_scheme_headers = cfg.secure_scheme_headers
-        elif isinstance(self.unreader, SocketUnreader):
-            remote_addr = self.unreader.sock.getpeername()
-            if isinstance(remote_addr, tuple):
-                remote_host = remote_addr[0]
-                if remote_host in cfg.forwarded_allow_ips:
-                    secure_scheme_headers = cfg.secure_scheme_headers
-            elif isinstance(remote_addr, string_types):
-                secure_scheme_headers = cfg.secure_scheme_headers
-
-        # Parse headers into key/value pairs paying attention
-        # to continuation lines.
-        while lines:
-            if len(headers) >= self.limit_request_fields:
-                raise LimitRequestHeaders("limit request headers fields")
-
-            # Parse initial header name : value pair.
-            curr = lines.pop(0)
-            header_length = len(curr)
-            if curr.find(":") < 0:
-                raise InvalidHeader(curr.strip())
-            name, value = curr.split(":", 1)
-            name = name.rstrip(" \t").upper()
-            if HEADER_RE.search(name):
-                raise InvalidHeaderName(name)
-
-            name, value = name.strip(), [value.lstrip()]
-
-            # Consume value continuation lines
-            while lines and lines[0].startswith((" ", "\t")):
-                curr = lines.pop(0)
-                header_length += len(curr)
-                if header_length > self.limit_request_field_size > 0:
-                    raise LimitRequestHeaders("limit request headers "
-                            + "fields size")
-                value.append(curr)
-            value = ''.join(value).rstrip()
-
-            if header_length > self.limit_request_field_size > 0:
-                raise LimitRequestHeaders("limit request headers fields size")
-
-            if name in secure_scheme_headers:
-                secure = value == secure_scheme_headers[name]
-                scheme = "https" if secure else "http"
-                if scheme_header:
-                    if scheme != self.scheme:
-                        raise InvalidSchemeHeaders()
-                else:
-                    scheme_header = True
-                    self.scheme = scheme
-
-            headers.append((name, value))
-
-        return headers
-
-    def set_body_reader(self):
-        chunked = False
-        content_length = None
-        for (name, value) in self.headers:
-            if name == "CONTENT-LENGTH":
-                content_length = value
-            elif name == "TRANSFER-ENCODING":
-                chunked = value.lower() == "chunked"
-            elif name == "SEC-WEBSOCKET-KEY1":
-                content_length = 8
-
-        if chunked:
-            self.body = Body(ChunkedReader(self, self.unreader))
-        elif content_length is not None:
-            try:
-                content_length = int(content_length)
-            except ValueError:
-                raise InvalidHeader("CONTENT-LENGTH", req=self)
-
-            if content_length < 0:
-                raise InvalidHeader("CONTENT-LENGTH", req=self)
-
-            self.body = Body(LengthReader(self.unreader, content_length))
-        else:
-            self.body = Body(EOFReader(self.unreader))
-
-    def should_close(self):
-        for (h, v) in self.headers:
-            if h == "CONNECTION":
-                v = v.lower().strip()
-                if v == "close":
-                    return True
-                elif v == "keep-alive":
-                    return False
-                break
-        return self.version <= (1, 0)
-
-
-class Request(Message):
-    def __init__(self, cfg, unreader, req_number=1):
-        self.method = None
-        self.uri = None
-        self.path = None
-        self.query = None
-        self.fragment = None
-
-        # get max request line size
-        self.limit_request_line = cfg.limit_request_line
-        if (self.limit_request_line < 0
-            or self.limit_request_line >= MAX_REQUEST_LINE):
-            self.limit_request_line = MAX_REQUEST_LINE
-
-        self.req_number = req_number
-        self.proxy_protocol_info = None
-        super(Request, self).__init__(cfg, unreader)
-
-    def get_data(self, unreader, buf, stop=False):
-        data = unreader.read()
-        if not data:
-            if stop:
-                raise StopIteration()
-            raise NoMoreData(buf.getvalue())
-        buf.write(data)
-
-    def parse(self, unreader):
-        buf = BytesIO()
-        self.get_data(unreader, buf, stop=True)
-
-        # get request line
-        line, rbuf = self.read_line(unreader, buf, self.limit_request_line)
-
-        # proxy protocol
-        if self.proxy_protocol(bytes_to_str(line)):
-            # get next request line
-            buf = BytesIO()
-            buf.write(rbuf)
-            line, rbuf = self.read_line(unreader, buf, self.limit_request_line)
-
-        self.parse_request_line(line)
-        buf = BytesIO()
-        buf.write(rbuf)
-
-        # Headers
-        data = buf.getvalue()
-        idx = data.find(b"\r\n\r\n")
-
-        done = data[:2] == b"\r\n"
-        while True:
-            idx = data.find(b"\r\n\r\n")
-            done = data[:2] == b"\r\n"
-
-            if idx < 0 and not done:
-                self.get_data(unreader, buf)
-                data = buf.getvalue()
-                if len(data) > self.max_buffer_headers:
-                    raise LimitRequestHeaders("max buffer headers")
-            else:
-                break
-
-        if done:
-            self.unreader.unread(data[2:])
-            return b""
-
-        self.headers = self.parse_headers(data[:idx])
-
-        ret = data[idx + 4:]
-        buf = None
-        return ret
-
-    def read_line(self, unreader, buf, limit=0):
-        data = buf.getvalue()
-
-        while True:
-            idx = data.find(b"\r\n")
-            if idx >= 0:
-                # check if the request line is too large
-                if idx > limit > 0:
-                    raise LimitRequestLine(idx, limit)
-                break
-            elif len(data) - 2 > limit > 0:
-                raise LimitRequestLine(len(data), limit)
-            self.get_data(unreader, buf)
-            data = buf.getvalue()
-
-        return (data[:idx],  # request line,
-                data[idx + 2:])  # residue in the buffer, skip \r\n
-
-    def proxy_protocol(self, line):
-        """\
-        Detect, check and parse proxy protocol.
-
-        :raises: ForbiddenProxyRequest, InvalidProxyLine.
-        :return: True for proxy protocol line else False
-        """
-        if not self.cfg.proxy_protocol:
-            return False
-
-        if self.req_number != 1:
-            return False
-
-        if not line.startswith("PROXY"):
-            return False
-
-        self.proxy_protocol_access_check()
-        self.parse_proxy_protocol(line)
-
-        return True
-
-    def proxy_protocol_access_check(self):
-        # check in allow list
-        if isinstance(self.unreader, SocketUnreader):
-            try:
-                remote_host = self.unreader.sock.getpeername()[0]
-            except socket.error as e:
-                if e.args[0] == ENOTCONN:
-                    raise ForbiddenProxyRequest("UNKNOW")
-                raise
-            if ("*" not in self.cfg.proxy_allow_ips and
-                    remote_host not in self.cfg.proxy_allow_ips):
-                raise ForbiddenProxyRequest(remote_host)
-
-    def parse_proxy_protocol(self, line):
-        bits = line.split()
-
-        if len(bits) != 6:
-            raise InvalidProxyLine(line)
-
-        # Extract data
-        proto = bits[1]
-        s_addr = bits[2]
-        d_addr = bits[3]
-
-        # Validation
-        if proto not in ["TCP4", "TCP6"]:
-            raise InvalidProxyLine("protocol '%s' not supported" % proto)
-        if proto == "TCP4":
-            try:
-                socket.inet_pton(socket.AF_INET, s_addr)
-                socket.inet_pton(socket.AF_INET, d_addr)
-            except socket.error:
-                raise InvalidProxyLine(line)
-        elif proto == "TCP6":
-            try:
-                socket.inet_pton(socket.AF_INET6, s_addr)
-                socket.inet_pton(socket.AF_INET6, d_addr)
-            except socket.error:
-                raise InvalidProxyLine(line)
-
-        try:
-            s_port = int(bits[4])
-            d_port = int(bits[5])
-        except ValueError:
-            raise InvalidProxyLine("invalid port %s" % line)
-
-        if not ((0 <= s_port <= 65535) and (0 <= d_port <= 65535)):
-            raise InvalidProxyLine("invalid port %s" % line)
-
-        # Set data
-        self.proxy_protocol_info = {
-            "proxy_protocol": proto,
-            "client_addr": s_addr,
-            "client_port": s_port,
-            "proxy_addr": d_addr,
-            "proxy_port": d_port
-        }
-
-    def parse_request_line(self, line_bytes):
-        bits = [bytes_to_str(bit) for bit in line_bytes.split(None, 2)]
-        if len(bits) != 3:
-            raise InvalidRequestLine(bytes_to_str(line_bytes))
-
-        # Method
-        if not METH_RE.match(bits[0]):
-            raise InvalidRequestMethod(bits[0])
-        self.method = bits[0].upper()
-
-        # URI
-        self.uri = bits[1]
-
-        try:
-            parts = split_request_uri(self.uri)
-        except ValueError:
-            raise InvalidRequestLine(bytes_to_str(line_bytes))
-        self.path = parts.path or ""
-        self.query = parts.query or ""
-        self.fragment = parts.fragment or ""
-
-        # Version
-        match = VERSION_RE.match(bits[2])
-        if match is None:
-            raise InvalidHTTPVersion(bits[2])
-        self.version = (int(match.group(1)), int(match.group(2)))
-
-    def set_body_reader(self):
-        super(Request, self).set_body_reader()
-        if isinstance(self.body.reader, EOFReader):
-            self.body = Body(LengthReader(self.unreader, 0))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/parser.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/parser.py
deleted file mode 100644
index a4a0f1e48..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/parser.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from gunicorn.http.message import Request
-from gunicorn.http.unreader import SocketUnreader, IterUnreader
-
-
-class Parser(object):
-
-    mesg_class = None
-
-    def __init__(self, cfg, source):
-        self.cfg = cfg
-        if hasattr(source, "recv"):
-            self.unreader = SocketUnreader(source)
-        else:
-            self.unreader = IterUnreader(source)
-        self.mesg = None
-
-        # request counter (for keepalive connetions)
-        self.req_count = 0
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        # Stop if HTTP dictates a stop.
-        if self.mesg and self.mesg.should_close():
-            raise StopIteration()
-
-        # Discard any unread body of the previous message
-        if self.mesg:
-            data = self.mesg.body.read(8192)
-            while data:
-                data = self.mesg.body.read(8192)
-
-        # Parse the next request
-        self.req_count += 1
-        self.mesg = self.mesg_class(self.cfg, self.unreader, self.req_count)
-        if not self.mesg:
-            raise StopIteration()
-        return self.mesg
-
-    next = __next__
-
-
-class RequestParser(Parser):
-
-    mesg_class = Request
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/unreader.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/unreader.py
deleted file mode 100644
index 9f312a802..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/unreader.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import os
-
-from gunicorn import six
-
-# Classes that can undo reading data from
-# a given type of data source.
-
-
-class Unreader(object):
-    def __init__(self):
-        self.buf = six.BytesIO()
-
-    def chunk(self):
-        raise NotImplementedError()
-
-    def read(self, size=None):
-        if size is not None and not isinstance(size, six.integer_types):
-            raise TypeError("size parameter must be an int or long.")
-
-        if size is not None:
-            if size == 0:
-                return b""
-            if size < 0:
-                size = None
-
-        self.buf.seek(0, os.SEEK_END)
-
-        if size is None and self.buf.tell():
-            ret = self.buf.getvalue()
-            self.buf = six.BytesIO()
-            return ret
-        if size is None:
-            d = self.chunk()
-            return d
-
-        while self.buf.tell() < size:
-            chunk = self.chunk()
-            if not chunk:
-                ret = self.buf.getvalue()
-                self.buf = six.BytesIO()
-                return ret
-            self.buf.write(chunk)
-        data = self.buf.getvalue()
-        self.buf = six.BytesIO()
-        self.buf.write(data[size:])
-        return data[:size]
-
-    def unread(self, data):
-        self.buf.seek(0, os.SEEK_END)
-        self.buf.write(data)
-
-
-class SocketUnreader(Unreader):
-    def __init__(self, sock, max_chunk=8192):
-        super(SocketUnreader, self).__init__()
-        self.sock = sock
-        self.mxchunk = max_chunk
-
-    def chunk(self):
-        return self.sock.recv(self.mxchunk)
-
-
-class IterUnreader(Unreader):
-    def __init__(self, iterable):
-        super(IterUnreader, self).__init__()
-        self.iter = iter(iterable)
-
-    def chunk(self):
-        if not self.iter:
-            return b""
-        try:
-            return six.next(self.iter)
-        except StopIteration:
-            self.iter = None
-            return b""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/wsgi.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/wsgi.py
deleted file mode 100644
index ff75974d3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/http/wsgi.py
+++ /dev/null
@@ -1,411 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import io
-import logging
-import os
-import re
-import sys
-
-from gunicorn._compat import unquote_to_wsgi_str
-from gunicorn.http.message import HEADER_RE
-from gunicorn.http.errors import InvalidHeader, InvalidHeaderName
-from gunicorn.six import string_types, binary_type, reraise
-from gunicorn import SERVER_SOFTWARE
-import gunicorn.util as util
-
-try:
-    # Python 3.3 has os.sendfile().
-    from os import sendfile
-except ImportError:
-    try:
-        from ._sendfile import sendfile
-    except ImportError:
-        sendfile = None
-
-# Send files in at most 1GB blocks as some operating systems can have problems
-# with sending files in blocks over 2GB.
-BLKSIZE = 0x3FFFFFFF
-
-HEADER_VALUE_RE = re.compile(r'[\x00-\x1F\x7F]')
-
-log = logging.getLogger(__name__)
-
-
-class FileWrapper(object):
-
-    def __init__(self, filelike, blksize=8192):
-        self.filelike = filelike
-        self.blksize = blksize
-        if hasattr(filelike, 'close'):
-            self.close = filelike.close
-
-    def __getitem__(self, key):
-        data = self.filelike.read(self.blksize)
-        if data:
-            return data
-        raise IndexError
-
-
-class WSGIErrorsWrapper(io.RawIOBase):
-
-    def __init__(self, cfg):
-        # There is no public __init__ method for RawIOBase so
-        # we don't need to call super() in the __init__ method.
-        # pylint: disable=super-init-not-called
-        errorlog = logging.getLogger("gunicorn.error")
-        handlers = errorlog.handlers
-        self.streams = []
-
-        if cfg.errorlog == "-":
-            self.streams.append(sys.stderr)
-            handlers = handlers[1:]
-
-        for h in handlers:
-            if hasattr(h, "stream"):
-                self.streams.append(h.stream)
-
-    def write(self, data):
-        for stream in self.streams:
-            try:
-                stream.write(data)
-            except UnicodeError:
-                stream.write(data.encode("UTF-8"))
-            stream.flush()
-
-
-def base_environ(cfg):
-    return {
-        "wsgi.errors": WSGIErrorsWrapper(cfg),
-        "wsgi.version": (1, 0),
-        "wsgi.multithread": False,
-        "wsgi.multiprocess": (cfg.workers > 1),
-        "wsgi.run_once": False,
-        "wsgi.file_wrapper": FileWrapper,
-        "SERVER_SOFTWARE": SERVER_SOFTWARE,
-    }
-
-
-def default_environ(req, sock, cfg):
-    env = base_environ(cfg)
-    env.update({
-        "wsgi.input": req.body,
-        "gunicorn.socket": sock,
-        "REQUEST_METHOD": req.method,
-        "QUERY_STRING": req.query,
-        "RAW_URI": req.uri,
-        "SERVER_PROTOCOL": "HTTP/%s" % ".".join([str(v) for v in req.version])
-    })
-    return env
-
-
-def proxy_environ(req):
-    info = req.proxy_protocol_info
-
-    if not info:
-        return {}
-
-    return {
-        "PROXY_PROTOCOL": info["proxy_protocol"],
-        "REMOTE_ADDR": info["client_addr"],
-        "REMOTE_PORT": str(info["client_port"]),
-        "PROXY_ADDR": info["proxy_addr"],
-        "PROXY_PORT": str(info["proxy_port"]),
-    }
-
-
-def create(req, sock, client, server, cfg):
-    resp = Response(req, sock, cfg)
-
-    # set initial environ
-    environ = default_environ(req, sock, cfg)
-
-    # default variables
-    host = None
-    script_name = os.environ.get("SCRIPT_NAME", "")
-
-    # add the headers to the environ
-    for hdr_name, hdr_value in req.headers:
-        if hdr_name == "EXPECT":
-            # handle expect
-            if hdr_value.lower() == "100-continue":
-                sock.send(b"HTTP/1.1 100 Continue\r\n\r\n")
-        elif hdr_name == 'HOST':
-            host = hdr_value
-        elif hdr_name == "SCRIPT_NAME":
-            script_name = hdr_value
-        elif hdr_name == "CONTENT-TYPE":
-            environ['CONTENT_TYPE'] = hdr_value
-            continue
-        elif hdr_name == "CONTENT-LENGTH":
-            environ['CONTENT_LENGTH'] = hdr_value
-            continue
-
-        key = 'HTTP_' + hdr_name.replace('-', '_')
-        if key in environ:
-            hdr_value = "%s,%s" % (environ[key], hdr_value)
-        environ[key] = hdr_value
-
-    # set the url scheme
-    environ['wsgi.url_scheme'] = req.scheme
-
-    # set the REMOTE_* keys in environ
-    # authors should be aware that REMOTE_HOST and REMOTE_ADDR
-    # may not qualify the remote addr:
-    # http://www.ietf.org/rfc/rfc3875
-    if isinstance(client, string_types):
-        environ['REMOTE_ADDR'] = client
-    elif isinstance(client, binary_type):
-        environ['REMOTE_ADDR'] = client.decode()
-    else:
-        environ['REMOTE_ADDR'] = client[0]
-        environ['REMOTE_PORT'] = str(client[1])
-
-    # handle the SERVER_*
-    # Normally only the application should use the Host header but since the
-    # WSGI spec doesn't support unix sockets, we are using it to create
-    # viable SERVER_* if possible.
-    if isinstance(server, string_types):
-        server = server.split(":")
-        if len(server) == 1:
-            # unix socket
-            if host:
-                server = host.split(':')
-                if len(server) == 1:
-                    if req.scheme == "http":
-                        server.append(80)
-                    elif req.scheme == "https":
-                        server.append(443)
-                    else:
-                        server.append('')
-            else:
-                # no host header given which means that we are not behind a
-                # proxy, so append an empty port.
-                server.append('')
-    environ['SERVER_NAME'] = server[0]
-    environ['SERVER_PORT'] = str(server[1])
-
-    # set the path and script name
-    path_info = req.path
-    if script_name:
-        path_info = path_info.split(script_name, 1)[1]
-    environ['PATH_INFO'] = unquote_to_wsgi_str(path_info)
-    environ['SCRIPT_NAME'] = script_name
-
-    # override the environ with the correct remote and server address if
-    # we are behind a proxy using the proxy protocol.
-    environ.update(proxy_environ(req))
-    return resp, environ
-
-
-class Response(object):
-
-    def __init__(self, req, sock, cfg):
-        self.req = req
-        self.sock = sock
-        self.version = SERVER_SOFTWARE
-        self.status = None
-        self.chunked = False
-        self.must_close = False
-        self.headers = []
-        self.headers_sent = False
-        self.response_length = None
-        self.sent = 0
-        self.upgrade = False
-        self.cfg = cfg
-
-    def force_close(self):
-        self.must_close = True
-
-    def should_close(self):
-        if self.must_close or self.req.should_close():
-            return True
-        if self.response_length is not None or self.chunked:
-            return False
-        if self.req.method == 'HEAD':
-            return False
-        if self.status_code < 200 or self.status_code in (204, 304):
-            return False
-        return True
-
-    def start_response(self, status, headers, exc_info=None):
-        if exc_info:
-            try:
-                if self.status and self.headers_sent:
-                    reraise(exc_info[0], exc_info[1], exc_info[2])
-            finally:
-                exc_info = None
-        elif self.status is not None:
-            raise AssertionError("Response headers already set!")
-
-        self.status = status
-
-        # get the status code from the response here so we can use it to check
-        # the need for the connection header later without parsing the string
-        # each time.
-        try:
-            self.status_code = int(self.status.split()[0])
-        except ValueError:
-            self.status_code = None
-
-        self.process_headers(headers)
-        self.chunked = self.is_chunked()
-        return self.write
-
-    def process_headers(self, headers):
-        for name, value in headers:
-            if not isinstance(name, string_types):
-                raise TypeError('%r is not a string' % name)
-
-            if HEADER_RE.search(name):
-                raise InvalidHeaderName('%r' % name)
-
-            if HEADER_VALUE_RE.search(value):
-                raise InvalidHeader('%r' % value)
-
-            value = str(value).strip()
-            lname = name.lower().strip()
-            if lname == "content-length":
-                self.response_length = int(value)
-            elif util.is_hoppish(name):
-                if lname == "connection":
-                    # handle websocket
-                    if value.lower().strip() == "upgrade":
-                        self.upgrade = True
-                elif lname == "upgrade":
-                    if value.lower().strip() == "websocket":
-                        self.headers.append((name.strip(), value))
-
-                # ignore hopbyhop headers
-                continue
-            self.headers.append((name.strip(), value))
-
-    def is_chunked(self):
-        # Only use chunked responses when the client is
-        # speaking HTTP/1.1 or newer and there was
-        # no Content-Length header set.
-        if self.response_length is not None:
-            return False
-        elif self.req.version <= (1, 0):
-            return False
-        elif self.req.method == 'HEAD':
-            # Responses to a HEAD request MUST NOT contain a response body.
-            return False
-        elif self.status_code in (204, 304):
-            # Do not use chunked responses when the response is guaranteed to
-            # not have a response body.
-            return False
-        return True
-
-    def default_headers(self):
-        # set the connection header
-        if self.upgrade:
-            connection = "upgrade"
-        elif self.should_close():
-            connection = "close"
-        else:
-            connection = "keep-alive"
-
-        headers = [
-            "HTTP/%s.%s %s\r\n" % (self.req.version[0],
-                self.req.version[1], self.status),
-            "Server: %s\r\n" % self.version,
-            "Date: %s\r\n" % util.http_date(),
-            "Connection: %s\r\n" % connection
-        ]
-        if self.chunked:
-            headers.append("Transfer-Encoding: chunked\r\n")
-        return headers
-
-    def send_headers(self):
-        if self.headers_sent:
-            return
-        tosend = self.default_headers()
-        tosend.extend(["%s: %s\r\n" % (k, v) for k, v in self.headers])
-
-        header_str = "%s\r\n" % "".join(tosend)
-        util.write(self.sock, util.to_bytestring(header_str, "ascii"))
-        self.headers_sent = True
-
-    def write(self, arg):
-        self.send_headers()
-        if not isinstance(arg, binary_type):
-            raise TypeError('%r is not a byte' % arg)
-        arglen = len(arg)
-        tosend = arglen
-        if self.response_length is not None:
-            if self.sent >= self.response_length:
-                # Never write more than self.response_length bytes
-                return
-
-            tosend = min(self.response_length - self.sent, tosend)
-            if tosend < arglen:
-                arg = arg[:tosend]
-
-        # Sending an empty chunk signals the end of the
-        # response and prematurely closes the response
-        if self.chunked and tosend == 0:
-            return
-
-        self.sent += tosend
-        util.write(self.sock, arg, self.chunked)
-
-    def can_sendfile(self):
-        return self.cfg.sendfile is not False and sendfile is not None
-
-    def sendfile(self, respiter):
-        if self.cfg.is_ssl or not self.can_sendfile():
-            return False
-
-        if not util.has_fileno(respiter.filelike):
-            return False
-
-        fileno = respiter.filelike.fileno()
-        try:
-            offset = os.lseek(fileno, 0, os.SEEK_CUR)
-            if self.response_length is None:
-                filesize = os.fstat(fileno).st_size
-
-                # The file may be special and sendfile will fail.
-                # It may also be zero-length, but that is okay.
-                if filesize == 0:
-                    return False
-
-                nbytes = filesize - offset
-            else:
-                nbytes = self.response_length
-        except (OSError, io.UnsupportedOperation):
-            return False
-
-        self.send_headers()
-
-        if self.is_chunked():
-            chunk_size = "%X\r\n" % nbytes
-            self.sock.sendall(chunk_size.encode('utf-8'))
-
-        sockno = self.sock.fileno()
-        sent = 0
-
-        while sent != nbytes:
-            count = min(nbytes - sent, BLKSIZE)
-            sent += sendfile(sockno, fileno, offset + sent, count)
-
-        if self.is_chunked():
-            self.sock.sendall(b"\r\n")
-
-        os.lseek(fileno, offset, os.SEEK_SET)
-
-        return True
-
-    def write_file(self, respiter):
-        if not self.sendfile(respiter):
-            for item in respiter:
-                self.write(item)
-
-    def close(self):
-        if not self.headers_sent:
-            self.send_headers()
-        if self.chunked:
-            util.write_chunk(self.sock, b"")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 8fbd5411a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/statsd.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/statsd.cpython-35.pyc
deleted file mode 100644
index 1830a411e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/__pycache__/statsd.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/statsd.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/statsd.py
deleted file mode 100644
index 4bbcb20a9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/instrument/statsd.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-"Bare-bones implementation of statsD's protocol, client-side"
-
-import socket
-import logging
-from re import sub
-
-from gunicorn.glogging import Logger
-from gunicorn import six
-
-# Instrumentation constants
-METRIC_VAR = "metric"
-VALUE_VAR = "value"
-MTYPE_VAR = "mtype"
-GAUGE_TYPE = "gauge"
-COUNTER_TYPE = "counter"
-HISTOGRAM_TYPE = "histogram"
-
-class Statsd(Logger):
-    """statsD-based instrumentation, that passes as a logger
-    """
-    def __init__(self, cfg):
-        """host, port: statsD server
-        """
-        Logger.__init__(self, cfg)
-        self.prefix = sub(r"^(.+[^.]+)\.*$", "\\g<1>.", cfg.statsd_prefix)
-        try:
-            host, port = cfg.statsd_host
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            self.sock.connect((host, int(port)))
-        except Exception:
-            self.sock = None
-
-    # Log errors and warnings
-    def critical(self, msg, *args, **kwargs):
-        Logger.critical(self, msg, *args, **kwargs)
-        self.increment("gunicorn.log.critical", 1)
-
-    def error(self, msg, *args, **kwargs):
-        Logger.error(self, msg, *args, **kwargs)
-        self.increment("gunicorn.log.error", 1)
-
-    def warning(self, msg, *args, **kwargs):
-        Logger.warning(self, msg, *args, **kwargs)
-        self.increment("gunicorn.log.warning", 1)
-
-    def exception(self, msg, *args, **kwargs):
-        Logger.exception(self, msg, *args, **kwargs)
-        self.increment("gunicorn.log.exception", 1)
-
-    # Special treatement for info, the most common log level
-    def info(self, msg, *args, **kwargs):
-        self.log(logging.INFO, msg, *args, **kwargs)
-
-    # skip the run-of-the-mill logs
-    def debug(self, msg, *args, **kwargs):
-        self.log(logging.DEBUG, msg, *args, **kwargs)
-
-    def log(self, lvl, msg, *args, **kwargs):
-        """Log a given statistic if metric, value and type are present
-        """
-        try:
-            extra = kwargs.get("extra", None)
-            if extra is not None:
-                metric = extra.get(METRIC_VAR, None)
-                value = extra.get(VALUE_VAR, None)
-                typ = extra.get(MTYPE_VAR, None)
-                if metric and value and typ:
-                    if typ == GAUGE_TYPE:
-                        self.gauge(metric, value)
-                    elif typ == COUNTER_TYPE:
-                        self.increment(metric, value)
-                    elif typ == HISTOGRAM_TYPE:
-                        self.histogram(metric, value)
-                    else:
-                        pass
-
-            # Log to parent logger only if there is something to say
-            if msg:
-                Logger.log(self, lvl, msg, *args, **kwargs)
-        except Exception:
-            Logger.warning(self, "Failed to log to statsd", exc_info=True)
-
-    # access logging
-    def access(self, resp, req, environ, request_time):
-        """Measure request duration
-        request_time is a datetime.timedelta
-        """
-        Logger.access(self, resp, req, environ, request_time)
-        duration_in_ms = request_time.seconds * 1000 + float(request_time.microseconds) / 10 ** 3
-        status = resp.status
-        if isinstance(status, str):
-            status = int(status.split(None, 1)[0])
-        self.histogram("gunicorn.request.duration", duration_in_ms)
-        self.increment("gunicorn.requests", 1)
-        self.increment("gunicorn.request.status.%d" % status, 1)
-
-    # statsD methods
-    # you can use those directly if you want
-    def gauge(self, name, value):
-        self._sock_send("{0}{1}:{2}|g".format(self.prefix, name, value))
-
-    def increment(self, name, value, sampling_rate=1.0):
-        self._sock_send("{0}{1}:{2}|c|@{3}".format(self.prefix, name, value, sampling_rate))
-
-    def decrement(self, name, value, sampling_rate=1.0):
-        self._sock_send("{0}{1}:-{2}|c|@{3}".format(self.prefix, name, value, sampling_rate))
-
-    def histogram(self, name, value):
-        self._sock_send("{0}{1}:{2}|ms".format(self.prefix, name, value))
-
-    def _sock_send(self, msg):
-        try:
-            if isinstance(msg, six.text_type):
-                msg = msg.encode("ascii")
-            if self.sock:
-                self.sock.send(msg)
-        except Exception:
-            Logger.warning(self, "Error sending message to statsd", exc_info=True)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/pidfile.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/pidfile.py
deleted file mode 100644
index a6e085fd5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/pidfile.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import errno
-import os
-import tempfile
-
-
-class Pidfile(object):
-    """\
-    Manage a PID file. If a specific name is provided
-    it and '"%s.oldpid" % name' will be used. Otherwise
-    we create a temp file using os.mkstemp.
-    """
-
-    def __init__(self, fname):
-        self.fname = fname
-        self.pid = None
-
-    def create(self, pid):
-        oldpid = self.validate()
-        if oldpid:
-            if oldpid == os.getpid():
-                return
-            msg = "Already running on PID %s (or pid file '%s' is stale)"
-            raise RuntimeError(msg % (oldpid, self.fname))
-
-        self.pid = pid
-
-        # Write pidfile
-        fdir = os.path.dirname(self.fname)
-        if fdir and not os.path.isdir(fdir):
-            raise RuntimeError("%s doesn't exist. Can't create pidfile." % fdir)
-        fd, fname = tempfile.mkstemp(dir=fdir)
-        os.write(fd, ("%s\n" % self.pid).encode('utf-8'))
-        if self.fname:
-            os.rename(fname, self.fname)
-        else:
-            self.fname = fname
-        os.close(fd)
-
-        # set permissions to -rw-r--r--
-        os.chmod(self.fname, 420)
-
-    def rename(self, path):
-        self.unlink()
-        self.fname = path
-        self.create(self.pid)
-
-    def unlink(self):
-        """ delete pidfile"""
-        try:
-            with open(self.fname, "r") as f:
-                pid1 = int(f.read() or 0)
-
-            if pid1 == self.pid:
-                os.unlink(self.fname)
-        except:
-            pass
-
-    def validate(self):
-        """ Validate pidfile and make it stale if needed"""
-        if not self.fname:
-            return
-        try:
-            with open(self.fname, "r") as f:
-                try:
-                    wpid = int(f.read())
-                except ValueError:
-                    return
-
-                try:
-                    os.kill(wpid, 0)
-                    return wpid
-                except OSError as e:
-                    if e.args[0] == errno.EPERM:
-                        return wpid
-                    if e.args[0] == errno.ESRCH:
-                        return
-                    raise
-        except IOError as e:
-            if e.args[0] == errno.ENOENT:
-                return
-            raise
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/reloader.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/reloader.py
deleted file mode 100644
index c87988540..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/reloader.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import os
-import os.path
-import re
-import sys
-import time
-import threading
-
-COMPILED_EXT_RE = re.compile(r'py[co]$')
-
-
-class Reloader(threading.Thread):
-    def __init__(self, extra_files=None, interval=1, callback=None):
-        super(Reloader, self).__init__()
-        self.setDaemon(True)
-        self._extra_files = set(extra_files or ())
-        self._extra_files_lock = threading.RLock()
-        self._interval = interval
-        self._callback = callback
-
-    def add_extra_file(self, filename):
-        with self._extra_files_lock:
-            self._extra_files.add(filename)
-
-    def get_files(self):
-        fnames = [
-            COMPILED_EXT_RE.sub('py', module.__file__)
-            for module in tuple(sys.modules.values())
-            if getattr(module, '__file__', None)
-        ]
-
-        with self._extra_files_lock:
-            fnames.extend(self._extra_files)
-
-        return fnames
-
-    def run(self):
-        mtimes = {}
-        while True:
-            for filename in self.get_files():
-                try:
-                    mtime = os.stat(filename).st_mtime
-                except OSError:
-                    continue
-                old_time = mtimes.get(filename)
-                if old_time is None:
-                    mtimes[filename] = mtime
-                    continue
-                elif mtime > old_time:
-                    if self._callback:
-                        self._callback(filename)
-            time.sleep(self._interval)
-
-has_inotify = False
-if sys.platform.startswith('linux'):
-    try:
-        from inotify.adapters import Inotify
-        import inotify.constants
-        has_inotify = True
-    except ImportError:
-        pass
-
-
-if has_inotify:
-
-    class InotifyReloader(threading.Thread):
-        event_mask = (inotify.constants.IN_CREATE | inotify.constants.IN_DELETE
-                      | inotify.constants.IN_DELETE_SELF | inotify.constants.IN_MODIFY
-                      | inotify.constants.IN_MOVE_SELF | inotify.constants.IN_MOVED_FROM
-                      | inotify.constants.IN_MOVED_TO)
-
-        def __init__(self, extra_files=None, callback=None):
-            super(InotifyReloader, self).__init__()
-            self.setDaemon(True)
-            self._callback = callback
-            self._dirs = set()
-            self._watcher = Inotify()
-
-            for extra_file in extra_files:
-                self.add_extra_file(extra_file)
-
-        def add_extra_file(self, filename):
-            dirname = os.path.dirname(filename)
-
-            if dirname in self._dirs:
-                return
-
-            self._watcher.add_watch(dirname, mask=self.event_mask)
-            self._dirs.add(dirname)
-
-        def get_dirs(self):
-            fnames = [
-                os.path.dirname(COMPILED_EXT_RE.sub('py', module.__file__))
-                for module in tuple(sys.modules.values())
-                if hasattr(module, '__file__')
-            ]
-
-            return set(fnames)
-
-        def run(self):
-            self._dirs = self.get_dirs()
-
-            for dirname in self._dirs:
-                self._watcher.add_watch(dirname, mask=self.event_mask)
-
-            for event in self._watcher.event_gen():
-                if event is None:
-                    continue
-
-                filename = event[3]
-
-                self._callback(filename)
-
-else:
-
-    class InotifyReloader(object):
-        def __init__(self, callback=None):
-            raise ImportError('You must have the inotify module installed to '
-                              'use the inotify reloader')
-
-
-preferred_reloader = InotifyReloader if has_inotify else Reloader
-
-reloader_engines = {
-    'auto': preferred_reloader,
-    'poll': Reloader,
-    'inotify': InotifyReloader,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/selectors.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/selectors.py
deleted file mode 100644
index cdae5690d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/selectors.py
+++ /dev/null
@@ -1,592 +0,0 @@
-"""Selectors module.
-
-This module allows high-level and efficient I/O multiplexing, built upon the
-`select` module primitives.
-
-The following code adapted from trollius.selectors.
-"""
-
-
-from abc import ABCMeta, abstractmethod
-from collections import namedtuple, Mapping
-import math
-import select
-import sys
-
-from gunicorn._compat import wrap_error, InterruptedError
-from gunicorn import six
-
-
-# generic events, that must be mapped to implementation-specific ones
-EVENT_READ = (1 << 0)
-EVENT_WRITE = (1 << 1)
-
-
-def _fileobj_to_fd(fileobj):
-    """Return a file descriptor from a file object.
-
-    Parameters:
-    fileobj -- file object or file descriptor
-
-    Returns:
-    corresponding file descriptor
-
-    Raises:
-    ValueError if the object is invalid
-    """
-    if isinstance(fileobj, six.integer_types):
-        fd = fileobj
-    else:
-        try:
-            fd = int(fileobj.fileno())
-        except (AttributeError, TypeError, ValueError):
-            raise ValueError("Invalid file object: "
-                             "{0!r}".format(fileobj))
-    if fd < 0:
-        raise ValueError("Invalid file descriptor: {0}".format(fd))
-    return fd
-
-
-SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
-"""Object used to associate a file object to its backing file descriptor,
-selected event mask and attached data."""
-
-
-class _SelectorMapping(Mapping):
-    """Mapping of file objects to selector keys."""
-
-    def __init__(self, selector):
-        self._selector = selector
-
-    def __len__(self):
-        return len(self._selector._fd_to_key)
-
-    def __getitem__(self, fileobj):
-        try:
-            fd = self._selector._fileobj_lookup(fileobj)
-            return self._selector._fd_to_key[fd]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-    def __iter__(self):
-        return iter(self._selector._fd_to_key)
-
-
-class BaseSelector(six.with_metaclass(ABCMeta)):
-    """Selector abstract base class.
-
-    A selector supports registering file objects to be monitored for specific
-    I/O events.
-
-    A file object is a file descriptor or any object with a `fileno()` method.
-    An arbitrary object can be attached to the file object, which can be used
-    for example to store context information, a callback, etc.
-
-    A selector can use various implementations (select(), poll(), epoll()...)
-    depending on the platform. The default `Selector` class uses the most
-    efficient implementation on the current platform.
-    """
-
-    @abstractmethod
-    def register(self, fileobj, events, data=None):
-        """Register a file object.
-
-        Parameters:
-        fileobj -- file object or file descriptor
-        events  -- events to monitor (bitwise mask of EVENT_READ|EVENT_WRITE)
-        data    -- attached data
-
-        Returns:
-        SelectorKey instance
-
-        Raises:
-        ValueError if events is invalid
-        KeyError if fileobj is already registered
-        OSError if fileobj is closed or otherwise is unacceptable to
-                the underlying system call (if a system call is made)
-
-        Note:
-        OSError may or may not be raised
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def unregister(self, fileobj):
-        """Unregister a file object.
-
-        Parameters:
-        fileobj -- file object or file descriptor
-
-        Returns:
-        SelectorKey instance
-
-        Raises:
-        KeyError if fileobj is not registered
-
-        Note:
-        If fileobj is registered but has since been closed this does
-        *not* raise OSError (even if the wrapped syscall does)
-        """
-        raise NotImplementedError
-
-    def modify(self, fileobj, events, data=None):
-        """Change a registered file object monitored events or attached data.
-
-        Parameters:
-        fileobj -- file object or file descriptor
-        events  -- events to monitor (bitwise mask of EVENT_READ|EVENT_WRITE)
-        data    -- attached data
-
-        Returns:
-        SelectorKey instance
-
-        Raises:
-        Anything that unregister() or register() raises
-        """
-        self.unregister(fileobj)
-        return self.register(fileobj, events, data)
-
-    @abstractmethod
-    def select(self, timeout=None):
-        """Perform the actual selection, until some monitored file objects are
-        ready or a timeout expires.
-
-        Parameters:
-        timeout -- if timeout > 0, this specifies the maximum wait time, in
-                   seconds
-                   if timeout <= 0, the select() call won't block, and will
-                   report the currently ready file objects
-                   if timeout is None, select() will block until a monitored
-                   file object becomes ready
-
-        Returns:
-        list of (key, events) for ready file objects
-        `events` is a bitwise mask of EVENT_READ|EVENT_WRITE
-        """
-        raise NotImplementedError
-
-    def close(self):
-        """Close the selector.
-
-        This must be called to make sure that any underlying resource is freed.
-        """
-        pass
-
-    def get_key(self, fileobj):
-        """Return the key associated to a registered file object.
-
-        Returns:
-        SelectorKey for this file object
-        """
-        mapping = self.get_map()
-        try:
-            return mapping[fileobj]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-    @abstractmethod
-    def get_map(self):
-        """Return a mapping of file objects to selector keys."""
-        raise NotImplementedError
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
-
-class _BaseSelectorImpl(BaseSelector):
-    """Base selector implementation."""
-
-    def __init__(self):
-        # this maps file descriptors to keys
-        self._fd_to_key = {}
-        # read-only mapping returned by get_map()
-        self._map = _SelectorMapping(self)
-
-    def _fileobj_lookup(self, fileobj):
-        """Return a file descriptor from a file object.
-
-        This wraps _fileobj_to_fd() to do an exhaustive search in case
-        the object is invalid but we still have it in our map.  This
-        is used by unregister() so we can unregister an object that
-        was previously registered even if it is closed.  It is also
-        used by _SelectorMapping.
-        """
-        try:
-            return _fileobj_to_fd(fileobj)
-        except ValueError:
-            # Do an exhaustive search.
-            for key in self._fd_to_key.values():
-                if key.fileobj is fileobj:
-                    return key.fd
-            # Raise ValueError after all.
-            raise
-
-    def register(self, fileobj, events, data=None):
-        if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
-            raise ValueError("Invalid events: {0!r}".format(events))
-
-        key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
-
-        if key.fd in self._fd_to_key:
-            raise KeyError("{0!r} (FD {1}) is already registered"
-                           .format(fileobj, key.fd))
-
-        self._fd_to_key[key.fd] = key
-        return key
-
-    def unregister(self, fileobj):
-        try:
-            key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-        return key
-
-    def modify(self, fileobj, events, data=None):
-        # TODO: Subclasses can probably optimize this even further.
-        try:
-            key = self._fd_to_key[self._fileobj_lookup(fileobj)]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-        if events != key.events:
-            self.unregister(fileobj)
-            key = self.register(fileobj, events, data)
-        elif data != key.data:
-            # Use a shortcut to update the data.
-            key = key._replace(data=data)
-            self._fd_to_key[key.fd] = key
-        return key
-
-    def close(self):
-        self._fd_to_key.clear()
-
-    def get_map(self):
-        return self._map
-
-    def _key_from_fd(self, fd):
-        """Return the key associated to a given file descriptor.
-
-        Parameters:
-        fd -- file descriptor
-
-        Returns:
-        corresponding key, or None if not found
-        """
-        try:
-            return self._fd_to_key[fd]
-        except KeyError:
-            return None
-
-
-class SelectSelector(_BaseSelectorImpl):
-    """Select-based selector."""
-
-    def __init__(self):
-        super(SelectSelector, self).__init__()
-        self._readers = set()
-        self._writers = set()
-
-    def register(self, fileobj, events, data=None):
-        key = super(SelectSelector, self).register(fileobj, events, data)
-        if events & EVENT_READ:
-            self._readers.add(key.fd)
-        if events & EVENT_WRITE:
-            self._writers.add(key.fd)
-        return key
-
-    def unregister(self, fileobj):
-        key = super(SelectSelector, self).unregister(fileobj)
-        self._readers.discard(key.fd)
-        self._writers.discard(key.fd)
-        return key
-
-    if sys.platform == 'win32':
-        def _select(self, r, w, _, timeout=None):
-            r, w, x = select.select(r, w, w, timeout)
-            return r, w + x, []
-    else:
-        _select = select.select
-
-    def select(self, timeout=None):
-        timeout = None if timeout is None else max(timeout, 0)
-        ready = []
-        try:
-            r, w, _ = wrap_error(self._select,
-                                 self._readers, self._writers, [], timeout)
-        except InterruptedError:
-            return ready
-        r = set(r)
-        w = set(w)
-        for fd in r | w:
-            events = 0
-            if fd in r:
-                events |= EVENT_READ
-            if fd in w:
-                events |= EVENT_WRITE
-
-            key = self._key_from_fd(fd)
-            if key:
-                ready.append((key, events & key.events))
-        return ready
-
-
-if hasattr(select, 'poll'):
-
-    class PollSelector(_BaseSelectorImpl):
-        """Poll-based selector."""
-
-        def __init__(self):
-            super(PollSelector, self).__init__()
-            self._poll = select.poll()
-
-        def register(self, fileobj, events, data=None):
-            key = super(PollSelector, self).register(fileobj, events, data)
-            poll_events = 0
-            if events & EVENT_READ:
-                poll_events |= select.POLLIN
-            if events & EVENT_WRITE:
-                poll_events |= select.POLLOUT
-            self._poll.register(key.fd, poll_events)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(PollSelector, self).unregister(fileobj)
-            self._poll.unregister(key.fd)
-            return key
-
-        def select(self, timeout=None):
-            if timeout is None:
-                timeout = None
-            elif timeout <= 0:
-                timeout = 0
-            else:
-                # poll() has a resolution of 1 millisecond, round away from
-                # zero to wait *at least* timeout seconds.
-                timeout = int(math.ceil(timeout * 1e3))
-            ready = []
-            try:
-                fd_event_list = wrap_error(self._poll.poll, timeout)
-            except InterruptedError:
-                return ready
-            for fd, event in fd_event_list:
-                events = 0
-                if event & ~select.POLLIN:
-                    events |= EVENT_WRITE
-                if event & ~select.POLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-
-if hasattr(select, 'epoll'):
-
-    class EpollSelector(_BaseSelectorImpl):
-        """Epoll-based selector."""
-
-        def __init__(self):
-            super(EpollSelector, self).__init__()
-            self._epoll = select.epoll()
-
-        def fileno(self):
-            return self._epoll.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(EpollSelector, self).register(fileobj, events, data)
-            epoll_events = 0
-            if events & EVENT_READ:
-                epoll_events |= select.EPOLLIN
-            if events & EVENT_WRITE:
-                epoll_events |= select.EPOLLOUT
-            self._epoll.register(key.fd, epoll_events)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(EpollSelector, self).unregister(fileobj)
-            try:
-                self._epoll.unregister(key.fd)
-            except OSError:
-                # This can happen if the FD was closed since it
-                # was registered.
-                pass
-            return key
-
-        def select(self, timeout=None):
-            if timeout is None:
-                timeout = -1
-            elif timeout <= 0:
-                timeout = 0
-            else:
-                # epoll_wait() has a resolution of 1 millisecond, round away
-                # from zero to wait *at least* timeout seconds.
-                timeout = math.ceil(timeout * 1e3) * 1e-3
-            max_ev = len(self._fd_to_key)
-            ready = []
-            try:
-                fd_event_list = wrap_error(self._epoll.poll, timeout, max_ev)
-            except InterruptedError:
-                return ready
-            for fd, event in fd_event_list:
-                events = 0
-                if event & ~select.EPOLLIN:
-                    events |= EVENT_WRITE
-                if event & ~select.EPOLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-        def close(self):
-            self._epoll.close()
-            super(EpollSelector, self).close()
-
-
-if hasattr(select, 'devpoll'):
-
-    class DevpollSelector(_BaseSelectorImpl):
-        """Solaris /dev/poll selector."""
-
-        def __init__(self):
-            super(DevpollSelector, self).__init__()
-            self._devpoll = select.devpoll()
-
-        def fileno(self):
-            return self._devpoll.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(DevpollSelector, self).register(fileobj, events, data)
-            poll_events = 0
-            if events & EVENT_READ:
-                poll_events |= select.POLLIN
-            if events & EVENT_WRITE:
-                poll_events |= select.POLLOUT
-            self._devpoll.register(key.fd, poll_events)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(DevpollSelector, self).unregister(fileobj)
-            self._devpoll.unregister(key.fd)
-            return key
-
-        def select(self, timeout=None):
-            if timeout is None:
-                timeout = None
-            elif timeout <= 0:
-                timeout = 0
-            else:
-                # devpoll() has a resolution of 1 millisecond, round away from
-                # zero to wait *at least* timeout seconds.
-                timeout = math.ceil(timeout * 1e3)
-            ready = []
-            try:
-                fd_event_list = self._devpoll.poll(timeout)
-            except InterruptedError:
-                return ready
-            for fd, event in fd_event_list:
-                events = 0
-                if event & ~select.POLLIN:
-                    events |= EVENT_WRITE
-                if event & ~select.POLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-        def close(self):
-            self._devpoll.close()
-            super(DevpollSelector, self).close()
-
-
-if hasattr(select, 'kqueue'):
-
-    class KqueueSelector(_BaseSelectorImpl):
-        """Kqueue-based selector."""
-
-        def __init__(self):
-            super(KqueueSelector, self).__init__()
-            self._kqueue = select.kqueue()
-
-        def fileno(self):
-            return self._kqueue.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(KqueueSelector, self).register(fileobj, events, data)
-            if events & EVENT_READ:
-                kev = select.kevent(key.fd, select.KQ_FILTER_READ,
-                                    select.KQ_EV_ADD)
-                self._kqueue.control([kev], 0, 0)
-            if events & EVENT_WRITE:
-                kev = select.kevent(key.fd, select.KQ_FILTER_WRITE,
-                                    select.KQ_EV_ADD)
-                self._kqueue.control([kev], 0, 0)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(KqueueSelector, self).unregister(fileobj)
-            if key.events & EVENT_READ:
-                kev = select.kevent(key.fd, select.KQ_FILTER_READ,
-                                    select.KQ_EV_DELETE)
-                try:
-                    self._kqueue.control([kev], 0, 0)
-                except OSError:
-                    # This can happen if the FD was closed since it
-                    # was registered.
-                    pass
-            if key.events & EVENT_WRITE:
-                kev = select.kevent(key.fd, select.KQ_FILTER_WRITE,
-                                    select.KQ_EV_DELETE)
-                try:
-                    self._kqueue.control([kev], 0, 0)
-                except OSError:
-                    # See comment above.
-                    pass
-            return key
-
-        def select(self, timeout=None):
-            timeout = None if timeout is None else max(timeout, 0)
-            max_ev = len(self._fd_to_key)
-            ready = []
-            try:
-                kev_list = wrap_error(self._kqueue.control,
-                                      None, max_ev, timeout)
-            except InterruptedError:
-                return ready
-            for kev in kev_list:
-                fd = kev.ident
-                flag = kev.filter
-                events = 0
-                if flag == select.KQ_FILTER_READ:
-                    events |= EVENT_READ
-                if flag == select.KQ_FILTER_WRITE:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-        def close(self):
-            self._kqueue.close()
-            super(KqueueSelector, self).close()
-
-
-# Choose the best implementation: roughly, epoll|kqueue|devpoll > poll > select.
-# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
-if 'KqueueSelector' in globals():
-    DefaultSelector = KqueueSelector
-elif 'EpollSelector' in globals():
-    DefaultSelector = EpollSelector
-elif 'DevpollSelector' in globals():
-    DefaultSelector = DevpollSelector
-elif 'PollSelector' in globals():
-    DefaultSelector = PollSelector
-else:
-    DefaultSelector = SelectSelector
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/six.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/six.py
deleted file mode 100644
index 21b0e8032..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/six.py
+++ /dev/null
@@ -1,762 +0,0 @@
-"""Utilities for writing code that runs on Python 2 and 3"""
-
-# Copyright (c) 2010-2014 Benjamin Peterson
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-from __future__ import absolute_import
-
-import functools
-import operator
-import sys
-import types
-
-__author__ = "Benjamin Peterson <benjamin@python.org>"
-__version__ = "1.8.0"
-
-
-# Useful for very coarse version differentiation.
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    string_types = str,
-    integer_types = int,
-    class_types = type,
-    text_type = str
-    binary_type = bytes
-
-    MAXSIZE = sys.maxsize
-else:
-    string_types = basestring,
-    integer_types = (int, long)
-    class_types = (type, types.ClassType)
-    text_type = unicode
-    binary_type = str
-
-    if sys.platform.startswith("java"):
-        # Jython always uses 32 bits.
-        MAXSIZE = int((1 << 31) - 1)
-    else:
-        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
-        class X(object):
-            def __len__(self):
-                return 1 << 31
-        try:
-            len(X())
-        except OverflowError:
-            # 32-bit
-            MAXSIZE = int((1 << 31) - 1)
-        else:
-            # 64-bit
-            MAXSIZE = int((1 << 63) - 1)
-        del X
-
-
-def _add_doc(func, doc):
-    """Add documentation to a function."""
-    func.__doc__ = doc
-
-
-def _import_module(name):
-    """Import module, returning the module after the last dot."""
-    __import__(name)
-    return sys.modules[name]
-
-
-class _LazyDescr(object):
-
-    def __init__(self, name):
-        self.name = name
-
-    def __get__(self, obj, tp):
-        result = self._resolve()
-        setattr(obj, self.name, result) # Invokes __set__.
-        # This is a bit ugly, but it avoids running this again.
-        delattr(obj.__class__, self.name)
-        return result
-
-
-class MovedModule(_LazyDescr):
-
-    def __init__(self, name, old, new=None):
-        super(MovedModule, self).__init__(name)
-        if PY3:
-            if new is None:
-                new = name
-            self.mod = new
-        else:
-            self.mod = old
-
-    def _resolve(self):
-        return _import_module(self.mod)
-
-    def __getattr__(self, attr):
-        _module = self._resolve()
-        value = getattr(_module, attr)
-        setattr(self, attr, value)
-        return value
-
-
-class _LazyModule(types.ModuleType):
-
-    def __init__(self, name):
-        super(_LazyModule, self).__init__(name)
-        self.__doc__ = self.__class__.__doc__
-
-    def __dir__(self):
-        attrs = ["__doc__", "__name__"]
-        attrs += [attr.name for attr in self._moved_attributes]
-        return attrs
-
-    # Subclasses should override this
-    _moved_attributes = []
-
-
-class MovedAttribute(_LazyDescr):
-
-    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
-        super(MovedAttribute, self).__init__(name)
-        if PY3:
-            if new_mod is None:
-                new_mod = name
-            self.mod = new_mod
-            if new_attr is None:
-                if old_attr is None:
-                    new_attr = name
-                else:
-                    new_attr = old_attr
-            self.attr = new_attr
-        else:
-            self.mod = old_mod
-            if old_attr is None:
-                old_attr = name
-            self.attr = old_attr
-
-    def _resolve(self):
-        module = _import_module(self.mod)
-        return getattr(module, self.attr)
-
-
-class _SixMetaPathImporter(object):
-    """
-    A meta path importer to import six.moves and its submodules.
-
-    This class implements a PEP302 finder and loader. It should be compatible
-    with Python 2.5 and all existing versions of Python3
-    """
-    def __init__(self, six_module_name):
-        self.name = six_module_name
-        self.known_modules = {}
-
-    def _add_module(self, mod, *fullnames):
-        for fullname in fullnames:
-            self.known_modules[self.name + "." + fullname] = mod
-
-    def _get_module(self, fullname):
-        return self.known_modules[self.name + "." + fullname]
-
-    def find_module(self, fullname, path=None):
-        if fullname in self.known_modules:
-            return self
-        return None
-
-    def __get_module(self, fullname):
-        try:
-            return self.known_modules[fullname]
-        except KeyError:
-            raise ImportError("This loader does not know module " + fullname)
-
-    def load_module(self, fullname):
-        try:
-            # in case of a reload
-            return sys.modules[fullname]
-        except KeyError:
-            pass
-        mod = self.__get_module(fullname)
-        if isinstance(mod, MovedModule):
-            mod = mod._resolve()
-        else:
-            mod.__loader__ = self
-        sys.modules[fullname] = mod
-        return mod
-
-    def is_package(self, fullname):
-        """
-        Return true, if the named module is a package.
-
-        We need this method to get correct spec objects with
-        Python 3.4 (see PEP451)
-        """
-        return hasattr(self.__get_module(fullname), "__path__")
-
-    def get_code(self, fullname):
-        """Return None
-
-        Required, if is_package is implemented"""
-        self.__get_module(fullname)  # eventually raises ImportError
-        return None
-    get_source = get_code  # same as get_code
-
-_importer = _SixMetaPathImporter(__name__)
-
-
-class _MovedItems(_LazyModule):
-    """Lazy loading of moved objects"""
-    __path__ = []  # mark as package
-
-
-_moved_attributes = [
-    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
-    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
-    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
-    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
-    MovedAttribute("intern", "__builtin__", "sys"),
-    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
-    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("reload_module", "__builtin__", "imp", "reload"),
-    MovedAttribute("reduce", "__builtin__", "functools"),
-    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
-    MovedAttribute("StringIO", "StringIO", "io"),
-    MovedAttribute("UserDict", "UserDict", "collections"),
-    MovedAttribute("UserList", "UserList", "collections"),
-    MovedAttribute("UserString", "UserString", "collections"),
-    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
-    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
-
-    MovedModule("builtins", "__builtin__"),
-    MovedModule("configparser", "ConfigParser"),
-    MovedModule("copyreg", "copy_reg"),
-    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
-    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
-    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
-    MovedModule("http_cookies", "Cookie", "http.cookies"),
-    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
-    MovedModule("html_parser", "HTMLParser", "html.parser"),
-    MovedModule("http_client", "httplib", "http.client"),
-    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
-    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
-    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
-    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
-    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
-    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
-    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
-    MovedModule("cPickle", "cPickle", "pickle"),
-    MovedModule("queue", "Queue"),
-    MovedModule("reprlib", "repr"),
-    MovedModule("socketserver", "SocketServer"),
-    MovedModule("_thread", "thread", "_thread"),
-    MovedModule("tkinter", "Tkinter"),
-    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
-    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
-    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
-    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
-    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
-    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
-    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
-    MovedModule("tkinter_colorchooser", "tkColorChooser",
-                "tkinter.colorchooser"),
-    MovedModule("tkinter_commondialog", "tkCommonDialog",
-                "tkinter.commondialog"),
-    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
-    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
-    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
-                "tkinter.simpledialog"),
-    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
-    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
-    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
-    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
-    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
-    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
-    MovedModule("winreg", "_winreg"),
-]
-for attr in _moved_attributes:
-    setattr(_MovedItems, attr.name, attr)
-    if isinstance(attr, MovedModule):
-        _importer._add_module(attr, "moves." + attr.name)
-del attr
-
-_MovedItems._moved_attributes = _moved_attributes
-
-moves = _MovedItems(__name__ + ".moves")
-_importer._add_module(moves, "moves")
-
-
-class Module_six_moves_urllib_parse(_LazyModule):
-    """Lazy loading of moved objects in six.moves.urllib_parse"""
-
-
-_urllib_parse_moved_attributes = [
-    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
-    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
-    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
-    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
-    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("quote", "urllib", "urllib.parse"),
-    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("unquote", "urllib", "urllib.parse"),
-    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("urlencode", "urllib", "urllib.parse"),
-    MovedAttribute("splitquery", "urllib", "urllib.parse"),
-    MovedAttribute("splittag", "urllib", "urllib.parse"),
-    MovedAttribute("splituser", "urllib", "urllib.parse"),
-    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
-]
-for attr in _urllib_parse_moved_attributes:
-    setattr(Module_six_moves_urllib_parse, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
-                      "moves.urllib_parse", "moves.urllib.parse")
-
-
-class Module_six_moves_urllib_error(_LazyModule):
-    """Lazy loading of moved objects in six.moves.urllib_error"""
-
-
-_urllib_error_moved_attributes = [
-    MovedAttribute("URLError", "urllib2", "urllib.error"),
-    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
-    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
-]
-for attr in _urllib_error_moved_attributes:
-    setattr(Module_six_moves_urllib_error, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
-                      "moves.urllib_error", "moves.urllib.error")
-
-
-class Module_six_moves_urllib_request(_LazyModule):
-    """Lazy loading of moved objects in six.moves.urllib_request"""
-
-
-_urllib_request_moved_attributes = [
-    MovedAttribute("urlopen", "urllib2", "urllib.request"),
-    MovedAttribute("install_opener", "urllib2", "urllib.request"),
-    MovedAttribute("build_opener", "urllib2", "urllib.request"),
-    MovedAttribute("pathname2url", "urllib", "urllib.request"),
-    MovedAttribute("url2pathname", "urllib", "urllib.request"),
-    MovedAttribute("getproxies", "urllib", "urllib.request"),
-    MovedAttribute("Request", "urllib2", "urllib.request"),
-    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
-    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
-    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
-    MovedAttribute("URLopener", "urllib", "urllib.request"),
-    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
-    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
-]
-for attr in _urllib_request_moved_attributes:
-    setattr(Module_six_moves_urllib_request, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
-                      "moves.urllib_request", "moves.urllib.request")
-
-
-class Module_six_moves_urllib_response(_LazyModule):
-    """Lazy loading of moved objects in six.moves.urllib_response"""
-
-
-_urllib_response_moved_attributes = [
-    MovedAttribute("addbase", "urllib", "urllib.response"),
-    MovedAttribute("addclosehook", "urllib", "urllib.response"),
-    MovedAttribute("addinfo", "urllib", "urllib.response"),
-    MovedAttribute("addinfourl", "urllib", "urllib.response"),
-]
-for attr in _urllib_response_moved_attributes:
-    setattr(Module_six_moves_urllib_response, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
-                      "moves.urllib_response", "moves.urllib.response")
-
-
-class Module_six_moves_urllib_robotparser(_LazyModule):
-    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
-
-
-_urllib_robotparser_moved_attributes = [
-    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
-]
-for attr in _urllib_robotparser_moved_attributes:
-    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
-                      "moves.urllib_robotparser", "moves.urllib.robotparser")
-
-
-class Module_six_moves_urllib(types.ModuleType):
-    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
-    __path__ = []  # mark as package
-    parse = _importer._get_module("moves.urllib_parse")
-    error = _importer._get_module("moves.urllib_error")
-    request = _importer._get_module("moves.urllib_request")
-    response = _importer._get_module("moves.urllib_response")
-    robotparser = _importer._get_module("moves.urllib_robotparser")
-
-    def __dir__(self):
-        return ['parse', 'error', 'request', 'response', 'robotparser']
-
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
-                      "moves.urllib")
-
-
-def add_move(move):
-    """Add an item to six.moves."""
-    setattr(_MovedItems, move.name, move)
-
-
-def remove_move(name):
-    """Remove item from six.moves."""
-    try:
-        delattr(_MovedItems, name)
-    except AttributeError:
-        try:
-            del moves.__dict__[name]
-        except KeyError:
-            raise AttributeError("no such move, %r" % (name,))
-
-
-if PY3:
-    _meth_func = "__func__"
-    _meth_self = "__self__"
-
-    _func_closure = "__closure__"
-    _func_code = "__code__"
-    _func_defaults = "__defaults__"
-    _func_globals = "__globals__"
-else:
-    _meth_func = "im_func"
-    _meth_self = "im_self"
-
-    _func_closure = "func_closure"
-    _func_code = "func_code"
-    _func_defaults = "func_defaults"
-    _func_globals = "func_globals"
-
-
-try:
-    advance_iterator = next
-except NameError:
-    def advance_iterator(it):
-        return it.next()
-next = advance_iterator
-
-
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-if PY3:
-    def get_unbound_function(unbound):
-        return unbound
-
-    create_bound_method = types.MethodType
-
-    Iterator = object
-else:
-    def get_unbound_function(unbound):
-        return unbound.im_func
-
-    def create_bound_method(func, obj):
-        return types.MethodType(func, obj, obj.__class__)
-
-    class Iterator(object):
-
-        def next(self):
-            return type(self).__next__(self)
-
-    callable = callable
-_add_doc(get_unbound_function,
-         """Get the function out of a possibly unbound function""")
-
-
-get_method_function = operator.attrgetter(_meth_func)
-get_method_self = operator.attrgetter(_meth_self)
-get_function_closure = operator.attrgetter(_func_closure)
-get_function_code = operator.attrgetter(_func_code)
-get_function_defaults = operator.attrgetter(_func_defaults)
-get_function_globals = operator.attrgetter(_func_globals)
-
-
-if PY3:
-    def iterkeys(d, **kw):
-        return iter(d.keys(**kw))
-
-    def itervalues(d, **kw):
-        return iter(d.values(**kw))
-
-    def iteritems(d, **kw):
-        return iter(d.items(**kw))
-
-    def iterlists(d, **kw):
-        return iter(d.lists(**kw))
-else:
-    def iterkeys(d, **kw):
-        return iter(d.iterkeys(**kw))
-
-    def itervalues(d, **kw):
-        return iter(d.itervalues(**kw))
-
-    def iteritems(d, **kw):
-        return iter(d.iteritems(**kw))
-
-    def iterlists(d, **kw):
-        return iter(d.iterlists(**kw))
-
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
-_add_doc(iteritems,
-         "Return an iterator over the (key, value) pairs of a dictionary.")
-_add_doc(iterlists,
-         "Return an iterator over the (key, [values]) pairs of a dictionary.")
-
-
-if PY3:
-    def b(s):
-        return s.encode("latin-1")
-    def u(s):
-        return s
-    unichr = chr
-    if sys.version_info[1] <= 1:
-        def int2byte(i):
-            return bytes((i,))
-    else:
-        # This is about 2x faster than the implementation above on 3.2+
-        int2byte = operator.methodcaller("to_bytes", 1, "big")
-    byte2int = operator.itemgetter(0)
-    indexbytes = operator.getitem
-    iterbytes = iter
-    import io
-    StringIO = io.StringIO
-    BytesIO = io.BytesIO
-else:
-    def b(s):
-        return s
-    # Workaround for standalone backslash
-    def u(s):
-        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
-    unichr = unichr
-    int2byte = chr
-    def byte2int(bs):
-        return ord(bs[0])
-    def indexbytes(buf, i):
-        return ord(buf[i])
-    def iterbytes(buf):
-        return (ord(byte) for byte in buf)
-    import StringIO
-    StringIO = BytesIO = StringIO.StringIO
-_add_doc(b, """Byte literal""")
-_add_doc(u, """Text literal""")
-
-
-if PY3:
-    exec_ = getattr(moves.builtins, "exec")
-
-
-    def reraise(tp, value, tb=None):
-        if value is None:
-            value = tp()
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-else:
-    def exec_(_code_, _globs_=None, _locs_=None):
-        """Execute code in a namespace."""
-        if _globs_ is None:
-            frame = sys._getframe(1)
-            _globs_ = frame.f_globals
-            if _locs_ is None:
-                _locs_ = frame.f_locals
-            del frame
-        elif _locs_ is None:
-            _locs_ = _globs_
-        exec("""exec _code_ in _globs_, _locs_""")
-
-
-    exec_("""def reraise(tp, value, tb=None):
-    raise tp, value, tb
-""")
-
-
-print_ = getattr(moves.builtins, "print", None)
-if print_ is None:
-    def print_(*args, **kwargs):
-        """The new-style print function for Python 2.4 and 2.5."""
-        fp = kwargs.pop("file", sys.stdout)
-        if fp is None:
-            return
-        def write(data):
-            if not isinstance(data, basestring):
-                data = str(data)
-            # If the file has an encoding, encode unicode with it.
-            if (isinstance(fp, file) and
-                isinstance(data, unicode) and
-                fp.encoding is not None):
-                errors = getattr(fp, "errors", None)
-                if errors is None:
-                    errors = "strict"
-                data = data.encode(fp.encoding, errors)
-            fp.write(data)
-        want_unicode = False
-        sep = kwargs.pop("sep", None)
-        if sep is not None:
-            if isinstance(sep, unicode):
-                want_unicode = True
-            elif not isinstance(sep, str):
-                raise TypeError("sep must be None or a string")
-        end = kwargs.pop("end", None)
-        if end is not None:
-            if isinstance(end, unicode):
-                want_unicode = True
-            elif not isinstance(end, str):
-                raise TypeError("end must be None or a string")
-        if kwargs:
-            raise TypeError("invalid keyword arguments to print()")
-        if not want_unicode:
-            for arg in args:
-                if isinstance(arg, unicode):
-                    want_unicode = True
-                    break
-        if want_unicode:
-            newline = unicode("\n")
-            space = unicode(" ")
-        else:
-            newline = "\n"
-            space = " "
-        if sep is None:
-            sep = space
-        if end is None:
-            end = newline
-        for i, arg in enumerate(args):
-            if i:
-                write(sep)
-            write(arg)
-        write(end)
-
-_add_doc(reraise, """Reraise an exception.""")
-
-if sys.version_info[0:2] < (3, 4):
-    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
-              updated=functools.WRAPPER_UPDATES):
-        def wrapper(f):
-            f = functools.wraps(wrapped)(f)
-            f.__wrapped__ = wrapped
-            return f
-        return wrapper
-else:
-    wraps = functools.wraps
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-def add_metaclass(metaclass):
-    """Class decorator for creating a class with a metaclass."""
-    def wrapper(cls):
-        orig_vars = cls.__dict__.copy()
-        slots = orig_vars.get('__slots__')
-        if slots is not None:
-            if isinstance(slots, str):
-                slots = [slots]
-            for slots_var in slots:
-                orig_vars.pop(slots_var)
-        orig_vars.pop('__dict__', None)
-        orig_vars.pop('__weakref__', None)
-        return metaclass(cls.__name__, cls.__bases__, orig_vars)
-    return wrapper
-
-# Complete the moves implementation.
-# This code is at the end of this module to speed up module loading.
-# Turn this module into a package.
-__path__ = []  # required for PEP 302 and PEP 451
-__package__ = __name__  # see PEP 366 @ReservedAssignment
-if globals().get("__spec__") is not None:
-    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
-# Remove other six meta path importers, since they cause problems. This can
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does
-# this for some reason.)
-if sys.meta_path:
-    for i, importer in enumerate(sys.meta_path):
-        # Here's some real nastiness: Another "instance" of the six module might
-        # be floating around. Therefore, we can't use isinstance() to check for
-        # the six meta path importer, since the other six instance will have
-        # inserted an importer with different class.
-        if (type(importer).__name__ == "_SixMetaPathImporter" and
-            importer.name == __name__):
-            del sys.meta_path[i]
-            break
-    del i, importer
-# Finally, add the importer to the meta path import hook.
-sys.meta_path.append(_importer)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/sock.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/sock.py
deleted file mode 100644
index 8870936a9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/sock.py
+++ /dev/null
@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import errno
-import os
-import socket
-import stat
-import sys
-import time
-
-from gunicorn import util
-from gunicorn.six import string_types
-
-
-class BaseSocket(object):
-
-    def __init__(self, address, conf, log, fd=None):
-        self.log = log
-        self.conf = conf
-
-        self.cfg_addr = address
-        if fd is None:
-            sock = socket.socket(self.FAMILY, socket.SOCK_STREAM)
-            bound = False
-        else:
-            sock = socket.fromfd(fd, self.FAMILY, socket.SOCK_STREAM)
-            os.close(fd)
-            bound = True
-
-        self.sock = self.set_options(sock, bound=bound)
-
-    def __str__(self):
-        return "<socket %d>" % self.sock.fileno()
-
-    def __getattr__(self, name):
-        return getattr(self.sock, name)
-
-    def set_options(self, sock, bound=False):
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        if (self.conf.reuse_port
-            and hasattr(socket, 'SO_REUSEPORT')):  # pragma: no cover
-            try:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-            except socket.error as err:
-                if err.errno not in (errno.ENOPROTOOPT, errno.EINVAL):
-                    raise
-        if not bound:
-            self.bind(sock)
-        sock.setblocking(0)
-
-        # make sure that the socket can be inherited
-        if hasattr(sock, "set_inheritable"):
-            sock.set_inheritable(True)
-
-        sock.listen(self.conf.backlog)
-        return sock
-
-    def bind(self, sock):
-        sock.bind(self.cfg_addr)
-
-    def close(self):
-        if self.sock is None:
-            return
-
-        try:
-            self.sock.close()
-        except socket.error as e:
-            self.log.info("Error while closing socket %s", str(e))
-
-        self.sock = None
-
-
-class TCPSocket(BaseSocket):
-
-    FAMILY = socket.AF_INET
-
-    def __str__(self):
-        if self.conf.is_ssl:
-            scheme = "https"
-        else:
-            scheme = "http"
-
-        addr = self.sock.getsockname()
-        return "%s://%s:%d" % (scheme, addr[0], addr[1])
-
-    def set_options(self, sock, bound=False):
-        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        return super(TCPSocket, self).set_options(sock, bound=bound)
-
-
-class TCP6Socket(TCPSocket):
-
-    FAMILY = socket.AF_INET6
-
-    def __str__(self):
-        (host, port, _, _) = self.sock.getsockname()
-        return "http://[%s]:%d" % (host, port)
-
-
-class UnixSocket(BaseSocket):
-
-    FAMILY = socket.AF_UNIX
-
-    def __init__(self, addr, conf, log, fd=None):
-        if fd is None:
-            try:
-                st = os.stat(addr)
-            except OSError as e:
-                if e.args[0] != errno.ENOENT:
-                    raise
-            else:
-                if stat.S_ISSOCK(st.st_mode):
-                    os.remove(addr)
-                else:
-                    raise ValueError("%r is not a socket" % addr)
-        super(UnixSocket, self).__init__(addr, conf, log, fd=fd)
-
-    def __str__(self):
-        return "unix:%s" % self.cfg_addr
-
-    def bind(self, sock):
-        old_umask = os.umask(self.conf.umask)
-        sock.bind(self.cfg_addr)
-        util.chown(self.cfg_addr, self.conf.uid, self.conf.gid)
-        os.umask(old_umask)
-
-
-def _sock_type(addr):
-    if isinstance(addr, tuple):
-        if util.is_ipv6(addr[0]):
-            sock_type = TCP6Socket
-        else:
-            sock_type = TCPSocket
-    elif isinstance(addr, string_types):
-        sock_type = UnixSocket
-    else:
-        raise TypeError("Unable to create socket from: %r" % addr)
-    return sock_type
-
-
-def create_sockets(conf, log, fds=None):
-    """
-    Create a new socket for the configured addresses or file descriptors.
-
-    If a configured address is a tuple then a TCP socket is created.
-    If it is a string, a Unix socket is created. Otherwise, a TypeError is
-    raised.
-    """
-    listeners = []
-
-    # get it only once
-    laddr = conf.address
-
-    # check ssl config early to raise the error on startup
-    # only the certfile is needed since it can contains the keyfile
-    if conf.certfile and not os.path.exists(conf.certfile):
-        raise ValueError('certfile "%s" does not exist' % conf.certfile)
-
-    if conf.keyfile and not os.path.exists(conf.keyfile):
-        raise ValueError('keyfile "%s" does not exist' % conf.keyfile)
-
-    # sockets are already bound
-    if fds is not None:
-        for fd in fds:
-            sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
-            sock_name = sock.getsockname()
-            sock_type = _sock_type(sock_name)
-            listener = sock_type(sock_name, conf, log, fd=fd)
-            listeners.append(listener)
-
-        return listeners
-
-    # no sockets is bound, first initialization of gunicorn in this env.
-    for addr in laddr:
-        sock_type = _sock_type(addr)
-        sock = None
-        for i in range(5):
-            try:
-                sock = sock_type(addr, conf, log)
-            except socket.error as e:
-                if e.args[0] == errno.EADDRINUSE:
-                    log.error("Connection in use: %s", str(addr))
-                if e.args[0] == errno.EADDRNOTAVAIL:
-                    log.error("Invalid address: %s", str(addr))
-                if i < 5:
-                    msg = "connection to {addr} failed: {error}"
-                    log.debug(msg.format(addr=str(addr), error=str(e)))
-                    log.error("Retrying in 1 second.")
-                    time.sleep(1)
-            else:
-                break
-
-        if sock is None:
-            log.error("Can't connect to %s", str(addr))
-            sys.exit(1)
-
-        listeners.append(sock)
-
-    return listeners
-
-
-def close_sockets(listeners, unlink=True):
-    for sock in listeners:
-        sock_name = sock.getsockname()
-        sock.close()
-        if unlink and _sock_type(sock_name) is UnixSocket:
-            os.unlink(sock_name)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/systemd.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/systemd.py
deleted file mode 100644
index 10ffb8d85..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/systemd.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import os
-
-SD_LISTEN_FDS_START = 3
-
-
-def listen_fds(unset_environment=True):
-    """
-    Get the number of sockets inherited from systemd socket activation.
-
-    :param unset_environment: clear systemd environment variables unless False
-    :type unset_environment: bool
-    :return: the number of sockets to inherit from systemd socket activation
-    :rtype: int
-
-    Returns zero immediately if $LISTEN_PID is not set to the current pid.
-    Otherwise, returns the number of systemd activation sockets specified by
-    $LISTEN_FDS.
-
-    When $LISTEN_PID matches the current pid, unsets the environment variables
-    unless the ``unset_environment`` flag is ``False``.
-
-    .. note::
-        Unlike the sd_listen_fds C function, this implementation does not set
-        the FD_CLOEXEC flag because the gunicorn arbiter never needs to do this.
-
-    .. seealso::
-        `<https://www.freedesktop.org/software/systemd/man/sd_listen_fds.html>`_
-
-    """
-    fds = int(os.environ.get('LISTEN_FDS', 0))
-    listen_pid = int(os.environ.get('LISTEN_PID', 0))
-
-    if listen_pid != os.getpid():
-        return 0
-
-    if unset_environment:
-        os.environ.pop('LISTEN_PID', None)
-        os.environ.pop('LISTEN_FDS', None)
-
-    return fds
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/util.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/util.py
deleted file mode 100644
index 84f693774..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/util.py
+++ /dev/null
@@ -1,557 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from __future__ import print_function
-
-import email.utils
-import fcntl
-import io
-import os
-import pkg_resources
-import pwd
-import random
-import socket
-import sys
-import textwrap
-import time
-import traceback
-import inspect
-import errno
-import warnings
-import logging
-import re
-
-from gunicorn import _compat
-from gunicorn.errors import AppImportError
-from gunicorn.six import text_type
-from gunicorn.workers import SUPPORTED_WORKERS
-
-REDIRECT_TO = getattr(os, 'devnull', '/dev/null')
-
-# Server and Date aren't technically hop-by-hop
-# headers, but they are in the purview of the
-# origin server which the WSGI spec says we should
-# act like. So we drop them and add our own.
-#
-# In the future, concatenation server header values
-# might be better, but nothing else does it and
-# dropping them is easier.
-hop_headers = set("""
-    connection keep-alive proxy-authenticate proxy-authorization
-    te trailers transfer-encoding upgrade
-    server date
-    """.split())
-
-try:
-    from setproctitle import setproctitle
-
-    def _setproctitle(title):
-        setproctitle("gunicorn: %s" % title)
-except ImportError:
-    def _setproctitle(title):
-        return
-
-
-try:
-    from importlib import import_module
-except ImportError:
-    def _resolve_name(name, package, level):
-        """Return the absolute name of the module to be imported."""
-        if not hasattr(package, 'rindex'):
-            raise ValueError("'package' not set to a string")
-        dot = len(package)
-        for _ in range(level, 1, -1):
-            try:
-                dot = package.rindex('.', 0, dot)
-            except ValueError:
-                msg = "attempted relative import beyond top-level package"
-                raise ValueError(msg)
-        return "%s.%s" % (package[:dot], name)
-
-    def import_module(name, package=None):
-        """Import a module.
-
-The 'package' argument is required when performing a relative import. It
-specifies the package to use as the anchor point from which to resolve the
-relative import to an absolute import.
-
-"""
-        if name.startswith('.'):
-            if not package:
-                raise TypeError("relative imports require the 'package' argument")
-            level = 0
-            for character in name:
-                if character != '.':
-                    break
-                level += 1
-            name = _resolve_name(name[level:], package, level)
-        __import__(name)
-        return sys.modules[name]
-
-
-def load_class(uri, default="gunicorn.workers.sync.SyncWorker",
-        section="gunicorn.workers"):
-    if inspect.isclass(uri):
-        return uri
-    if uri.startswith("egg:"):
-        # uses entry points
-        entry_str = uri.split("egg:")[1]
-        try:
-            dist, name = entry_str.rsplit("#", 1)
-        except ValueError:
-            dist = entry_str
-            name = default
-
-        try:
-            return pkg_resources.load_entry_point(dist, section, name)
-        except:
-            exc = traceback.format_exc()
-            msg = "class uri %r invalid or not found: \n\n[%s]"
-            raise RuntimeError(msg % (uri, exc))
-    else:
-        components = uri.split('.')
-        if len(components) == 1:
-            while True:
-                if uri.startswith("#"):
-                    uri = uri[1:]
-
-                if uri in SUPPORTED_WORKERS:
-                    components = SUPPORTED_WORKERS[uri].split(".")
-                    break
-
-                try:
-                    return pkg_resources.load_entry_point("gunicorn",
-                                section, uri)
-                except:
-                    exc = traceback.format_exc()
-                    msg = "class uri %r invalid or not found: \n\n[%s]"
-                    raise RuntimeError(msg % (uri, exc))
-
-        klass = components.pop(-1)
-
-        try:
-            mod = import_module('.'.join(components))
-        except:
-            exc = traceback.format_exc()
-            msg = "class uri %r invalid or not found: \n\n[%s]"
-            raise RuntimeError(msg % (uri, exc))
-        return getattr(mod, klass)
-
-
-def get_username(uid):
-    """ get the username for a user id"""
-    return pwd.getpwuid(uid).pw_name
-
-
-def set_owner_process(uid, gid, initgroups=False):
-    """ set user and group of workers processes """
-
-    if gid:
-        if uid:
-            try:
-                username = get_username(uid)
-            except KeyError:
-                initgroups = False
-
-        # versions of python < 2.6.2 don't manage unsigned int for
-        # groups like on osx or fedora
-        gid = abs(gid) & 0x7FFFFFFF
-
-        if initgroups:
-            os.initgroups(username, gid)
-        elif gid != os.getgid():
-            os.setgid(gid)
-
-    if uid:
-        os.setuid(uid)
-
-
-def chown(path, uid, gid):
-    gid = abs(gid) & 0x7FFFFFFF  # see note above.
-    os.chown(path, uid, gid)
-
-
-if sys.platform.startswith("win"):
-    def _waitfor(func, pathname, waitall=False):
-        # Peform the operation
-        func(pathname)
-        # Now setup the wait loop
-        if waitall:
-            dirname = pathname
-        else:
-            dirname, name = os.path.split(pathname)
-            dirname = dirname or '.'
-        # Check for `pathname` to be removed from the filesystem.
-        # The exponential backoff of the timeout amounts to a total
-        # of ~1 second after which the deletion is probably an error
-        # anyway.
-        # Testing on a i7@4.3GHz shows that usually only 1 iteration is
-        # required when contention occurs.
-        timeout = 0.001
-        while timeout < 1.0:
-            # Note we are only testing for the existence of the file(s) in
-            # the contents of the directory regardless of any security or
-            # access rights.  If we have made it this far, we have sufficient
-            # permissions to do that much using Python's equivalent of the
-            # Windows API FindFirstFile.
-            # Other Windows APIs can fail or give incorrect results when
-            # dealing with files that are pending deletion.
-            L = os.listdir(dirname)
-            if not L if waitall else name in L:
-                return
-            # Increase the timeout and try again
-            time.sleep(timeout)
-            timeout *= 2
-        warnings.warn('tests may fail, delete still pending for ' + pathname,
-                      RuntimeWarning, stacklevel=4)
-
-    def _unlink(filename):
-        _waitfor(os.unlink, filename)
-else:
-    _unlink = os.unlink
-
-
-def unlink(filename):
-    try:
-        _unlink(filename)
-    except OSError as error:
-        # The filename need not exist.
-        if error.errno not in (errno.ENOENT, errno.ENOTDIR):
-            raise
-
-
-def is_ipv6(addr):
-    try:
-        socket.inet_pton(socket.AF_INET6, addr)
-    except socket.error:  # not a valid address
-        return False
-    except ValueError:  # ipv6 not supported on this platform
-        return False
-    return True
-
-
-def parse_address(netloc, default_port=8000):
-    if re.match(r'unix:(//)?', netloc):
-        return re.split(r'unix:(//)?', netloc)[-1]
-
-    if netloc.startswith("tcp://"):
-        netloc = netloc.split("tcp://")[1]
-
-    # get host
-    if '[' in netloc and ']' in netloc:
-        host = netloc.split(']')[0][1:].lower()
-    elif ':' in netloc:
-        host = netloc.split(':')[0].lower()
-    elif netloc == "":
-        host = "0.0.0.0"
-    else:
-        host = netloc.lower()
-
-    #get port
-    netloc = netloc.split(']')[-1]
-    if ":" in netloc:
-        port = netloc.split(':', 1)[1]
-        if not port.isdigit():
-            raise RuntimeError("%r is not a valid port number." % port)
-        port = int(port)
-    else:
-        port = default_port
-    return (host, port)
-
-
-def close_on_exec(fd):
-    flags = fcntl.fcntl(fd, fcntl.F_GETFD)
-    flags |= fcntl.FD_CLOEXEC
-    fcntl.fcntl(fd, fcntl.F_SETFD, flags)
-
-
-def set_non_blocking(fd):
-    flags = fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK
-    fcntl.fcntl(fd, fcntl.F_SETFL, flags)
-
-
-def close(sock):
-    try:
-        sock.close()
-    except socket.error:
-        pass
-
-try:
-    from os import closerange
-except ImportError:
-    def closerange(fd_low, fd_high):
-        # Iterate through and close all file descriptors.
-        for fd in range(fd_low, fd_high):
-            try:
-                os.close(fd)
-            except OSError:  # ERROR, fd wasn't open to begin with (ignored)
-                pass
-
-
-def write_chunk(sock, data):
-    if isinstance(data, text_type):
-        data = data.encode('utf-8')
-    chunk_size = "%X\r\n" % len(data)
-    chunk = b"".join([chunk_size.encode('utf-8'), data, b"\r\n"])
-    sock.sendall(chunk)
-
-
-def write(sock, data, chunked=False):
-    if chunked:
-        return write_chunk(sock, data)
-    sock.sendall(data)
-
-
-def write_nonblock(sock, data, chunked=False):
-    timeout = sock.gettimeout()
-    if timeout != 0.0:
-        try:
-            sock.setblocking(0)
-            return write(sock, data, chunked)
-        finally:
-            sock.setblocking(1)
-    else:
-        return write(sock, data, chunked)
-
-
-def write_error(sock, status_int, reason, mesg):
-    html = textwrap.dedent("""\
-    <html>
-      <head>
-        <title>%(reason)s</title>
-      </head>
-      <body>
-        <h1><p>%(reason)s</p></h1>
-        %(mesg)s
-      </body>
-    </html>
-    """) % {"reason": reason, "mesg": _compat.html_escape(mesg)}
-
-    http = textwrap.dedent("""\
-    HTTP/1.1 %s %s\r
-    Connection: close\r
-    Content-Type: text/html\r
-    Content-Length: %d\r
-    \r
-    %s""") % (str(status_int), reason, len(html), html)
-    write_nonblock(sock, http.encode('latin1'))
-
-
-def import_app(module):
-    parts = module.split(":", 1)
-    if len(parts) == 1:
-        module, obj = module, "application"
-    else:
-        module, obj = parts[0], parts[1]
-
-    try:
-        __import__(module)
-    except ImportError:
-        if module.endswith(".py") and os.path.exists(module):
-            msg = "Failed to find application, did you mean '%s:%s'?"
-            raise ImportError(msg % (module.rsplit(".", 1)[0], obj))
-        else:
-            raise
-
-    mod = sys.modules[module]
-
-    is_debug = logging.root.level == logging.DEBUG
-    try:
-        app = eval(obj, vars(mod))
-    except NameError:
-        if is_debug:
-            traceback.print_exception(*sys.exc_info())
-        raise AppImportError("Failed to find application object %r in %r" % (obj, module))
-
-    if app is None:
-        raise AppImportError("Failed to find application object: %r" % obj)
-
-    if not callable(app):
-        raise AppImportError("Application object must be callable.")
-    return app
-
-
-def getcwd():
-    # get current path, try to use PWD env first
-    try:
-        a = os.stat(os.environ['PWD'])
-        b = os.stat(os.getcwd())
-        if a.st_ino == b.st_ino and a.st_dev == b.st_dev:
-            cwd = os.environ['PWD']
-        else:
-            cwd = os.getcwd()
-    except:
-        cwd = os.getcwd()
-    return cwd
-
-
-def http_date(timestamp=None):
-    """Return the current date and time formatted for a message header."""
-    if timestamp is None:
-        timestamp = time.time()
-    s = email.utils.formatdate(timestamp, localtime=False, usegmt=True)
-    return s
-
-
-def is_hoppish(header):
-    return header.lower().strip() in hop_headers
-
-
-def daemonize(enable_stdio_inheritance=False):
-    """\
-    Standard daemonization of a process.
-    http://www.svbug.com/documentation/comp.unix.programmer-FAQ/faq_2.html#SEC16
-    """
-    if 'GUNICORN_FD' not in os.environ:
-        if os.fork():
-            os._exit(0)
-        os.setsid()
-
-        if os.fork():
-            os._exit(0)
-
-        os.umask(0o22)
-
-        # In both the following any file descriptors above stdin
-        # stdout and stderr are left untouched. The inheritance
-        # option simply allows one to have output go to a file
-        # specified by way of shell redirection when not wanting
-        # to use --error-log option.
-
-        if not enable_stdio_inheritance:
-            # Remap all of stdin, stdout and stderr on to
-            # /dev/null. The expectation is that users have
-            # specified the --error-log option.
-
-            closerange(0, 3)
-
-            fd_null = os.open(REDIRECT_TO, os.O_RDWR)
-
-            if fd_null != 0:
-                os.dup2(fd_null, 0)
-
-            os.dup2(fd_null, 1)
-            os.dup2(fd_null, 2)
-
-        else:
-            fd_null = os.open(REDIRECT_TO, os.O_RDWR)
-
-            # Always redirect stdin to /dev/null as we would
-            # never expect to need to read interactive input.
-
-            if fd_null != 0:
-                os.close(0)
-                os.dup2(fd_null, 0)
-
-            # If stdout and stderr are still connected to
-            # their original file descriptors we check to see
-            # if they are associated with terminal devices.
-            # When they are we map them to /dev/null so that
-            # are still detached from any controlling terminal
-            # properly. If not we preserve them as they are.
-            #
-            # If stdin and stdout were not hooked up to the
-            # original file descriptors, then all bets are
-            # off and all we can really do is leave them as
-            # they were.
-            #
-            # This will allow 'gunicorn ... > output.log 2>&1'
-            # to work with stdout/stderr going to the file
-            # as expected.
-            #
-            # Note that if using --error-log option, the log
-            # file specified through shell redirection will
-            # only be used up until the log file specified
-            # by the option takes over. As it replaces stdout
-            # and stderr at the file descriptor level, then
-            # anything using stdout or stderr, including having
-            # cached a reference to them, will still work.
-
-            def redirect(stream, fd_expect):
-                try:
-                    fd = stream.fileno()
-                    if fd == fd_expect and stream.isatty():
-                        os.close(fd)
-                        os.dup2(fd_null, fd)
-                except AttributeError:
-                    pass
-
-            redirect(sys.stdout, 1)
-            redirect(sys.stderr, 2)
-
-
-def seed():
-    try:
-        random.seed(os.urandom(64))
-    except NotImplementedError:
-        random.seed('%s.%s' % (time.time(), os.getpid()))
-
-
-def check_is_writeable(path):
-    try:
-        f = open(path, 'a')
-    except IOError as e:
-        raise RuntimeError("Error: '%s' isn't writable [%r]" % (path, e))
-    f.close()
-
-
-def to_bytestring(value, encoding="utf8"):
-    """Converts a string argument to a byte string"""
-    if isinstance(value, bytes):
-        return value
-    if not isinstance(value, text_type):
-        raise TypeError('%r is not a string' % value)
-
-    return value.encode(encoding)
-
-def has_fileno(obj):
-    if not hasattr(obj, "fileno"):
-        return False
-
-    # check BytesIO case and maybe others
-    try:
-        obj.fileno()
-    except (AttributeError, IOError, io.UnsupportedOperation):
-        return False
-
-    return True
-
-
-def warn(msg):
-    print("!!!", file=sys.stderr)
-
-    lines = msg.splitlines()
-    for i, line in enumerate(lines):
-        if i == 0:
-            line = "WARNING: %s" % line
-        print("!!! %s" % line, file=sys.stderr)
-
-    print("!!!\n", file=sys.stderr)
-    sys.stderr.flush()
-
-
-def make_fail_app(msg):
-    msg = to_bytestring(msg)
-
-    def app(environ, start_response):
-        start_response("500 Internal Server Error", [
-            ("Content-Type", "text/plain"),
-            ("Content-Length", str(len(msg)))
-        ])
-        return [msg]
-
-    return app
-
-
-def split_request_uri(uri):
-    if uri.startswith("//"):
-        # When the path starts with //, urlsplit considers it as a
-        # relative uri while the RFC says we should consider it as abs_path
-        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
-        # We use temporary dot prefix to workaround this behaviour
-        parts = _compat.urlsplit("." + uri)
-        return parts._replace(path=parts.path[1:])
-
-    return _compat.urlsplit(uri)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__init__.py
deleted file mode 100644
index 074e0012e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__init__.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import sys
-
-# supported gunicorn workers.
-SUPPORTED_WORKERS = {
-    "sync": "gunicorn.workers.sync.SyncWorker",
-    "eventlet": "gunicorn.workers.geventlet.EventletWorker",
-    "gevent": "gunicorn.workers.ggevent.GeventWorker",
-    "gevent_wsgi": "gunicorn.workers.ggevent.GeventPyWSGIWorker",
-    "gevent_pywsgi": "gunicorn.workers.ggevent.GeventPyWSGIWorker",
-    "tornado": "gunicorn.workers.gtornado.TornadoWorker",
-    "gthread": "gunicorn.workers.gthread.ThreadWorker",
-}
-
-
-if sys.version_info >= (3, 4):
-    # gaiohttp worker can be used with Python 3.4+ only.
-    SUPPORTED_WORKERS["gaiohttp"] = "gunicorn.workers.gaiohttp.AiohttpWorker"
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 34593feae..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/_gaiohttp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/_gaiohttp.cpython-35.pyc
deleted file mode 100644
index 96e3521b9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/_gaiohttp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base.cpython-35.pyc
deleted file mode 100644
index f5428081d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base_async.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base_async.cpython-35.pyc
deleted file mode 100644
index 4393d6c15..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/base_async.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gaiohttp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gaiohttp.cpython-35.pyc
deleted file mode 100644
index 29d55cd8b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gaiohttp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-35.pyc
deleted file mode 100644
index 598da04ae..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/geventlet.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-35.pyc
deleted file mode 100644
index b04a51952..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/ggevent.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gthread.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gthread.cpython-35.pyc
deleted file mode 100644
index 023b44b13..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gthread.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gtornado.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gtornado.cpython-35.pyc
deleted file mode 100644
index 6fa6e2867..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/gtornado.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/sync.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/sync.cpython-35.pyc
deleted file mode 100644
index e4161aa12..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/sync.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/workertmp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/workertmp.cpython-35.pyc
deleted file mode 100644
index 39bf87260..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/__pycache__/workertmp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/_gaiohttp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/_gaiohttp.py
deleted file mode 100644
index fe378c351..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/_gaiohttp.py
+++ /dev/null
@@ -1,168 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import asyncio
-import datetime
-import functools
-import logging
-import os
-
-try:
-    import ssl
-except ImportError:
-    ssl = None
-
-import gunicorn.workers.base as base
-
-from aiohttp.wsgi import WSGIServerHttpProtocol as OldWSGIServerHttpProtocol
-
-
-class WSGIServerHttpProtocol(OldWSGIServerHttpProtocol):
-    def log_access(self, request, environ, response, time):
-        self.logger.access(response, request, environ, datetime.timedelta(0, 0, time))
-
-
-class AiohttpWorker(base.Worker):
-
-    def __init__(self, *args, **kw):  # pragma: no cover
-        super().__init__(*args, **kw)
-        cfg = self.cfg
-        if cfg.is_ssl:
-            self.ssl_context = self._create_ssl_context(cfg)
-        else:
-            self.ssl_context = None
-        self.servers = []
-        self.connections = {}
-
-    def init_process(self):
-        # create new event_loop after fork
-        asyncio.get_event_loop().close()
-
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-
-        super().init_process()
-
-    def run(self):
-        self._runner = asyncio.ensure_future(self._run(), loop=self.loop)
-
-        try:
-            self.loop.run_until_complete(self._runner)
-        finally:
-            self.loop.close()
-
-    def wrap_protocol(self, proto):
-        proto.connection_made = _wrp(
-            proto, proto.connection_made, self.connections)
-        proto.connection_lost = _wrp(
-            proto, proto.connection_lost, self.connections, False)
-        return proto
-
-    def factory(self, wsgi, addr):
-        # are we in debug level
-        is_debug = self.log.loglevel == logging.DEBUG
-
-        proto = WSGIServerHttpProtocol(
-            wsgi, readpayload=True,
-            loop=self.loop,
-            log=self.log,
-            debug=is_debug,
-            keep_alive=self.cfg.keepalive,
-            access_log=self.log.access_log,
-            access_log_format=self.cfg.access_log_format)
-        return self.wrap_protocol(proto)
-
-    def get_factory(self, sock, addr):
-        return functools.partial(self.factory, self.wsgi, addr)
-
-    @asyncio.coroutine
-    def close(self):
-        try:
-            if hasattr(self.wsgi, 'close'):
-                yield from self.wsgi.close()
-        except:
-            self.log.exception('Process shutdown exception')
-
-    @asyncio.coroutine
-    def _run(self):
-        for sock in self.sockets:
-            factory = self.get_factory(sock.sock, sock.cfg_addr)
-            self.servers.append(
-                (yield from self._create_server(factory, sock)))
-
-        # If our parent changed then we shut down.
-        pid = os.getpid()
-        try:
-            while self.alive or self.connections:
-                self.notify()
-
-                if (self.alive and
-                        pid == os.getpid() and self.ppid != os.getppid()):
-                    self.log.info("Parent changed, shutting down: %s", self)
-                    self.alive = False
-
-                # stop accepting requests
-                if not self.alive:
-                    if self.servers:
-                        self.log.info(
-                            "Stopping server: %s, connections: %s",
-                            pid, len(self.connections))
-                        for server in self.servers:
-                            server.close()
-                        self.servers.clear()
-
-                    # prepare connections for closing
-                    for conn in self.connections.values():
-                        if hasattr(conn, 'closing'):
-                            conn.closing()
-
-                yield from asyncio.sleep(1.0, loop=self.loop)
-        except KeyboardInterrupt:
-            pass
-
-        if self.servers:
-            for server in self.servers:
-                server.close()
-
-        yield from self.close()
-
-    @asyncio.coroutine
-    def _create_server(self, factory, sock):
-        return self.loop.create_server(factory, sock=sock.sock,
-                                       ssl=self.ssl_context)
-
-    @staticmethod
-    def _create_ssl_context(cfg):
-        """ Creates SSLContext instance for usage in asyncio.create_server.
-
-        See ssl.SSLSocket.__init__ for more details.
-        """
-        ctx = ssl.SSLContext(cfg.ssl_version)
-        ctx.load_cert_chain(cfg.certfile, cfg.keyfile)
-        ctx.verify_mode = cfg.cert_reqs
-        if cfg.ca_certs:
-            ctx.load_verify_locations(cfg.ca_certs)
-        if cfg.ciphers:
-            ctx.set_ciphers(cfg.ciphers)
-        return ctx
-
-
-class _wrp:
-
-    def __init__(self, proto, meth, tracking, add=True):
-        self._proto = proto
-        self._id = id(proto)
-        self._meth = meth
-        self._tracking = tracking
-        self._add = add
-
-    def __call__(self, *args):
-        if self._add:
-            self._tracking[self._id] = self._proto
-        elif self._id in self._tracking:
-            del self._tracking[self._id]
-
-        conn = self._meth(*args)
-        return conn
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base.py
deleted file mode 100644
index 881efa0f0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from datetime import datetime
-import os
-from random import randint
-import signal
-from ssl import SSLError
-import sys
-import time
-import traceback
-
-from gunicorn import six
-from gunicorn import util
-from gunicorn.workers.workertmp import WorkerTmp
-from gunicorn.reloader import reloader_engines
-from gunicorn.http.errors import (
-    InvalidHeader, InvalidHeaderName, InvalidRequestLine, InvalidRequestMethod,
-    InvalidHTTPVersion, LimitRequestLine, LimitRequestHeaders,
-)
-from gunicorn.http.errors import InvalidProxyLine, ForbiddenProxyRequest
-from gunicorn.http.errors import InvalidSchemeHeaders
-from gunicorn.http.wsgi import default_environ, Response
-from gunicorn.six import MAXSIZE
-
-
-class Worker(object):
-
-    SIGNALS = [getattr(signal, "SIG%s" % x)
-            for x in "ABRT HUP QUIT INT TERM USR1 USR2 WINCH CHLD".split()]
-
-    PIPE = []
-
-    def __init__(self, age, ppid, sockets, app, timeout, cfg, log):
-        """\
-        This is called pre-fork so it shouldn't do anything to the
-        current process. If there's a need to make process wide
-        changes you'll want to do that in ``self.init_process()``.
-        """
-        self.age = age
-        self.pid = "[booting]"
-        self.ppid = ppid
-        self.sockets = sockets
-        self.app = app
-        self.timeout = timeout
-        self.cfg = cfg
-        self.booted = False
-        self.aborted = False
-        self.reloader = None
-
-        self.nr = 0
-        jitter = randint(0, cfg.max_requests_jitter)
-        self.max_requests = cfg.max_requests + jitter or MAXSIZE
-        self.alive = True
-        self.log = log
-        self.tmp = WorkerTmp(cfg)
-
-    def __str__(self):
-        return "<Worker %s>" % self.pid
-
-    def notify(self):
-        """\
-        Your worker subclass must arrange to have this method called
-        once every ``self.timeout`` seconds. If you fail in accomplishing
-        this task, the master process will murder your workers.
-        """
-        self.tmp.notify()
-
-    def run(self):
-        """\
-        This is the mainloop of a worker process. You should override
-        this method in a subclass to provide the intended behaviour
-        for your particular evil schemes.
-        """
-        raise NotImplementedError()
-
-    def init_process(self):
-        """\
-        If you override this method in a subclass, the last statement
-        in the function should be to call this method with
-        super(MyWorkerClass, self).init_process() so that the ``run()``
-        loop is initiated.
-        """
-
-        # set environment' variables
-        if self.cfg.env:
-            for k, v in self.cfg.env.items():
-                os.environ[k] = v
-
-        util.set_owner_process(self.cfg.uid, self.cfg.gid,
-                               initgroups=self.cfg.initgroups)
-
-        # Reseed the random number generator
-        util.seed()
-
-        # For waking ourselves up
-        self.PIPE = os.pipe()
-        for p in self.PIPE:
-            util.set_non_blocking(p)
-            util.close_on_exec(p)
-
-        # Prevent fd inheritance
-        for s in self.sockets:
-            util.close_on_exec(s)
-        util.close_on_exec(self.tmp.fileno())
-
-        self.wait_fds = self.sockets + [self.PIPE[0]]
-
-        self.log.close_on_exec()
-
-        self.init_signals()
-
-        # start the reloader
-        if self.cfg.reload:
-            def changed(fname):
-                self.log.info("Worker reloading: %s modified", fname)
-                self.alive = False
-                self.cfg.worker_int(self)
-                time.sleep(0.1)
-                sys.exit(0)
-
-            reloader_cls = reloader_engines[self.cfg.reload_engine]
-            self.reloader = reloader_cls(extra_files=self.cfg.reload_extra_files,
-                                         callback=changed)
-            self.reloader.start()
-
-        self.load_wsgi()
-        self.cfg.post_worker_init(self)
-
-        # Enter main run loop
-        self.booted = True
-        self.run()
-
-    def load_wsgi(self):
-        try:
-            self.wsgi = self.app.wsgi()
-        except SyntaxError as e:
-            if not self.cfg.reload:
-                raise
-
-            self.log.exception(e)
-
-            # fix from PR #1228
-            # storing the traceback into exc_tb will create a circular reference.
-            # per https://docs.python.org/2/library/sys.html#sys.exc_info warning,
-            # delete the traceback after use.
-            try:
-                _, exc_val, exc_tb = sys.exc_info()
-                self.reloader.add_extra_file(exc_val.filename)
-
-                tb_string = six.StringIO()
-                traceback.print_tb(exc_tb, file=tb_string)
-                self.wsgi = util.make_fail_app(tb_string.getvalue())
-            finally:
-                del exc_tb
-
-    def init_signals(self):
-        # reset signaling
-        for s in self.SIGNALS:
-            signal.signal(s, signal.SIG_DFL)
-        # init new signaling
-        signal.signal(signal.SIGQUIT, self.handle_quit)
-        signal.signal(signal.SIGTERM, self.handle_exit)
-        signal.signal(signal.SIGINT, self.handle_quit)
-        signal.signal(signal.SIGWINCH, self.handle_winch)
-        signal.signal(signal.SIGUSR1, self.handle_usr1)
-        signal.signal(signal.SIGABRT, self.handle_abort)
-
-        # Don't let SIGTERM and SIGUSR1 disturb active requests
-        # by interrupting system calls
-        if hasattr(signal, 'siginterrupt'):  # python >= 2.6
-            signal.siginterrupt(signal.SIGTERM, False)
-            signal.siginterrupt(signal.SIGUSR1, False)
-
-        if hasattr(signal, 'set_wakeup_fd'):
-            signal.set_wakeup_fd(self.PIPE[1])
-
-    def handle_usr1(self, sig, frame):
-        self.log.reopen_files()
-
-    def handle_exit(self, sig, frame):
-        self.alive = False
-
-    def handle_quit(self, sig, frame):
-        self.alive = False
-        # worker_int callback
-        self.cfg.worker_int(self)
-        time.sleep(0.1)
-        sys.exit(0)
-
-    def handle_abort(self, sig, frame):
-        self.alive = False
-        self.cfg.worker_abort(self)
-        sys.exit(1)
-
-    def handle_error(self, req, client, addr, exc):
-        request_start = datetime.now()
-        addr = addr or ('', -1)  # unix socket case
-        if isinstance(exc, (InvalidRequestLine, InvalidRequestMethod,
-                InvalidHTTPVersion, InvalidHeader, InvalidHeaderName,
-                LimitRequestLine, LimitRequestHeaders,
-                InvalidProxyLine, ForbiddenProxyRequest,
-                InvalidSchemeHeaders,
-                SSLError)):
-
-            status_int = 400
-            reason = "Bad Request"
-
-            if isinstance(exc, InvalidRequestLine):
-                mesg = "Invalid Request Line '%s'" % str(exc)
-            elif isinstance(exc, InvalidRequestMethod):
-                mesg = "Invalid Method '%s'" % str(exc)
-            elif isinstance(exc, InvalidHTTPVersion):
-                mesg = "Invalid HTTP Version '%s'" % str(exc)
-            elif isinstance(exc, (InvalidHeaderName, InvalidHeader,)):
-                mesg = "%s" % str(exc)
-                if not req and hasattr(exc, "req"):
-                    req = exc.req  # for access log
-            elif isinstance(exc, LimitRequestLine):
-                mesg = "%s" % str(exc)
-            elif isinstance(exc, LimitRequestHeaders):
-                mesg = "Error parsing headers: '%s'" % str(exc)
-            elif isinstance(exc, InvalidProxyLine):
-                mesg = "'%s'" % str(exc)
-            elif isinstance(exc, ForbiddenProxyRequest):
-                reason = "Forbidden"
-                mesg = "Request forbidden"
-                status_int = 403
-            elif isinstance(exc, InvalidSchemeHeaders):
-                mesg = "%s" % str(exc)
-            elif isinstance(exc, SSLError):
-                reason = "Forbidden"
-                mesg = "'%s'" % str(exc)
-                status_int = 403
-
-            msg = "Invalid request from ip={ip}: {error}"
-            self.log.debug(msg.format(ip=addr[0], error=str(exc)))
-        else:
-            if hasattr(req, "uri"):
-                self.log.exception("Error handling request %s", req.uri)
-            status_int = 500
-            reason = "Internal Server Error"
-            mesg = ""
-
-        if req is not None:
-            request_time = datetime.now() - request_start
-            environ = default_environ(req, client, self.cfg)
-            environ['REMOTE_ADDR'] = addr[0]
-            environ['REMOTE_PORT'] = str(addr[1])
-            resp = Response(req, client, self.cfg)
-            resp.status = "%s %s" % (status_int, reason)
-            resp.response_length = len(mesg)
-            self.log.access(resp, req, environ, request_time)
-
-        try:
-            util.write_error(client, status_int, reason, mesg)
-        except:
-            self.log.debug("Failed to send error message.")
-
-    def handle_winch(self, sig, fname):
-        # Ignore SIGWINCH in worker. Fixes a crash on OpenBSD.
-        self.log.debug("worker: SIGWINCH ignored.")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base_async.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base_async.py
deleted file mode 100644
index a3a0f9129..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/base_async.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from datetime import datetime
-import errno
-import socket
-import ssl
-import sys
-
-import gunicorn.http as http
-import gunicorn.http.wsgi as wsgi
-import gunicorn.util as util
-import gunicorn.workers.base as base
-from gunicorn import six
-
-ALREADY_HANDLED = object()
-
-
-class AsyncWorker(base.Worker):
-
-    def __init__(self, *args, **kwargs):
-        super(AsyncWorker, self).__init__(*args, **kwargs)
-        self.worker_connections = self.cfg.worker_connections
-
-    def timeout_ctx(self):
-        raise NotImplementedError()
-
-    def is_already_handled(self, respiter):
-        # some workers will need to overload this function to raise a StopIteration
-        return respiter == ALREADY_HANDLED
-
-    def handle(self, listener, client, addr):
-        req = None
-        try:
-            parser = http.RequestParser(self.cfg, client)
-            try:
-                listener_name = listener.getsockname()
-                if not self.cfg.keepalive:
-                    req = six.next(parser)
-                    self.handle_request(listener_name, req, client, addr)
-                else:
-                    # keepalive loop
-                    proxy_protocol_info = {}
-                    while True:
-                        req = None
-                        with self.timeout_ctx():
-                            req = six.next(parser)
-                        if not req:
-                            break
-                        if req.proxy_protocol_info:
-                            proxy_protocol_info = req.proxy_protocol_info
-                        else:
-                            req.proxy_protocol_info = proxy_protocol_info
-                        self.handle_request(listener_name, req, client, addr)
-            except http.errors.NoMoreData as e:
-                self.log.debug("Ignored premature client disconnection. %s", e)
-            except StopIteration as e:
-                self.log.debug("Closing connection. %s", e)
-            except ssl.SSLError:
-                # pass to next try-except level
-                six.reraise(*sys.exc_info())
-            except EnvironmentError:
-                # pass to next try-except level
-                six.reraise(*sys.exc_info())
-            except Exception as e:
-                self.handle_error(req, client, addr, e)
-        except ssl.SSLError as e:
-            if e.args[0] == ssl.SSL_ERROR_EOF:
-                self.log.debug("ssl connection closed")
-                client.close()
-            else:
-                self.log.debug("Error processing SSL request.")
-                self.handle_error(req, client, addr, e)
-        except EnvironmentError as e:
-            if e.errno not in (errno.EPIPE, errno.ECONNRESET):
-                self.log.exception("Socket error processing request.")
-            else:
-                if e.errno == errno.ECONNRESET:
-                    self.log.debug("Ignoring connection reset")
-                else:
-                    self.log.debug("Ignoring EPIPE")
-        except Exception as e:
-            self.handle_error(req, client, addr, e)
-        finally:
-            util.close(client)
-
-    def handle_request(self, listener_name, req, sock, addr):
-        request_start = datetime.now()
-        environ = {}
-        resp = None
-        try:
-            self.cfg.pre_request(self, req)
-            resp, environ = wsgi.create(req, sock, addr,
-                    listener_name, self.cfg)
-            environ["wsgi.multithread"] = True
-            self.nr += 1
-            if self.alive and self.nr >= self.max_requests:
-                self.log.info("Autorestarting worker after current request.")
-                resp.force_close()
-                self.alive = False
-
-            if not self.cfg.keepalive:
-                resp.force_close()
-
-            respiter = self.wsgi(environ, resp.start_response)
-            if self.is_already_handled(respiter):
-                return False
-            try:
-                if isinstance(respiter, environ['wsgi.file_wrapper']):
-                    resp.write_file(respiter)
-                else:
-                    for item in respiter:
-                        resp.write(item)
-                resp.close()
-                request_time = datetime.now() - request_start
-                self.log.access(resp, req, environ, request_time)
-            finally:
-                if hasattr(respiter, "close"):
-                    respiter.close()
-            if resp.should_close():
-                raise StopIteration()
-        except StopIteration:
-            raise
-        except EnvironmentError:
-            # If the original exception was a socket.error we delegate
-            # handling it to the caller (where handle() might ignore it)
-            six.reraise(*sys.exc_info())
-        except Exception:
-            if resp and resp.headers_sent:
-                # If the requests have already been sent, we should close the
-                # connection to indicate the error.
-                self.log.exception("Error handling request")
-                try:
-                    sock.shutdown(socket.SHUT_RDWR)
-                    sock.close()
-                except EnvironmentError:
-                    pass
-                raise StopIteration()
-            raise
-        finally:
-            try:
-                self.cfg.post_request(self, req, environ, resp)
-            except Exception:
-                self.log.exception("Exception in post_request hook")
-        return True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gaiohttp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gaiohttp.py
deleted file mode 100644
index bef6b4957..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gaiohttp.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import sys
-
-from gunicorn import util
-
-if sys.version_info >= (3, 4):
-    try:
-        import aiohttp  # pylint: disable=unused-import
-    except ImportError:
-        raise RuntimeError("You need aiohttp installed to use this worker.")
-    else:
-        try:
-            from aiohttp.worker import GunicornWebWorker as AiohttpWorker
-        except ImportError:
-            from gunicorn.workers._gaiohttp import AiohttpWorker
-
-        util.warn(
-            "The 'gaiohttp' worker is deprecated. See --worker-class "
-            "documentation for more information."
-        )
-        __all__ = ['AiohttpWorker']
-else:
-    raise RuntimeError("You need Python >= 3.4 to use the gaiohttp worker")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/geventlet.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/geventlet.py
deleted file mode 100644
index 189062c89..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/geventlet.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-from functools import partial
-import errno
-import sys
-
-try:
-    import eventlet
-except ImportError:
-    raise RuntimeError("You need eventlet installed to use this worker.")
-
-# validate the eventlet version
-if eventlet.version_info < (0, 9, 7):
-    raise RuntimeError("You need eventlet >= 0.9.7")
-
-
-from eventlet import hubs, greenthread
-from eventlet.greenio import GreenSocket
-from eventlet.hubs import trampoline
-from eventlet.wsgi import ALREADY_HANDLED as EVENTLET_ALREADY_HANDLED
-import greenlet
-
-from gunicorn.http.wsgi import sendfile as o_sendfile
-from gunicorn.workers.base_async import AsyncWorker
-
-def _eventlet_sendfile(fdout, fdin, offset, nbytes):
-    while True:
-        try:
-            return o_sendfile(fdout, fdin, offset, nbytes)
-        except OSError as e:
-            if e.args[0] == errno.EAGAIN:
-                trampoline(fdout, write=True)
-            else:
-                raise
-
-
-def _eventlet_serve(sock, handle, concurrency):
-    """
-    Serve requests forever.
-
-    This code is nearly identical to ``eventlet.convenience.serve`` except
-    that it attempts to join the pool at the end, which allows for gunicorn
-    graceful shutdowns.
-    """
-    pool = eventlet.greenpool.GreenPool(concurrency)
-    server_gt = eventlet.greenthread.getcurrent()
-
-    while True:
-        try:
-            conn, addr = sock.accept()
-            gt = pool.spawn(handle, conn, addr)
-            gt.link(_eventlet_stop, server_gt, conn)
-            conn, addr, gt = None, None, None
-        except eventlet.StopServe:
-            sock.close()
-            pool.waitall()
-            return
-
-
-def _eventlet_stop(client, server, conn):
-    """
-    Stop a greenlet handling a request and close its connection.
-
-    This code is lifted from eventlet so as not to depend on undocumented
-    functions in the library.
-    """
-    try:
-        try:
-            client.wait()
-        finally:
-            conn.close()
-    except greenlet.GreenletExit:
-        pass
-    except Exception:
-        greenthread.kill(server, *sys.exc_info())
-
-
-def patch_sendfile():
-    from gunicorn.http import wsgi
-
-    if o_sendfile is not None:
-        setattr(wsgi, "sendfile", _eventlet_sendfile)
-
-
-class EventletWorker(AsyncWorker):
-
-    def patch(self):
-        hubs.use_hub()
-        eventlet.monkey_patch(os=False)
-        patch_sendfile()
-
-    def is_already_handled(self, respiter):
-        if respiter == EVENTLET_ALREADY_HANDLED:
-            raise StopIteration()
-        else:
-            return super(EventletWorker, self).is_already_handled(respiter)
-
-    def init_process(self):
-        super(EventletWorker, self).init_process()
-        self.patch()
-
-    def handle_quit(self, sig, frame):
-        eventlet.spawn(super(EventletWorker, self).handle_quit, sig, frame)
-
-    def handle_usr1(self, sig, frame):
-        eventlet.spawn(super(EventletWorker, self).handle_usr1, sig, frame)
-
-    def timeout_ctx(self):
-        return eventlet.Timeout(self.cfg.keepalive or None, False)
-
-    def handle(self, listener, client, addr):
-        if self.cfg.is_ssl:
-            client = eventlet.wrap_ssl(client, server_side=True,
-                                       **self.cfg.ssl_options)
-
-        super(EventletWorker, self).handle(listener, client, addr)
-
-    def run(self):
-        acceptors = []
-        for sock in self.sockets:
-            gsock = GreenSocket(sock)
-            gsock.setblocking(1)
-            hfun = partial(self.handle, gsock)
-            acceptor = eventlet.spawn(_eventlet_serve, gsock, hfun,
-                                      self.worker_connections)
-
-            acceptors.append(acceptor)
-            eventlet.sleep(0.0)
-
-        while self.alive:
-            self.notify()
-            eventlet.sleep(1.0)
-
-        self.notify()
-        try:
-            with eventlet.Timeout(self.cfg.graceful_timeout) as t:
-                for a in acceptors:
-                    a.kill(eventlet.StopServe())
-                for a in acceptors:
-                    a.wait()
-        except eventlet.Timeout as te:
-            if te != t:
-                raise
-            for a in acceptors:
-                a.kill()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/ggevent.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/ggevent.py
deleted file mode 100644
index fb9d91947..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/ggevent.py
+++ /dev/null
@@ -1,246 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import errno
-import os
-import sys
-from datetime import datetime
-from functools import partial
-import time
-
-_socket = __import__("socket")
-
-# workaround on osx, disable kqueue
-if sys.platform == "darwin":
-    os.environ['EVENT_NOKQUEUE'] = "1"
-
-try:
-    import gevent
-except ImportError:
-    raise RuntimeError("You need gevent installed to use this worker.")
-from gevent.pool import Pool
-from gevent.server import StreamServer
-from gevent.socket import wait_write, socket
-from gevent import pywsgi
-
-import gunicorn
-from gunicorn.http.wsgi import base_environ
-from gunicorn.workers.base_async import AsyncWorker
-from gunicorn.http.wsgi import sendfile as o_sendfile
-
-VERSION = "gevent/%s gunicorn/%s" % (gevent.__version__, gunicorn.__version__)
-
-def _gevent_sendfile(fdout, fdin, offset, nbytes):
-    while True:
-        try:
-            return o_sendfile(fdout, fdin, offset, nbytes)
-        except OSError as e:
-            if e.args[0] == errno.EAGAIN:
-                wait_write(fdout)
-            else:
-                raise
-
-def patch_sendfile():
-    from gunicorn.http import wsgi
-
-    if o_sendfile is not None:
-        setattr(wsgi, "sendfile", _gevent_sendfile)
-
-
-class GeventWorker(AsyncWorker):
-
-    server_class = None
-    wsgi_handler = None
-
-    def patch(self):
-        from gevent import monkey
-        monkey.noisy = False
-
-        # if the new version is used make sure to patch subprocess
-        if gevent.version_info[0] == 0:
-            monkey.patch_all()
-        else:
-            monkey.patch_all(subprocess=True)
-
-        # monkey patch sendfile to make it none blocking
-        patch_sendfile()
-
-        # patch sockets
-        sockets = []
-        for s in self.sockets:
-            if sys.version_info[0] == 3:
-                sockets.append(socket(s.FAMILY, _socket.SOCK_STREAM,
-                    fileno=s.sock.fileno()))
-            else:
-                sockets.append(socket(s.FAMILY, _socket.SOCK_STREAM,
-                    _sock=s))
-        self.sockets = sockets
-
-    def notify(self):
-        super(GeventWorker, self).notify()
-        if self.ppid != os.getppid():
-            self.log.info("Parent changed, shutting down: %s", self)
-            sys.exit(0)
-
-    def timeout_ctx(self):
-        return gevent.Timeout(self.cfg.keepalive, False)
-
-    def run(self):
-        servers = []
-        ssl_args = {}
-
-        if self.cfg.is_ssl:
-            ssl_args = dict(server_side=True, **self.cfg.ssl_options)
-
-        for s in self.sockets:
-            s.setblocking(1)
-            pool = Pool(self.worker_connections)
-            if self.server_class is not None:
-                environ = base_environ(self.cfg)
-                environ.update({
-                    "wsgi.multithread": True,
-                    "SERVER_SOFTWARE": VERSION,
-                })
-                server = self.server_class(
-                    s, application=self.wsgi, spawn=pool, log=self.log,
-                    handler_class=self.wsgi_handler, environ=environ,
-                    **ssl_args)
-            else:
-                hfun = partial(self.handle, s)
-                server = StreamServer(s, handle=hfun, spawn=pool, **ssl_args)
-
-            server.start()
-            servers.append(server)
-
-        while self.alive:
-            self.notify()
-            gevent.sleep(1.0)
-
-        try:
-            # Stop accepting requests
-            for server in servers:
-                if hasattr(server, 'close'):  # gevent 1.0
-                    server.close()
-                if hasattr(server, 'kill'):  # gevent < 1.0
-                    server.kill()
-
-            # Handle current requests until graceful_timeout
-            ts = time.time()
-            while time.time() - ts <= self.cfg.graceful_timeout:
-                accepting = 0
-                for server in servers:
-                    if server.pool.free_count() != server.pool.size:
-                        accepting += 1
-
-                # if no server is accepting a connection, we can exit
-                if not accepting:
-                    return
-
-                self.notify()
-                gevent.sleep(1.0)
-
-            # Force kill all active the handlers
-            self.log.warning("Worker graceful timeout (pid:%s)" % self.pid)
-            for server in servers:
-                server.stop(timeout=1)
-        except:
-            pass
-
-    def handle(self, listener, client, addr):
-        # Connected socket timeout defaults to socket.getdefaulttimeout().
-        # This forces to blocking mode.
-        client.setblocking(1)
-        super(GeventWorker, self).handle(listener, client, addr)
-
-    def handle_request(self, listener_name, req, sock, addr):
-        try:
-            super(GeventWorker, self).handle_request(listener_name, req, sock,
-                                                     addr)
-        except gevent.GreenletExit:
-            pass
-        except SystemExit:
-            pass
-
-    def handle_quit(self, sig, frame):
-        # Move this out of the signal handler so we can use
-        # blocking calls. See #1126
-        gevent.spawn(super(GeventWorker, self).handle_quit, sig, frame)
-
-    def handle_usr1(self, sig, frame):
-        # Make the gevent workers handle the usr1 signal
-        # by deferring to a new greenlet. See #1645
-        gevent.spawn(super(GeventWorker, self).handle_usr1, sig, frame)
-
-    if gevent.version_info[0] == 0:
-
-        def init_process(self):
-            # monkey patch here
-            self.patch()
-
-            # reinit the hub
-            import gevent.core
-            gevent.core.reinit()
-
-            #gevent 0.13 and older doesn't reinitialize dns for us after forking
-            #here's the workaround
-            gevent.core.dns_shutdown(fail_requests=1)
-            gevent.core.dns_init()
-            super(GeventWorker, self).init_process()
-
-    else:
-
-        def init_process(self):
-            # monkey patch here
-            self.patch()
-
-            # reinit the hub
-            from gevent import hub
-            hub.reinit()
-
-            # then initialize the process
-            super(GeventWorker, self).init_process()
-
-
-class GeventResponse(object):
-
-    status = None
-    headers = None
-    sent = None
-
-    def __init__(self, status, headers, clength):
-        self.status = status
-        self.headers = headers
-        self.sent = clength
-
-
-class PyWSGIHandler(pywsgi.WSGIHandler):
-
-    def log_request(self):
-        start = datetime.fromtimestamp(self.time_start)
-        finish = datetime.fromtimestamp(self.time_finish)
-        response_time = finish - start
-        resp_headers = getattr(self, 'response_headers', {})
-        resp = GeventResponse(self.status, resp_headers, self.response_length)
-        if hasattr(self, 'headers'):
-            req_headers = self.headers.items()
-        else:
-            req_headers = []
-        self.server.log.access(resp, req_headers, self.environ, response_time)
-
-    def get_environ(self):
-        env = super(PyWSGIHandler, self).get_environ()
-        env['gunicorn.sock'] = self.socket
-        env['RAW_URI'] = self.path
-        return env
-
-
-class PyWSGIServer(pywsgi.WSGIServer):
-    pass
-
-
-class GeventPyWSGIWorker(GeventWorker):
-    "The Gevent StreamServer based workers."
-    server_class = PyWSGIServer
-    wsgi_handler = PyWSGIHandler
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gthread.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gthread.py
deleted file mode 100644
index 862f873d8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gthread.py
+++ /dev/null
@@ -1,367 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-# design:
-# a threaded worker accepts connections in the main loop, accepted
-# connections are are added to the thread pool as a connection job. On
-# keepalive connections are put back in the loop waiting for an event.
-# If no event happen after the keep alive timeout, the connectoin is
-# closed.
-
-from collections import deque
-from datetime import datetime
-import errno
-from functools import partial
-import os
-import socket
-import ssl
-import sys
-from threading import RLock
-import time
-
-from .. import http
-from ..http import wsgi
-from .. import util
-from . import base
-from .. import six
-
-
-try:
-    import concurrent.futures as futures
-except ImportError:
-    raise RuntimeError("""
-    You need to install the 'futures' package to use this worker with this
-    Python version.
-    """)
-
-try:
-    from asyncio import selectors
-except ImportError:
-    from gunicorn import selectors
-
-
-class TConn(object):
-
-    def __init__(self, cfg, sock, client, server):
-        self.cfg = cfg
-        self.sock = sock
-        self.client = client
-        self.server = server
-
-        self.timeout = None
-        self.parser = None
-
-        # set the socket to non blocking
-        self.sock.setblocking(False)
-
-    def init(self):
-        self.sock.setblocking(True)
-        if self.parser is None:
-            # wrap the socket if needed
-            if self.cfg.is_ssl:
-                self.sock = ssl.wrap_socket(self.sock, server_side=True,
-                        **self.cfg.ssl_options)
-
-            # initialize the parser
-            self.parser = http.RequestParser(self.cfg, self.sock)
-
-    def set_timeout(self):
-        # set the timeout
-        self.timeout = time.time() + self.cfg.keepalive
-
-    def close(self):
-        util.close(self.sock)
-
-
-class ThreadWorker(base.Worker):
-
-    def __init__(self, *args, **kwargs):
-        super(ThreadWorker, self).__init__(*args, **kwargs)
-        self.worker_connections = self.cfg.worker_connections
-        self.max_keepalived = self.cfg.worker_connections - self.cfg.threads
-        # initialise the pool
-        self.tpool = None
-        self.poller = None
-        self._lock = None
-        self.futures = deque()
-        self._keep = deque()
-        self.nr_conns = 0
-
-    @classmethod
-    def check_config(cls, cfg, log):
-        max_keepalived = cfg.worker_connections - cfg.threads
-
-        if max_keepalived <= 0 and cfg.keepalive:
-            log.warning("No keepalived connections can be handled. " +
-                    "Check the number of worker connections and threads.")
-
-    def init_process(self):
-        self.tpool = futures.ThreadPoolExecutor(max_workers=self.cfg.threads)
-        self.poller = selectors.DefaultSelector()
-        self._lock = RLock()
-        super(ThreadWorker, self).init_process()
-
-    def handle_quit(self, sig, frame):
-        self.alive = False
-        # worker_int callback
-        self.cfg.worker_int(self)
-        self.tpool.shutdown(False)
-        time.sleep(0.1)
-        sys.exit(0)
-
-    def _wrap_future(self, fs, conn):
-        fs.conn = conn
-        self.futures.append(fs)
-        fs.add_done_callback(self.finish_request)
-
-    def enqueue_req(self, conn):
-        conn.init()
-        # submit the connection to a worker
-        fs = self.tpool.submit(self.handle, conn)
-        self._wrap_future(fs, conn)
-
-    def accept(self, server, listener):
-        try:
-            sock, client = listener.accept()
-            # initialize the connection object
-            conn = TConn(self.cfg, sock, client, server)
-            self.nr_conns += 1
-            # enqueue the job
-            self.enqueue_req(conn)
-        except EnvironmentError as e:
-            if e.errno not in (errno.EAGAIN,
-                    errno.ECONNABORTED, errno.EWOULDBLOCK):
-                raise
-
-    def reuse_connection(self, conn, client):
-        with self._lock:
-            # unregister the client from the poller
-            self.poller.unregister(client)
-            # remove the connection from keepalive
-            try:
-                self._keep.remove(conn)
-            except ValueError:
-                # race condition
-                return
-
-        # submit the connection to a worker
-        self.enqueue_req(conn)
-
-    def murder_keepalived(self):
-        now = time.time()
-        while True:
-            with self._lock:
-                try:
-                    # remove the connection from the queue
-                    conn = self._keep.popleft()
-                except IndexError:
-                    break
-
-            delta = conn.timeout - now
-            if delta > 0:
-                # add the connection back to the queue
-                with self._lock:
-                    self._keep.appendleft(conn)
-                break
-            else:
-                self.nr_conns -= 1
-                # remove the socket from the poller
-                with self._lock:
-                    try:
-                        self.poller.unregister(conn.sock)
-                    except EnvironmentError as e:
-                        if e.errno != errno.EBADF:
-                            raise
-                    except KeyError:
-                        # already removed by the system, continue
-                        pass
-
-                # close the socket
-                conn.close()
-
-    def is_parent_alive(self):
-        # If our parent changed then we shut down.
-        if self.ppid != os.getppid():
-            self.log.info("Parent changed, shutting down: %s", self)
-            return False
-        return True
-
-    def run(self):
-        # init listeners, add them to the event loop
-        for sock in self.sockets:
-            sock.setblocking(False)
-            # a race condition during graceful shutdown may make the listener
-            # name unavailable in the request handler so capture it once here
-            server = sock.getsockname()
-            acceptor = partial(self.accept, server)
-            self.poller.register(sock, selectors.EVENT_READ, acceptor)
-
-        while self.alive:
-            # notify the arbiter we are alive
-            self.notify()
-
-            # can we accept more connections?
-            if self.nr_conns < self.worker_connections:
-                # wait for an event
-                events = self.poller.select(1.0)
-                for key, _ in events:
-                    callback = key.data
-                    callback(key.fileobj)
-
-                # check (but do not wait) for finished requests
-                result = futures.wait(self.futures, timeout=0,
-                        return_when=futures.FIRST_COMPLETED)
-            else:
-                # wait for a request to finish
-                result = futures.wait(self.futures, timeout=1.0,
-                        return_when=futures.FIRST_COMPLETED)
-
-            # clean up finished requests
-            for fut in result.done:
-                self.futures.remove(fut)
-
-            if not self.is_parent_alive():
-                break
-
-            # hanle keepalive timeouts
-            self.murder_keepalived()
-
-        self.tpool.shutdown(False)
-        self.poller.close()
-
-        for s in self.sockets:
-            s.close()
-
-        futures.wait(self.futures, timeout=self.cfg.graceful_timeout)
-
-    def finish_request(self, fs):
-        if fs.cancelled():
-            self.nr_conns -= 1
-            fs.conn.close()
-            return
-
-        try:
-            (keepalive, conn) = fs.result()
-            # if the connection should be kept alived add it
-            # to the eventloop and record it
-            if keepalive:
-                # flag the socket as non blocked
-                conn.sock.setblocking(False)
-
-                # register the connection
-                conn.set_timeout()
-                with self._lock:
-                    self._keep.append(conn)
-
-                    # add the socket to the event loop
-                    self.poller.register(conn.sock, selectors.EVENT_READ,
-                            partial(self.reuse_connection, conn))
-            else:
-                self.nr_conns -= 1
-                conn.close()
-        except:
-            # an exception happened, make sure to close the
-            # socket.
-            self.nr_conns -= 1
-            fs.conn.close()
-
-    def handle(self, conn):
-        keepalive = False
-        req = None
-        try:
-            req = six.next(conn.parser)
-            if not req:
-                return (False, conn)
-
-            # handle the request
-            keepalive = self.handle_request(req, conn)
-            if keepalive:
-                return (keepalive, conn)
-        except http.errors.NoMoreData as e:
-            self.log.debug("Ignored premature client disconnection. %s", e)
-
-        except StopIteration as e:
-            self.log.debug("Closing connection. %s", e)
-        except ssl.SSLError as e:
-            if e.args[0] == ssl.SSL_ERROR_EOF:
-                self.log.debug("ssl connection closed")
-                conn.sock.close()
-            else:
-                self.log.debug("Error processing SSL request.")
-                self.handle_error(req, conn.sock, conn.client, e)
-
-        except EnvironmentError as e:
-            if e.errno not in (errno.EPIPE, errno.ECONNRESET):
-                self.log.exception("Socket error processing request.")
-            else:
-                if e.errno == errno.ECONNRESET:
-                    self.log.debug("Ignoring connection reset")
-                else:
-                    self.log.debug("Ignoring connection epipe")
-        except Exception as e:
-            self.handle_error(req, conn.sock, conn.client, e)
-
-        return (False, conn)
-
-    def handle_request(self, req, conn):
-        environ = {}
-        resp = None
-        try:
-            self.cfg.pre_request(self, req)
-            request_start = datetime.now()
-            resp, environ = wsgi.create(req, conn.sock, conn.client,
-                    conn.server, self.cfg)
-            environ["wsgi.multithread"] = True
-            self.nr += 1
-            if self.alive and self.nr >= self.max_requests:
-                self.log.info("Autorestarting worker after current request.")
-                resp.force_close()
-                self.alive = False
-
-            if not self.cfg.keepalive:
-                resp.force_close()
-            elif len(self._keep) >= self.max_keepalived:
-                resp.force_close()
-
-            respiter = self.wsgi(environ, resp.start_response)
-            try:
-                if isinstance(respiter, environ['wsgi.file_wrapper']):
-                    resp.write_file(respiter)
-                else:
-                    for item in respiter:
-                        resp.write(item)
-
-                resp.close()
-                request_time = datetime.now() - request_start
-                self.log.access(resp, req, environ, request_time)
-            finally:
-                if hasattr(respiter, "close"):
-                    respiter.close()
-
-            if resp.should_close():
-                self.log.debug("Closing connection.")
-                return False
-        except EnvironmentError:
-            # pass to next try-except level
-            six.reraise(*sys.exc_info())
-        except Exception:
-            if resp and resp.headers_sent:
-                # If the requests have already been sent, we should close the
-                # connection to indicate the error.
-                self.log.exception("Error handling request")
-                try:
-                    conn.sock.shutdown(socket.SHUT_RDWR)
-                    conn.sock.close()
-                except EnvironmentError:
-                    pass
-                raise StopIteration()
-            raise
-        finally:
-            try:
-                self.cfg.post_request(self, req, environ, resp)
-            except Exception:
-                self.log.exception("Exception in post_request hook")
-
-        return True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gtornado.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gtornado.py
deleted file mode 100644
index 7c1b1184b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/gtornado.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import copy
-import os
-import sys
-
-try:
-    import tornado
-except ImportError:
-    raise RuntimeError("You need tornado installed to use this worker.")
-import tornado.web
-import tornado.httpserver
-from tornado.ioloop import IOLoop, PeriodicCallback
-from tornado.wsgi import WSGIContainer
-from gunicorn.workers.base import Worker
-from gunicorn import __version__ as gversion
-
-
-# `io_loop` arguments to many Tornado functions have been removed in Tornado 5.0
-# <http://www.tornadoweb.org/en/stable/releases/v5.0.0.html#backwards-compatibility-notes>
-IOLOOP_PARAMETER_REMOVED = tornado.version_info >= (5, 0, 0)
-
-
-class TornadoWorker(Worker):
-
-    @classmethod
-    def setup(cls):
-        web = sys.modules.pop("tornado.web")
-        old_clear = web.RequestHandler.clear
-
-        def clear(self):
-            old_clear(self)
-            if "Gunicorn" not in self._headers["Server"]:
-                self._headers["Server"] += " (Gunicorn/%s)" % gversion
-        web.RequestHandler.clear = clear
-        sys.modules["tornado.web"] = web
-
-    def handle_exit(self, sig, frame):
-        if self.alive:
-            super(TornadoWorker, self).handle_exit(sig, frame)
-
-    def handle_request(self):
-        self.nr += 1
-        if self.alive and self.nr >= self.max_requests:
-            self.log.info("Autorestarting worker after current request.")
-            self.alive = False
-
-    def watchdog(self):
-        if self.alive:
-            self.notify()
-
-        if self.ppid != os.getppid():
-            self.log.info("Parent changed, shutting down: %s", self)
-            self.alive = False
-
-    def heartbeat(self):
-        if not self.alive:
-            if self.server_alive:
-                if hasattr(self, 'server'):
-                    try:
-                        self.server.stop()
-                    except Exception:
-                        pass
-                self.server_alive = False
-            else:
-                if not self.ioloop._callbacks:
-                    self.ioloop.stop()
-
-    def run(self):
-        self.ioloop = IOLoop.instance()
-        self.alive = True
-        self.server_alive = False
-        if IOLOOP_PARAMETER_REMOVED:
-            PeriodicCallback(self.watchdog, 1000).start()
-            PeriodicCallback(self.heartbeat, 1000).start()
-        else:
-            PeriodicCallback(self.watchdog, 1000, io_loop=self.ioloop).start()
-            PeriodicCallback(self.heartbeat, 1000, io_loop=self.ioloop).start()
-
-        # Assume the app is a WSGI callable if its not an
-        # instance of tornado.web.Application or is an
-        # instance of tornado.wsgi.WSGIApplication
-        app = self.wsgi
-        if not isinstance(app, tornado.web.Application) or \
-           isinstance(app, tornado.wsgi.WSGIApplication):
-            app = WSGIContainer(app)
-
-        # Monkey-patching HTTPConnection.finish to count the
-        # number of requests being handled by Tornado. This
-        # will help gunicorn shutdown the worker if max_requests
-        # is exceeded.
-        httpserver = sys.modules["tornado.httpserver"]
-        if hasattr(httpserver, 'HTTPConnection'):
-            old_connection_finish = httpserver.HTTPConnection.finish
-
-            def finish(other):
-                self.handle_request()
-                old_connection_finish(other)
-            httpserver.HTTPConnection.finish = finish
-            sys.modules["tornado.httpserver"] = httpserver
-
-            server_class = tornado.httpserver.HTTPServer
-        else:
-
-            class _HTTPServer(tornado.httpserver.HTTPServer):
-
-                def on_close(instance, server_conn):
-                    self.handle_request()
-                    super(_HTTPServer, instance).on_close(server_conn)
-
-            server_class = _HTTPServer
-
-        if self.cfg.is_ssl:
-            _ssl_opt = copy.deepcopy(self.cfg.ssl_options)
-            # tornado refuses initialization if ssl_options contains following
-            # options
-            del _ssl_opt["do_handshake_on_connect"]
-            del _ssl_opt["suppress_ragged_eofs"]
-            if IOLOOP_PARAMETER_REMOVED:
-                server = server_class(app, ssl_options=_ssl_opt)
-            else:
-                server = server_class(app, io_loop=self.ioloop,
-                                      ssl_options=_ssl_opt)
-        else:
-            if IOLOOP_PARAMETER_REMOVED:
-                server = server_class(app)
-            else:
-                server = server_class(app, io_loop=self.ioloop)
-
-        self.server = server
-        self.server_alive = True
-
-        for s in self.sockets:
-            s.setblocking(0)
-            if hasattr(server, "add_socket"):  # tornado > 2.0
-                server.add_socket(s)
-            elif hasattr(server, "_sockets"):  # tornado 2.0
-                server._sockets[s.fileno()] = s
-
-        server.no_keep_alive = self.cfg.keepalive <= 0
-        server.start(num_processes=1)
-
-        self.ioloop.start()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/sync.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/sync.py
deleted file mode 100644
index 1d2ce2f60..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/sync.py
+++ /dev/null
@@ -1,208 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-#
-
-from datetime import datetime
-import errno
-import os
-import select
-import socket
-import ssl
-import sys
-
-import gunicorn.http as http
-import gunicorn.http.wsgi as wsgi
-import gunicorn.util as util
-import gunicorn.workers.base as base
-from gunicorn import six
-
-class StopWaiting(Exception):
-    """ exception raised to stop waiting for a connnection """
-
-class SyncWorker(base.Worker):
-
-    def accept(self, listener):
-        client, addr = listener.accept()
-        client.setblocking(1)
-        util.close_on_exec(client)
-        self.handle(listener, client, addr)
-
-    def wait(self, timeout):
-        try:
-            self.notify()
-            ret = select.select(self.wait_fds, [], [], timeout)
-            if ret[0]:
-                if self.PIPE[0] in ret[0]:
-                    os.read(self.PIPE[0], 1)
-                return ret[0]
-
-        except select.error as e:
-            if e.args[0] == errno.EINTR:
-                return self.sockets
-            if e.args[0] == errno.EBADF:
-                if self.nr < 0:
-                    return self.sockets
-                else:
-                    raise StopWaiting
-            raise
-
-    def is_parent_alive(self):
-        # If our parent changed then we shut down.
-        if self.ppid != os.getppid():
-            self.log.info("Parent changed, shutting down: %s", self)
-            return False
-        return True
-
-    def run_for_one(self, timeout):
-        listener = self.sockets[0]
-        while self.alive:
-            self.notify()
-
-            # Accept a connection. If we get an error telling us
-            # that no connection is waiting we fall down to the
-            # select which is where we'll wait for a bit for new
-            # workers to come give us some love.
-            try:
-                self.accept(listener)
-                # Keep processing clients until no one is waiting. This
-                # prevents the need to select() for every client that we
-                # process.
-                continue
-
-            except EnvironmentError as e:
-                if e.errno not in (errno.EAGAIN, errno.ECONNABORTED,
-                        errno.EWOULDBLOCK):
-                    raise
-
-            if not self.is_parent_alive():
-                return
-
-            try:
-                self.wait(timeout)
-            except StopWaiting:
-                return
-
-    def run_for_multiple(self, timeout):
-        while self.alive:
-            self.notify()
-
-            try:
-                ready = self.wait(timeout)
-            except StopWaiting:
-                return
-
-            if ready is not None:
-                for listener in ready:
-                    if listener == self.PIPE[0]:
-                        continue
-
-                    try:
-                        self.accept(listener)
-                    except EnvironmentError as e:
-                        if e.errno not in (errno.EAGAIN, errno.ECONNABORTED,
-                                errno.EWOULDBLOCK):
-                            raise
-
-            if not self.is_parent_alive():
-                return
-
-    def run(self):
-        # if no timeout is given the worker will never wait and will
-        # use the CPU for nothing. This minimal timeout prevent it.
-        timeout = self.timeout or 0.5
-
-        # self.socket appears to lose its blocking status after
-        # we fork in the arbiter. Reset it here.
-        for s in self.sockets:
-            s.setblocking(0)
-
-        if len(self.sockets) > 1:
-            self.run_for_multiple(timeout)
-        else:
-            self.run_for_one(timeout)
-
-    def handle(self, listener, client, addr):
-        req = None
-        try:
-            if self.cfg.is_ssl:
-                client = ssl.wrap_socket(client, server_side=True,
-                    **self.cfg.ssl_options)
-
-            parser = http.RequestParser(self.cfg, client)
-            req = six.next(parser)
-            self.handle_request(listener, req, client, addr)
-        except http.errors.NoMoreData as e:
-            self.log.debug("Ignored premature client disconnection. %s", e)
-        except StopIteration as e:
-            self.log.debug("Closing connection. %s", e)
-        except ssl.SSLError as e:
-            if e.args[0] == ssl.SSL_ERROR_EOF:
-                self.log.debug("ssl connection closed")
-                client.close()
-            else:
-                self.log.debug("Error processing SSL request.")
-                self.handle_error(req, client, addr, e)
-        except EnvironmentError as e:
-            if e.errno not in (errno.EPIPE, errno.ECONNRESET):
-                self.log.exception("Socket error processing request.")
-            else:
-                if e.errno == errno.ECONNRESET:
-                    self.log.debug("Ignoring connection reset")
-                else:
-                    self.log.debug("Ignoring EPIPE")
-        except Exception as e:
-            self.handle_error(req, client, addr, e)
-        finally:
-            util.close(client)
-
-    def handle_request(self, listener, req, client, addr):
-        environ = {}
-        resp = None
-        try:
-            self.cfg.pre_request(self, req)
-            request_start = datetime.now()
-            resp, environ = wsgi.create(req, client, addr,
-                    listener.getsockname(), self.cfg)
-            # Force the connection closed until someone shows
-            # a buffering proxy that supports Keep-Alive to
-            # the backend.
-            resp.force_close()
-            self.nr += 1
-            if self.nr >= self.max_requests:
-                self.log.info("Autorestarting worker after current request.")
-                self.alive = False
-            respiter = self.wsgi(environ, resp.start_response)
-            try:
-                if isinstance(respiter, environ['wsgi.file_wrapper']):
-                    resp.write_file(respiter)
-                else:
-                    for item in respiter:
-                        resp.write(item)
-                resp.close()
-                request_time = datetime.now() - request_start
-                self.log.access(resp, req, environ, request_time)
-            finally:
-                if hasattr(respiter, "close"):
-                    respiter.close()
-        except EnvironmentError:
-            # pass to next try-except level
-            six.reraise(*sys.exc_info())
-        except Exception:
-            if resp and resp.headers_sent:
-                # If the requests have already been sent, we should close the
-                # connection to indicate the error.
-                self.log.exception("Error handling request")
-                try:
-                    client.shutdown(socket.SHUT_RDWR)
-                    client.close()
-                except EnvironmentError:
-                    pass
-                raise StopIteration()
-            raise
-        finally:
-            try:
-                self.cfg.post_request(self, req, environ, resp)
-            except Exception:
-                self.log.exception("Exception in post_request hook")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/workertmp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/workertmp.py
deleted file mode 100644
index 36bc97a66..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/gunicorn/workers/workertmp.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -
-#
-# This file is part of gunicorn released under the MIT license.
-# See the NOTICE for more information.
-
-import os
-import platform
-import tempfile
-
-from gunicorn import util
-
-PLATFORM = platform.system()
-IS_CYGWIN = PLATFORM.startswith('CYGWIN')
-
-
-class WorkerTmp(object):
-
-    def __init__(self, cfg):
-        old_umask = os.umask(cfg.umask)
-        fdir = cfg.worker_tmp_dir
-        if fdir and not os.path.isdir(fdir):
-            raise RuntimeError("%s doesn't exist. Can't create workertmp." % fdir)
-        fd, name = tempfile.mkstemp(prefix="wgunicorn-", dir=fdir)
-
-        # allows the process to write to the file
-        util.chown(name, cfg.uid, cfg.gid)
-        os.umask(old_umask)
-
-        # unlink the file so we don't leak tempory files
-        try:
-            if not IS_CYGWIN:
-                util.unlink(name)
-            self._tmp = os.fdopen(fd, 'w+b', 1)
-        except:
-            os.close(fd)
-            raise
-
-        self.spinner = 0
-
-    def notify(self):
-        try:
-            self.spinner = (self.spinner + 1) % 2
-            os.fchmod(self._tmp.fileno(), self.spinner)
-        except AttributeError:
-            # python < 2.6
-            self._tmp.truncate(0)
-            os.write(self._tmp.fileno(), b"X")
-
-    def last_update(self):
-        return os.fstat(self._tmp.fileno()).st_ctime
-
-    def fileno(self):
-        return self._tmp.fileno()
-
-    def close(self):
-        return self._tmp.close()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/LICENSE.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/LICENSE.rst
deleted file mode 100644
index ef9c19474..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,47 +0,0 @@
-`BSD 3-Clause <https://opensource.org/licenses/BSD-3-Clause>`_
-
-Copyright © 2011 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
--   Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
--   Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
--   Neither the name of the copyright holder nor the names of its
-    contributors may be used to endorse or promote products derived from
-    this software without specific prior written permission.
-
-We kindly ask you to use these themes in an unmodified manner only with
-Pallets and Pallets-related projects, not for unrelated projects. If you
-like the visual style and want to use it for your own projects, please
-consider making some larger changes to the themes (such as changing font
-faces, sizes, colors or margins).
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-
-----
-
-The initial implementation of itsdangerous was inspired by Django's
-signing module.
-
-Copyright © Django Software Foundation and individual contributors.
-All rights reserved.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/METADATA
deleted file mode 100644
index 7389a4d23..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/METADATA
+++ /dev/null
@@ -1,98 +0,0 @@
-Metadata-Version: 2.1
-Name: itsdangerous
-Version: 1.1.0
-Summary: Various helpers to pass data to untrusted environments and back.
-Home-page: https://palletsprojects.com/p/itsdangerous/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets Team
-Maintainer-email: contact@palletsprojects.com
-License: BSD
-Project-URL: Documentation, https://itsdangerous.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/itsdangerous
-Project-URL: Issue tracker, https://github.com/pallets/itsdangerous/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
-
-itsdangerous
-============
-
-... so better sign this
-
-Various helpers to pass data to untrusted environments and to get it
-back safe and sound. Data is cryptographically signed to ensure that a
-token has not been tampered with.
-
-It's possible to customize how data is serialized. Data is compressed as
-needed. A timestamp can be added and verified automatically while
-loading a token.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U itsdangerous
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-A Simple Example
-----------------
-
-Here's how you could generate a token for transmitting a user's id and
-name between web requests.
-
-.. code-block:: python
-
-    from itsdangerous import URLSafeSerializer
-    auth_s = URLSafeSerializer("secret key", "auth")
-    token = auth_s.dumps({"id": 5, "name": "itsdangerous"})
-
-    print(token)
-    # eyJpZCI6NSwibmFtZSI6Iml0c2Rhbmdlcm91cyJ9.6YP6T0BaO67XP--9UzTrmurXSmg
-
-    data = auth_s.loads(token)
-    print(data["name"])
-    # itsdangerous
-
-
-Donate
-------
-
-The Pallets organization develops and supports itsdangerous and other
-popular packages. In order to grow the community of contributors and
-users, and allow the maintainers to devote more time to the projects,
-`please donate today`_.
-
-.. _please donate today: https://palletsprojects.com/donate
-
-
-Links
------
-
-*   Website: https://palletsprojects.com/p/itsdangerous/
-*   Documentation: https://itsdangerous.palletsprojects.com/
-*   License: `BSD <https://github.com/pallets/itsdangerous/blob/master/LICENSE.rst>`_
-*   Releases: https://pypi.org/project/itsdangerous/
-*   Code: https://github.com/pallets/itsdangerous
-*   Issue tracker: https://github.com/pallets/itsdangerous/issues
-*   Test status: https://travis-ci.org/pallets/itsdangerous
-*   Test coverage: https://codecov.io/gh/pallets/itsdangerous
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/RECORD
deleted file mode 100644
index c1bdb8534..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/RECORD
+++ /dev/null
@@ -1,26 +0,0 @@
-itsdangerous/__init__.py,sha256=Dr-SkfFdOyiR_WjiqIXnlFpYRMW0XvPBNV5muzE5N_A,708
-itsdangerous/_compat.py,sha256=oAAMcQAjwQXQpIbuHT3o-aL56ztm_7Fe-4lD7IteF6A,1133
-itsdangerous/_json.py,sha256=W7BLL4RPnSOjNdo2gfKT3BeARMCIikY6O75rwWV0XoE,431
-itsdangerous/encoding.py,sha256=KhY85PsH3bGHe5JANN4LMZ_3b0IwUWRRnnw1wvLlaIg,1224
-itsdangerous/exc.py,sha256=KFxg7K2XMliMQAxL4jkRNgE8e73z2jcRaLrzwqVObnI,2959
-itsdangerous/jws.py,sha256=6Lh9W-Lu8D9s7bRazs0Zb35eyAZm3pzLeZqHmRELeII,7470
-itsdangerous/serializer.py,sha256=bT-dfjKec9zcKa8Qo8n7mHW_8M-XCTPMOFq1TQI_Fv4,8653
-itsdangerous/signer.py,sha256=OOZbK8XomBjQfOFEul8osesn7fc80MXB0L1r7E86_GQ,6345
-itsdangerous/timed.py,sha256=on5Q5lX7LT_LaETOhzF1ZmrRbia8P98263R8FiRyM6Y,5635
-itsdangerous/url_safe.py,sha256=xnFTaukIPmW6Qwn6uNQLgzdau8RuAKnp5N7ukuXykj0,2275
-itsdangerous-1.1.0.dist-info/LICENSE.rst,sha256=_rKL-jSNgWsOfbrt3xhJnufoAHxngT241qs3xl4EbNQ,2120
-itsdangerous-1.1.0.dist-info/METADATA,sha256=yyKjL2WOg_WybH2Yt-7NIvGpV3B93IsMc2HbToWc7Sk,3062
-itsdangerous-1.1.0.dist-info/WHEEL,sha256=CihQvCnsGZQBGAHLEUMf0IdA4fRduS_NBUTMgCTtvPM,110
-itsdangerous-1.1.0.dist-info/top_level.txt,sha256=gKN1OKLk81i7fbWWildJA88EQ9NhnGMSvZqhfz9ICjk,13
-itsdangerous-1.1.0.dist-info/RECORD,,
-itsdangerous-1.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-itsdangerous/__pycache__/jws.cpython-35.pyc,,
-itsdangerous/__pycache__/url_safe.cpython-35.pyc,,
-itsdangerous/__pycache__/_json.cpython-35.pyc,,
-itsdangerous/__pycache__/signer.cpython-35.pyc,,
-itsdangerous/__pycache__/timed.cpython-35.pyc,,
-itsdangerous/__pycache__/exc.cpython-35.pyc,,
-itsdangerous/__pycache__/serializer.cpython-35.pyc,,
-itsdangerous/__pycache__/encoding.cpython-35.pyc,,
-itsdangerous/__pycache__/_compat.cpython-35.pyc,,
-itsdangerous/__pycache__/__init__.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/WHEEL
deleted file mode 100644
index dea0e20cc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.32.2)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/top_level.txt
deleted file mode 100644
index e163955e8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous-1.1.0.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-itsdangerous
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__init__.py
deleted file mode 100644
index 0fcd8c1b1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__init__.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from ._json import json
-from .encoding import base64_decode
-from .encoding import base64_encode
-from .encoding import want_bytes
-from .exc import BadData
-from .exc import BadHeader
-from .exc import BadPayload
-from .exc import BadSignature
-from .exc import BadTimeSignature
-from .exc import SignatureExpired
-from .jws import JSONWebSignatureSerializer
-from .jws import TimedJSONWebSignatureSerializer
-from .serializer import Serializer
-from .signer import HMACAlgorithm
-from .signer import NoneAlgorithm
-from .signer import Signer
-from .timed import TimedSerializer
-from .timed import TimestampSigner
-from .url_safe import URLSafeSerializer
-from .url_safe import URLSafeTimedSerializer
-
-__version__ = "1.1.0"
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index b46492c18..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 2b2017a4d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_json.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_json.cpython-35.pyc
deleted file mode 100644
index 012ed3456..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/_json.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/encoding.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/encoding.cpython-35.pyc
deleted file mode 100644
index 10da251d4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/encoding.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/exc.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/exc.cpython-35.pyc
deleted file mode 100644
index e8e2b3b1a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/exc.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/jws.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/jws.cpython-35.pyc
deleted file mode 100644
index 06686ff45..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/jws.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/serializer.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/serializer.cpython-35.pyc
deleted file mode 100644
index 8248bf0f0..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/serializer.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/signer.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/signer.cpython-35.pyc
deleted file mode 100644
index 7db91c3d6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/signer.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/timed.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/timed.cpython-35.pyc
deleted file mode 100644
index 0414f9ac7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/timed.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/url_safe.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/url_safe.cpython-35.pyc
deleted file mode 100644
index 39273671d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/__pycache__/url_safe.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_compat.py
deleted file mode 100644
index 2291bce24..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_compat.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import decimal
-import hmac
-import numbers
-import sys
-
-PY2 = sys.version_info[0] == 2
-
-if PY2:
-    from itertools import izip
-
-    text_type = unicode  # noqa: 821
-else:
-    izip = zip
-    text_type = str
-
-number_types = (numbers.Real, decimal.Decimal)
-
-
-def _constant_time_compare(val1, val2):
-    """Return ``True`` if the two strings are equal, ``False``
-    otherwise.
-
-    The time taken is independent of the number of characters that
-    match. Do not use this function for anything else than comparision
-    with known length targets.
-
-    This is should be implemented in C in order to get it completely
-    right.
-
-    This is an alias of :func:`hmac.compare_digest` on Python>=2.7,3.3.
-    """
-    len_eq = len(val1) == len(val2)
-    if len_eq:
-        result = 0
-        left = val1
-    else:
-        result = 1
-        left = val2
-    for x, y in izip(bytearray(left), bytearray(val2)):
-        result |= x ^ y
-    return result == 0
-
-
-# Starting with 2.7/3.3 the standard library has a c-implementation for
-# constant time string compares.
-constant_time_compare = getattr(hmac, "compare_digest", _constant_time_compare)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_json.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_json.py
deleted file mode 100644
index 426b36e9a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/_json.py
+++ /dev/null
@@ -1,18 +0,0 @@
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-
-class _CompactJSON(object):
-    """Wrapper around json module that strips whitespace."""
-
-    @staticmethod
-    def loads(payload):
-        return json.loads(payload)
-
-    @staticmethod
-    def dumps(obj, **kwargs):
-        kwargs.setdefault("ensure_ascii", False)
-        kwargs.setdefault("separators", (",", ":"))
-        return json.dumps(obj, **kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/encoding.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/encoding.py
deleted file mode 100644
index 1e28969d2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/encoding.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import base64
-import string
-import struct
-
-from ._compat import text_type
-from .exc import BadData
-
-
-def want_bytes(s, encoding="utf-8", errors="strict"):
-    if isinstance(s, text_type):
-        s = s.encode(encoding, errors)
-    return s
-
-
-def base64_encode(string):
-    """Base64 encode a string of bytes or text. The resulting bytes are
-    safe to use in URLs.
-    """
-    string = want_bytes(string)
-    return base64.urlsafe_b64encode(string).rstrip(b"=")
-
-
-def base64_decode(string):
-    """Base64 decode a URL-safe string of bytes or text. The result is
-    bytes.
-    """
-    string = want_bytes(string, encoding="ascii", errors="ignore")
-    string += b"=" * (-len(string) % 4)
-
-    try:
-        return base64.urlsafe_b64decode(string)
-    except (TypeError, ValueError):
-        raise BadData("Invalid base64-encoded data")
-
-
-# The alphabet used by base64.urlsafe_*
-_base64_alphabet = (string.ascii_letters + string.digits + "-_=").encode("ascii")
-
-_int64_struct = struct.Struct(">Q")
-_int_to_bytes = _int64_struct.pack
-_bytes_to_int = _int64_struct.unpack
-
-
-def int_to_bytes(num):
-    return _int_to_bytes(num).lstrip(b"\x00")
-
-
-def bytes_to_int(bytestr):
-    return _bytes_to_int(bytestr.rjust(8, b"\x00"))[0]
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/exc.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/exc.py
deleted file mode 100644
index 287d6917a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/exc.py
+++ /dev/null
@@ -1,98 +0,0 @@
-from ._compat import PY2
-from ._compat import text_type
-
-
-class BadData(Exception):
-    """Raised if bad data of any sort was encountered. This is the base
-    for all exceptions that itsdangerous defines.
-
-    .. versionadded:: 0.15
-    """
-
-    message = None
-
-    def __init__(self, message):
-        super(BadData, self).__init__(self, message)
-        self.message = message
-
-    def __str__(self):
-        return text_type(self.message)
-
-    if PY2:
-        __unicode__ = __str__
-
-        def __str__(self):
-            return self.__unicode__().encode("utf-8")
-
-
-class BadSignature(BadData):
-    """Raised if a signature does not match."""
-
-    def __init__(self, message, payload=None):
-        BadData.__init__(self, message)
-
-        #: The payload that failed the signature test. In some
-        #: situations you might still want to inspect this, even if
-        #: you know it was tampered with.
-        #:
-        #: .. versionadded:: 0.14
-        self.payload = payload
-
-
-class BadTimeSignature(BadSignature):
-    """Raised if a time-based signature is invalid. This is a subclass
-    of :class:`BadSignature`.
-    """
-
-    def __init__(self, message, payload=None, date_signed=None):
-        BadSignature.__init__(self, message, payload)
-
-        #: If the signature expired this exposes the date of when the
-        #: signature was created. This can be helpful in order to
-        #: tell the user how long a link has been gone stale.
-        #:
-        #: .. versionadded:: 0.14
-        self.date_signed = date_signed
-
-
-class SignatureExpired(BadTimeSignature):
-    """Raised if a signature timestamp is older than ``max_age``. This
-    is a subclass of :exc:`BadTimeSignature`.
-    """
-
-
-class BadHeader(BadSignature):
-    """Raised if a signed header is invalid in some form. This only
-    happens for serializers that have a header that goes with the
-    signature.
-
-    .. versionadded:: 0.24
-    """
-
-    def __init__(self, message, payload=None, header=None, original_error=None):
-        BadSignature.__init__(self, message, payload)
-
-        #: If the header is actually available but just malformed it
-        #: might be stored here.
-        self.header = header
-
-        #: If available, the error that indicates why the payload was
-        #: not valid. This might be ``None``.
-        self.original_error = original_error
-
-
-class BadPayload(BadData):
-    """Raised if a payload is invalid. This could happen if the payload
-    is loaded despite an invalid signature, or if there is a mismatch
-    between the serializer and deserializer. The original exception
-    that occurred during loading is stored on as :attr:`original_error`.
-
-    .. versionadded:: 0.15
-    """
-
-    def __init__(self, message, original_error=None):
-        BadData.__init__(self, message)
-
-        #: If available, the error that indicates why the payload was
-        #: not valid. This might be ``None``.
-        self.original_error = original_error
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/jws.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/jws.py
deleted file mode 100644
index 92e9ec8b4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/jws.py
+++ /dev/null
@@ -1,218 +0,0 @@
-import hashlib
-import time
-from datetime import datetime
-
-from ._compat import number_types
-from ._json import _CompactJSON
-from ._json import json
-from .encoding import base64_decode
-from .encoding import base64_encode
-from .encoding import want_bytes
-from .exc import BadData
-from .exc import BadHeader
-from .exc import BadPayload
-from .exc import BadSignature
-from .exc import SignatureExpired
-from .serializer import Serializer
-from .signer import HMACAlgorithm
-from .signer import NoneAlgorithm
-
-
-class JSONWebSignatureSerializer(Serializer):
-    """This serializer implements JSON Web Signature (JWS) support. Only
-    supports the JWS Compact Serialization.
-    """
-
-    jws_algorithms = {
-        "HS256": HMACAlgorithm(hashlib.sha256),
-        "HS384": HMACAlgorithm(hashlib.sha384),
-        "HS512": HMACAlgorithm(hashlib.sha512),
-        "none": NoneAlgorithm(),
-    }
-
-    #: The default algorithm to use for signature generation
-    default_algorithm = "HS512"
-
-    default_serializer = _CompactJSON
-
-    def __init__(
-        self,
-        secret_key,
-        salt=None,
-        serializer=None,
-        serializer_kwargs=None,
-        signer=None,
-        signer_kwargs=None,
-        algorithm_name=None,
-    ):
-        Serializer.__init__(
-            self,
-            secret_key=secret_key,
-            salt=salt,
-            serializer=serializer,
-            serializer_kwargs=serializer_kwargs,
-            signer=signer,
-            signer_kwargs=signer_kwargs,
-        )
-        if algorithm_name is None:
-            algorithm_name = self.default_algorithm
-        self.algorithm_name = algorithm_name
-        self.algorithm = self.make_algorithm(algorithm_name)
-
-    def load_payload(self, payload, serializer=None, return_header=False):
-        payload = want_bytes(payload)
-        if b"." not in payload:
-            raise BadPayload('No "." found in value')
-        base64d_header, base64d_payload = payload.split(b".", 1)
-        try:
-            json_header = base64_decode(base64d_header)
-        except Exception as e:
-            raise BadHeader(
-                "Could not base64 decode the header because of an exception",
-                original_error=e,
-            )
-        try:
-            json_payload = base64_decode(base64d_payload)
-        except Exception as e:
-            raise BadPayload(
-                "Could not base64 decode the payload because of an exception",
-                original_error=e,
-            )
-        try:
-            header = Serializer.load_payload(self, json_header, serializer=json)
-        except BadData as e:
-            raise BadHeader(
-                "Could not unserialize header because it was malformed",
-                original_error=e,
-            )
-        if not isinstance(header, dict):
-            raise BadHeader("Header payload is not a JSON object", header=header)
-        payload = Serializer.load_payload(self, json_payload, serializer=serializer)
-        if return_header:
-            return payload, header
-        return payload
-
-    def dump_payload(self, header, obj):
-        base64d_header = base64_encode(
-            self.serializer.dumps(header, **self.serializer_kwargs)
-        )
-        base64d_payload = base64_encode(
-            self.serializer.dumps(obj, **self.serializer_kwargs)
-        )
-        return base64d_header + b"." + base64d_payload
-
-    def make_algorithm(self, algorithm_name):
-        try:
-            return self.jws_algorithms[algorithm_name]
-        except KeyError:
-            raise NotImplementedError("Algorithm not supported")
-
-    def make_signer(self, salt=None, algorithm=None):
-        if salt is None:
-            salt = self.salt
-        key_derivation = "none" if salt is None else None
-        if algorithm is None:
-            algorithm = self.algorithm
-        return self.signer(
-            self.secret_key,
-            salt=salt,
-            sep=".",
-            key_derivation=key_derivation,
-            algorithm=algorithm,
-        )
-
-    def make_header(self, header_fields):
-        header = header_fields.copy() if header_fields else {}
-        header["alg"] = self.algorithm_name
-        return header
-
-    def dumps(self, obj, salt=None, header_fields=None):
-        """Like :meth:`.Serializer.dumps` but creates a JSON Web
-        Signature. It also allows for specifying additional fields to be
-        included in the JWS header.
-        """
-        header = self.make_header(header_fields)
-        signer = self.make_signer(salt, self.algorithm)
-        return signer.sign(self.dump_payload(header, obj))
-
-    def loads(self, s, salt=None, return_header=False):
-        """Reverse of :meth:`dumps`. If requested via ``return_header``
-        it will return a tuple of payload and header.
-        """
-        payload, header = self.load_payload(
-            self.make_signer(salt, self.algorithm).unsign(want_bytes(s)),
-            return_header=True,
-        )
-        if header.get("alg") != self.algorithm_name:
-            raise BadHeader("Algorithm mismatch", header=header, payload=payload)
-        if return_header:
-            return payload, header
-        return payload
-
-    def loads_unsafe(self, s, salt=None, return_header=False):
-        kwargs = {"return_header": return_header}
-        return self._loads_unsafe_impl(s, salt, kwargs, kwargs)
-
-
-class TimedJSONWebSignatureSerializer(JSONWebSignatureSerializer):
-    """Works like the regular :class:`JSONWebSignatureSerializer` but
-    also records the time of the signing and can be used to expire
-    signatures.
-
-    JWS currently does not specify this behavior but it mentions a
-    possible extension like this in the spec. Expiry date is encoded
-    into the header similar to what's specified in `draft-ietf-oauth
-    -json-web-token <http://self-issued.info/docs/draft-ietf-oauth-json
-    -web-token.html#expDef>`_.
-    """
-
-    DEFAULT_EXPIRES_IN = 3600
-
-    def __init__(self, secret_key, expires_in=None, **kwargs):
-        JSONWebSignatureSerializer.__init__(self, secret_key, **kwargs)
-        if expires_in is None:
-            expires_in = self.DEFAULT_EXPIRES_IN
-        self.expires_in = expires_in
-
-    def make_header(self, header_fields):
-        header = JSONWebSignatureSerializer.make_header(self, header_fields)
-        iat = self.now()
-        exp = iat + self.expires_in
-        header["iat"] = iat
-        header["exp"] = exp
-        return header
-
-    def loads(self, s, salt=None, return_header=False):
-        payload, header = JSONWebSignatureSerializer.loads(
-            self, s, salt, return_header=True
-        )
-
-        if "exp" not in header:
-            raise BadSignature("Missing expiry date", payload=payload)
-
-        int_date_error = BadHeader("Expiry date is not an IntDate", payload=payload)
-        try:
-            header["exp"] = int(header["exp"])
-        except ValueError:
-            raise int_date_error
-        if header["exp"] < 0:
-            raise int_date_error
-
-        if header["exp"] < self.now():
-            raise SignatureExpired(
-                "Signature expired",
-                payload=payload,
-                date_signed=self.get_issue_date(header),
-            )
-
-        if return_header:
-            return payload, header
-        return payload
-
-    def get_issue_date(self, header):
-        rv = header.get("iat")
-        if isinstance(rv, number_types):
-            return datetime.utcfromtimestamp(int(rv))
-
-    def now(self):
-        return int(time.time())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/serializer.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/serializer.py
deleted file mode 100644
index 12c20f46d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/serializer.py
+++ /dev/null
@@ -1,233 +0,0 @@
-import hashlib
-
-from ._compat import text_type
-from ._json import json
-from .encoding import want_bytes
-from .exc import BadPayload
-from .exc import BadSignature
-from .signer import Signer
-
-
-def is_text_serializer(serializer):
-    """Checks whether a serializer generates text or binary."""
-    return isinstance(serializer.dumps({}), text_type)
-
-
-class Serializer(object):
-    """This class provides a serialization interface on top of the
-    signer. It provides a similar API to json/pickle and other modules
-    but is structured differently internally. If you want to change the
-    underlying implementation for parsing and loading you have to
-    override the :meth:`load_payload` and :meth:`dump_payload`
-    functions.
-
-    This implementation uses simplejson if available for dumping and
-    loading and will fall back to the standard library's json module if
-    it's not available.
-
-    You do not need to subclass this class in order to switch out or
-    customize the :class:`.Signer`. You can instead pass a different
-    class to the constructor as well as keyword arguments as a dict that
-    should be forwarded.
-
-    .. code-block:: python
-
-        s = Serializer(signer_kwargs={'key_derivation': 'hmac'})
-
-    You may want to upgrade the signing parameters without invalidating
-    existing signatures that are in use. Fallback signatures can be
-    given that will be tried if unsigning with the current signer fails.
-
-    Fallback signers can be defined by providing a list of
-    ``fallback_signers``. Each item can be one of the following: a
-    signer class (which is instantiated with ``signer_kwargs``,
-    ``salt``, and ``secret_key``), a tuple
-    ``(signer_class, signer_kwargs)``, or a dict of ``signer_kwargs``.
-
-    For example, this is a serializer that signs using SHA-512, but will
-    unsign using either SHA-512 or SHA1:
-
-    .. code-block:: python
-
-        s = Serializer(
-            signer_kwargs={"digest_method": hashlib.sha512},
-            fallback_signers=[{"digest_method": hashlib.sha1}]
-        )
-
-    .. versionchanged:: 0.14:
-        The ``signer`` and ``signer_kwargs`` parameters were added to
-        the constructor.
-
-    .. versionchanged:: 1.1.0:
-        Added support for ``fallback_signers`` and configured a default
-        SHA-512 fallback. This fallback is for users who used the yanked
-        1.0.0 release which defaulted to SHA-512.
-    """
-
-    #: If a serializer module or class is not passed to the constructor
-    #: this one is picked up. This currently defaults to :mod:`json`.
-    default_serializer = json
-
-    #: The default :class:`Signer` class that is being used by this
-    #: serializer.
-    #:
-    #: .. versionadded:: 0.14
-    default_signer = Signer
-
-    #: The default fallback signers.
-    default_fallback_signers = [{"digest_method": hashlib.sha512}]
-
-    def __init__(
-        self,
-        secret_key,
-        salt=b"itsdangerous",
-        serializer=None,
-        serializer_kwargs=None,
-        signer=None,
-        signer_kwargs=None,
-        fallback_signers=None,
-    ):
-        self.secret_key = want_bytes(secret_key)
-        self.salt = want_bytes(salt)
-        if serializer is None:
-            serializer = self.default_serializer
-        self.serializer = serializer
-        self.is_text_serializer = is_text_serializer(serializer)
-        if signer is None:
-            signer = self.default_signer
-        self.signer = signer
-        self.signer_kwargs = signer_kwargs or {}
-        if fallback_signers is None:
-            fallback_signers = list(self.default_fallback_signers or ())
-        self.fallback_signers = fallback_signers
-        self.serializer_kwargs = serializer_kwargs or {}
-
-    def load_payload(self, payload, serializer=None):
-        """Loads the encoded object. This function raises
-        :class:`.BadPayload` if the payload is not valid. The
-        ``serializer`` parameter can be used to override the serializer
-        stored on the class. The encoded ``payload`` should always be
-        bytes.
-        """
-        if serializer is None:
-            serializer = self.serializer
-            is_text = self.is_text_serializer
-        else:
-            is_text = is_text_serializer(serializer)
-        try:
-            if is_text:
-                payload = payload.decode("utf-8")
-            return serializer.loads(payload)
-        except Exception as e:
-            raise BadPayload(
-                "Could not load the payload because an exception"
-                " occurred on unserializing the data.",
-                original_error=e,
-            )
-
-    def dump_payload(self, obj):
-        """Dumps the encoded object. The return value is always bytes.
-        If the internal serializer returns text, the value will be
-        encoded as UTF-8.
-        """
-        return want_bytes(self.serializer.dumps(obj, **self.serializer_kwargs))
-
-    def make_signer(self, salt=None):
-        """Creates a new instance of the signer to be used. The default
-        implementation uses the :class:`.Signer` base class.
-        """
-        if salt is None:
-            salt = self.salt
-        return self.signer(self.secret_key, salt=salt, **self.signer_kwargs)
-
-    def iter_unsigners(self, salt=None):
-        """Iterates over all signers to be tried for unsigning. Starts
-        with the configured signer, then constructs each signer
-        specified in ``fallback_signers``.
-        """
-        if salt is None:
-            salt = self.salt
-        yield self.make_signer(salt)
-        for fallback in self.fallback_signers:
-            if type(fallback) is dict:
-                kwargs = fallback
-                fallback = self.signer
-            elif type(fallback) is tuple:
-                fallback, kwargs = fallback
-            else:
-                kwargs = self.signer_kwargs
-            yield fallback(self.secret_key, salt=salt, **kwargs)
-
-    def dumps(self, obj, salt=None):
-        """Returns a signed string serialized with the internal
-        serializer. The return value can be either a byte or unicode
-        string depending on the format of the internal serializer.
-        """
-        payload = want_bytes(self.dump_payload(obj))
-        rv = self.make_signer(salt).sign(payload)
-        if self.is_text_serializer:
-            rv = rv.decode("utf-8")
-        return rv
-
-    def dump(self, obj, f, salt=None):
-        """Like :meth:`dumps` but dumps into a file. The file handle has
-        to be compatible with what the internal serializer expects.
-        """
-        f.write(self.dumps(obj, salt))
-
-    def loads(self, s, salt=None):
-        """Reverse of :meth:`dumps`. Raises :exc:`.BadSignature` if the
-        signature validation fails.
-        """
-        s = want_bytes(s)
-        last_exception = None
-        for signer in self.iter_unsigners(salt):
-            try:
-                return self.load_payload(signer.unsign(s))
-            except BadSignature as err:
-                last_exception = err
-        raise last_exception
-
-    def load(self, f, salt=None):
-        """Like :meth:`loads` but loads from a file."""
-        return self.loads(f.read(), salt)
-
-    def loads_unsafe(self, s, salt=None):
-        """Like :meth:`loads` but without verifying the signature. This
-        is potentially very dangerous to use depending on how your
-        serializer works. The return value is ``(signature_valid,
-        payload)`` instead of just the payload. The first item will be a
-        boolean that indicates if the signature is valid. This function
-        never fails.
-
-        Use it for debugging only and if you know that your serializer
-        module is not exploitable (for example, do not use it with a
-        pickle serializer).
-
-        .. versionadded:: 0.15
-        """
-        return self._loads_unsafe_impl(s, salt)
-
-    def _loads_unsafe_impl(self, s, salt, load_kwargs=None, load_payload_kwargs=None):
-        """Low level helper function to implement :meth:`loads_unsafe`
-        in serializer subclasses.
-        """
-        try:
-            return True, self.loads(s, salt=salt, **(load_kwargs or {}))
-        except BadSignature as e:
-            if e.payload is None:
-                return False, None
-            try:
-                return (
-                    False,
-                    self.load_payload(e.payload, **(load_payload_kwargs or {})),
-                )
-            except BadPayload:
-                return False, None
-
-    def load_unsafe(self, f, *args, **kwargs):
-        """Like :meth:`loads_unsafe` but loads from a file.
-
-        .. versionadded:: 0.15
-        """
-        return self.loads_unsafe(f.read(), *args, **kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/signer.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/signer.py
deleted file mode 100644
index 6bddc0396..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/signer.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import hashlib
-import hmac
-
-from ._compat import constant_time_compare
-from .encoding import _base64_alphabet
-from .encoding import base64_decode
-from .encoding import base64_encode
-from .encoding import want_bytes
-from .exc import BadSignature
-
-
-class SigningAlgorithm(object):
-    """Subclasses must implement :meth:`get_signature` to provide
-    signature generation functionality.
-    """
-
-    def get_signature(self, key, value):
-        """Returns the signature for the given key and value."""
-        raise NotImplementedError()
-
-    def verify_signature(self, key, value, sig):
-        """Verifies the given signature matches the expected
-        signature.
-        """
-        return constant_time_compare(sig, self.get_signature(key, value))
-
-
-class NoneAlgorithm(SigningAlgorithm):
-    """Provides an algorithm that does not perform any signing and
-    returns an empty signature.
-    """
-
-    def get_signature(self, key, value):
-        return b""
-
-
-class HMACAlgorithm(SigningAlgorithm):
-    """Provides signature generation using HMACs."""
-
-    #: The digest method to use with the MAC algorithm. This defaults to
-    #: SHA1, but can be changed to any other function in the hashlib
-    #: module.
-    default_digest_method = staticmethod(hashlib.sha1)
-
-    def __init__(self, digest_method=None):
-        if digest_method is None:
-            digest_method = self.default_digest_method
-        self.digest_method = digest_method
-
-    def get_signature(self, key, value):
-        mac = hmac.new(key, msg=value, digestmod=self.digest_method)
-        return mac.digest()
-
-
-class Signer(object):
-    """This class can sign and unsign bytes, validating the signature
-    provided.
-
-    Salt can be used to namespace the hash, so that a signed string is
-    only valid for a given namespace. Leaving this at the default value
-    or re-using a salt value across different parts of your application
-    where the same signed value in one part can mean something different
-    in another part is a security risk.
-
-    See :ref:`the-salt` for an example of what the salt is doing and how
-    you can utilize it.
-
-    .. versionadded:: 0.14
-        ``key_derivation`` and ``digest_method`` were added as arguments
-        to the class constructor.
-
-    .. versionadded:: 0.18
-        ``algorithm`` was added as an argument to the class constructor.
-    """
-
-    #: The digest method to use for the signer.  This defaults to
-    #: SHA1 but can be changed to any other function in the hashlib
-    #: module.
-    #:
-    #: .. versionadded:: 0.14
-    default_digest_method = staticmethod(hashlib.sha1)
-
-    #: Controls how the key is derived. The default is Django-style
-    #: concatenation. Possible values are ``concat``, ``django-concat``
-    #: and ``hmac``. This is used for deriving a key from the secret key
-    #: with an added salt.
-    #:
-    #: .. versionadded:: 0.14
-    default_key_derivation = "django-concat"
-
-    def __init__(
-        self,
-        secret_key,
-        salt=None,
-        sep=".",
-        key_derivation=None,
-        digest_method=None,
-        algorithm=None,
-    ):
-        self.secret_key = want_bytes(secret_key)
-        self.sep = want_bytes(sep)
-        if self.sep in _base64_alphabet:
-            raise ValueError(
-                "The given separator cannot be used because it may be"
-                " contained in the signature itself. Alphanumeric"
-                " characters and `-_=` must not be used."
-            )
-        self.salt = "itsdangerous.Signer" if salt is None else salt
-        if key_derivation is None:
-            key_derivation = self.default_key_derivation
-        self.key_derivation = key_derivation
-        if digest_method is None:
-            digest_method = self.default_digest_method
-        self.digest_method = digest_method
-        if algorithm is None:
-            algorithm = HMACAlgorithm(self.digest_method)
-        self.algorithm = algorithm
-
-    def derive_key(self):
-        """This method is called to derive the key. The default key
-        derivation choices can be overridden here. Key derivation is not
-        intended to be used as a security method to make a complex key
-        out of a short password. Instead you should use large random
-        secret keys.
-        """
-        salt = want_bytes(self.salt)
-        if self.key_derivation == "concat":
-            return self.digest_method(salt + self.secret_key).digest()
-        elif self.key_derivation == "django-concat":
-            return self.digest_method(salt + b"signer" + self.secret_key).digest()
-        elif self.key_derivation == "hmac":
-            mac = hmac.new(self.secret_key, digestmod=self.digest_method)
-            mac.update(salt)
-            return mac.digest()
-        elif self.key_derivation == "none":
-            return self.secret_key
-        else:
-            raise TypeError("Unknown key derivation method")
-
-    def get_signature(self, value):
-        """Returns the signature for the given value."""
-        value = want_bytes(value)
-        key = self.derive_key()
-        sig = self.algorithm.get_signature(key, value)
-        return base64_encode(sig)
-
-    def sign(self, value):
-        """Signs the given string."""
-        return want_bytes(value) + want_bytes(self.sep) + self.get_signature(value)
-
-    def verify_signature(self, value, sig):
-        """Verifies the signature for the given value."""
-        key = self.derive_key()
-        try:
-            sig = base64_decode(sig)
-        except Exception:
-            return False
-        return self.algorithm.verify_signature(key, value, sig)
-
-    def unsign(self, signed_value):
-        """Unsigns the given string."""
-        signed_value = want_bytes(signed_value)
-        sep = want_bytes(self.sep)
-        if sep not in signed_value:
-            raise BadSignature("No %r found in value" % self.sep)
-        value, sig = signed_value.rsplit(sep, 1)
-        if self.verify_signature(value, sig):
-            return value
-        raise BadSignature("Signature %r does not match" % sig, payload=value)
-
-    def validate(self, signed_value):
-        """Only validates the given signed value. Returns ``True`` if
-        the signature exists and is valid.
-        """
-        try:
-            self.unsign(signed_value)
-            return True
-        except BadSignature:
-            return False
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/timed.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/timed.py
deleted file mode 100644
index 4c117e419..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/timed.py
+++ /dev/null
@@ -1,147 +0,0 @@
-import time
-from datetime import datetime
-
-from ._compat import text_type
-from .encoding import base64_decode
-from .encoding import base64_encode
-from .encoding import bytes_to_int
-from .encoding import int_to_bytes
-from .encoding import want_bytes
-from .exc import BadSignature
-from .exc import BadTimeSignature
-from .exc import SignatureExpired
-from .serializer import Serializer
-from .signer import Signer
-
-
-class TimestampSigner(Signer):
-    """Works like the regular :class:`.Signer` but also records the time
-    of the signing and can be used to expire signatures. The
-    :meth:`unsign` method can raise :exc:`.SignatureExpired` if the
-    unsigning failed because the signature is expired.
-    """
-
-    def get_timestamp(self):
-        """Returns the current timestamp. The function must return an
-        integer.
-        """
-        return int(time.time())
-
-    def timestamp_to_datetime(self, ts):
-        """Used to convert the timestamp from :meth:`get_timestamp` into
-        a datetime object.
-        """
-        return datetime.utcfromtimestamp(ts)
-
-    def sign(self, value):
-        """Signs the given string and also attaches time information."""
-        value = want_bytes(value)
-        timestamp = base64_encode(int_to_bytes(self.get_timestamp()))
-        sep = want_bytes(self.sep)
-        value = value + sep + timestamp
-        return value + sep + self.get_signature(value)
-
-    def unsign(self, value, max_age=None, return_timestamp=False):
-        """Works like the regular :meth:`.Signer.unsign` but can also
-        validate the time. See the base docstring of the class for
-        the general behavior. If ``return_timestamp`` is ``True`` the
-        timestamp of the signature will be returned as a naive
-        :class:`datetime.datetime` object in UTC.
-        """
-        try:
-            result = Signer.unsign(self, value)
-            sig_error = None
-        except BadSignature as e:
-            sig_error = e
-            result = e.payload or b""
-        sep = want_bytes(self.sep)
-
-        # If there is no timestamp in the result there is something
-        # seriously wrong. In case there was a signature error, we raise
-        # that one directly, otherwise we have a weird situation in
-        # which we shouldn't have come except someone uses a time-based
-        # serializer on non-timestamp data, so catch that.
-        if sep not in result:
-            if sig_error:
-                raise sig_error
-            raise BadTimeSignature("timestamp missing", payload=result)
-
-        value, timestamp = result.rsplit(sep, 1)
-        try:
-            timestamp = bytes_to_int(base64_decode(timestamp))
-        except Exception:
-            timestamp = None
-
-        # Signature is *not* okay. Raise a proper error now that we have
-        # split the value and the timestamp.
-        if sig_error is not None:
-            raise BadTimeSignature(
-                text_type(sig_error), payload=value, date_signed=timestamp
-            )
-
-        # Signature was okay but the timestamp is actually not there or
-        # malformed. Should not happen, but we handle it anyway.
-        if timestamp is None:
-            raise BadTimeSignature("Malformed timestamp", payload=value)
-
-        # Check timestamp is not older than max_age
-        if max_age is not None:
-            age = self.get_timestamp() - timestamp
-            if age > max_age:
-                raise SignatureExpired(
-                    "Signature age %s > %s seconds" % (age, max_age),
-                    payload=value,
-                    date_signed=self.timestamp_to_datetime(timestamp),
-                )
-
-        if return_timestamp:
-            return value, self.timestamp_to_datetime(timestamp)
-        return value
-
-    def validate(self, signed_value, max_age=None):
-        """Only validates the given signed value. Returns ``True`` if
-        the signature exists and is valid."""
-        try:
-            self.unsign(signed_value, max_age=max_age)
-            return True
-        except BadSignature:
-            return False
-
-
-class TimedSerializer(Serializer):
-    """Uses :class:`TimestampSigner` instead of the default
-    :class:`.Signer`.
-    """
-
-    default_signer = TimestampSigner
-
-    def loads(self, s, max_age=None, return_timestamp=False, salt=None):
-        """Reverse of :meth:`dumps`, raises :exc:`.BadSignature` if the
-        signature validation fails. If a ``max_age`` is provided it will
-        ensure the signature is not older than that time in seconds. In
-        case the signature is outdated, :exc:`.SignatureExpired` is
-        raised. All arguments are forwarded to the signer's
-        :meth:`~TimestampSigner.unsign` method.
-        """
-        s = want_bytes(s)
-        last_exception = None
-        for signer in self.iter_unsigners(salt):
-            try:
-                base64d, timestamp = signer.unsign(s, max_age, return_timestamp=True)
-                payload = self.load_payload(base64d)
-                if return_timestamp:
-                    return payload, timestamp
-                return payload
-            # If we get a signature expired it means we could read the
-            # signature but it's invalid.  In that case we do not want to
-            # try the next signer.
-            except SignatureExpired:
-                raise
-            except BadSignature as err:
-                last_exception = err
-        raise last_exception
-
-    def loads_unsafe(self, s, max_age=None, salt=None):
-        load_kwargs = {"max_age": max_age}
-        load_payload_kwargs = {}
-        return self._loads_unsafe_impl(s, salt, load_kwargs, load_payload_kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/url_safe.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/url_safe.py
deleted file mode 100644
index fcaa01123..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/itsdangerous/url_safe.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import zlib
-
-from ._json import _CompactJSON
-from .encoding import base64_decode
-from .encoding import base64_encode
-from .exc import BadPayload
-from .serializer import Serializer
-from .timed import TimedSerializer
-
-
-class URLSafeSerializerMixin(object):
-    """Mixed in with a regular serializer it will attempt to zlib
-    compress the string to make it shorter if necessary. It will also
-    base64 encode the string so that it can safely be placed in a URL.
-    """
-
-    default_serializer = _CompactJSON
-
-    def load_payload(self, payload, *args, **kwargs):
-        decompress = False
-        if payload.startswith(b"."):
-            payload = payload[1:]
-            decompress = True
-        try:
-            json = base64_decode(payload)
-        except Exception as e:
-            raise BadPayload(
-                "Could not base64 decode the payload because of an exception",
-                original_error=e,
-            )
-        if decompress:
-            try:
-                json = zlib.decompress(json)
-            except Exception as e:
-                raise BadPayload(
-                    "Could not zlib decompress the payload before decoding the payload",
-                    original_error=e,
-                )
-        return super(URLSafeSerializerMixin, self).load_payload(json, *args, **kwargs)
-
-    def dump_payload(self, obj):
-        json = super(URLSafeSerializerMixin, self).dump_payload(obj)
-        is_compressed = False
-        compressed = zlib.compress(json)
-        if len(compressed) < (len(json) - 1):
-            json = compressed
-            is_compressed = True
-        base64d = base64_encode(json)
-        if is_compressed:
-            base64d = b"." + base64d
-        return base64d
-
-
-class URLSafeSerializer(URLSafeSerializerMixin, Serializer):
-    """Works like :class:`.Serializer` but dumps and loads into a URL
-    safe string consisting of the upper and lowercase character of the
-    alphabet as well as ``'_'``, ``'-'`` and ``'.'``.
-    """
-
-
-class URLSafeTimedSerializer(URLSafeSerializerMixin, TimedSerializer):
-    """Works like :class:`.TimedSerializer` but dumps and loads into a
-    URL safe string consisting of the upper and lowercase character of
-    the alphabet as well as ``'_'``, ``'-'`` and ``'.'``.
-    """
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__init__.py
deleted file mode 100644
index 42aa763d5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__init__.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2
-    ~~~~~~
-
-    Jinja2 is a template engine written in pure Python.  It provides a
-    Django inspired non-XML syntax but supports inline expressions and
-    an optional sandboxed environment.
-
-    Nutshell
-    --------
-
-    Here a small example of a Jinja2 template::
-
-        {% extends 'base.html' %}
-        {% block title %}Memberlist{% endblock %}
-        {% block content %}
-          <ul>
-          {% for user in users %}
-            <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-          {% endfor %}
-          </ul>
-        {% endblock %}
-
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-__docformat__ = 'restructuredtext en'
-__version__ = '2.10'
-
-# high level interface
-from jinja2.environment import Environment, Template
-
-# loaders
-from jinja2.loaders import BaseLoader, FileSystemLoader, PackageLoader, \
-     DictLoader, FunctionLoader, PrefixLoader, ChoiceLoader, \
-     ModuleLoader
-
-# bytecode caches
-from jinja2.bccache import BytecodeCache, FileSystemBytecodeCache, \
-     MemcachedBytecodeCache
-
-# undefined types
-from jinja2.runtime import Undefined, DebugUndefined, StrictUndefined, \
-     make_logging_undefined
-
-# exceptions
-from jinja2.exceptions import TemplateError, UndefinedError, \
-     TemplateNotFound, TemplatesNotFound, TemplateSyntaxError, \
-     TemplateAssertionError, TemplateRuntimeError
-
-# decorators and public utilities
-from jinja2.filters import environmentfilter, contextfilter, \
-     evalcontextfilter
-from jinja2.utils import Markup, escape, clear_caches, \
-     environmentfunction, evalcontextfunction, contextfunction, \
-     is_undefined, select_autoescape
-
-__all__ = [
-    'Environment', 'Template', 'BaseLoader', 'FileSystemLoader',
-    'PackageLoader', 'DictLoader', 'FunctionLoader', 'PrefixLoader',
-    'ChoiceLoader', 'BytecodeCache', 'FileSystemBytecodeCache',
-    'MemcachedBytecodeCache', 'Undefined', 'DebugUndefined',
-    'StrictUndefined', 'TemplateError', 'UndefinedError', 'TemplateNotFound',
-    'TemplatesNotFound', 'TemplateSyntaxError', 'TemplateAssertionError',
-    'TemplateRuntimeError',
-    'ModuleLoader', 'environmentfilter', 'contextfilter', 'Markup', 'escape',
-    'environmentfunction', 'contextfunction', 'clear_caches', 'is_undefined',
-    'evalcontextfilter', 'evalcontextfunction', 'make_logging_undefined',
-    'select_autoescape',
-]
-
-
-def _patch_async():
-    from jinja2.utils import have_async_gen
-    if have_async_gen:
-        from jinja2.asyncsupport import patch_all
-        patch_all()
-
-
-_patch_async()
-del _patch_async
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a399900f1..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 33665d2ac..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_identifier.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_identifier.cpython-35.pyc
deleted file mode 100644
index 23722c9d6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/_identifier.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/bccache.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/bccache.cpython-35.pyc
deleted file mode 100644
index 55cafd4d6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/bccache.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/compiler.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/compiler.cpython-35.pyc
deleted file mode 100644
index 16dc12044..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/compiler.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/constants.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/constants.cpython-35.pyc
deleted file mode 100644
index 5e6529942..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/constants.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/debug.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/debug.cpython-35.pyc
deleted file mode 100644
index fb7a92459..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/debug.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/defaults.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/defaults.cpython-35.pyc
deleted file mode 100644
index 9934973bd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/defaults.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/environment.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/environment.cpython-35.pyc
deleted file mode 100644
index f895f23fd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/environment.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/exceptions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/exceptions.cpython-35.pyc
deleted file mode 100644
index 838f31d01..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/exceptions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/ext.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/ext.cpython-35.pyc
deleted file mode 100644
index 8b53119a6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/ext.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/filters.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/filters.cpython-35.pyc
deleted file mode 100644
index 03eaf5525..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/filters.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/idtracking.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/idtracking.cpython-35.pyc
deleted file mode 100644
index 4f0da21c7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/idtracking.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/lexer.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/lexer.cpython-35.pyc
deleted file mode 100644
index 91650f830..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/lexer.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/loaders.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/loaders.cpython-35.pyc
deleted file mode 100644
index 028828225..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/loaders.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/meta.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/meta.cpython-35.pyc
deleted file mode 100644
index fbd38b857..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/meta.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nativetypes.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nativetypes.cpython-35.pyc
deleted file mode 100644
index 3986f9191..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nativetypes.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nodes.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nodes.cpython-35.pyc
deleted file mode 100644
index e2a301d31..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/nodes.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/optimizer.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/optimizer.cpython-35.pyc
deleted file mode 100644
index 9ab932b04..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/optimizer.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/parser.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/parser.cpython-35.pyc
deleted file mode 100644
index 426de9d54..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/parser.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/runtime.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/runtime.cpython-35.pyc
deleted file mode 100644
index 8615c77e2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/runtime.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/sandbox.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/sandbox.cpython-35.pyc
deleted file mode 100644
index 76d3f72bd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/sandbox.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/tests.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/tests.cpython-35.pyc
deleted file mode 100644
index dd43d00b1..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/tests.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/utils.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/utils.cpython-35.pyc
deleted file mode 100644
index ef5774bb2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/utils.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/visitor.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/visitor.cpython-35.pyc
deleted file mode 100644
index 0cdd042e7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/__pycache__/visitor.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_compat.py
deleted file mode 100644
index 61d85301a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_compat.py
+++ /dev/null
@@ -1,99 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2._compat
-    ~~~~~~~~~~~~~~
-
-    Some py2/py3 compatibility support based on a stripped down
-    version of six so we don't have to depend on a specific version
-    of it.
-
-    :copyright: Copyright 2013 by the Jinja team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-import sys
-
-PY2 = sys.version_info[0] == 2
-PYPY = hasattr(sys, 'pypy_translation_info')
-_identity = lambda x: x
-
-
-if not PY2:
-    unichr = chr
-    range_type = range
-    text_type = str
-    string_types = (str,)
-    integer_types = (int,)
-
-    iterkeys = lambda d: iter(d.keys())
-    itervalues = lambda d: iter(d.values())
-    iteritems = lambda d: iter(d.items())
-
-    import pickle
-    from io import BytesIO, StringIO
-    NativeStringIO = StringIO
-
-    def reraise(tp, value, tb=None):
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-    ifilter = filter
-    imap = map
-    izip = zip
-    intern = sys.intern
-
-    implements_iterator = _identity
-    implements_to_string = _identity
-    encode_filename = _identity
-
-else:
-    unichr = unichr
-    text_type = unicode
-    range_type = xrange
-    string_types = (str, unicode)
-    integer_types = (int, long)
-
-    iterkeys = lambda d: d.iterkeys()
-    itervalues = lambda d: d.itervalues()
-    iteritems = lambda d: d.iteritems()
-
-    import cPickle as pickle
-    from cStringIO import StringIO as BytesIO, StringIO
-    NativeStringIO = BytesIO
-
-    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
-
-    from itertools import imap, izip, ifilter
-    intern = intern
-
-    def implements_iterator(cls):
-        cls.next = cls.__next__
-        del cls.__next__
-        return cls
-
-    def implements_to_string(cls):
-        cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
-        return cls
-
-    def encode_filename(filename):
-        if isinstance(filename, unicode):
-            return filename.encode('utf-8')
-        return filename
-
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a
-    # dummy metaclass for one level of class instantiation that replaces
-    # itself with the actual metaclass.
-    class metaclass(type):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-try:
-    from urllib.parse import quote_from_bytes as url_quote
-except ImportError:
-    from urllib import quote as url_quote
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_identifier.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_identifier.py
deleted file mode 100644
index 2eac35d5c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/_identifier.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# generated by scripts/generate_identifier_pattern.py
-pattern = '·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-ٰٟۖ-ۜ۟-۪ۤۧۨ-ܑۭܰ-݊ަ-ް߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣔ-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣঁ-ঃ়া-ৄেৈো-্ৗৢৣਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑੰੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣஂா-ூெ-ைொ-்ௗఀ-ఃా-ౄె-ైొ-్ౕౖౢౣಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣංඃ්ා-ුූෘ-ෟෲෳัิ-ฺ็-๎ັິ-ູົຼ່-ໍ༹༘༙༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏႚ-ႝ፝-፟ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝᠋-᠍ᢅᢆᢩᤠ-ᤫᤰ-᤻ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼᪰-᪽ᬀ-ᬄ᬴-᭄᭫-᭳ᮀ-ᮂᮡ-ᮭ᯦-᯳ᰤ-᰷᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰℘℮⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣠-꣱ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀ꧥꨩ-ꨶꩃꩌꩍꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭ﬞ︀-️︠-︯︳︴﹍-﹏＿𐇽𐋠𐍶-𐍺𐨁-𐨃𐨅𐨆𐨌-𐨏𐨸-𐨿𐨺𐫦𐫥𑀀-𑀂𑀸-𑁆𑁿-𑂂𑂰-𑂺𑄀-𑄂𑄧-𑅳𑄴𑆀-𑆂𑆳-𑇊𑇀-𑇌𑈬-𑈷𑈾𑋟-𑋪𑌀-𑌃𑌼𑌾-𑍄𑍇𑍈𑍋-𑍍𑍗𑍢𑍣𑍦-𑍬𑍰-𑍴𑐵-𑑆𑒰-𑓃𑖯-𑖵𑖸-𑗀𑗜𑗝𑘰-𑙀𑚫-𑚷𑜝-𑜫𑰯-𑰶𑰸-𑰿𑲒-𑲧𑲩-𑲶𖫰-𖫴𖬰-𖬶𖽑-𖽾𖾏-𖾒𛲝𛲞𝅥-𝅩𝅭-𝅲𝅻-𝆂𝆅-𝆋𝆪-𝆭𝉂-𝉄𝨀-𝨶𝨻-𝩬𝩵𝪄𝪛-𝪟𝪡-𝪯𞀀-𞀆𞀈-𞀘𞀛-𞀡𞀣𞀤𞀦-𞣐𞀪-𞣖𞥄-𞥊󠄀-󠇯'
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncfilters.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncfilters.py
deleted file mode 100644
index 5c1f46d7f..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncfilters.py
+++ /dev/null
@@ -1,146 +0,0 @@
-from functools import wraps
-
-from jinja2.asyncsupport import auto_aiter
-from jinja2 import filters
-
-
-async def auto_to_seq(value):
-    seq = []
-    if hasattr(value, '__aiter__'):
-        async for item in value:
-            seq.append(item)
-    else:
-        for item in value:
-            seq.append(item)
-    return seq
-
-
-async def async_select_or_reject(args, kwargs, modfunc, lookup_attr):
-    seq, func = filters.prepare_select_or_reject(
-        args, kwargs, modfunc, lookup_attr)
-    if seq:
-        async for item in auto_aiter(seq):
-            if func(item):
-                yield item
-
-
-def dualfilter(normal_filter, async_filter):
-    wrap_evalctx = False
-    if getattr(normal_filter, 'environmentfilter', False):
-        is_async = lambda args: args[0].is_async
-        wrap_evalctx = False
-    else:
-        if not getattr(normal_filter, 'evalcontextfilter', False) and \
-           not getattr(normal_filter, 'contextfilter', False):
-            wrap_evalctx = True
-        is_async = lambda args: args[0].environment.is_async
-
-    @wraps(normal_filter)
-    def wrapper(*args, **kwargs):
-        b = is_async(args)
-        if wrap_evalctx:
-            args = args[1:]
-        if b:
-            return async_filter(*args, **kwargs)
-        return normal_filter(*args, **kwargs)
-
-    if wrap_evalctx:
-        wrapper.evalcontextfilter = True
-
-    wrapper.asyncfiltervariant = True
-
-    return wrapper
-
-
-def asyncfiltervariant(original):
-    def decorator(f):
-        return dualfilter(original, f)
-    return decorator
-
-
-@asyncfiltervariant(filters.do_first)
-async def do_first(environment, seq):
-    try:
-        return await auto_aiter(seq).__anext__()
-    except StopAsyncIteration:
-        return environment.undefined('No first item, sequence was empty.')
-
-
-@asyncfiltervariant(filters.do_groupby)
-async def do_groupby(environment, value, attribute):
-    expr = filters.make_attrgetter(environment, attribute)
-    return [filters._GroupTuple(key, await auto_to_seq(values))
-            for key, values in filters.groupby(sorted(
-                await auto_to_seq(value), key=expr), expr)]
-
-
-@asyncfiltervariant(filters.do_join)
-async def do_join(eval_ctx, value, d=u'', attribute=None):
-    return filters.do_join(eval_ctx, await auto_to_seq(value), d, attribute)
-
-
-@asyncfiltervariant(filters.do_list)
-async def do_list(value):
-    return await auto_to_seq(value)
-
-
-@asyncfiltervariant(filters.do_reject)
-async def do_reject(*args, **kwargs):
-    return async_select_or_reject(args, kwargs, lambda x: not x, False)
-
-
-@asyncfiltervariant(filters.do_rejectattr)
-async def do_rejectattr(*args, **kwargs):
-    return async_select_or_reject(args, kwargs, lambda x: not x, True)
-
-
-@asyncfiltervariant(filters.do_select)
-async def do_select(*args, **kwargs):
-    return async_select_or_reject(args, kwargs, lambda x: x, False)
-
-
-@asyncfiltervariant(filters.do_selectattr)
-async def do_selectattr(*args, **kwargs):
-    return async_select_or_reject(args, kwargs, lambda x: x, True)
-
-
-@asyncfiltervariant(filters.do_map)
-async def do_map(*args, **kwargs):
-    seq, func = filters.prepare_map(args, kwargs)
-    if seq:
-        async for item in auto_aiter(seq):
-            yield func(item)
-
-
-@asyncfiltervariant(filters.do_sum)
-async def do_sum(environment, iterable, attribute=None, start=0):
-    rv = start
-    if attribute is not None:
-        func = filters.make_attrgetter(environment, attribute)
-    else:
-        func = lambda x: x
-    async for item in auto_aiter(iterable):
-        rv += func(item)
-    return rv
-
-
-@asyncfiltervariant(filters.do_slice)
-async def do_slice(value, slices, fill_with=None):
-    return filters.do_slice(await auto_to_seq(value), slices, fill_with)
-
-
-ASYNC_FILTERS = {
-    'first':        do_first,
-    'groupby':      do_groupby,
-    'join':         do_join,
-    'list':         do_list,
-    # we intentionally do not support do_last because that would be
-    # ridiculous
-    'reject':       do_reject,
-    'rejectattr':   do_rejectattr,
-    'map':          do_map,
-    'select':       do_select,
-    'selectattr':   do_selectattr,
-    'sum':          do_sum,
-    'slice':        do_slice,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncsupport.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncsupport.py
deleted file mode 100644
index b1e7b5ce9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/asyncsupport.py
+++ /dev/null
@@ -1,256 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.asyncsupport
-    ~~~~~~~~~~~~~~~~~~~
-
-    Has all the code for async support which is implemented as a patch
-    for supported Python versions.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-import asyncio
-import inspect
-from functools import update_wrapper
-
-from jinja2.utils import concat, internalcode, Markup
-from jinja2.environment import TemplateModule
-from jinja2.runtime import LoopContextBase, _last_iteration
-
-
-async def concat_async(async_gen):
-    rv = []
-    async def collect():
-        async for event in async_gen:
-            rv.append(event)
-    await collect()
-    return concat(rv)
-
-
-async def generate_async(self, *args, **kwargs):
-    vars = dict(*args, **kwargs)
-    try:
-        async for event in self.root_render_func(self.new_context(vars)):
-            yield event
-    except Exception:
-        exc_info = sys.exc_info()
-    else:
-        return
-    yield self.environment.handle_exception(exc_info, True)
-
-
-def wrap_generate_func(original_generate):
-    def _convert_generator(self, loop, args, kwargs):
-        async_gen = self.generate_async(*args, **kwargs)
-        try:
-            while 1:
-                yield loop.run_until_complete(async_gen.__anext__())
-        except StopAsyncIteration:
-            pass
-    def generate(self, *args, **kwargs):
-        if not self.environment.is_async:
-            return original_generate(self, *args, **kwargs)
-        return _convert_generator(self, asyncio.get_event_loop(), args, kwargs)
-    return update_wrapper(generate, original_generate)
-
-
-async def render_async(self, *args, **kwargs):
-    if not self.environment.is_async:
-        raise RuntimeError('The environment was not created with async mode '
-                           'enabled.')
-
-    vars = dict(*args, **kwargs)
-    ctx = self.new_context(vars)
-
-    try:
-        return await concat_async(self.root_render_func(ctx))
-    except Exception:
-        exc_info = sys.exc_info()
-    return self.environment.handle_exception(exc_info, True)
-
-
-def wrap_render_func(original_render):
-    def render(self, *args, **kwargs):
-        if not self.environment.is_async:
-            return original_render(self, *args, **kwargs)
-        loop = asyncio.get_event_loop()
-        return loop.run_until_complete(self.render_async(*args, **kwargs))
-    return update_wrapper(render, original_render)
-
-
-def wrap_block_reference_call(original_call):
-    @internalcode
-    async def async_call(self):
-        rv = await concat_async(self._stack[self._depth](self._context))
-        if self._context.eval_ctx.autoescape:
-            rv = Markup(rv)
-        return rv
-
-    @internalcode
-    def __call__(self):
-        if not self._context.environment.is_async:
-            return original_call(self)
-        return async_call(self)
-
-    return update_wrapper(__call__, original_call)
-
-
-def wrap_macro_invoke(original_invoke):
-    @internalcode
-    async def async_invoke(self, arguments, autoescape):
-        rv = await self._func(*arguments)
-        if autoescape:
-            rv = Markup(rv)
-        return rv
-
-    @internalcode
-    def _invoke(self, arguments, autoescape):
-        if not self._environment.is_async:
-            return original_invoke(self, arguments, autoescape)
-        return async_invoke(self, arguments, autoescape)
-    return update_wrapper(_invoke, original_invoke)
-
-
-@internalcode
-async def get_default_module_async(self):
-    if self._module is not None:
-        return self._module
-    self._module = rv = await self.make_module_async()
-    return rv
-
-
-def wrap_default_module(original_default_module):
-    @internalcode
-    def _get_default_module(self):
-        if self.environment.is_async:
-            raise RuntimeError('Template module attribute is unavailable '
-                               'in async mode')
-        return original_default_module(self)
-    return _get_default_module
-
-
-async def make_module_async(self, vars=None, shared=False, locals=None):
-    context = self.new_context(vars, shared, locals)
-    body_stream = []
-    async for item in self.root_render_func(context):
-        body_stream.append(item)
-    return TemplateModule(self, context, body_stream)
-
-
-def patch_template():
-    from jinja2 import Template
-    Template.generate = wrap_generate_func(Template.generate)
-    Template.generate_async = update_wrapper(
-        generate_async, Template.generate_async)
-    Template.render_async = update_wrapper(
-        render_async, Template.render_async)
-    Template.render = wrap_render_func(Template.render)
-    Template._get_default_module = wrap_default_module(
-        Template._get_default_module)
-    Template._get_default_module_async = get_default_module_async
-    Template.make_module_async = update_wrapper(
-        make_module_async, Template.make_module_async)
-
-
-def patch_runtime():
-    from jinja2.runtime import BlockReference, Macro
-    BlockReference.__call__ = wrap_block_reference_call(
-        BlockReference.__call__)
-    Macro._invoke = wrap_macro_invoke(Macro._invoke)
-
-
-def patch_filters():
-    from jinja2.filters import FILTERS
-    from jinja2.asyncfilters import ASYNC_FILTERS
-    FILTERS.update(ASYNC_FILTERS)
-
-
-def patch_all():
-    patch_template()
-    patch_runtime()
-    patch_filters()
-
-
-async def auto_await(value):
-    if inspect.isawaitable(value):
-        return await value
-    return value
-
-
-async def auto_aiter(iterable):
-    if hasattr(iterable, '__aiter__'):
-        async for item in iterable:
-            yield item
-        return
-    for item in iterable:
-        yield item
-
-
-class AsyncLoopContext(LoopContextBase):
-
-    def __init__(self, async_iterator, undefined, after, length, recurse=None,
-                 depth0=0):
-        LoopContextBase.__init__(self, undefined, recurse, depth0)
-        self._async_iterator = async_iterator
-        self._after = after
-        self._length = length
-
-    @property
-    def length(self):
-        if self._length is None:
-            raise TypeError('Loop length for some iterators cannot be '
-                            'lazily calculated in async mode')
-        return self._length
-
-    def __aiter__(self):
-        return AsyncLoopContextIterator(self)
-
-
-class AsyncLoopContextIterator(object):
-    __slots__ = ('context',)
-
-    def __init__(self, context):
-        self.context = context
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        ctx = self.context
-        ctx.index0 += 1
-        if ctx._after is _last_iteration:
-            raise StopAsyncIteration()
-        ctx._before = ctx._current
-        ctx._current = ctx._after
-        try:
-            ctx._after = await ctx._async_iterator.__anext__()
-        except StopAsyncIteration:
-            ctx._after = _last_iteration
-        return ctx._current, ctx
-
-
-async def make_async_loop_context(iterable, undefined, recurse=None, depth0=0):
-    # Length is more complicated and less efficient in async mode.  The
-    # reason for this is that we cannot know if length will be used
-    # upfront but because length is a property we cannot lazily execute it
-    # later.  This means that we need to buffer it up and measure :(
-    #
-    # We however only do this for actual iterators, not for async
-    # iterators as blocking here does not seem like the best idea in the
-    # world.
-    try:
-        length = len(iterable)
-    except (TypeError, AttributeError):
-        if not hasattr(iterable, '__aiter__'):
-            iterable = tuple(iterable)
-            length = len(iterable)
-        else:
-            length = None
-    async_iterator = auto_aiter(iterable)
-    try:
-        after = await async_iterator.__anext__()
-    except StopAsyncIteration:
-        after = _last_iteration
-    return AsyncLoopContext(async_iterator, undefined, after, length, recurse,
-                            depth0)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/bccache.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/bccache.py
deleted file mode 100644
index 080e527ca..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/bccache.py
+++ /dev/null
@@ -1,362 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.bccache
-    ~~~~~~~~~~~~~~
-
-    This module implements the bytecode cache system Jinja is optionally
-    using.  This is useful if you have very complex template situations and
-    the compiliation of all those templates slow down your application too
-    much.
-
-    Situations where this is useful are often forking web applications that
-    are initialized on the first request.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-from os import path, listdir
-import os
-import sys
-import stat
-import errno
-import marshal
-import tempfile
-import fnmatch
-from hashlib import sha1
-from jinja2.utils import open_if_exists
-from jinja2._compat import BytesIO, pickle, PY2, text_type
-
-
-# marshal works better on 3.x, one hack less required
-if not PY2:
-    marshal_dump = marshal.dump
-    marshal_load = marshal.load
-else:
-
-    def marshal_dump(code, f):
-        if isinstance(f, file):
-            marshal.dump(code, f)
-        else:
-            f.write(marshal.dumps(code))
-
-    def marshal_load(f):
-        if isinstance(f, file):
-            return marshal.load(f)
-        return marshal.loads(f.read())
-
-
-bc_version = 3
-
-# magic version used to only change with new jinja versions.  With 2.6
-# we change this to also take Python version changes into account.  The
-# reason for this is that Python tends to segfault if fed earlier bytecode
-# versions because someone thought it would be a good idea to reuse opcodes
-# or make Python incompatible with earlier versions.
-bc_magic = 'j2'.encode('ascii') + \
-    pickle.dumps(bc_version, 2) + \
-    pickle.dumps((sys.version_info[0] << 24) | sys.version_info[1])
-
-
-class Bucket(object):
-    """Buckets are used to store the bytecode for one template.  It's created
-    and initialized by the bytecode cache and passed to the loading functions.
-
-    The buckets get an internal checksum from the cache assigned and use this
-    to automatically reject outdated cache material.  Individual bytecode
-    cache subclasses don't have to care about cache invalidation.
-    """
-
-    def __init__(self, environment, key, checksum):
-        self.environment = environment
-        self.key = key
-        self.checksum = checksum
-        self.reset()
-
-    def reset(self):
-        """Resets the bucket (unloads the bytecode)."""
-        self.code = None
-
-    def load_bytecode(self, f):
-        """Loads bytecode from a file or file like object."""
-        # make sure the magic header is correct
-        magic = f.read(len(bc_magic))
-        if magic != bc_magic:
-            self.reset()
-            return
-        # the source code of the file changed, we need to reload
-        checksum = pickle.load(f)
-        if self.checksum != checksum:
-            self.reset()
-            return
-        # if marshal_load fails then we need to reload
-        try:
-            self.code = marshal_load(f)
-        except (EOFError, ValueError, TypeError):
-            self.reset()
-            return
-
-    def write_bytecode(self, f):
-        """Dump the bytecode into the file or file like object passed."""
-        if self.code is None:
-            raise TypeError('can\'t write empty bucket')
-        f.write(bc_magic)
-        pickle.dump(self.checksum, f, 2)
-        marshal_dump(self.code, f)
-
-    def bytecode_from_string(self, string):
-        """Load bytecode from a string."""
-        self.load_bytecode(BytesIO(string))
-
-    def bytecode_to_string(self):
-        """Return the bytecode as string."""
-        out = BytesIO()
-        self.write_bytecode(out)
-        return out.getvalue()
-
-
-class BytecodeCache(object):
-    """To implement your own bytecode cache you have to subclass this class
-    and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of
-    these methods are passed a :class:`~jinja2.bccache.Bucket`.
-
-    A very basic bytecode cache that saves the bytecode on the file system::
-
-        from os import path
-
-        class MyCache(BytecodeCache):
-
-            def __init__(self, directory):
-                self.directory = directory
-
-            def load_bytecode(self, bucket):
-                filename = path.join(self.directory, bucket.key)
-                if path.exists(filename):
-                    with open(filename, 'rb') as f:
-                        bucket.load_bytecode(f)
-
-            def dump_bytecode(self, bucket):
-                filename = path.join(self.directory, bucket.key)
-                with open(filename, 'wb') as f:
-                    bucket.write_bytecode(f)
-
-    A more advanced version of a filesystem based bytecode cache is part of
-    Jinja2.
-    """
-
-    def load_bytecode(self, bucket):
-        """Subclasses have to override this method to load bytecode into a
-        bucket.  If they are not able to find code in the cache for the
-        bucket, it must not do anything.
-        """
-        raise NotImplementedError()
-
-    def dump_bytecode(self, bucket):
-        """Subclasses have to override this method to write the bytecode
-        from a bucket back to the cache.  If it unable to do so it must not
-        fail silently but raise an exception.
-        """
-        raise NotImplementedError()
-
-    def clear(self):
-        """Clears the cache.  This method is not used by Jinja2 but should be
-        implemented to allow applications to clear the bytecode cache used
-        by a particular environment.
-        """
-
-    def get_cache_key(self, name, filename=None):
-        """Returns the unique hash key for this template name."""
-        hash = sha1(name.encode('utf-8'))
-        if filename is not None:
-            filename = '|' + filename
-            if isinstance(filename, text_type):
-                filename = filename.encode('utf-8')
-            hash.update(filename)
-        return hash.hexdigest()
-
-    def get_source_checksum(self, source):
-        """Returns a checksum for the source."""
-        return sha1(source.encode('utf-8')).hexdigest()
-
-    def get_bucket(self, environment, name, filename, source):
-        """Return a cache bucket for the given template.  All arguments are
-        mandatory but filename may be `None`.
-        """
-        key = self.get_cache_key(name, filename)
-        checksum = self.get_source_checksum(source)
-        bucket = Bucket(environment, key, checksum)
-        self.load_bytecode(bucket)
-        return bucket
-
-    def set_bucket(self, bucket):
-        """Put the bucket into the cache."""
-        self.dump_bytecode(bucket)
-
-
-class FileSystemBytecodeCache(BytecodeCache):
-    """A bytecode cache that stores bytecode on the filesystem.  It accepts
-    two arguments: The directory where the cache items are stored and a
-    pattern string that is used to build the filename.
-
-    If no directory is specified a default cache directory is selected.  On
-    Windows the user's temp directory is used, on UNIX systems a directory
-    is created for the user in the system temp directory.
-
-    The pattern can be used to have multiple separate caches operate on the
-    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
-    is replaced with the cache key.
-
-    >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
-
-    This bytecode cache supports clearing of the cache using the clear method.
-    """
-
-    def __init__(self, directory=None, pattern='__jinja2_%s.cache'):
-        if directory is None:
-            directory = self._get_default_cache_dir()
-        self.directory = directory
-        self.pattern = pattern
-
-    def _get_default_cache_dir(self):
-        def _unsafe_dir():
-            raise RuntimeError('Cannot determine safe temp directory.  You '
-                               'need to explicitly provide one.')
-
-        tmpdir = tempfile.gettempdir()
-
-        # On windows the temporary directory is used specific unless
-        # explicitly forced otherwise.  We can just use that.
-        if os.name == 'nt':
-            return tmpdir
-        if not hasattr(os, 'getuid'):
-            _unsafe_dir()
-
-        dirname = '_jinja2-cache-%d' % os.getuid()
-        actual_dir = os.path.join(tmpdir, dirname)
-
-        try:
-            os.mkdir(actual_dir, stat.S_IRWXU)
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
-        try:
-            os.chmod(actual_dir, stat.S_IRWXU)
-            actual_dir_stat = os.lstat(actual_dir)
-            if actual_dir_stat.st_uid != os.getuid() \
-               or not stat.S_ISDIR(actual_dir_stat.st_mode) \
-               or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
-                _unsafe_dir()
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
-
-        actual_dir_stat = os.lstat(actual_dir)
-        if actual_dir_stat.st_uid != os.getuid() \
-           or not stat.S_ISDIR(actual_dir_stat.st_mode) \
-           or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU:
-            _unsafe_dir()
-
-        return actual_dir
-
-    def _get_cache_filename(self, bucket):
-        return path.join(self.directory, self.pattern % bucket.key)
-
-    def load_bytecode(self, bucket):
-        f = open_if_exists(self._get_cache_filename(bucket), 'rb')
-        if f is not None:
-            try:
-                bucket.load_bytecode(f)
-            finally:
-                f.close()
-
-    def dump_bytecode(self, bucket):
-        f = open(self._get_cache_filename(bucket), 'wb')
-        try:
-            bucket.write_bytecode(f)
-        finally:
-            f.close()
-
-    def clear(self):
-        # imported lazily here because google app-engine doesn't support
-        # write access on the file system and the function does not exist
-        # normally.
-        from os import remove
-        files = fnmatch.filter(listdir(self.directory), self.pattern % '*')
-        for filename in files:
-            try:
-                remove(path.join(self.directory, filename))
-            except OSError:
-                pass
-
-
-class MemcachedBytecodeCache(BytecodeCache):
-    """This class implements a bytecode cache that uses a memcache cache for
-    storing the information.  It does not enforce a specific memcache library
-    (tummy's memcache or cmemcache) but will accept any class that provides
-    the minimal interface required.
-
-    Libraries compatible with this class:
-
-    -   `werkzeug <http://werkzeug.pocoo.org/>`_.contrib.cache
-    -   `python-memcached <https://www.tummy.com/Community/software/python-memcached/>`_
-    -   `cmemcache <http://gijsbert.org/cmemcache/>`_
-
-    (Unfortunately the django cache interface is not compatible because it
-    does not support storing binary data, only unicode.  You can however pass
-    the underlying cache client to the bytecode cache which is available
-    as `django.core.cache.cache._client`.)
-
-    The minimal interface for the client passed to the constructor is this:
-
-    .. class:: MinimalClientInterface
-
-        .. method:: set(key, value[, timeout])
-
-            Stores the bytecode in the cache.  `value` is a string and
-            `timeout` the timeout of the key.  If timeout is not provided
-            a default timeout or no timeout should be assumed, if it's
-            provided it's an integer with the number of seconds the cache
-            item should exist.
-
-        .. method:: get(key)
-
-            Returns the value for the cache key.  If the item does not
-            exist in the cache the return value must be `None`.
-
-    The other arguments to the constructor are the prefix for all keys that
-    is added before the actual cache key and the timeout for the bytecode in
-    the cache system.  We recommend a high (or no) timeout.
-
-    This bytecode cache does not support clearing of used items in the cache.
-    The clear method is a no-operation function.
-
-    .. versionadded:: 2.7
-       Added support for ignoring memcache errors through the
-       `ignore_memcache_errors` parameter.
-    """
-
-    def __init__(self, client, prefix='jinja2/bytecode/', timeout=None,
-                 ignore_memcache_errors=True):
-        self.client = client
-        self.prefix = prefix
-        self.timeout = timeout
-        self.ignore_memcache_errors = ignore_memcache_errors
-
-    def load_bytecode(self, bucket):
-        try:
-            code = self.client.get(self.prefix + bucket.key)
-        except Exception:
-            if not self.ignore_memcache_errors:
-                raise
-            code = None
-        if code is not None:
-            bucket.bytecode_from_string(code)
-
-    def dump_bytecode(self, bucket):
-        args = (self.prefix + bucket.key, bucket.bytecode_to_string())
-        if self.timeout is not None:
-            args += (self.timeout,)
-        try:
-            self.client.set(*args)
-        except Exception:
-            if not self.ignore_memcache_errors:
-                raise
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/compiler.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/compiler.py
deleted file mode 100644
index d534a8273..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/compiler.py
+++ /dev/null
@@ -1,1721 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.compiler
-    ~~~~~~~~~~~~~~~
-
-    Compiles nodes into python code.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from itertools import chain
-from copy import deepcopy
-from keyword import iskeyword as is_python_keyword
-from functools import update_wrapper
-from jinja2 import nodes
-from jinja2.nodes import EvalContext
-from jinja2.visitor import NodeVisitor
-from jinja2.optimizer import Optimizer
-from jinja2.exceptions import TemplateAssertionError
-from jinja2.utils import Markup, concat, escape
-from jinja2._compat import range_type, text_type, string_types, \
-     iteritems, NativeStringIO, imap, izip
-from jinja2.idtracking import Symbols, VAR_LOAD_PARAMETER, \
-     VAR_LOAD_RESOLVE, VAR_LOAD_ALIAS, VAR_LOAD_UNDEFINED
-
-
-operators = {
-    'eq':       '==',
-    'ne':       '!=',
-    'gt':       '>',
-    'gteq':     '>=',
-    'lt':       '<',
-    'lteq':     '<=',
-    'in':       'in',
-    'notin':    'not in'
-}
-
-# what method to iterate over items do we want to use for dict iteration
-# in generated code?  on 2.x let's go with iteritems, on 3.x with items
-if hasattr(dict, 'iteritems'):
-    dict_item_iter = 'iteritems'
-else:
-    dict_item_iter = 'items'
-
-code_features = ['division']
-
-# does this python version support generator stops? (PEP 0479)
-try:
-    exec('from __future__ import generator_stop')
-    code_features.append('generator_stop')
-except SyntaxError:
-    pass
-
-# does this python version support yield from?
-try:
-    exec('def f(): yield from x()')
-except SyntaxError:
-    supports_yield_from = False
-else:
-    supports_yield_from = True
-
-
-def optimizeconst(f):
-    def new_func(self, node, frame, **kwargs):
-        # Only optimize if the frame is not volatile
-        if self.optimized and not frame.eval_ctx.volatile:
-            new_node = self.optimizer.visit(node, frame.eval_ctx)
-            if new_node != node:
-                return self.visit(new_node, frame)
-        return f(self, node, frame, **kwargs)
-    return update_wrapper(new_func, f)
-
-
-def generate(node, environment, name, filename, stream=None,
-             defer_init=False, optimized=True):
-    """Generate the python source for a node tree."""
-    if not isinstance(node, nodes.Template):
-        raise TypeError('Can\'t compile non template nodes')
-    generator = environment.code_generator_class(environment, name, filename,
-                                                 stream, defer_init,
-                                                 optimized)
-    generator.visit(node)
-    if stream is None:
-        return generator.stream.getvalue()
-
-
-def has_safe_repr(value):
-    """Does the node have a safe representation?"""
-    if value is None or value is NotImplemented or value is Ellipsis:
-        return True
-    if type(value) in (bool, int, float, complex, range_type, Markup) + string_types:
-        return True
-    if type(value) in (tuple, list, set, frozenset):
-        for item in value:
-            if not has_safe_repr(item):
-                return False
-        return True
-    elif type(value) is dict:
-        for key, value in iteritems(value):
-            if not has_safe_repr(key):
-                return False
-            if not has_safe_repr(value):
-                return False
-        return True
-    return False
-
-
-def find_undeclared(nodes, names):
-    """Check if the names passed are accessed undeclared.  The return value
-    is a set of all the undeclared names from the sequence of names found.
-    """
-    visitor = UndeclaredNameVisitor(names)
-    try:
-        for node in nodes:
-            visitor.visit(node)
-    except VisitorExit:
-        pass
-    return visitor.undeclared
-
-
-class MacroRef(object):
-
-    def __init__(self, node):
-        self.node = node
-        self.accesses_caller = False
-        self.accesses_kwargs = False
-        self.accesses_varargs = False
-
-
-class Frame(object):
-    """Holds compile time information for us."""
-
-    def __init__(self, eval_ctx, parent=None, level=None):
-        self.eval_ctx = eval_ctx
-        self.symbols = Symbols(parent and parent.symbols or None,
-                               level=level)
-
-        # a toplevel frame is the root + soft frames such as if conditions.
-        self.toplevel = False
-
-        # the root frame is basically just the outermost frame, so no if
-        # conditions.  This information is used to optimize inheritance
-        # situations.
-        self.rootlevel = False
-
-        # in some dynamic inheritance situations the compiler needs to add
-        # write tests around output statements.
-        self.require_output_check = parent and parent.require_output_check
-
-        # inside some tags we are using a buffer rather than yield statements.
-        # this for example affects {% filter %} or {% macro %}.  If a frame
-        # is buffered this variable points to the name of the list used as
-        # buffer.
-        self.buffer = None
-
-        # the name of the block we're in, otherwise None.
-        self.block = parent and parent.block or None
-
-        # the parent of this frame
-        self.parent = parent
-
-        if parent is not None:
-            self.buffer = parent.buffer
-
-    def copy(self):
-        """Create a copy of the current one."""
-        rv = object.__new__(self.__class__)
-        rv.__dict__.update(self.__dict__)
-        rv.symbols = self.symbols.copy()
-        return rv
-
-    def inner(self, isolated=False):
-        """Return an inner frame."""
-        if isolated:
-            return Frame(self.eval_ctx, level=self.symbols.level + 1)
-        return Frame(self.eval_ctx, self)
-
-    def soft(self):
-        """Return a soft frame.  A soft frame may not be modified as
-        standalone thing as it shares the resources with the frame it
-        was created of, but it's not a rootlevel frame any longer.
-
-        This is only used to implement if-statements.
-        """
-        rv = self.copy()
-        rv.rootlevel = False
-        return rv
-
-    __copy__ = copy
-
-
-class VisitorExit(RuntimeError):
-    """Exception used by the `UndeclaredNameVisitor` to signal a stop."""
-
-
-class DependencyFinderVisitor(NodeVisitor):
-    """A visitor that collects filter and test calls."""
-
-    def __init__(self):
-        self.filters = set()
-        self.tests = set()
-
-    def visit_Filter(self, node):
-        self.generic_visit(node)
-        self.filters.add(node.name)
-
-    def visit_Test(self, node):
-        self.generic_visit(node)
-        self.tests.add(node.name)
-
-    def visit_Block(self, node):
-        """Stop visiting at blocks."""
-
-
-class UndeclaredNameVisitor(NodeVisitor):
-    """A visitor that checks if a name is accessed without being
-    declared.  This is different from the frame visitor as it will
-    not stop at closure frames.
-    """
-
-    def __init__(self, names):
-        self.names = set(names)
-        self.undeclared = set()
-
-    def visit_Name(self, node):
-        if node.ctx == 'load' and node.name in self.names:
-            self.undeclared.add(node.name)
-            if self.undeclared == self.names:
-                raise VisitorExit()
-        else:
-            self.names.discard(node.name)
-
-    def visit_Block(self, node):
-        """Stop visiting a blocks."""
-
-
-class CompilerExit(Exception):
-    """Raised if the compiler encountered a situation where it just
-    doesn't make sense to further process the code.  Any block that
-    raises such an exception is not further processed.
-    """
-
-
-class CodeGenerator(NodeVisitor):
-
-    def __init__(self, environment, name, filename, stream=None,
-                 defer_init=False, optimized=True):
-        if stream is None:
-            stream = NativeStringIO()
-        self.environment = environment
-        self.name = name
-        self.filename = filename
-        self.stream = stream
-        self.created_block_context = False
-        self.defer_init = defer_init
-        self.optimized = optimized
-        if optimized:
-            self.optimizer = Optimizer(environment)
-
-        # aliases for imports
-        self.import_aliases = {}
-
-        # a registry for all blocks.  Because blocks are moved out
-        # into the global python scope they are registered here
-        self.blocks = {}
-
-        # the number of extends statements so far
-        self.extends_so_far = 0
-
-        # some templates have a rootlevel extends.  In this case we
-        # can safely assume that we're a child template and do some
-        # more optimizations.
-        self.has_known_extends = False
-
-        # the current line number
-        self.code_lineno = 1
-
-        # registry of all filters and tests (global, not block local)
-        self.tests = {}
-        self.filters = {}
-
-        # the debug information
-        self.debug_info = []
-        self._write_debug_info = None
-
-        # the number of new lines before the next write()
-        self._new_lines = 0
-
-        # the line number of the last written statement
-        self._last_line = 0
-
-        # true if nothing was written so far.
-        self._first_write = True
-
-        # used by the `temporary_identifier` method to get new
-        # unique, temporary identifier
-        self._last_identifier = 0
-
-        # the current indentation
-        self._indentation = 0
-
-        # Tracks toplevel assignments
-        self._assign_stack = []
-
-        # Tracks parameter definition blocks
-        self._param_def_block = []
-
-        # Tracks the current context.
-        self._context_reference_stack = ['context']
-
-    # -- Various compilation helpers
-
-    def fail(self, msg, lineno):
-        """Fail with a :exc:`TemplateAssertionError`."""
-        raise TemplateAssertionError(msg, lineno, self.name, self.filename)
-
-    def temporary_identifier(self):
-        """Get a new unique identifier."""
-        self._last_identifier += 1
-        return 't_%d' % self._last_identifier
-
-    def buffer(self, frame):
-        """Enable buffering for the frame from that point onwards."""
-        frame.buffer = self.temporary_identifier()
-        self.writeline('%s = []' % frame.buffer)
-
-    def return_buffer_contents(self, frame, force_unescaped=False):
-        """Return the buffer contents of the frame."""
-        if not force_unescaped:
-            if frame.eval_ctx.volatile:
-                self.writeline('if context.eval_ctx.autoescape:')
-                self.indent()
-                self.writeline('return Markup(concat(%s))' % frame.buffer)
-                self.outdent()
-                self.writeline('else:')
-                self.indent()
-                self.writeline('return concat(%s)' % frame.buffer)
-                self.outdent()
-                return
-            elif frame.eval_ctx.autoescape:
-                self.writeline('return Markup(concat(%s))' % frame.buffer)
-                return
-        self.writeline('return concat(%s)' % frame.buffer)
-
-    def indent(self):
-        """Indent by one."""
-        self._indentation += 1
-
-    def outdent(self, step=1):
-        """Outdent by step."""
-        self._indentation -= step
-
-    def start_write(self, frame, node=None):
-        """Yield or write into the frame buffer."""
-        if frame.buffer is None:
-            self.writeline('yield ', node)
-        else:
-            self.writeline('%s.append(' % frame.buffer, node)
-
-    def end_write(self, frame):
-        """End the writing process started by `start_write`."""
-        if frame.buffer is not None:
-            self.write(')')
-
-    def simple_write(self, s, frame, node=None):
-        """Simple shortcut for start_write + write + end_write."""
-        self.start_write(frame, node)
-        self.write(s)
-        self.end_write(frame)
-
-    def blockvisit(self, nodes, frame):
-        """Visit a list of nodes as block in a frame.  If the current frame
-        is no buffer a dummy ``if 0: yield None`` is written automatically.
-        """
-        try:
-            self.writeline('pass')
-            for node in nodes:
-                self.visit(node, frame)
-        except CompilerExit:
-            pass
-
-    def write(self, x):
-        """Write a string into the output stream."""
-        if self._new_lines:
-            if not self._first_write:
-                self.stream.write('\n' * self._new_lines)
-                self.code_lineno += self._new_lines
-                if self._write_debug_info is not None:
-                    self.debug_info.append((self._write_debug_info,
-                                            self.code_lineno))
-                    self._write_debug_info = None
-            self._first_write = False
-            self.stream.write('    ' * self._indentation)
-            self._new_lines = 0
-        self.stream.write(x)
-
-    def writeline(self, x, node=None, extra=0):
-        """Combination of newline and write."""
-        self.newline(node, extra)
-        self.write(x)
-
-    def newline(self, node=None, extra=0):
-        """Add one or more newlines before the next write."""
-        self._new_lines = max(self._new_lines, 1 + extra)
-        if node is not None and node.lineno != self._last_line:
-            self._write_debug_info = node.lineno
-            self._last_line = node.lineno
-
-    def signature(self, node, frame, extra_kwargs=None):
-        """Writes a function call to the stream for the current node.
-        A leading comma is added automatically.  The extra keyword
-        arguments may not include python keywords otherwise a syntax
-        error could occour.  The extra keyword arguments should be given
-        as python dict.
-        """
-        # if any of the given keyword arguments is a python keyword
-        # we have to make sure that no invalid call is created.
-        kwarg_workaround = False
-        for kwarg in chain((x.key for x in node.kwargs), extra_kwargs or ()):
-            if is_python_keyword(kwarg):
-                kwarg_workaround = True
-                break
-
-        for arg in node.args:
-            self.write(', ')
-            self.visit(arg, frame)
-
-        if not kwarg_workaround:
-            for kwarg in node.kwargs:
-                self.write(', ')
-                self.visit(kwarg, frame)
-            if extra_kwargs is not None:
-                for key, value in iteritems(extra_kwargs):
-                    self.write(', %s=%s' % (key, value))
-        if node.dyn_args:
-            self.write(', *')
-            self.visit(node.dyn_args, frame)
-
-        if kwarg_workaround:
-            if node.dyn_kwargs is not None:
-                self.write(', **dict({')
-            else:
-                self.write(', **{')
-            for kwarg in node.kwargs:
-                self.write('%r: ' % kwarg.key)
-                self.visit(kwarg.value, frame)
-                self.write(', ')
-            if extra_kwargs is not None:
-                for key, value in iteritems(extra_kwargs):
-                    self.write('%r: %s, ' % (key, value))
-            if node.dyn_kwargs is not None:
-                self.write('}, **')
-                self.visit(node.dyn_kwargs, frame)
-                self.write(')')
-            else:
-                self.write('}')
-
-        elif node.dyn_kwargs is not None:
-            self.write(', **')
-            self.visit(node.dyn_kwargs, frame)
-
-    def pull_dependencies(self, nodes):
-        """Pull all the dependencies."""
-        visitor = DependencyFinderVisitor()
-        for node in nodes:
-            visitor.visit(node)
-        for dependency in 'filters', 'tests':
-            mapping = getattr(self, dependency)
-            for name in getattr(visitor, dependency):
-                if name not in mapping:
-                    mapping[name] = self.temporary_identifier()
-                self.writeline('%s = environment.%s[%r]' %
-                               (mapping[name], dependency, name))
-
-    def enter_frame(self, frame):
-        undefs = []
-        for target, (action, param) in iteritems(frame.symbols.loads):
-            if action == VAR_LOAD_PARAMETER:
-                pass
-            elif action == VAR_LOAD_RESOLVE:
-                self.writeline('%s = %s(%r)' %
-                               (target, self.get_resolve_func(), param))
-            elif action == VAR_LOAD_ALIAS:
-                self.writeline('%s = %s' % (target, param))
-            elif action == VAR_LOAD_UNDEFINED:
-                undefs.append(target)
-            else:
-                raise NotImplementedError('unknown load instruction')
-        if undefs:
-            self.writeline('%s = missing' % ' = '.join(undefs))
-
-    def leave_frame(self, frame, with_python_scope=False):
-        if not with_python_scope:
-            undefs = []
-            for target, _ in iteritems(frame.symbols.loads):
-                undefs.append(target)
-            if undefs:
-                self.writeline('%s = missing' % ' = '.join(undefs))
-
-    def func(self, name):
-        if self.environment.is_async:
-            return 'async def %s' % name
-        return 'def %s' % name
-
-    def macro_body(self, node, frame):
-        """Dump the function def of a macro or call block."""
-        frame = frame.inner()
-        frame.symbols.analyze_node(node)
-        macro_ref = MacroRef(node)
-
-        explicit_caller = None
-        skip_special_params = set()
-        args = []
-        for idx, arg in enumerate(node.args):
-            if arg.name == 'caller':
-                explicit_caller = idx
-            if arg.name in ('kwargs', 'varargs'):
-                skip_special_params.add(arg.name)
-            args.append(frame.symbols.ref(arg.name))
-
-        undeclared = find_undeclared(node.body, ('caller', 'kwargs', 'varargs'))
-
-        if 'caller' in undeclared:
-            # In older Jinja2 versions there was a bug that allowed caller
-            # to retain the special behavior even if it was mentioned in
-            # the argument list.  However thankfully this was only really
-            # working if it was the last argument.  So we are explicitly
-            # checking this now and error out if it is anywhere else in
-            # the argument list.
-            if explicit_caller is not None:
-                try:
-                    node.defaults[explicit_caller - len(node.args)]
-                except IndexError:
-                    self.fail('When defining macros or call blocks the '
-                              'special "caller" argument must be omitted '
-                              'or be given a default.', node.lineno)
-            else:
-                args.append(frame.symbols.declare_parameter('caller'))
-            macro_ref.accesses_caller = True
-        if 'kwargs' in undeclared and not 'kwargs' in skip_special_params:
-            args.append(frame.symbols.declare_parameter('kwargs'))
-            macro_ref.accesses_kwargs = True
-        if 'varargs' in undeclared and not 'varargs' in skip_special_params:
-            args.append(frame.symbols.declare_parameter('varargs'))
-            macro_ref.accesses_varargs = True
-
-        # macros are delayed, they never require output checks
-        frame.require_output_check = False
-        frame.symbols.analyze_node(node)
-        self.writeline('%s(%s):' % (self.func('macro'), ', '.join(args)), node)
-        self.indent()
-
-        self.buffer(frame)
-        self.enter_frame(frame)
-
-        self.push_parameter_definitions(frame)
-        for idx, arg in enumerate(node.args):
-            ref = frame.symbols.ref(arg.name)
-            self.writeline('if %s is missing:' % ref)
-            self.indent()
-            try:
-                default = node.defaults[idx - len(node.args)]
-            except IndexError:
-                self.writeline('%s = undefined(%r, name=%r)' % (
-                    ref,
-                    'parameter %r was not provided' % arg.name,
-                    arg.name))
-            else:
-                self.writeline('%s = ' % ref)
-                self.visit(default, frame)
-            self.mark_parameter_stored(ref)
-            self.outdent()
-        self.pop_parameter_definitions()
-
-        self.blockvisit(node.body, frame)
-        self.return_buffer_contents(frame, force_unescaped=True)
-        self.leave_frame(frame, with_python_scope=True)
-        self.outdent()
-
-        return frame, macro_ref
-
-    def macro_def(self, macro_ref, frame):
-        """Dump the macro definition for the def created by macro_body."""
-        arg_tuple = ', '.join(repr(x.name) for x in macro_ref.node.args)
-        name = getattr(macro_ref.node, 'name', None)
-        if len(macro_ref.node.args) == 1:
-            arg_tuple += ','
-        self.write('Macro(environment, macro, %r, (%s), %r, %r, %r, '
-                   'context.eval_ctx.autoescape)' %
-                   (name, arg_tuple, macro_ref.accesses_kwargs,
-                    macro_ref.accesses_varargs, macro_ref.accesses_caller))
-
-    def position(self, node):
-        """Return a human readable position for the node."""
-        rv = 'line %d' % node.lineno
-        if self.name is not None:
-            rv += ' in ' + repr(self.name)
-        return rv
-
-    def dump_local_context(self, frame):
-        return '{%s}' % ', '.join(
-            '%r: %s' % (name, target) for name, target
-            in iteritems(frame.symbols.dump_stores()))
-
-    def write_commons(self):
-        """Writes a common preamble that is used by root and block functions.
-        Primarily this sets up common local helpers and enforces a generator
-        through a dead branch.
-        """
-        self.writeline('resolve = context.resolve_or_missing')
-        self.writeline('undefined = environment.undefined')
-        self.writeline('if 0: yield None')
-
-    def push_parameter_definitions(self, frame):
-        """Pushes all parameter targets from the given frame into a local
-        stack that permits tracking of yet to be assigned parameters.  In
-        particular this enables the optimization from `visit_Name` to skip
-        undefined expressions for parameters in macros as macros can reference
-        otherwise unbound parameters.
-        """
-        self._param_def_block.append(frame.symbols.dump_param_targets())
-
-    def pop_parameter_definitions(self):
-        """Pops the current parameter definitions set."""
-        self._param_def_block.pop()
-
-    def mark_parameter_stored(self, target):
-        """Marks a parameter in the current parameter definitions as stored.
-        This will skip the enforced undefined checks.
-        """
-        if self._param_def_block:
-            self._param_def_block[-1].discard(target)
-
-    def push_context_reference(self, target):
-        self._context_reference_stack.append(target)
-
-    def pop_context_reference(self):
-        self._context_reference_stack.pop()
-
-    def get_context_ref(self):
-        return self._context_reference_stack[-1]
-
-    def get_resolve_func(self):
-        target = self._context_reference_stack[-1]
-        if target == 'context':
-            return 'resolve'
-        return '%s.resolve' % target
-
-    def derive_context(self, frame):
-        return '%s.derived(%s)' % (
-            self.get_context_ref(),
-            self.dump_local_context(frame),
-        )
-
-    def parameter_is_undeclared(self, target):
-        """Checks if a given target is an undeclared parameter."""
-        if not self._param_def_block:
-            return False
-        return target in self._param_def_block[-1]
-
-    def push_assign_tracking(self):
-        """Pushes a new layer for assignment tracking."""
-        self._assign_stack.append(set())
-
-    def pop_assign_tracking(self, frame):
-        """Pops the topmost level for assignment tracking and updates the
-        context variables if necessary.
-        """
-        vars = self._assign_stack.pop()
-        if not frame.toplevel or not vars:
-            return
-        public_names = [x for x in vars if x[:1] != '_']
-        if len(vars) == 1:
-            name = next(iter(vars))
-            ref = frame.symbols.ref(name)
-            self.writeline('context.vars[%r] = %s' % (name, ref))
-        else:
-            self.writeline('context.vars.update({')
-            for idx, name in enumerate(vars):
-                if idx:
-                    self.write(', ')
-                ref = frame.symbols.ref(name)
-                self.write('%r: %s' % (name, ref))
-            self.write('})')
-        if public_names:
-            if len(public_names) == 1:
-                self.writeline('context.exported_vars.add(%r)' %
-                               public_names[0])
-            else:
-                self.writeline('context.exported_vars.update((%s))' %
-                               ', '.join(imap(repr, public_names)))
-
-    # -- Statement Visitors
-
-    def visit_Template(self, node, frame=None):
-        assert frame is None, 'no root frame allowed'
-        eval_ctx = EvalContext(self.environment, self.name)
-
-        from jinja2.runtime import __all__ as exported
-        self.writeline('from __future__ import %s' % ', '.join(code_features))
-        self.writeline('from jinja2.runtime import ' + ', '.join(exported))
-
-        if self.environment.is_async:
-            self.writeline('from jinja2.asyncsupport import auto_await, '
-                           'auto_aiter, make_async_loop_context')
-
-        # if we want a deferred initialization we cannot move the
-        # environment into a local name
-        envenv = not self.defer_init and ', environment=environment' or ''
-
-        # do we have an extends tag at all?  If not, we can save some
-        # overhead by just not processing any inheritance code.
-        have_extends = node.find(nodes.Extends) is not None
-
-        # find all blocks
-        for block in node.find_all(nodes.Block):
-            if block.name in self.blocks:
-                self.fail('block %r defined twice' % block.name, block.lineno)
-            self.blocks[block.name] = block
-
-        # find all imports and import them
-        for import_ in node.find_all(nodes.ImportedName):
-            if import_.importname not in self.import_aliases:
-                imp = import_.importname
-                self.import_aliases[imp] = alias = self.temporary_identifier()
-                if '.' in imp:
-                    module, obj = imp.rsplit('.', 1)
-                    self.writeline('from %s import %s as %s' %
-                                   (module, obj, alias))
-                else:
-                    self.writeline('import %s as %s' % (imp, alias))
-
-        # add the load name
-        self.writeline('name = %r' % self.name)
-
-        # generate the root render function.
-        self.writeline('%s(context, missing=missing%s):' %
-                       (self.func('root'), envenv), extra=1)
-        self.indent()
-        self.write_commons()
-
-        # process the root
-        frame = Frame(eval_ctx)
-        if 'self' in find_undeclared(node.body, ('self',)):
-            ref = frame.symbols.declare_parameter('self')
-            self.writeline('%s = TemplateReference(context)' % ref)
-        frame.symbols.analyze_node(node)
-        frame.toplevel = frame.rootlevel = True
-        frame.require_output_check = have_extends and not self.has_known_extends
-        if have_extends:
-            self.writeline('parent_template = None')
-        self.enter_frame(frame)
-        self.pull_dependencies(node.body)
-        self.blockvisit(node.body, frame)
-        self.leave_frame(frame, with_python_scope=True)
-        self.outdent()
-
-        # make sure that the parent root is called.
-        if have_extends:
-            if not self.has_known_extends:
-                self.indent()
-                self.writeline('if parent_template is not None:')
-            self.indent()
-            if supports_yield_from and not self.environment.is_async:
-                self.writeline('yield from parent_template.'
-                               'root_render_func(context)')
-            else:
-                self.writeline('%sfor event in parent_template.'
-                               'root_render_func(context):' %
-                               (self.environment.is_async and 'async ' or ''))
-                self.indent()
-                self.writeline('yield event')
-                self.outdent()
-            self.outdent(1 + (not self.has_known_extends))
-
-        # at this point we now have the blocks collected and can visit them too.
-        for name, block in iteritems(self.blocks):
-            self.writeline('%s(context, missing=missing%s):' %
-                           (self.func('block_' + name), envenv),
-                           block, 1)
-            self.indent()
-            self.write_commons()
-            # It's important that we do not make this frame a child of the
-            # toplevel template.  This would cause a variety of
-            # interesting issues with identifier tracking.
-            block_frame = Frame(eval_ctx)
-            undeclared = find_undeclared(block.body, ('self', 'super'))
-            if 'self' in undeclared:
-                ref = block_frame.symbols.declare_parameter('self')
-                self.writeline('%s = TemplateReference(context)' % ref)
-            if 'super' in undeclared:
-                ref = block_frame.symbols.declare_parameter('super')
-                self.writeline('%s = context.super(%r, '
-                               'block_%s)' % (ref, name, name))
-            block_frame.symbols.analyze_node(block)
-            block_frame.block = name
-            self.enter_frame(block_frame)
-            self.pull_dependencies(block.body)
-            self.blockvisit(block.body, block_frame)
-            self.leave_frame(block_frame, with_python_scope=True)
-            self.outdent()
-
-        self.writeline('blocks = {%s}' % ', '.join('%r: block_%s' % (x, x)
-                                                   for x in self.blocks),
-                       extra=1)
-
-        # add a function that returns the debug info
-        self.writeline('debug_info = %r' % '&'.join('%s=%s' % x for x
-                                                    in self.debug_info))
-
-    def visit_Block(self, node, frame):
-        """Call a block and register it for the template."""
-        level = 0
-        if frame.toplevel:
-            # if we know that we are a child template, there is no need to
-            # check if we are one
-            if self.has_known_extends:
-                return
-            if self.extends_so_far > 0:
-                self.writeline('if parent_template is None:')
-                self.indent()
-                level += 1
-
-        if node.scoped:
-            context = self.derive_context(frame)
-        else:
-            context = self.get_context_ref()
-
-        if supports_yield_from and not self.environment.is_async and \
-           frame.buffer is None:
-            self.writeline('yield from context.blocks[%r][0](%s)' % (
-                           node.name, context), node)
-        else:
-            loop = self.environment.is_async and 'async for' or 'for'
-            self.writeline('%s event in context.blocks[%r][0](%s):' % (
-                           loop, node.name, context), node)
-            self.indent()
-            self.simple_write('event', frame)
-            self.outdent()
-
-        self.outdent(level)
-
-    def visit_Extends(self, node, frame):
-        """Calls the extender."""
-        if not frame.toplevel:
-            self.fail('cannot use extend from a non top-level scope',
-                      node.lineno)
-
-        # if the number of extends statements in general is zero so
-        # far, we don't have to add a check if something extended
-        # the template before this one.
-        if self.extends_so_far > 0:
-
-            # if we have a known extends we just add a template runtime
-            # error into the generated code.  We could catch that at compile
-            # time too, but i welcome it not to confuse users by throwing the
-            # same error at different times just "because we can".
-            if not self.has_known_extends:
-                self.writeline('if parent_template is not None:')
-                self.indent()
-            self.writeline('raise TemplateRuntimeError(%r)' %
-                           'extended multiple times')
-
-            # if we have a known extends already we don't need that code here
-            # as we know that the template execution will end here.
-            if self.has_known_extends:
-                raise CompilerExit()
-            else:
-                self.outdent()
-
-        self.writeline('parent_template = environment.get_template(', node)
-        self.visit(node.template, frame)
-        self.write(', %r)' % self.name)
-        self.writeline('for name, parent_block in parent_template.'
-                       'blocks.%s():' % dict_item_iter)
-        self.indent()
-        self.writeline('context.blocks.setdefault(name, []).'
-                       'append(parent_block)')
-        self.outdent()
-
-        # if this extends statement was in the root level we can take
-        # advantage of that information and simplify the generated code
-        # in the top level from this point onwards
-        if frame.rootlevel:
-            self.has_known_extends = True
-
-        # and now we have one more
-        self.extends_so_far += 1
-
-    def visit_Include(self, node, frame):
-        """Handles includes."""
-        if node.ignore_missing:
-            self.writeline('try:')
-            self.indent()
-
-        func_name = 'get_or_select_template'
-        if isinstance(node.template, nodes.Const):
-            if isinstance(node.template.value, string_types):
-                func_name = 'get_template'
-            elif isinstance(node.template.value, (tuple, list)):
-                func_name = 'select_template'
-        elif isinstance(node.template, (nodes.Tuple, nodes.List)):
-            func_name = 'select_template'
-
-        self.writeline('template = environment.%s(' % func_name, node)
-        self.visit(node.template, frame)
-        self.write(', %r)' % self.name)
-        if node.ignore_missing:
-            self.outdent()
-            self.writeline('except TemplateNotFound:')
-            self.indent()
-            self.writeline('pass')
-            self.outdent()
-            self.writeline('else:')
-            self.indent()
-
-        skip_event_yield = False
-        if node.with_context:
-            loop = self.environment.is_async and 'async for' or 'for'
-            self.writeline('%s event in template.root_render_func('
-                           'template.new_context(context.get_all(), True, '
-                           '%s)):' % (loop, self.dump_local_context(frame)))
-        elif self.environment.is_async:
-            self.writeline('for event in (await '
-                           'template._get_default_module_async())'
-                           '._body_stream:')
-        else:
-            if supports_yield_from:
-                self.writeline('yield from template._get_default_module()'
-                               '._body_stream')
-                skip_event_yield = True
-            else:
-                self.writeline('for event in template._get_default_module()'
-                               '._body_stream:')
-
-        if not skip_event_yield:
-            self.indent()
-            self.simple_write('event', frame)
-            self.outdent()
-
-        if node.ignore_missing:
-            self.outdent()
-
-    def visit_Import(self, node, frame):
-        """Visit regular imports."""
-        self.writeline('%s = ' % frame.symbols.ref(node.target), node)
-        if frame.toplevel:
-            self.write('context.vars[%r] = ' % node.target)
-        if self.environment.is_async:
-            self.write('await ')
-        self.write('environment.get_template(')
-        self.visit(node.template, frame)
-        self.write(', %r).' % self.name)
-        if node.with_context:
-            self.write('make_module%s(context.get_all(), True, %s)'
-                       % (self.environment.is_async and '_async' or '',
-                          self.dump_local_context(frame)))
-        elif self.environment.is_async:
-            self.write('_get_default_module_async()')
-        else:
-            self.write('_get_default_module()')
-        if frame.toplevel and not node.target.startswith('_'):
-            self.writeline('context.exported_vars.discard(%r)' % node.target)
-
-    def visit_FromImport(self, node, frame):
-        """Visit named imports."""
-        self.newline(node)
-        self.write('included_template = %senvironment.get_template('
-                   % (self.environment.is_async and 'await ' or ''))
-        self.visit(node.template, frame)
-        self.write(', %r).' % self.name)
-        if node.with_context:
-            self.write('make_module%s(context.get_all(), True, %s)'
-                       % (self.environment.is_async and '_async' or '',
-                          self.dump_local_context(frame)))
-        elif self.environment.is_async:
-            self.write('_get_default_module_async()')
-        else:
-            self.write('_get_default_module()')
-
-        var_names = []
-        discarded_names = []
-        for name in node.names:
-            if isinstance(name, tuple):
-                name, alias = name
-            else:
-                alias = name
-            self.writeline('%s = getattr(included_template, '
-                           '%r, missing)' % (frame.symbols.ref(alias), name))
-            self.writeline('if %s is missing:' % frame.symbols.ref(alias))
-            self.indent()
-            self.writeline('%s = undefined(%r %% '
-                           'included_template.__name__, '
-                           'name=%r)' %
-                           (frame.symbols.ref(alias),
-                            'the template %%r (imported on %s) does '
-                            'not export the requested name %s' % (
-                                self.position(node),
-                                repr(name)
-                           ), name))
-            self.outdent()
-            if frame.toplevel:
-                var_names.append(alias)
-                if not alias.startswith('_'):
-                    discarded_names.append(alias)
-
-        if var_names:
-            if len(var_names) == 1:
-                name = var_names[0]
-                self.writeline('context.vars[%r] = %s' %
-                               (name, frame.symbols.ref(name)))
-            else:
-                self.writeline('context.vars.update({%s})' % ', '.join(
-                    '%r: %s' % (name, frame.symbols.ref(name)) for name in var_names
-                ))
-        if discarded_names:
-            if len(discarded_names) == 1:
-                self.writeline('context.exported_vars.discard(%r)' %
-                               discarded_names[0])
-            else:
-                self.writeline('context.exported_vars.difference_'
-                               'update((%s))' % ', '.join(imap(repr, discarded_names)))
-
-    def visit_For(self, node, frame):
-        loop_frame = frame.inner()
-        test_frame = frame.inner()
-        else_frame = frame.inner()
-
-        # try to figure out if we have an extended loop.  An extended loop
-        # is necessary if the loop is in recursive mode if the special loop
-        # variable is accessed in the body.
-        extended_loop = node.recursive or 'loop' in \
-                        find_undeclared(node.iter_child_nodes(
-                            only=('body',)), ('loop',))
-
-        loop_ref = None
-        if extended_loop:
-            loop_ref = loop_frame.symbols.declare_parameter('loop')
-
-        loop_frame.symbols.analyze_node(node, for_branch='body')
-        if node.else_:
-            else_frame.symbols.analyze_node(node, for_branch='else')
-
-        if node.test:
-            loop_filter_func = self.temporary_identifier()
-            test_frame.symbols.analyze_node(node, for_branch='test')
-            self.writeline('%s(fiter):' % self.func(loop_filter_func), node.test)
-            self.indent()
-            self.enter_frame(test_frame)
-            self.writeline(self.environment.is_async and 'async for ' or 'for ')
-            self.visit(node.target, loop_frame)
-            self.write(' in ')
-            self.write(self.environment.is_async and 'auto_aiter(fiter)' or 'fiter')
-            self.write(':')
-            self.indent()
-            self.writeline('if ', node.test)
-            self.visit(node.test, test_frame)
-            self.write(':')
-            self.indent()
-            self.writeline('yield ')
-            self.visit(node.target, loop_frame)
-            self.outdent(3)
-            self.leave_frame(test_frame, with_python_scope=True)
-
-        # if we don't have an recursive loop we have to find the shadowed
-        # variables at that point.  Because loops can be nested but the loop
-        # variable is a special one we have to enforce aliasing for it.
-        if node.recursive:
-            self.writeline('%s(reciter, loop_render_func, depth=0):' %
-                           self.func('loop'), node)
-            self.indent()
-            self.buffer(loop_frame)
-
-            # Use the same buffer for the else frame
-            else_frame.buffer = loop_frame.buffer
-
-        # make sure the loop variable is a special one and raise a template
-        # assertion error if a loop tries to write to loop
-        if extended_loop:
-            self.writeline('%s = missing' % loop_ref)
-
-        for name in node.find_all(nodes.Name):
-            if name.ctx == 'store' and name.name == 'loop':
-                self.fail('Can\'t assign to special loop variable '
-                          'in for-loop target', name.lineno)
-
-        if node.else_:
-            iteration_indicator = self.temporary_identifier()
-            self.writeline('%s = 1' % iteration_indicator)
-
-        self.writeline(self.environment.is_async and 'async for ' or 'for ', node)
-        self.visit(node.target, loop_frame)
-        if extended_loop:
-            if self.environment.is_async:
-                self.write(', %s in await make_async_loop_context(' % loop_ref)
-            else:
-                self.write(', %s in LoopContext(' % loop_ref)
-        else:
-            self.write(' in ')
-
-        if node.test:
-            self.write('%s(' % loop_filter_func)
-        if node.recursive:
-            self.write('reciter')
-        else:
-            if self.environment.is_async and not extended_loop:
-                self.write('auto_aiter(')
-            self.visit(node.iter, frame)
-            if self.environment.is_async and not extended_loop:
-                self.write(')')
-        if node.test:
-            self.write(')')
-
-        if node.recursive:
-            self.write(', undefined, loop_render_func, depth):')
-        else:
-            self.write(extended_loop and ', undefined):' or ':')
-
-        self.indent()
-        self.enter_frame(loop_frame)
-
-        self.blockvisit(node.body, loop_frame)
-        if node.else_:
-            self.writeline('%s = 0' % iteration_indicator)
-        self.outdent()
-        self.leave_frame(loop_frame, with_python_scope=node.recursive
-                         and not node.else_)
-
-        if node.else_:
-            self.writeline('if %s:' % iteration_indicator)
-            self.indent()
-            self.enter_frame(else_frame)
-            self.blockvisit(node.else_, else_frame)
-            self.leave_frame(else_frame)
-            self.outdent()
-
-        # if the node was recursive we have to return the buffer contents
-        # and start the iteration code
-        if node.recursive:
-            self.return_buffer_contents(loop_frame)
-            self.outdent()
-            self.start_write(frame, node)
-            if self.environment.is_async:
-                self.write('await ')
-            self.write('loop(')
-            if self.environment.is_async:
-                self.write('auto_aiter(')
-            self.visit(node.iter, frame)
-            if self.environment.is_async:
-                self.write(')')
-            self.write(', loop)')
-            self.end_write(frame)
-
-    def visit_If(self, node, frame):
-        if_frame = frame.soft()
-        self.writeline('if ', node)
-        self.visit(node.test, if_frame)
-        self.write(':')
-        self.indent()
-        self.blockvisit(node.body, if_frame)
-        self.outdent()
-        for elif_ in node.elif_:
-            self.writeline('elif ', elif_)
-            self.visit(elif_.test, if_frame)
-            self.write(':')
-            self.indent()
-            self.blockvisit(elif_.body, if_frame)
-            self.outdent()
-        if node.else_:
-            self.writeline('else:')
-            self.indent()
-            self.blockvisit(node.else_, if_frame)
-            self.outdent()
-
-    def visit_Macro(self, node, frame):
-        macro_frame, macro_ref = self.macro_body(node, frame)
-        self.newline()
-        if frame.toplevel:
-            if not node.name.startswith('_'):
-                self.write('context.exported_vars.add(%r)' % node.name)
-            ref = frame.symbols.ref(node.name)
-            self.writeline('context.vars[%r] = ' % node.name)
-        self.write('%s = ' % frame.symbols.ref(node.name))
-        self.macro_def(macro_ref, macro_frame)
-
-    def visit_CallBlock(self, node, frame):
-        call_frame, macro_ref = self.macro_body(node, frame)
-        self.writeline('caller = ')
-        self.macro_def(macro_ref, call_frame)
-        self.start_write(frame, node)
-        self.visit_Call(node.call, frame, forward_caller=True)
-        self.end_write(frame)
-
-    def visit_FilterBlock(self, node, frame):
-        filter_frame = frame.inner()
-        filter_frame.symbols.analyze_node(node)
-        self.enter_frame(filter_frame)
-        self.buffer(filter_frame)
-        self.blockvisit(node.body, filter_frame)
-        self.start_write(frame, node)
-        self.visit_Filter(node.filter, filter_frame)
-        self.end_write(frame)
-        self.leave_frame(filter_frame)
-
-    def visit_With(self, node, frame):
-        with_frame = frame.inner()
-        with_frame.symbols.analyze_node(node)
-        self.enter_frame(with_frame)
-        for idx, (target, expr) in enumerate(izip(node.targets, node.values)):
-            self.newline()
-            self.visit(target, with_frame)
-            self.write(' = ')
-            self.visit(expr, frame)
-        self.blockvisit(node.body, with_frame)
-        self.leave_frame(with_frame)
-
-    def visit_ExprStmt(self, node, frame):
-        self.newline(node)
-        self.visit(node.node, frame)
-
-    def visit_Output(self, node, frame):
-        # if we have a known extends statement, we don't output anything
-        # if we are in a require_output_check section
-        if self.has_known_extends and frame.require_output_check:
-            return
-
-        allow_constant_finalize = True
-        if self.environment.finalize:
-            func = self.environment.finalize
-            if getattr(func, 'contextfunction', False) or \
-               getattr(func, 'evalcontextfunction', False):
-                allow_constant_finalize = False
-            elif getattr(func, 'environmentfunction', False):
-                finalize = lambda x: text_type(
-                    self.environment.finalize(self.environment, x))
-            else:
-                finalize = lambda x: text_type(self.environment.finalize(x))
-        else:
-            finalize = text_type
-
-        # if we are inside a frame that requires output checking, we do so
-        outdent_later = False
-        if frame.require_output_check:
-            self.writeline('if parent_template is None:')
-            self.indent()
-            outdent_later = True
-
-        # try to evaluate as many chunks as possible into a static
-        # string at compile time.
-        body = []
-        for child in node.nodes:
-            try:
-                if not allow_constant_finalize:
-                    raise nodes.Impossible()
-                const = child.as_const(frame.eval_ctx)
-            except nodes.Impossible:
-                body.append(child)
-                continue
-            # the frame can't be volatile here, becaus otherwise the
-            # as_const() function would raise an Impossible exception
-            # at that point.
-            try:
-                if frame.eval_ctx.autoescape:
-                    if hasattr(const, '__html__'):
-                        const = const.__html__()
-                    else:
-                        const = escape(const)
-                const = finalize(const)
-            except Exception:
-                # if something goes wrong here we evaluate the node
-                # at runtime for easier debugging
-                body.append(child)
-                continue
-            if body and isinstance(body[-1], list):
-                body[-1].append(const)
-            else:
-                body.append([const])
-
-        # if we have less than 3 nodes or a buffer we yield or extend/append
-        if len(body) < 3 or frame.buffer is not None:
-            if frame.buffer is not None:
-                # for one item we append, for more we extend
-                if len(body) == 1:
-                    self.writeline('%s.append(' % frame.buffer)
-                else:
-                    self.writeline('%s.extend((' % frame.buffer)
-                self.indent()
-            for item in body:
-                if isinstance(item, list):
-                    val = repr(concat(item))
-                    if frame.buffer is None:
-                        self.writeline('yield ' + val)
-                    else:
-                        self.writeline(val + ',')
-                else:
-                    if frame.buffer is None:
-                        self.writeline('yield ', item)
-                    else:
-                        self.newline(item)
-                    close = 1
-                    if frame.eval_ctx.volatile:
-                        self.write('(escape if context.eval_ctx.autoescape'
-                                   ' else to_string)(')
-                    elif frame.eval_ctx.autoescape:
-                        self.write('escape(')
-                    else:
-                        self.write('to_string(')
-                    if self.environment.finalize is not None:
-                        self.write('environment.finalize(')
-                        if getattr(self.environment.finalize,
-                                   "contextfunction", False):
-                            self.write('context, ')
-                        close += 1
-                    self.visit(item, frame)
-                    self.write(')' * close)
-                    if frame.buffer is not None:
-                        self.write(',')
-            if frame.buffer is not None:
-                # close the open parentheses
-                self.outdent()
-                self.writeline(len(body) == 1 and ')' or '))')
-
-        # otherwise we create a format string as this is faster in that case
-        else:
-            format = []
-            arguments = []
-            for item in body:
-                if isinstance(item, list):
-                    format.append(concat(item).replace('%', '%%'))
-                else:
-                    format.append('%s')
-                    arguments.append(item)
-            self.writeline('yield ')
-            self.write(repr(concat(format)) + ' % (')
-            self.indent()
-            for argument in arguments:
-                self.newline(argument)
-                close = 0
-                if frame.eval_ctx.volatile:
-                    self.write('(escape if context.eval_ctx.autoescape else'
-                               ' to_string)(')
-                    close += 1
-                elif frame.eval_ctx.autoescape:
-                    self.write('escape(')
-                    close += 1
-                if self.environment.finalize is not None:
-                    self.write('environment.finalize(')
-                    if getattr(self.environment.finalize,
-                               'contextfunction', False):
-                        self.write('context, ')
-                    elif getattr(self.environment.finalize,
-                               'evalcontextfunction', False):
-                        self.write('context.eval_ctx, ')
-                    elif getattr(self.environment.finalize,
-                               'environmentfunction', False):
-                        self.write('environment, ')
-                    close += 1
-                self.visit(argument, frame)
-                self.write(')' * close + ', ')
-            self.outdent()
-            self.writeline(')')
-
-        if outdent_later:
-            self.outdent()
-
-    def visit_Assign(self, node, frame):
-        self.push_assign_tracking()
-        self.newline(node)
-        self.visit(node.target, frame)
-        self.write(' = ')
-        self.visit(node.node, frame)
-        self.pop_assign_tracking(frame)
-
-    def visit_AssignBlock(self, node, frame):
-        self.push_assign_tracking()
-        block_frame = frame.inner()
-        # This is a special case.  Since a set block always captures we
-        # will disable output checks.  This way one can use set blocks
-        # toplevel even in extended templates.
-        block_frame.require_output_check = False
-        block_frame.symbols.analyze_node(node)
-        self.enter_frame(block_frame)
-        self.buffer(block_frame)
-        self.blockvisit(node.body, block_frame)
-        self.newline(node)
-        self.visit(node.target, frame)
-        self.write(' = (Markup if context.eval_ctx.autoescape '
-                   'else identity)(')
-        if node.filter is not None:
-            self.visit_Filter(node.filter, block_frame)
-        else:
-            self.write('concat(%s)' % block_frame.buffer)
-        self.write(')')
-        self.pop_assign_tracking(frame)
-        self.leave_frame(block_frame)
-
-    # -- Expression Visitors
-
-    def visit_Name(self, node, frame):
-        if node.ctx == 'store' and frame.toplevel:
-            if self._assign_stack:
-                self._assign_stack[-1].add(node.name)
-        ref = frame.symbols.ref(node.name)
-
-        # If we are looking up a variable we might have to deal with the
-        # case where it's undefined.  We can skip that case if the load
-        # instruction indicates a parameter which are always defined.
-        if node.ctx == 'load':
-            load = frame.symbols.find_load(ref)
-            if not (load is not None and load[0] == VAR_LOAD_PARAMETER and \
-                    not self.parameter_is_undeclared(ref)):
-                self.write('(undefined(name=%r) if %s is missing else %s)' %
-                           (node.name, ref, ref))
-                return
-
-        self.write(ref)
-
-    def visit_NSRef(self, node, frame):
-        # NSRefs can only be used to store values; since they use the normal
-        # `foo.bar` notation they will be parsed as a normal attribute access
-        # when used anywhere but in a `set` context
-        ref = frame.symbols.ref(node.name)
-        self.writeline('if not isinstance(%s, Namespace):' % ref)
-        self.indent()
-        self.writeline('raise TemplateRuntimeError(%r)' %
-                       'cannot assign attribute on non-namespace object')
-        self.outdent()
-        self.writeline('%s[%r]' % (ref, node.attr))
-
-    def visit_Const(self, node, frame):
-        val = node.as_const(frame.eval_ctx)
-        if isinstance(val, float):
-            self.write(str(val))
-        else:
-            self.write(repr(val))
-
-    def visit_TemplateData(self, node, frame):
-        try:
-            self.write(repr(node.as_const(frame.eval_ctx)))
-        except nodes.Impossible:
-            self.write('(Markup if context.eval_ctx.autoescape else identity)(%r)'
-                       % node.data)
-
-    def visit_Tuple(self, node, frame):
-        self.write('(')
-        idx = -1
-        for idx, item in enumerate(node.items):
-            if idx:
-                self.write(', ')
-            self.visit(item, frame)
-        self.write(idx == 0 and ',)' or ')')
-
-    def visit_List(self, node, frame):
-        self.write('[')
-        for idx, item in enumerate(node.items):
-            if idx:
-                self.write(', ')
-            self.visit(item, frame)
-        self.write(']')
-
-    def visit_Dict(self, node, frame):
-        self.write('{')
-        for idx, item in enumerate(node.items):
-            if idx:
-                self.write(', ')
-            self.visit(item.key, frame)
-            self.write(': ')
-            self.visit(item.value, frame)
-        self.write('}')
-
-    def binop(operator, interceptable=True):
-        @optimizeconst
-        def visitor(self, node, frame):
-            if self.environment.sandboxed and \
-               operator in self.environment.intercepted_binops:
-                self.write('environment.call_binop(context, %r, ' % operator)
-                self.visit(node.left, frame)
-                self.write(', ')
-                self.visit(node.right, frame)
-            else:
-                self.write('(')
-                self.visit(node.left, frame)
-                self.write(' %s ' % operator)
-                self.visit(node.right, frame)
-            self.write(')')
-        return visitor
-
-    def uaop(operator, interceptable=True):
-        @optimizeconst
-        def visitor(self, node, frame):
-            if self.environment.sandboxed and \
-               operator in self.environment.intercepted_unops:
-                self.write('environment.call_unop(context, %r, ' % operator)
-                self.visit(node.node, frame)
-            else:
-                self.write('(' + operator)
-                self.visit(node.node, frame)
-            self.write(')')
-        return visitor
-
-    visit_Add = binop('+')
-    visit_Sub = binop('-')
-    visit_Mul = binop('*')
-    visit_Div = binop('/')
-    visit_FloorDiv = binop('//')
-    visit_Pow = binop('**')
-    visit_Mod = binop('%')
-    visit_And = binop('and', interceptable=False)
-    visit_Or = binop('or', interceptable=False)
-    visit_Pos = uaop('+')
-    visit_Neg = uaop('-')
-    visit_Not = uaop('not ', interceptable=False)
-    del binop, uaop
-
-    @optimizeconst
-    def visit_Concat(self, node, frame):
-        if frame.eval_ctx.volatile:
-            func_name = '(context.eval_ctx.volatile and' \
-                        ' markup_join or unicode_join)'
-        elif frame.eval_ctx.autoescape:
-            func_name = 'markup_join'
-        else:
-            func_name = 'unicode_join'
-        self.write('%s((' % func_name)
-        for arg in node.nodes:
-            self.visit(arg, frame)
-            self.write(', ')
-        self.write('))')
-
-    @optimizeconst
-    def visit_Compare(self, node, frame):
-        self.visit(node.expr, frame)
-        for op in node.ops:
-            self.visit(op, frame)
-
-    def visit_Operand(self, node, frame):
-        self.write(' %s ' % operators[node.op])
-        self.visit(node.expr, frame)
-
-    @optimizeconst
-    def visit_Getattr(self, node, frame):
-        self.write('environment.getattr(')
-        self.visit(node.node, frame)
-        self.write(', %r)' % node.attr)
-
-    @optimizeconst
-    def visit_Getitem(self, node, frame):
-        # slices bypass the environment getitem method.
-        if isinstance(node.arg, nodes.Slice):
-            self.visit(node.node, frame)
-            self.write('[')
-            self.visit(node.arg, frame)
-            self.write(']')
-        else:
-            self.write('environment.getitem(')
-            self.visit(node.node, frame)
-            self.write(', ')
-            self.visit(node.arg, frame)
-            self.write(')')
-
-    def visit_Slice(self, node, frame):
-        if node.start is not None:
-            self.visit(node.start, frame)
-        self.write(':')
-        if node.stop is not None:
-            self.visit(node.stop, frame)
-        if node.step is not None:
-            self.write(':')
-            self.visit(node.step, frame)
-
-    @optimizeconst
-    def visit_Filter(self, node, frame):
-        if self.environment.is_async:
-            self.write('await auto_await(')
-        self.write(self.filters[node.name] + '(')
-        func = self.environment.filters.get(node.name)
-        if func is None:
-            self.fail('no filter named %r' % node.name, node.lineno)
-        if getattr(func, 'contextfilter', False):
-            self.write('context, ')
-        elif getattr(func, 'evalcontextfilter', False):
-            self.write('context.eval_ctx, ')
-        elif getattr(func, 'environmentfilter', False):
-            self.write('environment, ')
-
-        # if the filter node is None we are inside a filter block
-        # and want to write to the current buffer
-        if node.node is not None:
-            self.visit(node.node, frame)
-        elif frame.eval_ctx.volatile:
-            self.write('(context.eval_ctx.autoescape and'
-                       ' Markup(concat(%s)) or concat(%s))' %
-                       (frame.buffer, frame.buffer))
-        elif frame.eval_ctx.autoescape:
-            self.write('Markup(concat(%s))' % frame.buffer)
-        else:
-            self.write('concat(%s)' % frame.buffer)
-        self.signature(node, frame)
-        self.write(')')
-        if self.environment.is_async:
-            self.write(')')
-
-    @optimizeconst
-    def visit_Test(self, node, frame):
-        self.write(self.tests[node.name] + '(')
-        if node.name not in self.environment.tests:
-            self.fail('no test named %r' % node.name, node.lineno)
-        self.visit(node.node, frame)
-        self.signature(node, frame)
-        self.write(')')
-
-    @optimizeconst
-    def visit_CondExpr(self, node, frame):
-        def write_expr2():
-            if node.expr2 is not None:
-                return self.visit(node.expr2, frame)
-            self.write('undefined(%r)' % ('the inline if-'
-                       'expression on %s evaluated to false and '
-                       'no else section was defined.' % self.position(node)))
-
-        self.write('(')
-        self.visit(node.expr1, frame)
-        self.write(' if ')
-        self.visit(node.test, frame)
-        self.write(' else ')
-        write_expr2()
-        self.write(')')
-
-    @optimizeconst
-    def visit_Call(self, node, frame, forward_caller=False):
-        if self.environment.is_async:
-            self.write('await auto_await(')
-        if self.environment.sandboxed:
-            self.write('environment.call(context, ')
-        else:
-            self.write('context.call(')
-        self.visit(node.node, frame)
-        extra_kwargs = forward_caller and {'caller': 'caller'} or None
-        self.signature(node, frame, extra_kwargs)
-        self.write(')')
-        if self.environment.is_async:
-            self.write(')')
-
-    def visit_Keyword(self, node, frame):
-        self.write(node.key + '=')
-        self.visit(node.value, frame)
-
-    # -- Unused nodes for extensions
-
-    def visit_MarkSafe(self, node, frame):
-        self.write('Markup(')
-        self.visit(node.expr, frame)
-        self.write(')')
-
-    def visit_MarkSafeIfAutoescape(self, node, frame):
-        self.write('(context.eval_ctx.autoescape and Markup or identity)(')
-        self.visit(node.expr, frame)
-        self.write(')')
-
-    def visit_EnvironmentAttribute(self, node, frame):
-        self.write('environment.' + node.name)
-
-    def visit_ExtensionAttribute(self, node, frame):
-        self.write('environment.extensions[%r].%s' % (node.identifier, node.name))
-
-    def visit_ImportedName(self, node, frame):
-        self.write(self.import_aliases[node.importname])
-
-    def visit_InternalName(self, node, frame):
-        self.write(node.name)
-
-    def visit_ContextReference(self, node, frame):
-        self.write('context')
-
-    def visit_Continue(self, node, frame):
-        self.writeline('continue', node)
-
-    def visit_Break(self, node, frame):
-        self.writeline('break', node)
-
-    def visit_Scope(self, node, frame):
-        scope_frame = frame.inner()
-        scope_frame.symbols.analyze_node(node)
-        self.enter_frame(scope_frame)
-        self.blockvisit(node.body, scope_frame)
-        self.leave_frame(scope_frame)
-
-    def visit_OverlayScope(self, node, frame):
-        ctx = self.temporary_identifier()
-        self.writeline('%s = %s' % (ctx, self.derive_context(frame)))
-        self.writeline('%s.vars = ' % ctx)
-        self.visit(node.context, frame)
-        self.push_context_reference(ctx)
-
-        scope_frame = frame.inner(isolated=True)
-        scope_frame.symbols.analyze_node(node)
-        self.enter_frame(scope_frame)
-        self.blockvisit(node.body, scope_frame)
-        self.leave_frame(scope_frame)
-        self.pop_context_reference()
-
-    def visit_EvalContextModifier(self, node, frame):
-        for keyword in node.options:
-            self.writeline('context.eval_ctx.%s = ' % keyword.key)
-            self.visit(keyword.value, frame)
-            try:
-                val = keyword.value.as_const(frame.eval_ctx)
-            except nodes.Impossible:
-                frame.eval_ctx.volatile = True
-            else:
-                setattr(frame.eval_ctx, keyword.key, val)
-
-    def visit_ScopedEvalContextModifier(self, node, frame):
-        old_ctx_name = self.temporary_identifier()
-        saved_ctx = frame.eval_ctx.save()
-        self.writeline('%s = context.eval_ctx.save()' % old_ctx_name)
-        self.visit_EvalContextModifier(node, frame)
-        for child in node.body:
-            self.visit(child, frame)
-        frame.eval_ctx.revert(saved_ctx)
-        self.writeline('context.eval_ctx.revert(%s)' % old_ctx_name)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/constants.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/constants.py
deleted file mode 100644
index 11efd1ed1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/constants.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja.constants
-    ~~~~~~~~~~~~~~~
-
-    Various constants.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-
-
-#: list of lorem ipsum words used by the lipsum() helper function
-LOREM_IPSUM_WORDS = u'''\
-a ac accumsan ad adipiscing aenean aliquam aliquet amet ante aptent arcu at
-auctor augue bibendum blandit class commodo condimentum congue consectetuer
-consequat conubia convallis cras cubilia cum curabitur curae cursus dapibus
-diam dictum dictumst dignissim dis dolor donec dui duis egestas eget eleifend
-elementum elit enim erat eros est et etiam eu euismod facilisi facilisis fames
-faucibus felis fermentum feugiat fringilla fusce gravida habitant habitasse hac
-hendrerit hymenaeos iaculis id imperdiet in inceptos integer interdum ipsum
-justo lacinia lacus laoreet lectus leo libero ligula litora lobortis lorem
-luctus maecenas magna magnis malesuada massa mattis mauris metus mi molestie
-mollis montes morbi mus nam nascetur natoque nec neque netus nibh nisi nisl non
-nonummy nostra nulla nullam nunc odio orci ornare parturient pede pellentesque
-penatibus per pharetra phasellus placerat platea porta porttitor posuere
-potenti praesent pretium primis proin pulvinar purus quam quis quisque rhoncus
-ridiculus risus rutrum sagittis sapien scelerisque sed sem semper senectus sit
-sociis sociosqu sodales sollicitudin suscipit suspendisse taciti tellus tempor
-tempus tincidunt torquent tortor tristique turpis ullamcorper ultrices
-ultricies urna ut varius vehicula vel velit venenatis vestibulum vitae vivamus
-viverra volutpat vulputate'''
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/debug.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/debug.py
deleted file mode 100644
index b61139f0c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/debug.py
+++ /dev/null
@@ -1,372 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.debug
-    ~~~~~~~~~~~~
-
-    Implements the debug interface for Jinja.  This module does some pretty
-    ugly stuff with the Python traceback system in order to achieve tracebacks
-    with correct line numbers, locals and contents.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-import traceback
-from types import TracebackType, CodeType
-from jinja2.utils import missing, internal_code
-from jinja2.exceptions import TemplateSyntaxError
-from jinja2._compat import iteritems, reraise, PY2
-
-# on pypy we can take advantage of transparent proxies
-try:
-    from __pypy__ import tproxy
-except ImportError:
-    tproxy = None
-
-
-# how does the raise helper look like?
-try:
-    exec("raise TypeError, 'foo'")
-except SyntaxError:
-    raise_helper = 'raise __jinja_exception__[1]'
-except TypeError:
-    raise_helper = 'raise __jinja_exception__[0], __jinja_exception__[1]'
-
-
-class TracebackFrameProxy(object):
-    """Proxies a traceback frame."""
-
-    def __init__(self, tb):
-        self.tb = tb
-        self._tb_next = None
-
-    @property
-    def tb_next(self):
-        return self._tb_next
-
-    def set_next(self, next):
-        if tb_set_next is not None:
-            try:
-                tb_set_next(self.tb, next and next.tb or None)
-            except Exception:
-                # this function can fail due to all the hackery it does
-                # on various python implementations.  We just catch errors
-                # down and ignore them if necessary.
-                pass
-        self._tb_next = next
-
-    @property
-    def is_jinja_frame(self):
-        return '__jinja_template__' in self.tb.tb_frame.f_globals
-
-    def __getattr__(self, name):
-        return getattr(self.tb, name)
-
-
-def make_frame_proxy(frame):
-    proxy = TracebackFrameProxy(frame)
-    if tproxy is None:
-        return proxy
-    def operation_handler(operation, *args, **kwargs):
-        if operation in ('__getattribute__', '__getattr__'):
-            return getattr(proxy, args[0])
-        elif operation == '__setattr__':
-            proxy.__setattr__(*args, **kwargs)
-        else:
-            return getattr(proxy, operation)(*args, **kwargs)
-    return tproxy(TracebackType, operation_handler)
-
-
-class ProcessedTraceback(object):
-    """Holds a Jinja preprocessed traceback for printing or reraising."""
-
-    def __init__(self, exc_type, exc_value, frames):
-        assert frames, 'no frames for this traceback?'
-        self.exc_type = exc_type
-        self.exc_value = exc_value
-        self.frames = frames
-
-        # newly concatenate the frames (which are proxies)
-        prev_tb = None
-        for tb in self.frames:
-            if prev_tb is not None:
-                prev_tb.set_next(tb)
-            prev_tb = tb
-        prev_tb.set_next(None)
-
-    def render_as_text(self, limit=None):
-        """Return a string with the traceback."""
-        lines = traceback.format_exception(self.exc_type, self.exc_value,
-                                           self.frames[0], limit=limit)
-        return ''.join(lines).rstrip()
-
-    def render_as_html(self, full=False):
-        """Return a unicode string with the traceback as rendered HTML."""
-        from jinja2.debugrenderer import render_traceback
-        return u'%s\n\n<!--\n%s\n-->' % (
-            render_traceback(self, full=full),
-            self.render_as_text().decode('utf-8', 'replace')
-        )
-
-    @property
-    def is_template_syntax_error(self):
-        """`True` if this is a template syntax error."""
-        return isinstance(self.exc_value, TemplateSyntaxError)
-
-    @property
-    def exc_info(self):
-        """Exception info tuple with a proxy around the frame objects."""
-        return self.exc_type, self.exc_value, self.frames[0]
-
-    @property
-    def standard_exc_info(self):
-        """Standard python exc_info for re-raising"""
-        tb = self.frames[0]
-        # the frame will be an actual traceback (or transparent proxy) if
-        # we are on pypy or a python implementation with support for tproxy
-        if type(tb) is not TracebackType:
-            tb = tb.tb
-        return self.exc_type, self.exc_value, tb
-
-
-def make_traceback(exc_info, source_hint=None):
-    """Creates a processed traceback object from the exc_info."""
-    exc_type, exc_value, tb = exc_info
-    if isinstance(exc_value, TemplateSyntaxError):
-        exc_info = translate_syntax_error(exc_value, source_hint)
-        initial_skip = 0
-    else:
-        initial_skip = 1
-    return translate_exception(exc_info, initial_skip)
-
-
-def translate_syntax_error(error, source=None):
-    """Rewrites a syntax error to please traceback systems."""
-    error.source = source
-    error.translated = True
-    exc_info = (error.__class__, error, None)
-    filename = error.filename
-    if filename is None:
-        filename = '<unknown>'
-    return fake_exc_info(exc_info, filename, error.lineno)
-
-
-def translate_exception(exc_info, initial_skip=0):
-    """If passed an exc_info it will automatically rewrite the exceptions
-    all the way down to the correct line numbers and frames.
-    """
-    tb = exc_info[2]
-    frames = []
-
-    # skip some internal frames if wanted
-    for x in range(initial_skip):
-        if tb is not None:
-            tb = tb.tb_next
-    initial_tb = tb
-
-    while tb is not None:
-        # skip frames decorated with @internalcode.  These are internal
-        # calls we can't avoid and that are useless in template debugging
-        # output.
-        if tb.tb_frame.f_code in internal_code:
-            tb = tb.tb_next
-            continue
-
-        # save a reference to the next frame if we override the current
-        # one with a faked one.
-        next = tb.tb_next
-
-        # fake template exceptions
-        template = tb.tb_frame.f_globals.get('__jinja_template__')
-        if template is not None:
-            lineno = template.get_corresponding_lineno(tb.tb_lineno)
-            tb = fake_exc_info(exc_info[:2] + (tb,), template.filename,
-                               lineno)[2]
-
-        frames.append(make_frame_proxy(tb))
-        tb = next
-
-    # if we don't have any exceptions in the frames left, we have to
-    # reraise it unchanged.
-    # XXX: can we backup here?  when could this happen?
-    if not frames:
-        reraise(exc_info[0], exc_info[1], exc_info[2])
-
-    return ProcessedTraceback(exc_info[0], exc_info[1], frames)
-
-
-def get_jinja_locals(real_locals):
-    ctx = real_locals.get('context')
-    if ctx:
-        locals = ctx.get_all().copy()
-    else:
-        locals = {}
-
-    local_overrides = {}
-
-    for name, value in iteritems(real_locals):
-        if not name.startswith('l_') or value is missing:
-            continue
-        try:
-            _, depth, name = name.split('_', 2)
-            depth = int(depth)
-        except ValueError:
-            continue
-        cur_depth = local_overrides.get(name, (-1,))[0]
-        if cur_depth < depth:
-            local_overrides[name] = (depth, value)
-
-    for name, (_, value) in iteritems(local_overrides):
-        if value is missing:
-            locals.pop(name, None)
-        else:
-            locals[name] = value
-
-    return locals
-
-
-def fake_exc_info(exc_info, filename, lineno):
-    """Helper for `translate_exception`."""
-    exc_type, exc_value, tb = exc_info
-
-    # figure the real context out
-    if tb is not None:
-        locals = get_jinja_locals(tb.tb_frame.f_locals)
-
-        # if there is a local called __jinja_exception__, we get
-        # rid of it to not break the debug functionality.
-        locals.pop('__jinja_exception__', None)
-    else:
-        locals = {}
-
-    # assamble fake globals we need
-    globals = {
-        '__name__':             filename,
-        '__file__':             filename,
-        '__jinja_exception__':  exc_info[:2],
-
-        # we don't want to keep the reference to the template around
-        # to not cause circular dependencies, but we mark it as Jinja
-        # frame for the ProcessedTraceback
-        '__jinja_template__':   None
-    }
-
-    # and fake the exception
-    code = compile('\n' * (lineno - 1) + raise_helper, filename, 'exec')
-
-    # if it's possible, change the name of the code.  This won't work
-    # on some python environments such as google appengine
-    try:
-        if tb is None:
-            location = 'template'
-        else:
-            function = tb.tb_frame.f_code.co_name
-            if function == 'root':
-                location = 'top-level template code'
-            elif function.startswith('block_'):
-                location = 'block "%s"' % function[6:]
-            else:
-                location = 'template'
-
-        if PY2:
-            code = CodeType(0, code.co_nlocals, code.co_stacksize,
-                            code.co_flags, code.co_code, code.co_consts,
-                            code.co_names, code.co_varnames, filename,
-                            location, code.co_firstlineno,
-                            code.co_lnotab, (), ())
-        else:
-            code = CodeType(0, code.co_kwonlyargcount,
-                            code.co_nlocals, code.co_stacksize,
-                            code.co_flags, code.co_code, code.co_consts,
-                            code.co_names, code.co_varnames, filename,
-                            location, code.co_firstlineno,
-                            code.co_lnotab, (), ())
-    except Exception as e:
-        pass
-
-    # execute the code and catch the new traceback
-    try:
-        exec(code, globals, locals)
-    except:
-        exc_info = sys.exc_info()
-        new_tb = exc_info[2].tb_next
-
-    # return without this frame
-    return exc_info[:2] + (new_tb,)
-
-
-def _init_ugly_crap():
-    """This function implements a few ugly things so that we can patch the
-    traceback objects.  The function returned allows resetting `tb_next` on
-    any python traceback object.  Do not attempt to use this on non cpython
-    interpreters
-    """
-    import ctypes
-    from types import TracebackType
-
-    if PY2:
-        # figure out size of _Py_ssize_t for Python 2:
-        if hasattr(ctypes.pythonapi, 'Py_InitModule4_64'):
-            _Py_ssize_t = ctypes.c_int64
-        else:
-            _Py_ssize_t = ctypes.c_int
-    else:
-        # platform ssize_t on Python 3
-        _Py_ssize_t = ctypes.c_ssize_t
-
-    # regular python
-    class _PyObject(ctypes.Structure):
-        pass
-    _PyObject._fields_ = [
-        ('ob_refcnt', _Py_ssize_t),
-        ('ob_type', ctypes.POINTER(_PyObject))
-    ]
-
-    # python with trace
-    if hasattr(sys, 'getobjects'):
-        class _PyObject(ctypes.Structure):
-            pass
-        _PyObject._fields_ = [
-            ('_ob_next', ctypes.POINTER(_PyObject)),
-            ('_ob_prev', ctypes.POINTER(_PyObject)),
-            ('ob_refcnt', _Py_ssize_t),
-            ('ob_type', ctypes.POINTER(_PyObject))
-        ]
-
-    class _Traceback(_PyObject):
-        pass
-    _Traceback._fields_ = [
-        ('tb_next', ctypes.POINTER(_Traceback)),
-        ('tb_frame', ctypes.POINTER(_PyObject)),
-        ('tb_lasti', ctypes.c_int),
-        ('tb_lineno', ctypes.c_int)
-    ]
-
-    def tb_set_next(tb, next):
-        """Set the tb_next attribute of a traceback object."""
-        if not (isinstance(tb, TracebackType) and
-                (next is None or isinstance(next, TracebackType))):
-            raise TypeError('tb_set_next arguments must be traceback objects')
-        obj = _Traceback.from_address(id(tb))
-        if tb.tb_next is not None:
-            old = _Traceback.from_address(id(tb.tb_next))
-            old.ob_refcnt -= 1
-        if next is None:
-            obj.tb_next = ctypes.POINTER(_Traceback)()
-        else:
-            next = _Traceback.from_address(id(next))
-            next.ob_refcnt += 1
-            obj.tb_next = ctypes.pointer(next)
-
-    return tb_set_next
-
-
-# try to get a tb_set_next implementation if we don't have transparent
-# proxies.
-tb_set_next = None
-if tproxy is None:
-    try:
-        tb_set_next = _init_ugly_crap()
-    except:
-        pass
-    del _init_ugly_crap
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/defaults.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/defaults.py
deleted file mode 100644
index 7c93dec0a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/defaults.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.defaults
-    ~~~~~~~~~~~~~~~
-
-    Jinja default filters and tags.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from jinja2._compat import range_type
-from jinja2.utils import generate_lorem_ipsum, Cycler, Joiner, Namespace
-
-
-# defaults for the parser / lexer
-BLOCK_START_STRING = '{%'
-BLOCK_END_STRING = '%}'
-VARIABLE_START_STRING = '{{'
-VARIABLE_END_STRING = '}}'
-COMMENT_START_STRING = '{#'
-COMMENT_END_STRING = '#}'
-LINE_STATEMENT_PREFIX = None
-LINE_COMMENT_PREFIX = None
-TRIM_BLOCKS = False
-LSTRIP_BLOCKS = False
-NEWLINE_SEQUENCE = '\n'
-KEEP_TRAILING_NEWLINE = False
-
-
-# default filters, tests and namespace
-from jinja2.filters import FILTERS as DEFAULT_FILTERS
-from jinja2.tests import TESTS as DEFAULT_TESTS
-DEFAULT_NAMESPACE = {
-    'range':        range_type,
-    'dict':         dict,
-    'lipsum':       generate_lorem_ipsum,
-    'cycler':       Cycler,
-    'joiner':       Joiner,
-    'namespace':    Namespace
-}
-
-
-# default policies
-DEFAULT_POLICIES = {
-    'compiler.ascii_str':   True,
-    'urlize.rel':           'noopener',
-    'urlize.target':        None,
-    'truncate.leeway':      5,
-    'json.dumps_function':  None,
-    'json.dumps_kwargs':    {'sort_keys': True},
-    'ext.i18n.trimmed':     False,
-}
-
-
-# export all constants
-__all__ = tuple(x for x in locals().keys() if x.isupper())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/environment.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/environment.py
deleted file mode 100644
index 549d9afab..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/environment.py
+++ /dev/null
@@ -1,1276 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.environment
-    ~~~~~~~~~~~~~~~~~~
-
-    Provides a class that holds runtime and parsing time options.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import sys
-import weakref
-from functools import reduce, partial
-from jinja2 import nodes
-from jinja2.defaults import BLOCK_START_STRING, \
-     BLOCK_END_STRING, VARIABLE_START_STRING, VARIABLE_END_STRING, \
-     COMMENT_START_STRING, COMMENT_END_STRING, LINE_STATEMENT_PREFIX, \
-     LINE_COMMENT_PREFIX, TRIM_BLOCKS, NEWLINE_SEQUENCE, \
-     DEFAULT_FILTERS, DEFAULT_TESTS, DEFAULT_NAMESPACE, \
-     DEFAULT_POLICIES, KEEP_TRAILING_NEWLINE, LSTRIP_BLOCKS
-from jinja2.lexer import get_lexer, TokenStream
-from jinja2.parser import Parser
-from jinja2.nodes import EvalContext
-from jinja2.compiler import generate, CodeGenerator
-from jinja2.runtime import Undefined, new_context, Context
-from jinja2.exceptions import TemplateSyntaxError, TemplateNotFound, \
-     TemplatesNotFound, TemplateRuntimeError
-from jinja2.utils import import_string, LRUCache, Markup, missing, \
-     concat, consume, internalcode, have_async_gen
-from jinja2._compat import imap, ifilter, string_types, iteritems, \
-     text_type, reraise, implements_iterator, implements_to_string, \
-     encode_filename, PY2, PYPY
-
-
-# for direct template usage we have up to ten living environments
-_spontaneous_environments = LRUCache(10)
-
-# the function to create jinja traceback objects.  This is dynamically
-# imported on the first exception in the exception handler.
-_make_traceback = None
-
-
-def get_spontaneous_environment(*args):
-    """Return a new spontaneous environment.  A spontaneous environment is an
-    unnamed and unaccessible (in theory) environment that is used for
-    templates generated from a string and not from the file system.
-    """
-    try:
-        env = _spontaneous_environments.get(args)
-    except TypeError:
-        return Environment(*args)
-    if env is not None:
-        return env
-    _spontaneous_environments[args] = env = Environment(*args)
-    env.shared = True
-    return env
-
-
-def create_cache(size):
-    """Return the cache class for the given size."""
-    if size == 0:
-        return None
-    if size < 0:
-        return {}
-    return LRUCache(size)
-
-
-def copy_cache(cache):
-    """Create an empty copy of the given cache."""
-    if cache is None:
-        return None
-    elif type(cache) is dict:
-        return {}
-    return LRUCache(cache.capacity)
-
-
-def load_extensions(environment, extensions):
-    """Load the extensions from the list and bind it to the environment.
-    Returns a dict of instantiated environments.
-    """
-    result = {}
-    for extension in extensions:
-        if isinstance(extension, string_types):
-            extension = import_string(extension)
-        result[extension.identifier] = extension(environment)
-    return result
-
-
-def fail_for_missing_callable(string, name):
-    msg = string % name
-    if isinstance(name, Undefined):
-        try:
-            name._fail_with_undefined_error()
-        except Exception as e:
-            msg = '%s (%s; did you forget to quote the callable name?)' % (msg, e)
-    raise TemplateRuntimeError(msg)
-
-
-def _environment_sanity_check(environment):
-    """Perform a sanity check on the environment."""
-    assert issubclass(environment.undefined, Undefined), 'undefined must ' \
-        'be a subclass of undefined because filters depend on it.'
-    assert environment.block_start_string != \
-        environment.variable_start_string != \
-        environment.comment_start_string, 'block, variable and comment ' \
-        'start strings must be different'
-    assert environment.newline_sequence in ('\r', '\r\n', '\n'), \
-        'newline_sequence set to unknown line ending string.'
-    return environment
-
-
-class Environment(object):
-    r"""The core component of Jinja is the `Environment`.  It contains
-    important shared variables like configuration, filters, tests,
-    globals and others.  Instances of this class may be modified if
-    they are not shared and if no template was loaded so far.
-    Modifications on environments after the first template was loaded
-    will lead to surprising effects and undefined behavior.
-
-    Here are the possible initialization parameters:
-
-        `block_start_string`
-            The string marking the beginning of a block.  Defaults to ``'{%'``.
-
-        `block_end_string`
-            The string marking the end of a block.  Defaults to ``'%}'``.
-
-        `variable_start_string`
-            The string marking the beginning of a print statement.
-            Defaults to ``'{{'``.
-
-        `variable_end_string`
-            The string marking the end of a print statement.  Defaults to
-            ``'}}'``.
-
-        `comment_start_string`
-            The string marking the beginning of a comment.  Defaults to ``'{#'``.
-
-        `comment_end_string`
-            The string marking the end of a comment.  Defaults to ``'#}'``.
-
-        `line_statement_prefix`
-            If given and a string, this will be used as prefix for line based
-            statements.  See also :ref:`line-statements`.
-
-        `line_comment_prefix`
-            If given and a string, this will be used as prefix for line based
-            comments.  See also :ref:`line-statements`.
-
-            .. versionadded:: 2.2
-
-        `trim_blocks`
-            If this is set to ``True`` the first newline after a block is
-            removed (block, not variable tag!).  Defaults to `False`.
-
-        `lstrip_blocks`
-            If this is set to ``True`` leading spaces and tabs are stripped
-            from the start of a line to a block.  Defaults to `False`.
-
-        `newline_sequence`
-            The sequence that starts a newline.  Must be one of ``'\r'``,
-            ``'\n'`` or ``'\r\n'``.  The default is ``'\n'`` which is a
-            useful default for Linux and OS X systems as well as web
-            applications.
-
-        `keep_trailing_newline`
-            Preserve the trailing newline when rendering templates.
-            The default is ``False``, which causes a single newline,
-            if present, to be stripped from the end of the template.
-
-            .. versionadded:: 2.7
-
-        `extensions`
-            List of Jinja extensions to use.  This can either be import paths
-            as strings or extension classes.  For more information have a
-            look at :ref:`the extensions documentation <jinja-extensions>`.
-
-        `optimized`
-            should the optimizer be enabled?  Default is ``True``.
-
-        `undefined`
-            :class:`Undefined` or a subclass of it that is used to represent
-            undefined values in the template.
-
-        `finalize`
-            A callable that can be used to process the result of a variable
-            expression before it is output.  For example one can convert
-            ``None`` implicitly into an empty string here.
-
-        `autoescape`
-            If set to ``True`` the XML/HTML autoescaping feature is enabled by
-            default.  For more details about autoescaping see
-            :class:`~jinja2.utils.Markup`.  As of Jinja 2.4 this can also
-            be a callable that is passed the template name and has to
-            return ``True`` or ``False`` depending on autoescape should be
-            enabled by default.
-
-            .. versionchanged:: 2.4
-               `autoescape` can now be a function
-
-        `loader`
-            The template loader for this environment.
-
-        `cache_size`
-            The size of the cache.  Per default this is ``400`` which means
-            that if more than 400 templates are loaded the loader will clean
-            out the least recently used template.  If the cache size is set to
-            ``0`` templates are recompiled all the time, if the cache size is
-            ``-1`` the cache will not be cleaned.
-
-            .. versionchanged:: 2.8
-               The cache size was increased to 400 from a low 50.
-
-        `auto_reload`
-            Some loaders load templates from locations where the template
-            sources may change (ie: file system or database).  If
-            ``auto_reload`` is set to ``True`` (default) every time a template is
-            requested the loader checks if the source changed and if yes, it
-            will reload the template.  For higher performance it's possible to
-            disable that.
-
-        `bytecode_cache`
-            If set to a bytecode cache object, this object will provide a
-            cache for the internal Jinja bytecode so that templates don't
-            have to be parsed if they were not changed.
-
-            See :ref:`bytecode-cache` for more information.
-
-        `enable_async`
-            If set to true this enables async template execution which allows
-            you to take advantage of newer Python features.  This requires
-            Python 3.6 or later.
-    """
-
-    #: if this environment is sandboxed.  Modifying this variable won't make
-    #: the environment sandboxed though.  For a real sandboxed environment
-    #: have a look at jinja2.sandbox.  This flag alone controls the code
-    #: generation by the compiler.
-    sandboxed = False
-
-    #: True if the environment is just an overlay
-    overlayed = False
-
-    #: the environment this environment is linked to if it is an overlay
-    linked_to = None
-
-    #: shared environments have this set to `True`.  A shared environment
-    #: must not be modified
-    shared = False
-
-    #: these are currently EXPERIMENTAL undocumented features.
-    exception_handler = None
-    exception_formatter = None
-
-    #: the class that is used for code generation.  See
-    #: :class:`~jinja2.compiler.CodeGenerator` for more information.
-    code_generator_class = CodeGenerator
-
-    #: the context class thatis used for templates.  See
-    #: :class:`~jinja2.runtime.Context` for more information.
-    context_class = Context
-
-    def __init__(self,
-                 block_start_string=BLOCK_START_STRING,
-                 block_end_string=BLOCK_END_STRING,
-                 variable_start_string=VARIABLE_START_STRING,
-                 variable_end_string=VARIABLE_END_STRING,
-                 comment_start_string=COMMENT_START_STRING,
-                 comment_end_string=COMMENT_END_STRING,
-                 line_statement_prefix=LINE_STATEMENT_PREFIX,
-                 line_comment_prefix=LINE_COMMENT_PREFIX,
-                 trim_blocks=TRIM_BLOCKS,
-                 lstrip_blocks=LSTRIP_BLOCKS,
-                 newline_sequence=NEWLINE_SEQUENCE,
-                 keep_trailing_newline=KEEP_TRAILING_NEWLINE,
-                 extensions=(),
-                 optimized=True,
-                 undefined=Undefined,
-                 finalize=None,
-                 autoescape=False,
-                 loader=None,
-                 cache_size=400,
-                 auto_reload=True,
-                 bytecode_cache=None,
-                 enable_async=False):
-        # !!Important notice!!
-        #   The constructor accepts quite a few arguments that should be
-        #   passed by keyword rather than position.  However it's important to
-        #   not change the order of arguments because it's used at least
-        #   internally in those cases:
-        #       -   spontaneous environments (i18n extension and Template)
-        #       -   unittests
-        #   If parameter changes are required only add parameters at the end
-        #   and don't change the arguments (or the defaults!) of the arguments
-        #   existing already.
-
-        # lexer / parser information
-        self.block_start_string = block_start_string
-        self.block_end_string = block_end_string
-        self.variable_start_string = variable_start_string
-        self.variable_end_string = variable_end_string
-        self.comment_start_string = comment_start_string
-        self.comment_end_string = comment_end_string
-        self.line_statement_prefix = line_statement_prefix
-        self.line_comment_prefix = line_comment_prefix
-        self.trim_blocks = trim_blocks
-        self.lstrip_blocks = lstrip_blocks
-        self.newline_sequence = newline_sequence
-        self.keep_trailing_newline = keep_trailing_newline
-
-        # runtime information
-        self.undefined = undefined
-        self.optimized = optimized
-        self.finalize = finalize
-        self.autoescape = autoescape
-
-        # defaults
-        self.filters = DEFAULT_FILTERS.copy()
-        self.tests = DEFAULT_TESTS.copy()
-        self.globals = DEFAULT_NAMESPACE.copy()
-
-        # set the loader provided
-        self.loader = loader
-        self.cache = create_cache(cache_size)
-        self.bytecode_cache = bytecode_cache
-        self.auto_reload = auto_reload
-
-        # configurable policies
-        self.policies = DEFAULT_POLICIES.copy()
-
-        # load extensions
-        self.extensions = load_extensions(self, extensions)
-
-        self.enable_async = enable_async
-        self.is_async = self.enable_async and have_async_gen
-
-        _environment_sanity_check(self)
-
-    def add_extension(self, extension):
-        """Adds an extension after the environment was created.
-
-        .. versionadded:: 2.5
-        """
-        self.extensions.update(load_extensions(self, [extension]))
-
-    def extend(self, **attributes):
-        """Add the items to the instance of the environment if they do not exist
-        yet.  This is used by :ref:`extensions <writing-extensions>` to register
-        callbacks and configuration values without breaking inheritance.
-        """
-        for key, value in iteritems(attributes):
-            if not hasattr(self, key):
-                setattr(self, key, value)
-
-    def overlay(self, block_start_string=missing, block_end_string=missing,
-                variable_start_string=missing, variable_end_string=missing,
-                comment_start_string=missing, comment_end_string=missing,
-                line_statement_prefix=missing, line_comment_prefix=missing,
-                trim_blocks=missing, lstrip_blocks=missing,
-                extensions=missing, optimized=missing,
-                undefined=missing, finalize=missing, autoescape=missing,
-                loader=missing, cache_size=missing, auto_reload=missing,
-                bytecode_cache=missing):
-        """Create a new overlay environment that shares all the data with the
-        current environment except for cache and the overridden attributes.
-        Extensions cannot be removed for an overlayed environment.  An overlayed
-        environment automatically gets all the extensions of the environment it
-        is linked to plus optional extra extensions.
-
-        Creating overlays should happen after the initial environment was set
-        up completely.  Not all attributes are truly linked, some are just
-        copied over so modifications on the original environment may not shine
-        through.
-        """
-        args = dict(locals())
-        del args['self'], args['cache_size'], args['extensions']
-
-        rv = object.__new__(self.__class__)
-        rv.__dict__.update(self.__dict__)
-        rv.overlayed = True
-        rv.linked_to = self
-
-        for key, value in iteritems(args):
-            if value is not missing:
-                setattr(rv, key, value)
-
-        if cache_size is not missing:
-            rv.cache = create_cache(cache_size)
-        else:
-            rv.cache = copy_cache(self.cache)
-
-        rv.extensions = {}
-        for key, value in iteritems(self.extensions):
-            rv.extensions[key] = value.bind(rv)
-        if extensions is not missing:
-            rv.extensions.update(load_extensions(rv, extensions))
-
-        return _environment_sanity_check(rv)
-
-    lexer = property(get_lexer, doc="The lexer for this environment.")
-
-    def iter_extensions(self):
-        """Iterates over the extensions by priority."""
-        return iter(sorted(self.extensions.values(),
-                           key=lambda x: x.priority))
-
-    def getitem(self, obj, argument):
-        """Get an item or attribute of an object but prefer the item."""
-        try:
-            return obj[argument]
-        except (AttributeError, TypeError, LookupError):
-            if isinstance(argument, string_types):
-                try:
-                    attr = str(argument)
-                except Exception:
-                    pass
-                else:
-                    try:
-                        return getattr(obj, attr)
-                    except AttributeError:
-                        pass
-            return self.undefined(obj=obj, name=argument)
-
-    def getattr(self, obj, attribute):
-        """Get an item or attribute of an object but prefer the attribute.
-        Unlike :meth:`getitem` the attribute *must* be a bytestring.
-        """
-        try:
-            return getattr(obj, attribute)
-        except AttributeError:
-            pass
-        try:
-            return obj[attribute]
-        except (TypeError, LookupError, AttributeError):
-            return self.undefined(obj=obj, name=attribute)
-
-    def call_filter(self, name, value, args=None, kwargs=None,
-                    context=None, eval_ctx=None):
-        """Invokes a filter on a value the same way the compiler does it.
-
-        Note that on Python 3 this might return a coroutine in case the
-        filter is running from an environment in async mode and the filter
-        supports async execution.  It's your responsibility to await this
-        if needed.
-
-        .. versionadded:: 2.7
-        """
-        func = self.filters.get(name)
-        if func is None:
-            fail_for_missing_callable('no filter named %r', name)
-        args = [value] + list(args or ())
-        if getattr(func, 'contextfilter', False):
-            if context is None:
-                raise TemplateRuntimeError('Attempted to invoke context '
-                                           'filter without context')
-            args.insert(0, context)
-        elif getattr(func, 'evalcontextfilter', False):
-            if eval_ctx is None:
-                if context is not None:
-                    eval_ctx = context.eval_ctx
-                else:
-                    eval_ctx = EvalContext(self)
-            args.insert(0, eval_ctx)
-        elif getattr(func, 'environmentfilter', False):
-            args.insert(0, self)
-        return func(*args, **(kwargs or {}))
-
-    def call_test(self, name, value, args=None, kwargs=None):
-        """Invokes a test on a value the same way the compiler does it.
-
-        .. versionadded:: 2.7
-        """
-        func = self.tests.get(name)
-        if func is None:
-            fail_for_missing_callable('no test named %r', name)
-        return func(value, *(args or ()), **(kwargs or {}))
-
-    @internalcode
-    def parse(self, source, name=None, filename=None):
-        """Parse the sourcecode and return the abstract syntax tree.  This
-        tree of nodes is used by the compiler to convert the template into
-        executable source- or bytecode.  This is useful for debugging or to
-        extract information from templates.
-
-        If you are :ref:`developing Jinja2 extensions <writing-extensions>`
-        this gives you a good overview of the node tree generated.
-        """
-        try:
-            return self._parse(source, name, filename)
-        except TemplateSyntaxError:
-            exc_info = sys.exc_info()
-        self.handle_exception(exc_info, source_hint=source)
-
-    def _parse(self, source, name, filename):
-        """Internal parsing function used by `parse` and `compile`."""
-        return Parser(self, source, name, encode_filename(filename)).parse()
-
-    def lex(self, source, name=None, filename=None):
-        """Lex the given sourcecode and return a generator that yields
-        tokens as tuples in the form ``(lineno, token_type, value)``.
-        This can be useful for :ref:`extension development <writing-extensions>`
-        and debugging templates.
-
-        This does not perform preprocessing.  If you want the preprocessing
-        of the extensions to be applied you have to filter source through
-        the :meth:`preprocess` method.
-        """
-        source = text_type(source)
-        try:
-            return self.lexer.tokeniter(source, name, filename)
-        except TemplateSyntaxError:
-            exc_info = sys.exc_info()
-        self.handle_exception(exc_info, source_hint=source)
-
-    def preprocess(self, source, name=None, filename=None):
-        """Preprocesses the source with all extensions.  This is automatically
-        called for all parsing and compiling methods but *not* for :meth:`lex`
-        because there you usually only want the actual source tokenized.
-        """
-        return reduce(lambda s, e: e.preprocess(s, name, filename),
-                      self.iter_extensions(), text_type(source))
-
-    def _tokenize(self, source, name, filename=None, state=None):
-        """Called by the parser to do the preprocessing and filtering
-        for all the extensions.  Returns a :class:`~jinja2.lexer.TokenStream`.
-        """
-        source = self.preprocess(source, name, filename)
-        stream = self.lexer.tokenize(source, name, filename, state)
-        for ext in self.iter_extensions():
-            stream = ext.filter_stream(stream)
-            if not isinstance(stream, TokenStream):
-                stream = TokenStream(stream, name, filename)
-        return stream
-
-    def _generate(self, source, name, filename, defer_init=False):
-        """Internal hook that can be overridden to hook a different generate
-        method in.
-
-        .. versionadded:: 2.5
-        """
-        return generate(source, self, name, filename, defer_init=defer_init,
-                        optimized=self.optimized)
-
-    def _compile(self, source, filename):
-        """Internal hook that can be overridden to hook a different compile
-        method in.
-
-        .. versionadded:: 2.5
-        """
-        return compile(source, filename, 'exec')
-
-    @internalcode
-    def compile(self, source, name=None, filename=None, raw=False,
-                defer_init=False):
-        """Compile a node or template source code.  The `name` parameter is
-        the load name of the template after it was joined using
-        :meth:`join_path` if necessary, not the filename on the file system.
-        the `filename` parameter is the estimated filename of the template on
-        the file system.  If the template came from a database or memory this
-        can be omitted.
-
-        The return value of this method is a python code object.  If the `raw`
-        parameter is `True` the return value will be a string with python
-        code equivalent to the bytecode returned otherwise.  This method is
-        mainly used internally.
-
-        `defer_init` is use internally to aid the module code generator.  This
-        causes the generated code to be able to import without the global
-        environment variable to be set.
-
-        .. versionadded:: 2.4
-           `defer_init` parameter added.
-        """
-        source_hint = None
-        try:
-            if isinstance(source, string_types):
-                source_hint = source
-                source = self._parse(source, name, filename)
-            source = self._generate(source, name, filename,
-                                    defer_init=defer_init)
-            if raw:
-                return source
-            if filename is None:
-                filename = '<template>'
-            else:
-                filename = encode_filename(filename)
-            return self._compile(source, filename)
-        except TemplateSyntaxError:
-            exc_info = sys.exc_info()
-        self.handle_exception(exc_info, source_hint=source_hint)
-
-    def compile_expression(self, source, undefined_to_none=True):
-        """A handy helper method that returns a callable that accepts keyword
-        arguments that appear as variables in the expression.  If called it
-        returns the result of the expression.
-
-        This is useful if applications want to use the same rules as Jinja
-        in template "configuration files" or similar situations.
-
-        Example usage:
-
-        >>> env = Environment()
-        >>> expr = env.compile_expression('foo == 42')
-        >>> expr(foo=23)
-        False
-        >>> expr(foo=42)
-        True
-
-        Per default the return value is converted to `None` if the
-        expression returns an undefined value.  This can be changed
-        by setting `undefined_to_none` to `False`.
-
-        >>> env.compile_expression('var')() is None
-        True
-        >>> env.compile_expression('var', undefined_to_none=False)()
-        Undefined
-
-        .. versionadded:: 2.1
-        """
-        parser = Parser(self, source, state='variable')
-        exc_info = None
-        try:
-            expr = parser.parse_expression()
-            if not parser.stream.eos:
-                raise TemplateSyntaxError('chunk after expression',
-                                          parser.stream.current.lineno,
-                                          None, None)
-            expr.set_environment(self)
-        except TemplateSyntaxError:
-            exc_info = sys.exc_info()
-        if exc_info is not None:
-            self.handle_exception(exc_info, source_hint=source)
-        body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
-        template = self.from_string(nodes.Template(body, lineno=1))
-        return TemplateExpression(template, undefined_to_none)
-
-    def compile_templates(self, target, extensions=None, filter_func=None,
-                          zip='deflated', log_function=None,
-                          ignore_errors=True, py_compile=False):
-        """Finds all the templates the loader can find, compiles them
-        and stores them in `target`.  If `zip` is `None`, instead of in a
-        zipfile, the templates will be stored in a directory.
-        By default a deflate zip algorithm is used. To switch to
-        the stored algorithm, `zip` can be set to ``'stored'``.
-
-        `extensions` and `filter_func` are passed to :meth:`list_templates`.
-        Each template returned will be compiled to the target folder or
-        zipfile.
-
-        By default template compilation errors are ignored.  In case a
-        log function is provided, errors are logged.  If you want template
-        syntax errors to abort the compilation you can set `ignore_errors`
-        to `False` and you will get an exception on syntax errors.
-
-        If `py_compile` is set to `True` .pyc files will be written to the
-        target instead of standard .py files.  This flag does not do anything
-        on pypy and Python 3 where pyc files are not picked up by itself and
-        don't give much benefit.
-
-        .. versionadded:: 2.4
-        """
-        from jinja2.loaders import ModuleLoader
-
-        if log_function is None:
-            log_function = lambda x: None
-
-        if py_compile:
-            if not PY2 or PYPY:
-                from warnings import warn
-                warn(Warning('py_compile has no effect on pypy or Python 3'))
-                py_compile = False
-            else:
-                import imp
-                import marshal
-                py_header = imp.get_magic() + \
-                    u'\xff\xff\xff\xff'.encode('iso-8859-15')
-
-                # Python 3.3 added a source filesize to the header
-                if sys.version_info >= (3, 3):
-                    py_header += u'\x00\x00\x00\x00'.encode('iso-8859-15')
-
-        def write_file(filename, data, mode):
-            if zip:
-                info = ZipInfo(filename)
-                info.external_attr = 0o755 << 16
-                zip_file.writestr(info, data)
-            else:
-                f = open(os.path.join(target, filename), mode)
-                try:
-                    f.write(data)
-                finally:
-                    f.close()
-
-        if zip is not None:
-            from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED, ZIP_STORED
-            zip_file = ZipFile(target, 'w', dict(deflated=ZIP_DEFLATED,
-                                                 stored=ZIP_STORED)[zip])
-            log_function('Compiling into Zip archive "%s"' % target)
-        else:
-            if not os.path.isdir(target):
-                os.makedirs(target)
-            log_function('Compiling into folder "%s"' % target)
-
-        try:
-            for name in self.list_templates(extensions, filter_func):
-                source, filename, _ = self.loader.get_source(self, name)
-                try:
-                    code = self.compile(source, name, filename, True, True)
-                except TemplateSyntaxError as e:
-                    if not ignore_errors:
-                        raise
-                    log_function('Could not compile "%s": %s' % (name, e))
-                    continue
-
-                filename = ModuleLoader.get_module_filename(name)
-
-                if py_compile:
-                    c = self._compile(code, encode_filename(filename))
-                    write_file(filename + 'c', py_header +
-                               marshal.dumps(c), 'wb')
-                    log_function('Byte-compiled "%s" as %s' %
-                                 (name, filename + 'c'))
-                else:
-                    write_file(filename, code, 'w')
-                    log_function('Compiled "%s" as %s' % (name, filename))
-        finally:
-            if zip:
-                zip_file.close()
-
-        log_function('Finished compiling templates')
-
-    def list_templates(self, extensions=None, filter_func=None):
-        """Returns a list of templates for this environment.  This requires
-        that the loader supports the loader's
-        :meth:`~BaseLoader.list_templates` method.
-
-        If there are other files in the template folder besides the
-        actual templates, the returned list can be filtered.  There are two
-        ways: either `extensions` is set to a list of file extensions for
-        templates, or a `filter_func` can be provided which is a callable that
-        is passed a template name and should return `True` if it should end up
-        in the result list.
-
-        If the loader does not support that, a :exc:`TypeError` is raised.
-
-        .. versionadded:: 2.4
-        """
-        x = self.loader.list_templates()
-        if extensions is not None:
-            if filter_func is not None:
-                raise TypeError('either extensions or filter_func '
-                                'can be passed, but not both')
-            filter_func = lambda x: '.' in x and \
-                                    x.rsplit('.', 1)[1] in extensions
-        if filter_func is not None:
-            x = list(ifilter(filter_func, x))
-        return x
-
-    def handle_exception(self, exc_info=None, rendered=False, source_hint=None):
-        """Exception handling helper.  This is used internally to either raise
-        rewritten exceptions or return a rendered traceback for the template.
-        """
-        global _make_traceback
-        if exc_info is None:
-            exc_info = sys.exc_info()
-
-        # the debugging module is imported when it's used for the first time.
-        # we're doing a lot of stuff there and for applications that do not
-        # get any exceptions in template rendering there is no need to load
-        # all of that.
-        if _make_traceback is None:
-            from jinja2.debug import make_traceback as _make_traceback
-        traceback = _make_traceback(exc_info, source_hint)
-        if rendered and self.exception_formatter is not None:
-            return self.exception_formatter(traceback)
-        if self.exception_handler is not None:
-            self.exception_handler(traceback)
-        exc_type, exc_value, tb = traceback.standard_exc_info
-        reraise(exc_type, exc_value, tb)
-
-    def join_path(self, template, parent):
-        """Join a template with the parent.  By default all the lookups are
-        relative to the loader root so this method returns the `template`
-        parameter unchanged, but if the paths should be relative to the
-        parent template, this function can be used to calculate the real
-        template name.
-
-        Subclasses may override this method and implement template path
-        joining here.
-        """
-        return template
-
-    @internalcode
-    def _load_template(self, name, globals):
-        if self.loader is None:
-            raise TypeError('no loader for this environment specified')
-        cache_key = (weakref.ref(self.loader), name)
-        if self.cache is not None:
-            template = self.cache.get(cache_key)
-            if template is not None and (not self.auto_reload or
-                                         template.is_up_to_date):
-                return template
-        template = self.loader.load(self, name, globals)
-        if self.cache is not None:
-            self.cache[cache_key] = template
-        return template
-
-    @internalcode
-    def get_template(self, name, parent=None, globals=None):
-        """Load a template from the loader.  If a loader is configured this
-        method asks the loader for the template and returns a :class:`Template`.
-        If the `parent` parameter is not `None`, :meth:`join_path` is called
-        to get the real template name before loading.
-
-        The `globals` parameter can be used to provide template wide globals.
-        These variables are available in the context at render time.
-
-        If the template does not exist a :exc:`TemplateNotFound` exception is
-        raised.
-
-        .. versionchanged:: 2.4
-           If `name` is a :class:`Template` object it is returned from the
-           function unchanged.
-        """
-        if isinstance(name, Template):
-            return name
-        if parent is not None:
-            name = self.join_path(name, parent)
-        return self._load_template(name, self.make_globals(globals))
-
-    @internalcode
-    def select_template(self, names, parent=None, globals=None):
-        """Works like :meth:`get_template` but tries a number of templates
-        before it fails.  If it cannot find any of the templates, it will
-        raise a :exc:`TemplatesNotFound` exception.
-
-        .. versionadded:: 2.3
-
-        .. versionchanged:: 2.4
-           If `names` contains a :class:`Template` object it is returned
-           from the function unchanged.
-        """
-        if not names:
-            raise TemplatesNotFound(message=u'Tried to select from an empty list '
-                                            u'of templates.')
-        globals = self.make_globals(globals)
-        for name in names:
-            if isinstance(name, Template):
-                return name
-            if parent is not None:
-                name = self.join_path(name, parent)
-            try:
-                return self._load_template(name, globals)
-            except TemplateNotFound:
-                pass
-        raise TemplatesNotFound(names)
-
-    @internalcode
-    def get_or_select_template(self, template_name_or_list,
-                               parent=None, globals=None):
-        """Does a typecheck and dispatches to :meth:`select_template`
-        if an iterable of template names is given, otherwise to
-        :meth:`get_template`.
-
-        .. versionadded:: 2.3
-        """
-        if isinstance(template_name_or_list, string_types):
-            return self.get_template(template_name_or_list, parent, globals)
-        elif isinstance(template_name_or_list, Template):
-            return template_name_or_list
-        return self.select_template(template_name_or_list, parent, globals)
-
-    def from_string(self, source, globals=None, template_class=None):
-        """Load a template from a string.  This parses the source given and
-        returns a :class:`Template` object.
-        """
-        globals = self.make_globals(globals)
-        cls = template_class or self.template_class
-        return cls.from_code(self, self.compile(source), globals, None)
-
-    def make_globals(self, d):
-        """Return a dict for the globals."""
-        if not d:
-            return self.globals
-        return dict(self.globals, **d)
-
-
-class Template(object):
-    """The central template object.  This class represents a compiled template
-    and is used to evaluate it.
-
-    Normally the template object is generated from an :class:`Environment` but
-    it also has a constructor that makes it possible to create a template
-    instance directly using the constructor.  It takes the same arguments as
-    the environment constructor but it's not possible to specify a loader.
-
-    Every template object has a few methods and members that are guaranteed
-    to exist.  However it's important that a template object should be
-    considered immutable.  Modifications on the object are not supported.
-
-    Template objects created from the constructor rather than an environment
-    do have an `environment` attribute that points to a temporary environment
-    that is probably shared with other templates created with the constructor
-    and compatible settings.
-
-    >>> template = Template('Hello {{ name }}!')
-    >>> template.render(name='John Doe') == u'Hello John Doe!'
-    True
-    >>> stream = template.stream(name='John Doe')
-    >>> next(stream) == u'Hello John Doe!'
-    True
-    >>> next(stream)
-    Traceback (most recent call last):
-        ...
-    StopIteration
-    """
-
-    def __new__(cls, source,
-                block_start_string=BLOCK_START_STRING,
-                block_end_string=BLOCK_END_STRING,
-                variable_start_string=VARIABLE_START_STRING,
-                variable_end_string=VARIABLE_END_STRING,
-                comment_start_string=COMMENT_START_STRING,
-                comment_end_string=COMMENT_END_STRING,
-                line_statement_prefix=LINE_STATEMENT_PREFIX,
-                line_comment_prefix=LINE_COMMENT_PREFIX,
-                trim_blocks=TRIM_BLOCKS,
-                lstrip_blocks=LSTRIP_BLOCKS,
-                newline_sequence=NEWLINE_SEQUENCE,
-                keep_trailing_newline=KEEP_TRAILING_NEWLINE,
-                extensions=(),
-                optimized=True,
-                undefined=Undefined,
-                finalize=None,
-                autoescape=False,
-                enable_async=False):
-        env = get_spontaneous_environment(
-            block_start_string, block_end_string, variable_start_string,
-            variable_end_string, comment_start_string, comment_end_string,
-            line_statement_prefix, line_comment_prefix, trim_blocks,
-            lstrip_blocks, newline_sequence, keep_trailing_newline,
-            frozenset(extensions), optimized, undefined, finalize, autoescape,
-            None, 0, False, None, enable_async)
-        return env.from_string(source, template_class=cls)
-
-    @classmethod
-    def from_code(cls, environment, code, globals, uptodate=None):
-        """Creates a template object from compiled code and the globals.  This
-        is used by the loaders and environment to create a template object.
-        """
-        namespace = {
-            'environment':  environment,
-            '__file__':     code.co_filename
-        }
-        exec(code, namespace)
-        rv = cls._from_namespace(environment, namespace, globals)
-        rv._uptodate = uptodate
-        return rv
-
-    @classmethod
-    def from_module_dict(cls, environment, module_dict, globals):
-        """Creates a template object from a module.  This is used by the
-        module loader to create a template object.
-
-        .. versionadded:: 2.4
-        """
-        return cls._from_namespace(environment, module_dict, globals)
-
-    @classmethod
-    def _from_namespace(cls, environment, namespace, globals):
-        t = object.__new__(cls)
-        t.environment = environment
-        t.globals = globals
-        t.name = namespace['name']
-        t.filename = namespace['__file__']
-        t.blocks = namespace['blocks']
-
-        # render function and module
-        t.root_render_func = namespace['root']
-        t._module = None
-
-        # debug and loader helpers
-        t._debug_info = namespace['debug_info']
-        t._uptodate = None
-
-        # store the reference
-        namespace['environment'] = environment
-        namespace['__jinja_template__'] = t
-
-        return t
-
-    def render(self, *args, **kwargs):
-        """This method accepts the same arguments as the `dict` constructor:
-        A dict, a dict subclass or some keyword arguments.  If no arguments
-        are given the context will be empty.  These two calls do the same::
-
-            template.render(knights='that say nih')
-            template.render({'knights': 'that say nih'})
-
-        This will return the rendered template as unicode string.
-        """
-        vars = dict(*args, **kwargs)
-        try:
-            return concat(self.root_render_func(self.new_context(vars)))
-        except Exception:
-            exc_info = sys.exc_info()
-        return self.environment.handle_exception(exc_info, True)
-
-    def render_async(self, *args, **kwargs):
-        """This works similar to :meth:`render` but returns a coroutine
-        that when awaited returns the entire rendered template string.  This
-        requires the async feature to be enabled.
-
-        Example usage::
-
-            await template.render_async(knights='that say nih; asynchronously')
-        """
-        # see asyncsupport for the actual implementation
-        raise NotImplementedError('This feature is not available for this '
-                                  'version of Python')
-
-    def stream(self, *args, **kwargs):
-        """Works exactly like :meth:`generate` but returns a
-        :class:`TemplateStream`.
-        """
-        return TemplateStream(self.generate(*args, **kwargs))
-
-    def generate(self, *args, **kwargs):
-        """For very large templates it can be useful to not render the whole
-        template at once but evaluate each statement after another and yield
-        piece for piece.  This method basically does exactly that and returns
-        a generator that yields one item after another as unicode strings.
-
-        It accepts the same arguments as :meth:`render`.
-        """
-        vars = dict(*args, **kwargs)
-        try:
-            for event in self.root_render_func(self.new_context(vars)):
-                yield event
-        except Exception:
-            exc_info = sys.exc_info()
-        else:
-            return
-        yield self.environment.handle_exception(exc_info, True)
-
-    def generate_async(self, *args, **kwargs):
-        """An async version of :meth:`generate`.  Works very similarly but
-        returns an async iterator instead.
-        """
-        # see asyncsupport for the actual implementation
-        raise NotImplementedError('This feature is not available for this '
-                                  'version of Python')
-
-    def new_context(self, vars=None, shared=False, locals=None):
-        """Create a new :class:`Context` for this template.  The vars
-        provided will be passed to the template.  Per default the globals
-        are added to the context.  If shared is set to `True` the data
-        is passed as it to the context without adding the globals.
-
-        `locals` can be a dict of local variables for internal usage.
-        """
-        return new_context(self.environment, self.name, self.blocks,
-                           vars, shared, self.globals, locals)
-
-    def make_module(self, vars=None, shared=False, locals=None):
-        """This method works like the :attr:`module` attribute when called
-        without arguments but it will evaluate the template on every call
-        rather than caching it.  It's also possible to provide
-        a dict which is then used as context.  The arguments are the same
-        as for the :meth:`new_context` method.
-        """
-        return TemplateModule(self, self.new_context(vars, shared, locals))
-
-    def make_module_async(self, vars=None, shared=False, locals=None):
-        """As template module creation can invoke template code for
-        asynchronous exections this method must be used instead of the
-        normal :meth:`make_module` one.  Likewise the module attribute
-        becomes unavailable in async mode.
-        """
-        # see asyncsupport for the actual implementation
-        raise NotImplementedError('This feature is not available for this '
-                                  'version of Python')
-
-    @internalcode
-    def _get_default_module(self):
-        if self._module is not None:
-            return self._module
-        self._module = rv = self.make_module()
-        return rv
-
-    @property
-    def module(self):
-        """The template as module.  This is used for imports in the
-        template runtime but is also useful if one wants to access
-        exported template variables from the Python layer:
-
-        >>> t = Template('{% macro foo() %}42{% endmacro %}23')
-        >>> str(t.module)
-        '23'
-        >>> t.module.foo() == u'42'
-        True
-
-        This attribute is not available if async mode is enabled.
-        """
-        return self._get_default_module()
-
-    def get_corresponding_lineno(self, lineno):
-        """Return the source line number of a line number in the
-        generated bytecode as they are not in sync.
-        """
-        for template_line, code_line in reversed(self.debug_info):
-            if code_line <= lineno:
-                return template_line
-        return 1
-
-    @property
-    def is_up_to_date(self):
-        """If this variable is `False` there is a newer version available."""
-        if self._uptodate is None:
-            return True
-        return self._uptodate()
-
-    @property
-    def debug_info(self):
-        """The debug info mapping."""
-        return [tuple(imap(int, x.split('='))) for x in
-                self._debug_info.split('&')]
-
-    def __repr__(self):
-        if self.name is None:
-            name = 'memory:%x' % id(self)
-        else:
-            name = repr(self.name)
-        return '<%s %s>' % (self.__class__.__name__, name)
-
-
-@implements_to_string
-class TemplateModule(object):
-    """Represents an imported template.  All the exported names of the
-    template are available as attributes on this object.  Additionally
-    converting it into an unicode- or bytestrings renders the contents.
-    """
-
-    def __init__(self, template, context, body_stream=None):
-        if body_stream is None:
-            if context.environment.is_async:
-                raise RuntimeError('Async mode requires a body stream '
-                                   'to be passed to a template module.  Use '
-                                   'the async methods of the API you are '
-                                   'using.')
-            body_stream = list(template.root_render_func(context))
-        self._body_stream = body_stream
-        self.__dict__.update(context.get_exported())
-        self.__name__ = template.name
-
-    def __html__(self):
-        return Markup(concat(self._body_stream))
-
-    def __str__(self):
-        return concat(self._body_stream)
-
-    def __repr__(self):
-        if self.__name__ is None:
-            name = 'memory:%x' % id(self)
-        else:
-            name = repr(self.__name__)
-        return '<%s %s>' % (self.__class__.__name__, name)
-
-
-class TemplateExpression(object):
-    """The :meth:`jinja2.Environment.compile_expression` method returns an
-    instance of this object.  It encapsulates the expression-like access
-    to the template with an expression it wraps.
-    """
-
-    def __init__(self, template, undefined_to_none):
-        self._template = template
-        self._undefined_to_none = undefined_to_none
-
-    def __call__(self, *args, **kwargs):
-        context = self._template.new_context(dict(*args, **kwargs))
-        consume(self._template.root_render_func(context))
-        rv = context.vars['result']
-        if self._undefined_to_none and isinstance(rv, Undefined):
-            rv = None
-        return rv
-
-
-@implements_iterator
-class TemplateStream(object):
-    """A template stream works pretty much like an ordinary python generator
-    but it can buffer multiple items to reduce the number of total iterations.
-    Per default the output is unbuffered which means that for every unbuffered
-    instruction in the template one unicode string is yielded.
-
-    If buffering is enabled with a buffer size of 5, five items are combined
-    into a new unicode string.  This is mainly useful if you are streaming
-    big templates to a client via WSGI which flushes after each iteration.
-    """
-
-    def __init__(self, gen):
-        self._gen = gen
-        self.disable_buffering()
-
-    def dump(self, fp, encoding=None, errors='strict'):
-        """Dump the complete stream into a file or file-like object.
-        Per default unicode strings are written, if you want to encode
-        before writing specify an `encoding`.
-
-        Example usage::
-
-            Template('Hello {{ name }}!').stream(name='foo').dump('hello.html')
-        """
-        close = False
-        if isinstance(fp, string_types):
-            if encoding is None:
-                encoding = 'utf-8'
-            fp = open(fp, 'wb')
-            close = True
-        try:
-            if encoding is not None:
-                iterable = (x.encode(encoding, errors) for x in self)
-            else:
-                iterable = self
-            if hasattr(fp, 'writelines'):
-                fp.writelines(iterable)
-            else:
-                for item in iterable:
-                    fp.write(item)
-        finally:
-            if close:
-                fp.close()
-
-    def disable_buffering(self):
-        """Disable the output buffering."""
-        self._next = partial(next, self._gen)
-        self.buffered = False
-
-    def _buffered_generator(self, size):
-        buf = []
-        c_size = 0
-        push = buf.append
-
-        while 1:
-            try:
-                while c_size < size:
-                    c = next(self._gen)
-                    push(c)
-                    if c:
-                        c_size += 1
-            except StopIteration:
-                if not c_size:
-                    return
-            yield concat(buf)
-            del buf[:]
-            c_size = 0
-
-    def enable_buffering(self, size=5):
-        """Enable buffering.  Buffer `size` items before yielding them."""
-        if size <= 1:
-            raise ValueError('buffer size too small')
-
-        self.buffered = True
-        self._next = partial(next, self._buffered_generator(size))
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self._next()
-
-
-# hook in default template class.  if anyone reads this comment: ignore that
-# it's possible to use custom templates ;-)
-Environment.template_class = Template
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/exceptions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/exceptions.py
deleted file mode 100644
index c018a33e3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/exceptions.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.exceptions
-    ~~~~~~~~~~~~~~~~~
-
-    Jinja exceptions.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from jinja2._compat import imap, text_type, PY2, implements_to_string
-
-
-class TemplateError(Exception):
-    """Baseclass for all template errors."""
-
-    if PY2:
-        def __init__(self, message=None):
-            if message is not None:
-                message = text_type(message).encode('utf-8')
-            Exception.__init__(self, message)
-
-        @property
-        def message(self):
-            if self.args:
-                message = self.args[0]
-                if message is not None:
-                    return message.decode('utf-8', 'replace')
-
-        def __unicode__(self):
-            return self.message or u''
-    else:
-        def __init__(self, message=None):
-            Exception.__init__(self, message)
-
-        @property
-        def message(self):
-            if self.args:
-                message = self.args[0]
-                if message is not None:
-                    return message
-
-
-@implements_to_string
-class TemplateNotFound(IOError, LookupError, TemplateError):
-    """Raised if a template does not exist."""
-
-    # looks weird, but removes the warning descriptor that just
-    # bogusly warns us about message being deprecated
-    message = None
-
-    def __init__(self, name, message=None):
-        IOError.__init__(self)
-        if message is None:
-            message = name
-        self.message = message
-        self.name = name
-        self.templates = [name]
-
-    def __str__(self):
-        return self.message
-
-
-class TemplatesNotFound(TemplateNotFound):
-    """Like :class:`TemplateNotFound` but raised if multiple templates
-    are selected.  This is a subclass of :class:`TemplateNotFound`
-    exception, so just catching the base exception will catch both.
-
-    .. versionadded:: 2.2
-    """
-
-    def __init__(self, names=(), message=None):
-        if message is None:
-            message = u'none of the templates given were found: ' + \
-                      u', '.join(imap(text_type, names))
-        TemplateNotFound.__init__(self, names and names[-1] or None, message)
-        self.templates = list(names)
-
-
-@implements_to_string
-class TemplateSyntaxError(TemplateError):
-    """Raised to tell the user that there is a problem with the template."""
-
-    def __init__(self, message, lineno, name=None, filename=None):
-        TemplateError.__init__(self, message)
-        self.lineno = lineno
-        self.name = name
-        self.filename = filename
-        self.source = None
-
-        # this is set to True if the debug.translate_syntax_error
-        # function translated the syntax error into a new traceback
-        self.translated = False
-
-    def __str__(self):
-        # for translated errors we only return the message
-        if self.translated:
-            return self.message
-
-        # otherwise attach some stuff
-        location = 'line %d' % self.lineno
-        name = self.filename or self.name
-        if name:
-            location = 'File "%s", %s' % (name, location)
-        lines = [self.message, '  ' + location]
-
-        # if the source is set, add the line to the output
-        if self.source is not None:
-            try:
-                line = self.source.splitlines()[self.lineno - 1]
-            except IndexError:
-                line = None
-            if line:
-                lines.append('    ' + line.strip())
-
-        return u'\n'.join(lines)
-
-
-class TemplateAssertionError(TemplateSyntaxError):
-    """Like a template syntax error, but covers cases where something in the
-    template caused an error at compile time that wasn't necessarily caused
-    by a syntax error.  However it's a direct subclass of
-    :exc:`TemplateSyntaxError` and has the same attributes.
-    """
-
-
-class TemplateRuntimeError(TemplateError):
-    """A generic runtime error in the template engine.  Under some situations
-    Jinja may raise this exception.
-    """
-
-
-class UndefinedError(TemplateRuntimeError):
-    """Raised if a template tries to operate on :class:`Undefined`."""
-
-
-class SecurityError(TemplateRuntimeError):
-    """Raised if a template tries to do something insecure if the
-    sandbox is enabled.
-    """
-
-
-class FilterArgumentError(TemplateRuntimeError):
-    """This error is raised if a filter was called with inappropriate
-    arguments
-    """
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/ext.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/ext.py
deleted file mode 100644
index 0734a84f7..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/ext.py
+++ /dev/null
@@ -1,627 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.ext
-    ~~~~~~~~~~
-
-    Jinja extensions allow to add custom tags similar to the way django custom
-    tags work.  By default two example extensions exist: an i18n and a cache
-    extension.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-import re
-
-from jinja2 import nodes
-from jinja2.defaults import BLOCK_START_STRING, \
-     BLOCK_END_STRING, VARIABLE_START_STRING, VARIABLE_END_STRING, \
-     COMMENT_START_STRING, COMMENT_END_STRING, LINE_STATEMENT_PREFIX, \
-     LINE_COMMENT_PREFIX, TRIM_BLOCKS, NEWLINE_SEQUENCE, \
-     KEEP_TRAILING_NEWLINE, LSTRIP_BLOCKS
-from jinja2.environment import Environment
-from jinja2.runtime import concat
-from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
-from jinja2.utils import contextfunction, import_string, Markup
-from jinja2._compat import with_metaclass, string_types, iteritems
-
-
-# the only real useful gettext functions for a Jinja template.  Note
-# that ugettext must be assigned to gettext as Jinja doesn't support
-# non unicode strings.
-GETTEXT_FUNCTIONS = ('_', 'gettext', 'ngettext')
-
-
-class ExtensionRegistry(type):
-    """Gives the extension an unique identifier."""
-
-    def __new__(cls, name, bases, d):
-        rv = type.__new__(cls, name, bases, d)
-        rv.identifier = rv.__module__ + '.' + rv.__name__
-        return rv
-
-
-class Extension(with_metaclass(ExtensionRegistry, object)):
-    """Extensions can be used to add extra functionality to the Jinja template
-    system at the parser level.  Custom extensions are bound to an environment
-    but may not store environment specific data on `self`.  The reason for
-    this is that an extension can be bound to another environment (for
-    overlays) by creating a copy and reassigning the `environment` attribute.
-
-    As extensions are created by the environment they cannot accept any
-    arguments for configuration.  One may want to work around that by using
-    a factory function, but that is not possible as extensions are identified
-    by their import name.  The correct way to configure the extension is
-    storing the configuration values on the environment.  Because this way the
-    environment ends up acting as central configuration storage the
-    attributes may clash which is why extensions have to ensure that the names
-    they choose for configuration are not too generic.  ``prefix`` for example
-    is a terrible name, ``fragment_cache_prefix`` on the other hand is a good
-    name as includes the name of the extension (fragment cache).
-    """
-
-    #: if this extension parses this is the list of tags it's listening to.
-    tags = set()
-
-    #: the priority of that extension.  This is especially useful for
-    #: extensions that preprocess values.  A lower value means higher
-    #: priority.
-    #:
-    #: .. versionadded:: 2.4
-    priority = 100
-
-    def __init__(self, environment):
-        self.environment = environment
-
-    def bind(self, environment):
-        """Create a copy of this extension bound to another environment."""
-        rv = object.__new__(self.__class__)
-        rv.__dict__.update(self.__dict__)
-        rv.environment = environment
-        return rv
-
-    def preprocess(self, source, name, filename=None):
-        """This method is called before the actual lexing and can be used to
-        preprocess the source.  The `filename` is optional.  The return value
-        must be the preprocessed source.
-        """
-        return source
-
-    def filter_stream(self, stream):
-        """It's passed a :class:`~jinja2.lexer.TokenStream` that can be used
-        to filter tokens returned.  This method has to return an iterable of
-        :class:`~jinja2.lexer.Token`\\s, but it doesn't have to return a
-        :class:`~jinja2.lexer.TokenStream`.
-
-        In the `ext` folder of the Jinja2 source distribution there is a file
-        called `inlinegettext.py` which implements a filter that utilizes this
-        method.
-        """
-        return stream
-
-    def parse(self, parser):
-        """If any of the :attr:`tags` matched this method is called with the
-        parser as first argument.  The token the parser stream is pointing at
-        is the name token that matched.  This method has to return one or a
-        list of multiple nodes.
-        """
-        raise NotImplementedError()
-
-    def attr(self, name, lineno=None):
-        """Return an attribute node for the current extension.  This is useful
-        to pass constants on extensions to generated template code.
-
-        ::
-
-            self.attr('_my_attribute', lineno=lineno)
-        """
-        return nodes.ExtensionAttribute(self.identifier, name, lineno=lineno)
-
-    def call_method(self, name, args=None, kwargs=None, dyn_args=None,
-                    dyn_kwargs=None, lineno=None):
-        """Call a method of the extension.  This is a shortcut for
-        :meth:`attr` + :class:`jinja2.nodes.Call`.
-        """
-        if args is None:
-            args = []
-        if kwargs is None:
-            kwargs = []
-        return nodes.Call(self.attr(name, lineno=lineno), args, kwargs,
-                          dyn_args, dyn_kwargs, lineno=lineno)
-
-
-@contextfunction
-def _gettext_alias(__context, *args, **kwargs):
-    return __context.call(__context.resolve('gettext'), *args, **kwargs)
-
-
-def _make_new_gettext(func):
-    @contextfunction
-    def gettext(__context, __string, **variables):
-        rv = __context.call(func, __string)
-        if __context.eval_ctx.autoescape:
-            rv = Markup(rv)
-        return rv % variables
-    return gettext
-
-
-def _make_new_ngettext(func):
-    @contextfunction
-    def ngettext(__context, __singular, __plural, __num, **variables):
-        variables.setdefault('num', __num)
-        rv = __context.call(func, __singular, __plural, __num)
-        if __context.eval_ctx.autoescape:
-            rv = Markup(rv)
-        return rv % variables
-    return ngettext
-
-
-class InternationalizationExtension(Extension):
-    """This extension adds gettext support to Jinja2."""
-    tags = set(['trans'])
-
-    # TODO: the i18n extension is currently reevaluating values in a few
-    # situations.  Take this example:
-    #   {% trans count=something() %}{{ count }} foo{% pluralize
-    #     %}{{ count }} fooss{% endtrans %}
-    # something is called twice here.  One time for the gettext value and
-    # the other time for the n-parameter of the ngettext function.
-
-    def __init__(self, environment):
-        Extension.__init__(self, environment)
-        environment.globals['_'] = _gettext_alias
-        environment.extend(
-            install_gettext_translations=self._install,
-            install_null_translations=self._install_null,
-            install_gettext_callables=self._install_callables,
-            uninstall_gettext_translations=self._uninstall,
-            extract_translations=self._extract,
-            newstyle_gettext=False
-        )
-
-    def _install(self, translations, newstyle=None):
-        gettext = getattr(translations, 'ugettext', None)
-        if gettext is None:
-            gettext = translations.gettext
-        ngettext = getattr(translations, 'ungettext', None)
-        if ngettext is None:
-            ngettext = translations.ngettext
-        self._install_callables(gettext, ngettext, newstyle)
-
-    def _install_null(self, newstyle=None):
-        self._install_callables(
-            lambda x: x,
-            lambda s, p, n: (n != 1 and (p,) or (s,))[0],
-            newstyle
-        )
-
-    def _install_callables(self, gettext, ngettext, newstyle=None):
-        if newstyle is not None:
-            self.environment.newstyle_gettext = newstyle
-        if self.environment.newstyle_gettext:
-            gettext = _make_new_gettext(gettext)
-            ngettext = _make_new_ngettext(ngettext)
-        self.environment.globals.update(
-            gettext=gettext,
-            ngettext=ngettext
-        )
-
-    def _uninstall(self, translations):
-        for key in 'gettext', 'ngettext':
-            self.environment.globals.pop(key, None)
-
-    def _extract(self, source, gettext_functions=GETTEXT_FUNCTIONS):
-        if isinstance(source, string_types):
-            source = self.environment.parse(source)
-        return extract_from_ast(source, gettext_functions)
-
-    def parse(self, parser):
-        """Parse a translatable tag."""
-        lineno = next(parser.stream).lineno
-        num_called_num = False
-
-        # find all the variables referenced.  Additionally a variable can be
-        # defined in the body of the trans block too, but this is checked at
-        # a later state.
-        plural_expr = None
-        plural_expr_assignment = None
-        variables = {}
-        trimmed = None
-        while parser.stream.current.type != 'block_end':
-            if variables:
-                parser.stream.expect('comma')
-
-            # skip colon for python compatibility
-            if parser.stream.skip_if('colon'):
-                break
-
-            name = parser.stream.expect('name')
-            if name.value in variables:
-                parser.fail('translatable variable %r defined twice.' %
-                            name.value, name.lineno,
-                            exc=TemplateAssertionError)
-
-            # expressions
-            if parser.stream.current.type == 'assign':
-                next(parser.stream)
-                variables[name.value] = var = parser.parse_expression()
-            elif trimmed is None and name.value in ('trimmed', 'notrimmed'):
-                trimmed = name.value == 'trimmed'
-                continue
-            else:
-                variables[name.value] = var = nodes.Name(name.value, 'load')
-
-            if plural_expr is None:
-                if isinstance(var, nodes.Call):
-                    plural_expr = nodes.Name('_trans', 'load')
-                    variables[name.value] = plural_expr
-                    plural_expr_assignment = nodes.Assign(
-                        nodes.Name('_trans', 'store'), var)
-                else:
-                    plural_expr = var
-                num_called_num = name.value == 'num'
-
-        parser.stream.expect('block_end')
-
-        plural = None
-        have_plural = False
-        referenced = set()
-
-        # now parse until endtrans or pluralize
-        singular_names, singular = self._parse_block(parser, True)
-        if singular_names:
-            referenced.update(singular_names)
-            if plural_expr is None:
-                plural_expr = nodes.Name(singular_names[0], 'load')
-                num_called_num = singular_names[0] == 'num'
-
-        # if we have a pluralize block, we parse that too
-        if parser.stream.current.test('name:pluralize'):
-            have_plural = True
-            next(parser.stream)
-            if parser.stream.current.type != 'block_end':
-                name = parser.stream.expect('name')
-                if name.value not in variables:
-                    parser.fail('unknown variable %r for pluralization' %
-                                name.value, name.lineno,
-                                exc=TemplateAssertionError)
-                plural_expr = variables[name.value]
-                num_called_num = name.value == 'num'
-            parser.stream.expect('block_end')
-            plural_names, plural = self._parse_block(parser, False)
-            next(parser.stream)
-            referenced.update(plural_names)
-        else:
-            next(parser.stream)
-
-        # register free names as simple name expressions
-        for var in referenced:
-            if var not in variables:
-                variables[var] = nodes.Name(var, 'load')
-
-        if not have_plural:
-            plural_expr = None
-        elif plural_expr is None:
-            parser.fail('pluralize without variables', lineno)
-
-        if trimmed is None:
-            trimmed = self.environment.policies['ext.i18n.trimmed']
-        if trimmed:
-            singular = self._trim_whitespace(singular)
-            if plural:
-                plural = self._trim_whitespace(plural)
-
-        node = self._make_node(singular, plural, variables, plural_expr,
-                               bool(referenced),
-                               num_called_num and have_plural)
-        node.set_lineno(lineno)
-        if plural_expr_assignment is not None:
-            return [plural_expr_assignment, node]
-        else:
-            return node
-
-    def _trim_whitespace(self, string, _ws_re=re.compile(r'\s*\n\s*')):
-        return _ws_re.sub(' ', string.strip())
-
-    def _parse_block(self, parser, allow_pluralize):
-        """Parse until the next block tag with a given name."""
-        referenced = []
-        buf = []
-        while 1:
-            if parser.stream.current.type == 'data':
-                buf.append(parser.stream.current.value.replace('%', '%%'))
-                next(parser.stream)
-            elif parser.stream.current.type == 'variable_begin':
-                next(parser.stream)
-                name = parser.stream.expect('name').value
-                referenced.append(name)
-                buf.append('%%(%s)s' % name)
-                parser.stream.expect('variable_end')
-            elif parser.stream.current.type == 'block_begin':
-                next(parser.stream)
-                if parser.stream.current.test('name:endtrans'):
-                    break
-                elif parser.stream.current.test('name:pluralize'):
-                    if allow_pluralize:
-                        break
-                    parser.fail('a translatable section can have only one '
-                                'pluralize section')
-                parser.fail('control structures in translatable sections are '
-                            'not allowed')
-            elif parser.stream.eos:
-                parser.fail('unclosed translation block')
-            else:
-                assert False, 'internal parser error'
-
-        return referenced, concat(buf)
-
-    def _make_node(self, singular, plural, variables, plural_expr,
-                   vars_referenced, num_called_num):
-        """Generates a useful node from the data provided."""
-        # no variables referenced?  no need to escape for old style
-        # gettext invocations only if there are vars.
-        if not vars_referenced and not self.environment.newstyle_gettext:
-            singular = singular.replace('%%', '%')
-            if plural:
-                plural = plural.replace('%%', '%')
-
-        # singular only:
-        if plural_expr is None:
-            gettext = nodes.Name('gettext', 'load')
-            node = nodes.Call(gettext, [nodes.Const(singular)],
-                              [], None, None)
-
-        # singular and plural
-        else:
-            ngettext = nodes.Name('ngettext', 'load')
-            node = nodes.Call(ngettext, [
-                nodes.Const(singular),
-                nodes.Const(plural),
-                plural_expr
-            ], [], None, None)
-
-        # in case newstyle gettext is used, the method is powerful
-        # enough to handle the variable expansion and autoescape
-        # handling itself
-        if self.environment.newstyle_gettext:
-            for key, value in iteritems(variables):
-                # the function adds that later anyways in case num was
-                # called num, so just skip it.
-                if num_called_num and key == 'num':
-                    continue
-                node.kwargs.append(nodes.Keyword(key, value))
-
-        # otherwise do that here
-        else:
-            # mark the return value as safe if we are in an
-            # environment with autoescaping turned on
-            node = nodes.MarkSafeIfAutoescape(node)
-            if variables:
-                node = nodes.Mod(node, nodes.Dict([
-                    nodes.Pair(nodes.Const(key), value)
-                    for key, value in variables.items()
-                ]))
-        return nodes.Output([node])
-
-
-class ExprStmtExtension(Extension):
-    """Adds a `do` tag to Jinja2 that works like the print statement just
-    that it doesn't print the return value.
-    """
-    tags = set(['do'])
-
-    def parse(self, parser):
-        node = nodes.ExprStmt(lineno=next(parser.stream).lineno)
-        node.node = parser.parse_tuple()
-        return node
-
-
-class LoopControlExtension(Extension):
-    """Adds break and continue to the template engine."""
-    tags = set(['break', 'continue'])
-
-    def parse(self, parser):
-        token = next(parser.stream)
-        if token.value == 'break':
-            return nodes.Break(lineno=token.lineno)
-        return nodes.Continue(lineno=token.lineno)
-
-
-class WithExtension(Extension):
-    pass
-
-
-class AutoEscapeExtension(Extension):
-    pass
-
-
-def extract_from_ast(node, gettext_functions=GETTEXT_FUNCTIONS,
-                     babel_style=True):
-    """Extract localizable strings from the given template node.  Per
-    default this function returns matches in babel style that means non string
-    parameters as well as keyword arguments are returned as `None`.  This
-    allows Babel to figure out what you really meant if you are using
-    gettext functions that allow keyword arguments for placeholder expansion.
-    If you don't want that behavior set the `babel_style` parameter to `False`
-    which causes only strings to be returned and parameters are always stored
-    in tuples.  As a consequence invalid gettext calls (calls without a single
-    string parameter or string parameters after non-string parameters) are
-    skipped.
-
-    This example explains the behavior:
-
-    >>> from jinja2 import Environment
-    >>> env = Environment()
-    >>> node = env.parse('{{ (_("foo"), _(), ngettext("foo", "bar", 42)) }}')
-    >>> list(extract_from_ast(node))
-    [(1, '_', 'foo'), (1, '_', ()), (1, 'ngettext', ('foo', 'bar', None))]
-    >>> list(extract_from_ast(node, babel_style=False))
-    [(1, '_', ('foo',)), (1, 'ngettext', ('foo', 'bar'))]
-
-    For every string found this function yields a ``(lineno, function,
-    message)`` tuple, where:
-
-    * ``lineno`` is the number of the line on which the string was found,
-    * ``function`` is the name of the ``gettext`` function used (if the
-      string was extracted from embedded Python code), and
-    *  ``message`` is the string itself (a ``unicode`` object, or a tuple
-       of ``unicode`` objects for functions with multiple string arguments).
-
-    This extraction function operates on the AST and is because of that unable
-    to extract any comments.  For comment support you have to use the babel
-    extraction interface or extract comments yourself.
-    """
-    for node in node.find_all(nodes.Call):
-        if not isinstance(node.node, nodes.Name) or \
-           node.node.name not in gettext_functions:
-            continue
-
-        strings = []
-        for arg in node.args:
-            if isinstance(arg, nodes.Const) and \
-               isinstance(arg.value, string_types):
-                strings.append(arg.value)
-            else:
-                strings.append(None)
-
-        for arg in node.kwargs:
-            strings.append(None)
-        if node.dyn_args is not None:
-            strings.append(None)
-        if node.dyn_kwargs is not None:
-            strings.append(None)
-
-        if not babel_style:
-            strings = tuple(x for x in strings if x is not None)
-            if not strings:
-                continue
-        else:
-            if len(strings) == 1:
-                strings = strings[0]
-            else:
-                strings = tuple(strings)
-        yield node.lineno, node.node.name, strings
-
-
-class _CommentFinder(object):
-    """Helper class to find comments in a token stream.  Can only
-    find comments for gettext calls forwards.  Once the comment
-    from line 4 is found, a comment for line 1 will not return a
-    usable value.
-    """
-
-    def __init__(self, tokens, comment_tags):
-        self.tokens = tokens
-        self.comment_tags = comment_tags
-        self.offset = 0
-        self.last_lineno = 0
-
-    def find_backwards(self, offset):
-        try:
-            for _, token_type, token_value in \
-                    reversed(self.tokens[self.offset:offset]):
-                if token_type in ('comment', 'linecomment'):
-                    try:
-                        prefix, comment = token_value.split(None, 1)
-                    except ValueError:
-                        continue
-                    if prefix in self.comment_tags:
-                        return [comment.rstrip()]
-            return []
-        finally:
-            self.offset = offset
-
-    def find_comments(self, lineno):
-        if not self.comment_tags or self.last_lineno > lineno:
-            return []
-        for idx, (token_lineno, _, _) in enumerate(self.tokens[self.offset:]):
-            if token_lineno > lineno:
-                return self.find_backwards(self.offset + idx)
-        return self.find_backwards(len(self.tokens))
-
-
-def babel_extract(fileobj, keywords, comment_tags, options):
-    """Babel extraction method for Jinja templates.
-
-    .. versionchanged:: 2.3
-       Basic support for translation comments was added.  If `comment_tags`
-       is now set to a list of keywords for extraction, the extractor will
-       try to find the best preceeding comment that begins with one of the
-       keywords.  For best results, make sure to not have more than one
-       gettext call in one line of code and the matching comment in the
-       same line or the line before.
-
-    .. versionchanged:: 2.5.1
-       The `newstyle_gettext` flag can be set to `True` to enable newstyle
-       gettext calls.
-
-    .. versionchanged:: 2.7
-       A `silent` option can now be provided.  If set to `False` template
-       syntax errors are propagated instead of being ignored.
-
-    :param fileobj: the file-like object the messages should be extracted from
-    :param keywords: a list of keywords (i.e. function names) that should be
-                     recognized as translation functions
-    :param comment_tags: a list of translator tags to search for and include
-                         in the results.
-    :param options: a dictionary of additional options (optional)
-    :return: an iterator over ``(lineno, funcname, message, comments)`` tuples.
-             (comments will be empty currently)
-    """
-    extensions = set()
-    for extension in options.get('extensions', '').split(','):
-        extension = extension.strip()
-        if not extension:
-            continue
-        extensions.add(import_string(extension))
-    if InternationalizationExtension not in extensions:
-        extensions.add(InternationalizationExtension)
-
-    def getbool(options, key, default=False):
-        return options.get(key, str(default)).lower() in \
-            ('1', 'on', 'yes', 'true')
-
-    silent = getbool(options, 'silent', True)
-    environment = Environment(
-        options.get('block_start_string', BLOCK_START_STRING),
-        options.get('block_end_string', BLOCK_END_STRING),
-        options.get('variable_start_string', VARIABLE_START_STRING),
-        options.get('variable_end_string', VARIABLE_END_STRING),
-        options.get('comment_start_string', COMMENT_START_STRING),
-        options.get('comment_end_string', COMMENT_END_STRING),
-        options.get('line_statement_prefix') or LINE_STATEMENT_PREFIX,
-        options.get('line_comment_prefix') or LINE_COMMENT_PREFIX,
-        getbool(options, 'trim_blocks', TRIM_BLOCKS),
-        getbool(options, 'lstrip_blocks', LSTRIP_BLOCKS),
-        NEWLINE_SEQUENCE,
-        getbool(options, 'keep_trailing_newline', KEEP_TRAILING_NEWLINE),
-        frozenset(extensions),
-        cache_size=0,
-        auto_reload=False
-    )
-
-    if getbool(options, 'trimmed'):
-        environment.policies['ext.i18n.trimmed'] = True
-    if getbool(options, 'newstyle_gettext'):
-        environment.newstyle_gettext = True
-
-    source = fileobj.read().decode(options.get('encoding', 'utf-8'))
-    try:
-        node = environment.parse(source)
-        tokens = list(environment.lex(environment.preprocess(source)))
-    except TemplateSyntaxError as e:
-        if not silent:
-            raise
-        # skip templates with syntax errors
-        return
-
-    finder = _CommentFinder(tokens, comment_tags)
-    for lineno, func, message in extract_from_ast(node, keywords):
-        yield lineno, func, message, finder.find_comments(lineno)
-
-
-#: nicer import names
-i18n = InternationalizationExtension
-do = ExprStmtExtension
-loopcontrols = LoopControlExtension
-with_ = WithExtension
-autoescape = AutoEscapeExtension
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/filters.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/filters.py
deleted file mode 100644
index 267ddddaa..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/filters.py
+++ /dev/null
@@ -1,1190 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.filters
-    ~~~~~~~~~~~~~~
-
-    Bundled jinja filters.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import math
-import random
-import warnings
-
-from itertools import groupby, chain
-from collections import namedtuple
-from jinja2.utils import Markup, escape, pformat, urlize, soft_unicode, \
-     unicode_urlencode, htmlsafe_json_dumps
-from jinja2.runtime import Undefined
-from jinja2.exceptions import FilterArgumentError
-from jinja2._compat import imap, string_types, text_type, iteritems, PY2
-
-
-_word_re = re.compile(r'\w+', re.UNICODE)
-_word_beginning_split_re = re.compile(r'([-\s\(\{\[\<]+)', re.UNICODE)
-
-
-def contextfilter(f):
-    """Decorator for marking context dependent filters. The current
-    :class:`Context` will be passed as first argument.
-    """
-    f.contextfilter = True
-    return f
-
-
-def evalcontextfilter(f):
-    """Decorator for marking eval-context dependent filters.  An eval
-    context object is passed as first argument.  For more information
-    about the eval context, see :ref:`eval-context`.
-
-    .. versionadded:: 2.4
-    """
-    f.evalcontextfilter = True
-    return f
-
-
-def environmentfilter(f):
-    """Decorator for marking environment dependent filters.  The current
-    :class:`Environment` is passed to the filter as first argument.
-    """
-    f.environmentfilter = True
-    return f
-
-
-def ignore_case(value):
-    """For use as a postprocessor for :func:`make_attrgetter`. Converts strings
-    to lowercase and returns other types as-is."""
-    return value.lower() if isinstance(value, string_types) else value
-
-
-def make_attrgetter(environment, attribute, postprocess=None):
-    """Returns a callable that looks up the given attribute from a
-    passed object with the rules of the environment.  Dots are allowed
-    to access attributes of attributes.  Integer parts in paths are
-    looked up as integers.
-    """
-    if attribute is None:
-        attribute = []
-    elif isinstance(attribute, string_types):
-        attribute = [int(x) if x.isdigit() else x for x in attribute.split('.')]
-    else:
-        attribute = [attribute]
-
-    def attrgetter(item):
-        for part in attribute:
-            item = environment.getitem(item, part)
-
-        if postprocess is not None:
-            item = postprocess(item)
-
-        return item
-
-    return attrgetter
-
-
-def do_forceescape(value):
-    """Enforce HTML escaping.  This will probably double escape variables."""
-    if hasattr(value, '__html__'):
-        value = value.__html__()
-    return escape(text_type(value))
-
-
-def do_urlencode(value):
-    """Escape strings for use in URLs (uses UTF-8 encoding).  It accepts both
-    dictionaries and regular strings as well as pairwise iterables.
-
-    .. versionadded:: 2.7
-    """
-    itemiter = None
-    if isinstance(value, dict):
-        itemiter = iteritems(value)
-    elif not isinstance(value, string_types):
-        try:
-            itemiter = iter(value)
-        except TypeError:
-            pass
-    if itemiter is None:
-        return unicode_urlencode(value)
-    return u'&'.join(unicode_urlencode(k) + '=' +
-                     unicode_urlencode(v, for_qs=True)
-                     for k, v in itemiter)
-
-
-@evalcontextfilter
-def do_replace(eval_ctx, s, old, new, count=None):
-    """Return a copy of the value with all occurrences of a substring
-    replaced with a new one. The first argument is the substring
-    that should be replaced, the second is the replacement string.
-    If the optional third argument ``count`` is given, only the first
-    ``count`` occurrences are replaced:
-
-    .. sourcecode:: jinja
-
-        {{ "Hello World"|replace("Hello", "Goodbye") }}
-            -> Goodbye World
-
-        {{ "aaaaargh"|replace("a", "d'oh, ", 2) }}
-            -> d'oh, d'oh, aaargh
-    """
-    if count is None:
-        count = -1
-    if not eval_ctx.autoescape:
-        return text_type(s).replace(text_type(old), text_type(new), count)
-    if hasattr(old, '__html__') or hasattr(new, '__html__') and \
-       not hasattr(s, '__html__'):
-        s = escape(s)
-    else:
-        s = soft_unicode(s)
-    return s.replace(soft_unicode(old), soft_unicode(new), count)
-
-
-def do_upper(s):
-    """Convert a value to uppercase."""
-    return soft_unicode(s).upper()
-
-
-def do_lower(s):
-    """Convert a value to lowercase."""
-    return soft_unicode(s).lower()
-
-
-@evalcontextfilter
-def do_xmlattr(_eval_ctx, d, autospace=True):
-    """Create an SGML/XML attribute string based on the items in a dict.
-    All values that are neither `none` nor `undefined` are automatically
-    escaped:
-
-    .. sourcecode:: html+jinja
-
-        <ul{{ {'class': 'my_list', 'missing': none,
-                'id': 'list-%d'|format(variable)}|xmlattr }}>
-        ...
-        </ul>
-
-    Results in something like this:
-
-    .. sourcecode:: html
-
-        <ul class="my_list" id="list-42">
-        ...
-        </ul>
-
-    As you can see it automatically prepends a space in front of the item
-    if the filter returned something unless the second parameter is false.
-    """
-    rv = u' '.join(
-        u'%s="%s"' % (escape(key), escape(value))
-        for key, value in iteritems(d)
-        if value is not None and not isinstance(value, Undefined)
-    )
-    if autospace and rv:
-        rv = u' ' + rv
-    if _eval_ctx.autoescape:
-        rv = Markup(rv)
-    return rv
-
-
-def do_capitalize(s):
-    """Capitalize a value. The first character will be uppercase, all others
-    lowercase.
-    """
-    return soft_unicode(s).capitalize()
-
-
-def do_title(s):
-    """Return a titlecased version of the value. I.e. words will start with
-    uppercase letters, all remaining characters are lowercase.
-    """
-    return ''.join(
-        [item[0].upper() + item[1:].lower()
-         for item in _word_beginning_split_re.split(soft_unicode(s))
-         if item])
-
-
-def do_dictsort(value, case_sensitive=False, by='key', reverse=False):
-    """Sort a dict and yield (key, value) pairs. Because python dicts are
-    unsorted you may want to use this function to order them by either
-    key or value:
-
-    .. sourcecode:: jinja
-
-        {% for item in mydict|dictsort %}
-            sort the dict by key, case insensitive
-
-        {% for item in mydict|dictsort(reverse=true) %}
-            sort the dict by key, case insensitive, reverse order
-
-        {% for item in mydict|dictsort(true) %}
-            sort the dict by key, case sensitive
-
-        {% for item in mydict|dictsort(false, 'value') %}
-            sort the dict by value, case insensitive
-    """
-    if by == 'key':
-        pos = 0
-    elif by == 'value':
-        pos = 1
-    else:
-        raise FilterArgumentError(
-            'You can only sort by either "key" or "value"'
-        )
-
-    def sort_func(item):
-        value = item[pos]
-
-        if not case_sensitive:
-            value = ignore_case(value)
-
-        return value
-
-    return sorted(value.items(), key=sort_func, reverse=reverse)
-
-
-@environmentfilter
-def do_sort(
-    environment, value, reverse=False, case_sensitive=False, attribute=None
-):
-    """Sort an iterable.  Per default it sorts ascending, if you pass it
-    true as first argument it will reverse the sorting.
-
-    If the iterable is made of strings the third parameter can be used to
-    control the case sensitiveness of the comparison which is disabled by
-    default.
-
-    .. sourcecode:: jinja
-
-        {% for item in iterable|sort %}
-            ...
-        {% endfor %}
-
-    It is also possible to sort by an attribute (for example to sort
-    by the date of an object) by specifying the `attribute` parameter:
-
-    .. sourcecode:: jinja
-
-        {% for item in iterable|sort(attribute='date') %}
-            ...
-        {% endfor %}
-
-    .. versionchanged:: 2.6
-       The `attribute` parameter was added.
-    """
-    key_func = make_attrgetter(
-        environment, attribute,
-        postprocess=ignore_case if not case_sensitive else None
-    )
-    return sorted(value, key=key_func, reverse=reverse)
-
-
-@environmentfilter
-def do_unique(environment, value, case_sensitive=False, attribute=None):
-    """Returns a list of unique items from the the given iterable.
-
-    .. sourcecode:: jinja
-
-        {{ ['foo', 'bar', 'foobar', 'FooBar']|unique }}
-            -> ['foo', 'bar', 'foobar']
-
-    The unique items are yielded in the same order as their first occurrence in
-    the iterable passed to the filter.
-
-    :param case_sensitive: Treat upper and lower case strings as distinct.
-    :param attribute: Filter objects with unique values for this attribute.
-    """
-    getter = make_attrgetter(
-        environment, attribute,
-        postprocess=ignore_case if not case_sensitive else None
-    )
-    seen = set()
-
-    for item in value:
-        key = getter(item)
-
-        if key not in seen:
-            seen.add(key)
-            yield item
-
-
-def _min_or_max(environment, value, func, case_sensitive, attribute):
-    it = iter(value)
-
-    try:
-        first = next(it)
-    except StopIteration:
-        return environment.undefined('No aggregated item, sequence was empty.')
-
-    key_func = make_attrgetter(
-        environment, attribute,
-        ignore_case if not case_sensitive else None
-    )
-    return func(chain([first], it), key=key_func)
-
-
-@environmentfilter
-def do_min(environment, value, case_sensitive=False, attribute=None):
-    """Return the smallest item from the sequence.
-
-    .. sourcecode:: jinja
-
-        {{ [1, 2, 3]|min }}
-            -> 1
-
-    :param case_sensitive: Treat upper and lower case strings as distinct.
-    :param attribute: Get the object with the max value of this attribute.
-    """
-    return _min_or_max(environment, value, min, case_sensitive, attribute)
-
-
-@environmentfilter
-def do_max(environment, value, case_sensitive=False, attribute=None):
-    """Return the largest item from the sequence.
-
-    .. sourcecode:: jinja
-
-        {{ [1, 2, 3]|max }}
-            -> 3
-
-    :param case_sensitive: Treat upper and lower case strings as distinct.
-    :param attribute: Get the object with the max value of this attribute.
-    """
-    return _min_or_max(environment, value, max, case_sensitive, attribute)
-
-
-def do_default(value, default_value=u'', boolean=False):
-    """If the value is undefined it will return the passed default value,
-    otherwise the value of the variable:
-
-    .. sourcecode:: jinja
-
-        {{ my_variable|default('my_variable is not defined') }}
-
-    This will output the value of ``my_variable`` if the variable was
-    defined, otherwise ``'my_variable is not defined'``. If you want
-    to use default with variables that evaluate to false you have to
-    set the second parameter to `true`:
-
-    .. sourcecode:: jinja
-
-        {{ ''|default('the string was empty', true) }}
-    """
-    if isinstance(value, Undefined) or (boolean and not value):
-        return default_value
-    return value
-
-
-@evalcontextfilter
-def do_join(eval_ctx, value, d=u'', attribute=None):
-    """Return a string which is the concatenation of the strings in the
-    sequence. The separator between elements is an empty string per
-    default, you can define it with the optional parameter:
-
-    .. sourcecode:: jinja
-
-        {{ [1, 2, 3]|join('|') }}
-            -> 1|2|3
-
-        {{ [1, 2, 3]|join }}
-            -> 123
-
-    It is also possible to join certain attributes of an object:
-
-    .. sourcecode:: jinja
-
-        {{ users|join(', ', attribute='username') }}
-
-    .. versionadded:: 2.6
-       The `attribute` parameter was added.
-    """
-    if attribute is not None:
-        value = imap(make_attrgetter(eval_ctx.environment, attribute), value)
-
-    # no automatic escaping?  joining is a lot eaiser then
-    if not eval_ctx.autoescape:
-        return text_type(d).join(imap(text_type, value))
-
-    # if the delimiter doesn't have an html representation we check
-    # if any of the items has.  If yes we do a coercion to Markup
-    if not hasattr(d, '__html__'):
-        value = list(value)
-        do_escape = False
-        for idx, item in enumerate(value):
-            if hasattr(item, '__html__'):
-                do_escape = True
-            else:
-                value[idx] = text_type(item)
-        if do_escape:
-            d = escape(d)
-        else:
-            d = text_type(d)
-        return d.join(value)
-
-    # no html involved, to normal joining
-    return soft_unicode(d).join(imap(soft_unicode, value))
-
-
-def do_center(value, width=80):
-    """Centers the value in a field of a given width."""
-    return text_type(value).center(width)
-
-
-@environmentfilter
-def do_first(environment, seq):
-    """Return the first item of a sequence."""
-    try:
-        return next(iter(seq))
-    except StopIteration:
-        return environment.undefined('No first item, sequence was empty.')
-
-
-@environmentfilter
-def do_last(environment, seq):
-    """Return the last item of a sequence."""
-    try:
-        return next(iter(reversed(seq)))
-    except StopIteration:
-        return environment.undefined('No last item, sequence was empty.')
-
-
-@contextfilter
-def do_random(context, seq):
-    """Return a random item from the sequence."""
-    try:
-        return random.choice(seq)
-    except IndexError:
-        return context.environment.undefined('No random item, sequence was empty.')
-
-
-def do_filesizeformat(value, binary=False):
-    """Format the value like a 'human-readable' file size (i.e. 13 kB,
-    4.1 MB, 102 Bytes, etc).  Per default decimal prefixes are used (Mega,
-    Giga, etc.), if the second parameter is set to `True` the binary
-    prefixes are used (Mebi, Gibi).
-    """
-    bytes = float(value)
-    base = binary and 1024 or 1000
-    prefixes = [
-        (binary and 'KiB' or 'kB'),
-        (binary and 'MiB' or 'MB'),
-        (binary and 'GiB' or 'GB'),
-        (binary and 'TiB' or 'TB'),
-        (binary and 'PiB' or 'PB'),
-        (binary and 'EiB' or 'EB'),
-        (binary and 'ZiB' or 'ZB'),
-        (binary and 'YiB' or 'YB')
-    ]
-    if bytes == 1:
-        return '1 Byte'
-    elif bytes < base:
-        return '%d Bytes' % bytes
-    else:
-        for i, prefix in enumerate(prefixes):
-            unit = base ** (i + 2)
-            if bytes < unit:
-                return '%.1f %s' % ((base * bytes / unit), prefix)
-        return '%.1f %s' % ((base * bytes / unit), prefix)
-
-
-def do_pprint(value, verbose=False):
-    """Pretty print a variable. Useful for debugging.
-
-    With Jinja 1.2 onwards you can pass it a parameter.  If this parameter
-    is truthy the output will be more verbose (this requires `pretty`)
-    """
-    return pformat(value, verbose=verbose)
-
-
-@evalcontextfilter
-def do_urlize(eval_ctx, value, trim_url_limit=None, nofollow=False,
-              target=None, rel=None):
-    """Converts URLs in plain text into clickable links.
-
-    If you pass the filter an additional integer it will shorten the urls
-    to that number. Also a third argument exists that makes the urls
-    "nofollow":
-
-    .. sourcecode:: jinja
-
-        {{ mytext|urlize(40, true) }}
-            links are shortened to 40 chars and defined with rel="nofollow"
-
-    If *target* is specified, the ``target`` attribute will be added to the
-    ``<a>`` tag:
-
-    .. sourcecode:: jinja
-
-       {{ mytext|urlize(40, target='_blank') }}
-
-    .. versionchanged:: 2.8+
-       The *target* parameter was added.
-    """
-    policies = eval_ctx.environment.policies
-    rel = set((rel or '').split() or [])
-    if nofollow:
-        rel.add('nofollow')
-    rel.update((policies['urlize.rel'] or '').split())
-    if target is None:
-        target = policies['urlize.target']
-    rel = ' '.join(sorted(rel)) or None
-    rv = urlize(value, trim_url_limit, rel=rel, target=target)
-    if eval_ctx.autoescape:
-        rv = Markup(rv)
-    return rv
-
-
-def do_indent(
-    s, width=4, first=False, blank=False, indentfirst=None
-):
-    """Return a copy of the string with each line indented by 4 spaces. The
-    first line and blank lines are not indented by default.
-
-    :param width: Number of spaces to indent by.
-    :param first: Don't skip indenting the first line.
-    :param blank: Don't skip indenting empty lines.
-
-    .. versionchanged:: 2.10
-        Blank lines are not indented by default.
-
-        Rename the ``indentfirst`` argument to ``first``.
-    """
-    if indentfirst is not None:
-        warnings.warn(DeprecationWarning(
-            'The "indentfirst" argument is renamed to "first".'
-        ), stacklevel=2)
-        first = indentfirst
-
-    s += u'\n'  # this quirk is necessary for splitlines method
-    indention = u' ' * width
-
-    if blank:
-        rv = (u'\n' + indention).join(s.splitlines())
-    else:
-        lines = s.splitlines()
-        rv = lines.pop(0)
-
-        if lines:
-            rv += u'\n' + u'\n'.join(
-                indention + line if line else line for line in lines
-            )
-
-    if first:
-        rv = indention + rv
-
-    return rv
-
-
-@environmentfilter
-def do_truncate(env, s, length=255, killwords=False, end='...', leeway=None):
-    """Return a truncated copy of the string. The length is specified
-    with the first parameter which defaults to ``255``. If the second
-    parameter is ``true`` the filter will cut the text at length. Otherwise
-    it will discard the last word. If the text was in fact
-    truncated it will append an ellipsis sign (``"..."``). If you want a
-    different ellipsis sign than ``"..."`` you can specify it using the
-    third parameter. Strings that only exceed the length by the tolerance
-    margin given in the fourth parameter will not be truncated.
-
-    .. sourcecode:: jinja
-
-        {{ "foo bar baz qux"|truncate(9) }}
-            -> "foo..."
-        {{ "foo bar baz qux"|truncate(9, True) }}
-            -> "foo ba..."
-        {{ "foo bar baz qux"|truncate(11) }}
-            -> "foo bar baz qux"
-        {{ "foo bar baz qux"|truncate(11, False, '...', 0) }}
-            -> "foo bar..."
-
-    The default leeway on newer Jinja2 versions is 5 and was 0 before but
-    can be reconfigured globally.
-    """
-    if leeway is None:
-        leeway = env.policies['truncate.leeway']
-    assert length >= len(end), 'expected length >= %s, got %s' % (len(end), length)
-    assert leeway >= 0, 'expected leeway >= 0, got %s' % leeway
-    if len(s) <= length + leeway:
-        return s
-    if killwords:
-        return s[:length - len(end)] + end
-    result = s[:length - len(end)].rsplit(' ', 1)[0]
-    return result + end
-
-
-@environmentfilter
-def do_wordwrap(environment, s, width=79, break_long_words=True,
-                wrapstring=None):
-    """
-    Return a copy of the string passed to the filter wrapped after
-    ``79`` characters.  You can override this default using the first
-    parameter.  If you set the second parameter to `false` Jinja will not
-    split words apart if they are longer than `width`. By default, the newlines
-    will be the default newlines for the environment, but this can be changed
-    using the wrapstring keyword argument.
-
-    .. versionadded:: 2.7
-       Added support for the `wrapstring` parameter.
-    """
-    if not wrapstring:
-        wrapstring = environment.newline_sequence
-    import textwrap
-    return wrapstring.join(textwrap.wrap(s, width=width, expand_tabs=False,
-                                   replace_whitespace=False,
-                                   break_long_words=break_long_words))
-
-
-def do_wordcount(s):
-    """Count the words in that string."""
-    return len(_word_re.findall(s))
-
-
-def do_int(value, default=0, base=10):
-    """Convert the value into an integer. If the
-    conversion doesn't work it will return ``0``. You can
-    override this default using the first parameter. You
-    can also override the default base (10) in the second
-    parameter, which handles input with prefixes such as
-    0b, 0o and 0x for bases 2, 8 and 16 respectively.
-    The base is ignored for decimal numbers and non-string values.
-    """
-    try:
-        if isinstance(value, string_types):
-            return int(value, base)
-        return int(value)
-    except (TypeError, ValueError):
-        # this quirk is necessary so that "42.23"|int gives 42.
-        try:
-            return int(float(value))
-        except (TypeError, ValueError):
-            return default
-
-
-def do_float(value, default=0.0):
-    """Convert the value into a floating point number. If the
-    conversion doesn't work it will return ``0.0``. You can
-    override this default using the first parameter.
-    """
-    try:
-        return float(value)
-    except (TypeError, ValueError):
-        return default
-
-
-def do_format(value, *args, **kwargs):
-    """
-    Apply python string formatting on an object:
-
-    .. sourcecode:: jinja
-
-        {{ "%s - %s"|format("Hello?", "Foo!") }}
-            -> Hello? - Foo!
-    """
-    if args and kwargs:
-        raise FilterArgumentError('can\'t handle positional and keyword '
-                                  'arguments at the same time')
-    return soft_unicode(value) % (kwargs or args)
-
-
-def do_trim(value):
-    """Strip leading and trailing whitespace."""
-    return soft_unicode(value).strip()
-
-
-def do_striptags(value):
-    """Strip SGML/XML tags and replace adjacent whitespace by one space.
-    """
-    if hasattr(value, '__html__'):
-        value = value.__html__()
-    return Markup(text_type(value)).striptags()
-
-
-def do_slice(value, slices, fill_with=None):
-    """Slice an iterator and return a list of lists containing
-    those items. Useful if you want to create a div containing
-    three ul tags that represent columns:
-
-    .. sourcecode:: html+jinja
-
-        <div class="columwrapper">
-          {%- for column in items|slice(3) %}
-            <ul class="column-{{ loop.index }}">
-            {%- for item in column %}
-              <li>{{ item }}</li>
-            {%- endfor %}
-            </ul>
-          {%- endfor %}
-        </div>
-
-    If you pass it a second argument it's used to fill missing
-    values on the last iteration.
-    """
-    seq = list(value)
-    length = len(seq)
-    items_per_slice = length // slices
-    slices_with_extra = length % slices
-    offset = 0
-    for slice_number in range(slices):
-        start = offset + slice_number * items_per_slice
-        if slice_number < slices_with_extra:
-            offset += 1
-        end = offset + (slice_number + 1) * items_per_slice
-        tmp = seq[start:end]
-        if fill_with is not None and slice_number >= slices_with_extra:
-            tmp.append(fill_with)
-        yield tmp
-
-
-def do_batch(value, linecount, fill_with=None):
-    """
-    A filter that batches items. It works pretty much like `slice`
-    just the other way round. It returns a list of lists with the
-    given number of items. If you provide a second parameter this
-    is used to fill up missing items. See this example:
-
-    .. sourcecode:: html+jinja
-
-        <table>
-        {%- for row in items|batch(3, '&nbsp;') %}
-          <tr>
-          {%- for column in row %}
-            <td>{{ column }}</td>
-          {%- endfor %}
-          </tr>
-        {%- endfor %}
-        </table>
-    """
-    tmp = []
-    for item in value:
-        if len(tmp) == linecount:
-            yield tmp
-            tmp = []
-        tmp.append(item)
-    if tmp:
-        if fill_with is not None and len(tmp) < linecount:
-            tmp += [fill_with] * (linecount - len(tmp))
-        yield tmp
-
-
-def do_round(value, precision=0, method='common'):
-    """Round the number to a given precision. The first
-    parameter specifies the precision (default is ``0``), the
-    second the rounding method:
-
-    - ``'common'`` rounds either up or down
-    - ``'ceil'`` always rounds up
-    - ``'floor'`` always rounds down
-
-    If you don't specify a method ``'common'`` is used.
-
-    .. sourcecode:: jinja
-
-        {{ 42.55|round }}
-            -> 43.0
-        {{ 42.55|round(1, 'floor') }}
-            -> 42.5
-
-    Note that even if rounded to 0 precision, a float is returned.  If
-    you need a real integer, pipe it through `int`:
-
-    .. sourcecode:: jinja
-
-        {{ 42.55|round|int }}
-            -> 43
-    """
-    if not method in ('common', 'ceil', 'floor'):
-        raise FilterArgumentError('method must be common, ceil or floor')
-    if method == 'common':
-        return round(value, precision)
-    func = getattr(math, method)
-    return func(value * (10 ** precision)) / (10 ** precision)
-
-
-# Use a regular tuple repr here.  This is what we did in the past and we
-# really want to hide this custom type as much as possible.  In particular
-# we do not want to accidentally expose an auto generated repr in case
-# people start to print this out in comments or something similar for
-# debugging.
-_GroupTuple = namedtuple('_GroupTuple', ['grouper', 'list'])
-_GroupTuple.__repr__ = tuple.__repr__
-_GroupTuple.__str__ = tuple.__str__
-
-@environmentfilter
-def do_groupby(environment, value, attribute):
-    """Group a sequence of objects by a common attribute.
-
-    If you for example have a list of dicts or objects that represent persons
-    with `gender`, `first_name` and `last_name` attributes and you want to
-    group all users by genders you can do something like the following
-    snippet:
-
-    .. sourcecode:: html+jinja
-
-        <ul>
-        {% for group in persons|groupby('gender') %}
-            <li>{{ group.grouper }}<ul>
-            {% for person in group.list %}
-                <li>{{ person.first_name }} {{ person.last_name }}</li>
-            {% endfor %}</ul></li>
-        {% endfor %}
-        </ul>
-
-    Additionally it's possible to use tuple unpacking for the grouper and
-    list:
-
-    .. sourcecode:: html+jinja
-
-        <ul>
-        {% for grouper, list in persons|groupby('gender') %}
-            ...
-        {% endfor %}
-        </ul>
-
-    As you can see the item we're grouping by is stored in the `grouper`
-    attribute and the `list` contains all the objects that have this grouper
-    in common.
-
-    .. versionchanged:: 2.6
-       It's now possible to use dotted notation to group by the child
-       attribute of another attribute.
-    """
-    expr = make_attrgetter(environment, attribute)
-    return [_GroupTuple(key, list(values)) for key, values
-            in groupby(sorted(value, key=expr), expr)]
-
-
-@environmentfilter
-def do_sum(environment, iterable, attribute=None, start=0):
-    """Returns the sum of a sequence of numbers plus the value of parameter
-    'start' (which defaults to 0).  When the sequence is empty it returns
-    start.
-
-    It is also possible to sum up only certain attributes:
-
-    .. sourcecode:: jinja
-
-        Total: {{ items|sum(attribute='price') }}
-
-    .. versionchanged:: 2.6
-       The `attribute` parameter was added to allow suming up over
-       attributes.  Also the `start` parameter was moved on to the right.
-    """
-    if attribute is not None:
-        iterable = imap(make_attrgetter(environment, attribute), iterable)
-    return sum(iterable, start)
-
-
-def do_list(value):
-    """Convert the value into a list.  If it was a string the returned list
-    will be a list of characters.
-    """
-    return list(value)
-
-
-def do_mark_safe(value):
-    """Mark the value as safe which means that in an environment with automatic
-    escaping enabled this variable will not be escaped.
-    """
-    return Markup(value)
-
-
-def do_mark_unsafe(value):
-    """Mark a value as unsafe.  This is the reverse operation for :func:`safe`."""
-    return text_type(value)
-
-
-def do_reverse(value):
-    """Reverse the object or return an iterator that iterates over it the other
-    way round.
-    """
-    if isinstance(value, string_types):
-        return value[::-1]
-    try:
-        return reversed(value)
-    except TypeError:
-        try:
-            rv = list(value)
-            rv.reverse()
-            return rv
-        except TypeError:
-            raise FilterArgumentError('argument must be iterable')
-
-
-@environmentfilter
-def do_attr(environment, obj, name):
-    """Get an attribute of an object.  ``foo|attr("bar")`` works like
-    ``foo.bar`` just that always an attribute is returned and items are not
-    looked up.
-
-    See :ref:`Notes on subscriptions <notes-on-subscriptions>` for more details.
-    """
-    try:
-        name = str(name)
-    except UnicodeError:
-        pass
-    else:
-        try:
-            value = getattr(obj, name)
-        except AttributeError:
-            pass
-        else:
-            if environment.sandboxed and not \
-               environment.is_safe_attribute(obj, name, value):
-                return environment.unsafe_undefined(obj, name)
-            return value
-    return environment.undefined(obj=obj, name=name)
-
-
-@contextfilter
-def do_map(*args, **kwargs):
-    """Applies a filter on a sequence of objects or looks up an attribute.
-    This is useful when dealing with lists of objects but you are really
-    only interested in a certain value of it.
-
-    The basic usage is mapping on an attribute.  Imagine you have a list
-    of users but you are only interested in a list of usernames:
-
-    .. sourcecode:: jinja
-
-        Users on this page: {{ users|map(attribute='username')|join(', ') }}
-
-    Alternatively you can let it invoke a filter by passing the name of the
-    filter and the arguments afterwards.  A good example would be applying a
-    text conversion filter on a sequence:
-
-    .. sourcecode:: jinja
-
-        Users on this page: {{ titles|map('lower')|join(', ') }}
-
-    .. versionadded:: 2.7
-    """
-    seq, func = prepare_map(args, kwargs)
-    if seq:
-        for item in seq:
-            yield func(item)
-
-
-@contextfilter
-def do_select(*args, **kwargs):
-    """Filters a sequence of objects by applying a test to each object,
-    and only selecting the objects with the test succeeding.
-
-    If no test is specified, each object will be evaluated as a boolean.
-
-    Example usage:
-
-    .. sourcecode:: jinja
-
-        {{ numbers|select("odd") }}
-        {{ numbers|select("odd") }}
-        {{ numbers|select("divisibleby", 3) }}
-        {{ numbers|select("lessthan", 42) }}
-        {{ strings|select("equalto", "mystring") }}
-
-    .. versionadded:: 2.7
-    """
-    return select_or_reject(args, kwargs, lambda x: x, False)
-
-
-@contextfilter
-def do_reject(*args, **kwargs):
-    """Filters a sequence of objects by applying a test to each object,
-    and rejecting the objects with the test succeeding.
-
-    If no test is specified, each object will be evaluated as a boolean.
-
-    Example usage:
-
-    .. sourcecode:: jinja
-
-        {{ numbers|reject("odd") }}
-
-    .. versionadded:: 2.7
-    """
-    return select_or_reject(args, kwargs, lambda x: not x, False)
-
-
-@contextfilter
-def do_selectattr(*args, **kwargs):
-    """Filters a sequence of objects by applying a test to the specified
-    attribute of each object, and only selecting the objects with the
-    test succeeding.
-
-    If no test is specified, the attribute's value will be evaluated as
-    a boolean.
-
-    Example usage:
-
-    .. sourcecode:: jinja
-
-        {{ users|selectattr("is_active") }}
-        {{ users|selectattr("email", "none") }}
-
-    .. versionadded:: 2.7
-    """
-    return select_or_reject(args, kwargs, lambda x: x, True)
-
-
-@contextfilter
-def do_rejectattr(*args, **kwargs):
-    """Filters a sequence of objects by applying a test to the specified
-    attribute of each object, and rejecting the objects with the test
-    succeeding.
-
-    If no test is specified, the attribute's value will be evaluated as
-    a boolean.
-
-    .. sourcecode:: jinja
-
-        {{ users|rejectattr("is_active") }}
-        {{ users|rejectattr("email", "none") }}
-
-    .. versionadded:: 2.7
-    """
-    return select_or_reject(args, kwargs, lambda x: not x, True)
-
-
-@evalcontextfilter
-def do_tojson(eval_ctx, value, indent=None):
-    """Dumps a structure to JSON so that it's safe to use in ``<script>``
-    tags.  It accepts the same arguments and returns a JSON string.  Note that
-    this is available in templates through the ``|tojson`` filter which will
-    also mark the result as safe.  Due to how this function escapes certain
-    characters this is safe even if used outside of ``<script>`` tags.
-
-    The following characters are escaped in strings:
-
-    -   ``<``
-    -   ``>``
-    -   ``&``
-    -   ``'``
-
-    This makes it safe to embed such strings in any place in HTML with the
-    notable exception of double quoted attributes.  In that case single
-    quote your attributes or HTML escape it in addition.
-
-    The indent parameter can be used to enable pretty printing.  Set it to
-    the number of spaces that the structures should be indented with.
-
-    Note that this filter is for use in HTML contexts only.
-
-    .. versionadded:: 2.9
-    """
-    policies = eval_ctx.environment.policies
-    dumper = policies['json.dumps_function']
-    options = policies['json.dumps_kwargs']
-    if indent is not None:
-        options = dict(options)
-        options['indent'] = indent
-    return htmlsafe_json_dumps(value, dumper=dumper, **options)
-
-
-def prepare_map(args, kwargs):
-    context = args[0]
-    seq = args[1]
-
-    if len(args) == 2 and 'attribute' in kwargs:
-        attribute = kwargs.pop('attribute')
-        if kwargs:
-            raise FilterArgumentError('Unexpected keyword argument %r' %
-                next(iter(kwargs)))
-        func = make_attrgetter(context.environment, attribute)
-    else:
-        try:
-            name = args[2]
-            args = args[3:]
-        except LookupError:
-            raise FilterArgumentError('map requires a filter argument')
-        func = lambda item: context.environment.call_filter(
-            name, item, args, kwargs, context=context)
-
-    return seq, func
-
-
-def prepare_select_or_reject(args, kwargs, modfunc, lookup_attr):
-    context = args[0]
-    seq = args[1]
-    if lookup_attr:
-        try:
-            attr = args[2]
-        except LookupError:
-            raise FilterArgumentError('Missing parameter for attribute name')
-        transfunc = make_attrgetter(context.environment, attr)
-        off = 1
-    else:
-        off = 0
-        transfunc = lambda x: x
-
-    try:
-        name = args[2 + off]
-        args = args[3 + off:]
-        func = lambda item: context.environment.call_test(
-            name, item, args, kwargs)
-    except LookupError:
-        func = bool
-
-    return seq, lambda item: modfunc(func(transfunc(item)))
-
-
-def select_or_reject(args, kwargs, modfunc, lookup_attr):
-    seq, func = prepare_select_or_reject(args, kwargs, modfunc, lookup_attr)
-    if seq:
-        for item in seq:
-            if func(item):
-                yield item
-
-
-FILTERS = {
-    'abs':                  abs,
-    'attr':                 do_attr,
-    'batch':                do_batch,
-    'capitalize':           do_capitalize,
-    'center':               do_center,
-    'count':                len,
-    'd':                    do_default,
-    'default':              do_default,
-    'dictsort':             do_dictsort,
-    'e':                    escape,
-    'escape':               escape,
-    'filesizeformat':       do_filesizeformat,
-    'first':                do_first,
-    'float':                do_float,
-    'forceescape':          do_forceescape,
-    'format':               do_format,
-    'groupby':              do_groupby,
-    'indent':               do_indent,
-    'int':                  do_int,
-    'join':                 do_join,
-    'last':                 do_last,
-    'length':               len,
-    'list':                 do_list,
-    'lower':                do_lower,
-    'map':                  do_map,
-    'min':                  do_min,
-    'max':                  do_max,
-    'pprint':               do_pprint,
-    'random':               do_random,
-    'reject':               do_reject,
-    'rejectattr':           do_rejectattr,
-    'replace':              do_replace,
-    'reverse':              do_reverse,
-    'round':                do_round,
-    'safe':                 do_mark_safe,
-    'select':               do_select,
-    'selectattr':           do_selectattr,
-    'slice':                do_slice,
-    'sort':                 do_sort,
-    'string':               soft_unicode,
-    'striptags':            do_striptags,
-    'sum':                  do_sum,
-    'title':                do_title,
-    'trim':                 do_trim,
-    'truncate':             do_truncate,
-    'unique':               do_unique,
-    'upper':                do_upper,
-    'urlencode':            do_urlencode,
-    'urlize':               do_urlize,
-    'wordcount':            do_wordcount,
-    'wordwrap':             do_wordwrap,
-    'xmlattr':              do_xmlattr,
-    'tojson':               do_tojson,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/idtracking.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/idtracking.py
deleted file mode 100644
index 491bfe083..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/idtracking.py
+++ /dev/null
@@ -1,286 +0,0 @@
-from jinja2.visitor import NodeVisitor
-from jinja2._compat import iteritems
-
-
-VAR_LOAD_PARAMETER = 'param'
-VAR_LOAD_RESOLVE = 'resolve'
-VAR_LOAD_ALIAS = 'alias'
-VAR_LOAD_UNDEFINED = 'undefined'
-
-
-def find_symbols(nodes, parent_symbols=None):
-    sym = Symbols(parent=parent_symbols)
-    visitor = FrameSymbolVisitor(sym)
-    for node in nodes:
-        visitor.visit(node)
-    return sym
-
-
-def symbols_for_node(node, parent_symbols=None):
-    sym = Symbols(parent=parent_symbols)
-    sym.analyze_node(node)
-    return sym
-
-
-class Symbols(object):
-
-    def __init__(self, parent=None, level=None):
-        if level is None:
-            if parent is None:
-                level = 0
-            else:
-                level = parent.level + 1
-        self.level = level
-        self.parent = parent
-        self.refs = {}
-        self.loads = {}
-        self.stores = set()
-
-    def analyze_node(self, node, **kwargs):
-        visitor = RootVisitor(self)
-        visitor.visit(node, **kwargs)
-
-    def _define_ref(self, name, load=None):
-        ident = 'l_%d_%s' % (self.level, name)
-        self.refs[name] = ident
-        if load is not None:
-            self.loads[ident] = load
-        return ident
-
-    def find_load(self, target):
-        if target in self.loads:
-            return self.loads[target]
-        if self.parent is not None:
-            return self.parent.find_load(target)
-
-    def find_ref(self, name):
-        if name in self.refs:
-            return self.refs[name]
-        if self.parent is not None:
-            return self.parent.find_ref(name)
-
-    def ref(self, name):
-        rv = self.find_ref(name)
-        if rv is None:
-            raise AssertionError('Tried to resolve a name to a reference that '
-                                 'was unknown to the frame (%r)' % name)
-        return rv
-
-    def copy(self):
-        rv = object.__new__(self.__class__)
-        rv.__dict__.update(self.__dict__)
-        rv.refs = self.refs.copy()
-        rv.loads = self.loads.copy()
-        rv.stores = self.stores.copy()
-        return rv
-
-    def store(self, name):
-        self.stores.add(name)
-
-        # If we have not see the name referenced yet, we need to figure
-        # out what to set it to.
-        if name not in self.refs:
-            # If there is a parent scope we check if the name has a
-            # reference there.  If it does it means we might have to alias
-            # to a variable there.
-            if self.parent is not None:
-                outer_ref = self.parent.find_ref(name)
-                if outer_ref is not None:
-                    self._define_ref(name, load=(VAR_LOAD_ALIAS, outer_ref))
-                    return
-
-            # Otherwise we can just set it to undefined.
-            self._define_ref(name, load=(VAR_LOAD_UNDEFINED, None))
-
-    def declare_parameter(self, name):
-        self.stores.add(name)
-        return self._define_ref(name, load=(VAR_LOAD_PARAMETER, None))
-
-    def load(self, name):
-        target = self.find_ref(name)
-        if target is None:
-            self._define_ref(name, load=(VAR_LOAD_RESOLVE, name))
-
-    def branch_update(self, branch_symbols):
-        stores = {}
-        for branch in branch_symbols:
-            for target in branch.stores:
-                if target in self.stores:
-                    continue
-                stores[target] = stores.get(target, 0) + 1
-
-        for sym in branch_symbols:
-            self.refs.update(sym.refs)
-            self.loads.update(sym.loads)
-            self.stores.update(sym.stores)
-
-        for name, branch_count in iteritems(stores):
-            if branch_count == len(branch_symbols):
-                continue
-            target = self.find_ref(name)
-            assert target is not None, 'should not happen'
-
-            if self.parent is not None:
-                outer_target = self.parent.find_ref(name)
-                if outer_target is not None:
-                    self.loads[target] = (VAR_LOAD_ALIAS, outer_target)
-                    continue
-            self.loads[target] = (VAR_LOAD_RESOLVE, name)
-
-    def dump_stores(self):
-        rv = {}
-        node = self
-        while node is not None:
-            for name in node.stores:
-                if name not in rv:
-                    rv[name] = self.find_ref(name)
-            node = node.parent
-        return rv
-
-    def dump_param_targets(self):
-        rv = set()
-        node = self
-        while node is not None:
-            for target, (instr, _) in iteritems(self.loads):
-                if instr == VAR_LOAD_PARAMETER:
-                    rv.add(target)
-            node = node.parent
-        return rv
-
-
-class RootVisitor(NodeVisitor):
-
-    def __init__(self, symbols):
-        self.sym_visitor = FrameSymbolVisitor(symbols)
-
-    def _simple_visit(self, node, **kwargs):
-        for child in node.iter_child_nodes():
-            self.sym_visitor.visit(child)
-
-    visit_Template = visit_Block = visit_Macro = visit_FilterBlock = \
-        visit_Scope = visit_If = visit_ScopedEvalContextModifier = \
-        _simple_visit
-
-    def visit_AssignBlock(self, node, **kwargs):
-        for child in node.body:
-            self.sym_visitor.visit(child)
-
-    def visit_CallBlock(self, node, **kwargs):
-        for child in node.iter_child_nodes(exclude=('call',)):
-            self.sym_visitor.visit(child)
-
-    def visit_OverlayScope(self, node, **kwargs):
-        for child in node.body:
-            self.sym_visitor.visit(child)
-
-    def visit_For(self, node, for_branch='body', **kwargs):
-        if for_branch == 'body':
-            self.sym_visitor.visit(node.target, store_as_param=True)
-            branch = node.body
-        elif for_branch == 'else':
-            branch = node.else_
-        elif for_branch == 'test':
-            self.sym_visitor.visit(node.target, store_as_param=True)
-            if node.test is not None:
-                self.sym_visitor.visit(node.test)
-            return
-        else:
-            raise RuntimeError('Unknown for branch')
-        for item in branch or ():
-            self.sym_visitor.visit(item)
-
-    def visit_With(self, node, **kwargs):
-        for target in node.targets:
-            self.sym_visitor.visit(target)
-        for child in node.body:
-            self.sym_visitor.visit(child)
-
-    def generic_visit(self, node, *args, **kwargs):
-        raise NotImplementedError('Cannot find symbols for %r' %
-                                  node.__class__.__name__)
-
-
-class FrameSymbolVisitor(NodeVisitor):
-    """A visitor for `Frame.inspect`."""
-
-    def __init__(self, symbols):
-        self.symbols = symbols
-
-    def visit_Name(self, node, store_as_param=False, **kwargs):
-        """All assignments to names go through this function."""
-        if store_as_param or node.ctx == 'param':
-            self.symbols.declare_parameter(node.name)
-        elif node.ctx == 'store':
-            self.symbols.store(node.name)
-        elif node.ctx == 'load':
-            self.symbols.load(node.name)
-
-    def visit_NSRef(self, node, **kwargs):
-        self.symbols.load(node.name)
-
-    def visit_If(self, node, **kwargs):
-        self.visit(node.test, **kwargs)
-
-        original_symbols = self.symbols
-
-        def inner_visit(nodes):
-            self.symbols = rv = original_symbols.copy()
-            for subnode in nodes:
-                self.visit(subnode, **kwargs)
-            self.symbols = original_symbols
-            return rv
-
-        body_symbols = inner_visit(node.body)
-        elif_symbols = inner_visit(node.elif_)
-        else_symbols = inner_visit(node.else_ or ())
-
-        self.symbols.branch_update([body_symbols, elif_symbols, else_symbols])
-
-    def visit_Macro(self, node, **kwargs):
-        self.symbols.store(node.name)
-
-    def visit_Import(self, node, **kwargs):
-        self.generic_visit(node, **kwargs)
-        self.symbols.store(node.target)
-
-    def visit_FromImport(self, node, **kwargs):
-        self.generic_visit(node, **kwargs)
-        for name in node.names:
-            if isinstance(name, tuple):
-                self.symbols.store(name[1])
-            else:
-                self.symbols.store(name)
-
-    def visit_Assign(self, node, **kwargs):
-        """Visit assignments in the correct order."""
-        self.visit(node.node, **kwargs)
-        self.visit(node.target, **kwargs)
-
-    def visit_For(self, node, **kwargs):
-        """Visiting stops at for blocks.  However the block sequence
-        is visited as part of the outer scope.
-        """
-        self.visit(node.iter, **kwargs)
-
-    def visit_CallBlock(self, node, **kwargs):
-        self.visit(node.call, **kwargs)
-
-    def visit_FilterBlock(self, node, **kwargs):
-        self.visit(node.filter, **kwargs)
-
-    def visit_With(self, node, **kwargs):
-        for target in node.values:
-            self.visit(target)
-
-    def visit_AssignBlock(self, node, **kwargs):
-        """Stop visiting at block assigns."""
-        self.visit(node.target, **kwargs)
-
-    def visit_Scope(self, node, **kwargs):
-        """Stop visiting at scopes."""
-
-    def visit_Block(self, node, **kwargs):
-        """Stop visiting at blocks."""
-
-    def visit_OverlayScope(self, node, **kwargs):
-        """Do not visit into overlay scopes."""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/lexer.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/lexer.py
deleted file mode 100644
index 6fd135dd5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/lexer.py
+++ /dev/null
@@ -1,739 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.lexer
-    ~~~~~~~~~~~~
-
-    This module implements a Jinja / Python combination lexer. The
-    `Lexer` class provided by this module is used to do some preprocessing
-    for Jinja.
-
-    On the one hand it filters out invalid operators like the bitshift
-    operators we don't allow in templates. On the other hand it separates
-    template code and python code in expressions.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-from collections import deque
-from operator import itemgetter
-
-from jinja2._compat import implements_iterator, intern, iteritems, text_type
-from jinja2.exceptions import TemplateSyntaxError
-from jinja2.utils import LRUCache
-
-# cache for the lexers. Exists in order to be able to have multiple
-# environments with the same lexer
-_lexer_cache = LRUCache(50)
-
-# static regular expressions
-whitespace_re = re.compile(r'\s+', re.U)
-string_re = re.compile(r"('([^'\\]*(?:\\.[^'\\]*)*)'"
-                       r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S)
-integer_re = re.compile(r'\d+')
-
-try:
-    # check if this Python supports Unicode identifiers
-    compile('föö', '<unknown>', 'eval')
-except SyntaxError:
-    # no Unicode support, use ASCII identifiers
-    name_re = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*')
-    check_ident = False
-else:
-    # Unicode support, build a pattern to match valid characters, and set flag
-    # to use str.isidentifier to validate during lexing
-    from jinja2 import _identifier
-    name_re = re.compile(r'[\w{0}]+'.format(_identifier.pattern))
-    check_ident = True
-    # remove the pattern from memory after building the regex
-    import sys
-    del sys.modules['jinja2._identifier']
-    import jinja2
-    del jinja2._identifier
-    del _identifier
-
-float_re = re.compile(r'(?<!\.)\d+\.\d+')
-newline_re = re.compile(r'(\r\n|\r|\n)')
-
-# internal the tokens and keep references to them
-TOKEN_ADD = intern('add')
-TOKEN_ASSIGN = intern('assign')
-TOKEN_COLON = intern('colon')
-TOKEN_COMMA = intern('comma')
-TOKEN_DIV = intern('div')
-TOKEN_DOT = intern('dot')
-TOKEN_EQ = intern('eq')
-TOKEN_FLOORDIV = intern('floordiv')
-TOKEN_GT = intern('gt')
-TOKEN_GTEQ = intern('gteq')
-TOKEN_LBRACE = intern('lbrace')
-TOKEN_LBRACKET = intern('lbracket')
-TOKEN_LPAREN = intern('lparen')
-TOKEN_LT = intern('lt')
-TOKEN_LTEQ = intern('lteq')
-TOKEN_MOD = intern('mod')
-TOKEN_MUL = intern('mul')
-TOKEN_NE = intern('ne')
-TOKEN_PIPE = intern('pipe')
-TOKEN_POW = intern('pow')
-TOKEN_RBRACE = intern('rbrace')
-TOKEN_RBRACKET = intern('rbracket')
-TOKEN_RPAREN = intern('rparen')
-TOKEN_SEMICOLON = intern('semicolon')
-TOKEN_SUB = intern('sub')
-TOKEN_TILDE = intern('tilde')
-TOKEN_WHITESPACE = intern('whitespace')
-TOKEN_FLOAT = intern('float')
-TOKEN_INTEGER = intern('integer')
-TOKEN_NAME = intern('name')
-TOKEN_STRING = intern('string')
-TOKEN_OPERATOR = intern('operator')
-TOKEN_BLOCK_BEGIN = intern('block_begin')
-TOKEN_BLOCK_END = intern('block_end')
-TOKEN_VARIABLE_BEGIN = intern('variable_begin')
-TOKEN_VARIABLE_END = intern('variable_end')
-TOKEN_RAW_BEGIN = intern('raw_begin')
-TOKEN_RAW_END = intern('raw_end')
-TOKEN_COMMENT_BEGIN = intern('comment_begin')
-TOKEN_COMMENT_END = intern('comment_end')
-TOKEN_COMMENT = intern('comment')
-TOKEN_LINESTATEMENT_BEGIN = intern('linestatement_begin')
-TOKEN_LINESTATEMENT_END = intern('linestatement_end')
-TOKEN_LINECOMMENT_BEGIN = intern('linecomment_begin')
-TOKEN_LINECOMMENT_END = intern('linecomment_end')
-TOKEN_LINECOMMENT = intern('linecomment')
-TOKEN_DATA = intern('data')
-TOKEN_INITIAL = intern('initial')
-TOKEN_EOF = intern('eof')
-
-# bind operators to token types
-operators = {
-    '+':            TOKEN_ADD,
-    '-':            TOKEN_SUB,
-    '/':            TOKEN_DIV,
-    '//':           TOKEN_FLOORDIV,
-    '*':            TOKEN_MUL,
-    '%':            TOKEN_MOD,
-    '**':           TOKEN_POW,
-    '~':            TOKEN_TILDE,
-    '[':            TOKEN_LBRACKET,
-    ']':            TOKEN_RBRACKET,
-    '(':            TOKEN_LPAREN,
-    ')':            TOKEN_RPAREN,
-    '{':            TOKEN_LBRACE,
-    '}':            TOKEN_RBRACE,
-    '==':           TOKEN_EQ,
-    '!=':           TOKEN_NE,
-    '>':            TOKEN_GT,
-    '>=':           TOKEN_GTEQ,
-    '<':            TOKEN_LT,
-    '<=':           TOKEN_LTEQ,
-    '=':            TOKEN_ASSIGN,
-    '.':            TOKEN_DOT,
-    ':':            TOKEN_COLON,
-    '|':            TOKEN_PIPE,
-    ',':            TOKEN_COMMA,
-    ';':            TOKEN_SEMICOLON
-}
-
-reverse_operators = dict([(v, k) for k, v in iteritems(operators)])
-assert len(operators) == len(reverse_operators), 'operators dropped'
-operator_re = re.compile('(%s)' % '|'.join(re.escape(x) for x in
-                         sorted(operators, key=lambda x: -len(x))))
-
-ignored_tokens = frozenset([TOKEN_COMMENT_BEGIN, TOKEN_COMMENT,
-                            TOKEN_COMMENT_END, TOKEN_WHITESPACE,
-                            TOKEN_LINECOMMENT_BEGIN, TOKEN_LINECOMMENT_END,
-                            TOKEN_LINECOMMENT])
-ignore_if_empty = frozenset([TOKEN_WHITESPACE, TOKEN_DATA,
-                             TOKEN_COMMENT, TOKEN_LINECOMMENT])
-
-
-def _describe_token_type(token_type):
-    if token_type in reverse_operators:
-        return reverse_operators[token_type]
-    return {
-        TOKEN_COMMENT_BEGIN:        'begin of comment',
-        TOKEN_COMMENT_END:          'end of comment',
-        TOKEN_COMMENT:              'comment',
-        TOKEN_LINECOMMENT:          'comment',
-        TOKEN_BLOCK_BEGIN:          'begin of statement block',
-        TOKEN_BLOCK_END:            'end of statement block',
-        TOKEN_VARIABLE_BEGIN:       'begin of print statement',
-        TOKEN_VARIABLE_END:         'end of print statement',
-        TOKEN_LINESTATEMENT_BEGIN:  'begin of line statement',
-        TOKEN_LINESTATEMENT_END:    'end of line statement',
-        TOKEN_DATA:                 'template data / text',
-        TOKEN_EOF:                  'end of template'
-    }.get(token_type, token_type)
-
-
-def describe_token(token):
-    """Returns a description of the token."""
-    if token.type == 'name':
-        return token.value
-    return _describe_token_type(token.type)
-
-
-def describe_token_expr(expr):
-    """Like `describe_token` but for token expressions."""
-    if ':' in expr:
-        type, value = expr.split(':', 1)
-        if type == 'name':
-            return value
-    else:
-        type = expr
-    return _describe_token_type(type)
-
-
-def count_newlines(value):
-    """Count the number of newline characters in the string.  This is
-    useful for extensions that filter a stream.
-    """
-    return len(newline_re.findall(value))
-
-
-def compile_rules(environment):
-    """Compiles all the rules from the environment into a list of rules."""
-    e = re.escape
-    rules = [
-        (len(environment.comment_start_string), 'comment',
-         e(environment.comment_start_string)),
-        (len(environment.block_start_string), 'block',
-         e(environment.block_start_string)),
-        (len(environment.variable_start_string), 'variable',
-         e(environment.variable_start_string))
-    ]
-
-    if environment.line_statement_prefix is not None:
-        rules.append((len(environment.line_statement_prefix), 'linestatement',
-                      r'^[ \t\v]*' + e(environment.line_statement_prefix)))
-    if environment.line_comment_prefix is not None:
-        rules.append((len(environment.line_comment_prefix), 'linecomment',
-                      r'(?:^|(?<=\S))[^\S\r\n]*' +
-                      e(environment.line_comment_prefix)))
-
-    return [x[1:] for x in sorted(rules, reverse=True)]
-
-
-class Failure(object):
-    """Class that raises a `TemplateSyntaxError` if called.
-    Used by the `Lexer` to specify known errors.
-    """
-
-    def __init__(self, message, cls=TemplateSyntaxError):
-        self.message = message
-        self.error_class = cls
-
-    def __call__(self, lineno, filename):
-        raise self.error_class(self.message, lineno, filename)
-
-
-class Token(tuple):
-    """Token class."""
-    __slots__ = ()
-    lineno, type, value = (property(itemgetter(x)) for x in range(3))
-
-    def __new__(cls, lineno, type, value):
-        return tuple.__new__(cls, (lineno, intern(str(type)), value))
-
-    def __str__(self):
-        if self.type in reverse_operators:
-            return reverse_operators[self.type]
-        elif self.type == 'name':
-            return self.value
-        return self.type
-
-    def test(self, expr):
-        """Test a token against a token expression.  This can either be a
-        token type or ``'token_type:token_value'``.  This can only test
-        against string values and types.
-        """
-        # here we do a regular string equality check as test_any is usually
-        # passed an iterable of not interned strings.
-        if self.type == expr:
-            return True
-        elif ':' in expr:
-            return expr.split(':', 1) == [self.type, self.value]
-        return False
-
-    def test_any(self, *iterable):
-        """Test against multiple token expressions."""
-        for expr in iterable:
-            if self.test(expr):
-                return True
-        return False
-
-    def __repr__(self):
-        return 'Token(%r, %r, %r)' % (
-            self.lineno,
-            self.type,
-            self.value
-        )
-
-
-@implements_iterator
-class TokenStreamIterator(object):
-    """The iterator for tokenstreams.  Iterate over the stream
-    until the eof token is reached.
-    """
-
-    def __init__(self, stream):
-        self.stream = stream
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        token = self.stream.current
-        if token.type is TOKEN_EOF:
-            self.stream.close()
-            raise StopIteration()
-        next(self.stream)
-        return token
-
-
-@implements_iterator
-class TokenStream(object):
-    """A token stream is an iterable that yields :class:`Token`\\s.  The
-    parser however does not iterate over it but calls :meth:`next` to go
-    one token ahead.  The current active token is stored as :attr:`current`.
-    """
-
-    def __init__(self, generator, name, filename):
-        self._iter = iter(generator)
-        self._pushed = deque()
-        self.name = name
-        self.filename = filename
-        self.closed = False
-        self.current = Token(1, TOKEN_INITIAL, '')
-        next(self)
-
-    def __iter__(self):
-        return TokenStreamIterator(self)
-
-    def __bool__(self):
-        return bool(self._pushed) or self.current.type is not TOKEN_EOF
-    __nonzero__ = __bool__  # py2
-
-    eos = property(lambda x: not x, doc="Are we at the end of the stream?")
-
-    def push(self, token):
-        """Push a token back to the stream."""
-        self._pushed.append(token)
-
-    def look(self):
-        """Look at the next token."""
-        old_token = next(self)
-        result = self.current
-        self.push(result)
-        self.current = old_token
-        return result
-
-    def skip(self, n=1):
-        """Got n tokens ahead."""
-        for x in range(n):
-            next(self)
-
-    def next_if(self, expr):
-        """Perform the token test and return the token if it matched.
-        Otherwise the return value is `None`.
-        """
-        if self.current.test(expr):
-            return next(self)
-
-    def skip_if(self, expr):
-        """Like :meth:`next_if` but only returns `True` or `False`."""
-        return self.next_if(expr) is not None
-
-    def __next__(self):
-        """Go one token ahead and return the old one.
-
-        Use the built-in :func:`next` instead of calling this directly.
-        """
-        rv = self.current
-        if self._pushed:
-            self.current = self._pushed.popleft()
-        elif self.current.type is not TOKEN_EOF:
-            try:
-                self.current = next(self._iter)
-            except StopIteration:
-                self.close()
-        return rv
-
-    def close(self):
-        """Close the stream."""
-        self.current = Token(self.current.lineno, TOKEN_EOF, '')
-        self._iter = None
-        self.closed = True
-
-    def expect(self, expr):
-        """Expect a given token type and return it.  This accepts the same
-        argument as :meth:`jinja2.lexer.Token.test`.
-        """
-        if not self.current.test(expr):
-            expr = describe_token_expr(expr)
-            if self.current.type is TOKEN_EOF:
-                raise TemplateSyntaxError('unexpected end of template, '
-                                          'expected %r.' % expr,
-                                          self.current.lineno,
-                                          self.name, self.filename)
-            raise TemplateSyntaxError("expected token %r, got %r" %
-                                      (expr, describe_token(self.current)),
-                                      self.current.lineno,
-                                      self.name, self.filename)
-        try:
-            return self.current
-        finally:
-            next(self)
-
-
-def get_lexer(environment):
-    """Return a lexer which is probably cached."""
-    key = (environment.block_start_string,
-           environment.block_end_string,
-           environment.variable_start_string,
-           environment.variable_end_string,
-           environment.comment_start_string,
-           environment.comment_end_string,
-           environment.line_statement_prefix,
-           environment.line_comment_prefix,
-           environment.trim_blocks,
-           environment.lstrip_blocks,
-           environment.newline_sequence,
-           environment.keep_trailing_newline)
-    lexer = _lexer_cache.get(key)
-    if lexer is None:
-        lexer = Lexer(environment)
-        _lexer_cache[key] = lexer
-    return lexer
-
-
-class Lexer(object):
-    """Class that implements a lexer for a given environment. Automatically
-    created by the environment class, usually you don't have to do that.
-
-    Note that the lexer is not automatically bound to an environment.
-    Multiple environments can share the same lexer.
-    """
-
-    def __init__(self, environment):
-        # shortcuts
-        c = lambda x: re.compile(x, re.M | re.S)
-        e = re.escape
-
-        # lexing rules for tags
-        tag_rules = [
-            (whitespace_re, TOKEN_WHITESPACE, None),
-            (float_re, TOKEN_FLOAT, None),
-            (integer_re, TOKEN_INTEGER, None),
-            (name_re, TOKEN_NAME, None),
-            (string_re, TOKEN_STRING, None),
-            (operator_re, TOKEN_OPERATOR, None)
-        ]
-
-        # assemble the root lexing rule. because "|" is ungreedy
-        # we have to sort by length so that the lexer continues working
-        # as expected when we have parsing rules like <% for block and
-        # <%= for variables. (if someone wants asp like syntax)
-        # variables are just part of the rules if variable processing
-        # is required.
-        root_tag_rules = compile_rules(environment)
-
-        # block suffix if trimming is enabled
-        block_suffix_re = environment.trim_blocks and '\\n?' or ''
-
-        # strip leading spaces if lstrip_blocks is enabled
-        prefix_re = {}
-        if environment.lstrip_blocks:
-            # use '{%+' to manually disable lstrip_blocks behavior
-            no_lstrip_re = e('+')
-            # detect overlap between block and variable or comment strings
-            block_diff = c(r'^%s(.*)' % e(environment.block_start_string))
-            # make sure we don't mistake a block for a variable or a comment
-            m = block_diff.match(environment.comment_start_string)
-            no_lstrip_re += m and r'|%s' % e(m.group(1)) or ''
-            m = block_diff.match(environment.variable_start_string)
-            no_lstrip_re += m and r'|%s' % e(m.group(1)) or ''
-
-            # detect overlap between comment and variable strings
-            comment_diff = c(r'^%s(.*)' % e(environment.comment_start_string))
-            m = comment_diff.match(environment.variable_start_string)
-            no_variable_re = m and r'(?!%s)' % e(m.group(1)) or ''
-
-            lstrip_re = r'^[ \t]*'
-            block_prefix_re = r'%s%s(?!%s)|%s\+?' % (
-                    lstrip_re,
-                    e(environment.block_start_string),
-                    no_lstrip_re,
-                    e(environment.block_start_string),
-                    )
-            comment_prefix_re = r'%s%s%s|%s\+?' % (
-                    lstrip_re,
-                    e(environment.comment_start_string),
-                    no_variable_re,
-                    e(environment.comment_start_string),
-                    )
-            prefix_re['block'] = block_prefix_re
-            prefix_re['comment'] = comment_prefix_re
-        else:
-            block_prefix_re = '%s' % e(environment.block_start_string)
-
-        self.newline_sequence = environment.newline_sequence
-        self.keep_trailing_newline = environment.keep_trailing_newline
-
-        # global lexing rules
-        self.rules = {
-            'root': [
-                # directives
-                (c('(.*?)(?:%s)' % '|'.join(
-                    [r'(?P<raw_begin>(?:\s*%s\-|%s)\s*raw\s*(?:\-%s\s*|%s))' % (
-                        e(environment.block_start_string),
-                        block_prefix_re,
-                        e(environment.block_end_string),
-                        e(environment.block_end_string)
-                    )] + [
-                        r'(?P<%s_begin>\s*%s\-|%s)' % (n, r, prefix_re.get(n,r))
-                        for n, r in root_tag_rules
-                    ])), (TOKEN_DATA, '#bygroup'), '#bygroup'),
-                # data
-                (c('.+'), TOKEN_DATA, None)
-            ],
-            # comments
-            TOKEN_COMMENT_BEGIN: [
-                (c(r'(.*?)((?:\-%s\s*|%s)%s)' % (
-                    e(environment.comment_end_string),
-                    e(environment.comment_end_string),
-                    block_suffix_re
-                )), (TOKEN_COMMENT, TOKEN_COMMENT_END), '#pop'),
-                (c('(.)'), (Failure('Missing end of comment tag'),), None)
-            ],
-            # blocks
-            TOKEN_BLOCK_BEGIN: [
-                (c(r'(?:\-%s\s*|%s)%s' % (
-                    e(environment.block_end_string),
-                    e(environment.block_end_string),
-                    block_suffix_re
-                )), TOKEN_BLOCK_END, '#pop'),
-            ] + tag_rules,
-            # variables
-            TOKEN_VARIABLE_BEGIN: [
-                (c(r'\-%s\s*|%s' % (
-                    e(environment.variable_end_string),
-                    e(environment.variable_end_string)
-                )), TOKEN_VARIABLE_END, '#pop')
-            ] + tag_rules,
-            # raw block
-            TOKEN_RAW_BEGIN: [
-                (c(r'(.*?)((?:\s*%s\-|%s)\s*endraw\s*(?:\-%s\s*|%s%s))' % (
-                    e(environment.block_start_string),
-                    block_prefix_re,
-                    e(environment.block_end_string),
-                    e(environment.block_end_string),
-                    block_suffix_re
-                )), (TOKEN_DATA, TOKEN_RAW_END), '#pop'),
-                (c('(.)'), (Failure('Missing end of raw directive'),), None)
-            ],
-            # line statements
-            TOKEN_LINESTATEMENT_BEGIN: [
-                (c(r'\s*(\n|$)'), TOKEN_LINESTATEMENT_END, '#pop')
-            ] + tag_rules,
-            # line comments
-            TOKEN_LINECOMMENT_BEGIN: [
-                (c(r'(.*?)()(?=\n|$)'), (TOKEN_LINECOMMENT,
-                 TOKEN_LINECOMMENT_END), '#pop')
-            ]
-        }
-
-    def _normalize_newlines(self, value):
-        """Called for strings and template data to normalize it to unicode."""
-        return newline_re.sub(self.newline_sequence, value)
-
-    def tokenize(self, source, name=None, filename=None, state=None):
-        """Calls tokeniter + tokenize and wraps it in a token stream.
-        """
-        stream = self.tokeniter(source, name, filename, state)
-        return TokenStream(self.wrap(stream, name, filename), name, filename)
-
-    def wrap(self, stream, name=None, filename=None):
-        """This is called with the stream as returned by `tokenize` and wraps
-        every token in a :class:`Token` and converts the value.
-        """
-        for lineno, token, value in stream:
-            if token in ignored_tokens:
-                continue
-            elif token == 'linestatement_begin':
-                token = 'block_begin'
-            elif token == 'linestatement_end':
-                token = 'block_end'
-            # we are not interested in those tokens in the parser
-            elif token in ('raw_begin', 'raw_end'):
-                continue
-            elif token == 'data':
-                value = self._normalize_newlines(value)
-            elif token == 'keyword':
-                token = value
-            elif token == 'name':
-                value = str(value)
-                if check_ident and not value.isidentifier():
-                    raise TemplateSyntaxError(
-                        'Invalid character in identifier',
-                        lineno, name, filename)
-            elif token == 'string':
-                # try to unescape string
-                try:
-                    value = self._normalize_newlines(value[1:-1]) \
-                        .encode('ascii', 'backslashreplace') \
-                        .decode('unicode-escape')
-                except Exception as e:
-                    msg = str(e).split(':')[-1].strip()
-                    raise TemplateSyntaxError(msg, lineno, name, filename)
-            elif token == 'integer':
-                value = int(value)
-            elif token == 'float':
-                value = float(value)
-            elif token == 'operator':
-                token = operators[value]
-            yield Token(lineno, token, value)
-
-    def tokeniter(self, source, name, filename=None, state=None):
-        """This method tokenizes the text and returns the tokens in a
-        generator.  Use this method if you just want to tokenize a template.
-        """
-        source = text_type(source)
-        lines = source.splitlines()
-        if self.keep_trailing_newline and source:
-            for newline in ('\r\n', '\r', '\n'):
-                if source.endswith(newline):
-                    lines.append('')
-                    break
-        source = '\n'.join(lines)
-        pos = 0
-        lineno = 1
-        stack = ['root']
-        if state is not None and state != 'root':
-            assert state in ('variable', 'block'), 'invalid state'
-            stack.append(state + '_begin')
-        else:
-            state = 'root'
-        statetokens = self.rules[stack[-1]]
-        source_length = len(source)
-
-        balancing_stack = []
-
-        while 1:
-            # tokenizer loop
-            for regex, tokens, new_state in statetokens:
-                m = regex.match(source, pos)
-                # if no match we try again with the next rule
-                if m is None:
-                    continue
-
-                # we only match blocks and variables if braces / parentheses
-                # are balanced. continue parsing with the lower rule which
-                # is the operator rule. do this only if the end tags look
-                # like operators
-                if balancing_stack and \
-                   tokens in ('variable_end', 'block_end',
-                              'linestatement_end'):
-                    continue
-
-                # tuples support more options
-                if isinstance(tokens, tuple):
-                    for idx, token in enumerate(tokens):
-                        # failure group
-                        if token.__class__ is Failure:
-                            raise token(lineno, filename)
-                        # bygroup is a bit more complex, in that case we
-                        # yield for the current token the first named
-                        # group that matched
-                        elif token == '#bygroup':
-                            for key, value in iteritems(m.groupdict()):
-                                if value is not None:
-                                    yield lineno, key, value
-                                    lineno += value.count('\n')
-                                    break
-                            else:
-                                raise RuntimeError('%r wanted to resolve '
-                                                   'the token dynamically'
-                                                   ' but no group matched'
-                                                   % regex)
-                        # normal group
-                        else:
-                            data = m.group(idx + 1)
-                            if data or token not in ignore_if_empty:
-                                yield lineno, token, data
-                            lineno += data.count('\n')
-
-                # strings as token just are yielded as it.
-                else:
-                    data = m.group()
-                    # update brace/parentheses balance
-                    if tokens == 'operator':
-                        if data == '{':
-                            balancing_stack.append('}')
-                        elif data == '(':
-                            balancing_stack.append(')')
-                        elif data == '[':
-                            balancing_stack.append(']')
-                        elif data in ('}', ')', ']'):
-                            if not balancing_stack:
-                                raise TemplateSyntaxError('unexpected \'%s\'' %
-                                                          data, lineno, name,
-                                                          filename)
-                            expected_op = balancing_stack.pop()
-                            if expected_op != data:
-                                raise TemplateSyntaxError('unexpected \'%s\', '
-                                                          'expected \'%s\'' %
-                                                          (data, expected_op),
-                                                          lineno, name,
-                                                          filename)
-                    # yield items
-                    if data or tokens not in ignore_if_empty:
-                        yield lineno, tokens, data
-                    lineno += data.count('\n')
-
-                # fetch new position into new variable so that we can check
-                # if there is a internal parsing error which would result
-                # in an infinite loop
-                pos2 = m.end()
-
-                # handle state changes
-                if new_state is not None:
-                    # remove the uppermost state
-                    if new_state == '#pop':
-                        stack.pop()
-                    # resolve the new state by group checking
-                    elif new_state == '#bygroup':
-                        for key, value in iteritems(m.groupdict()):
-                            if value is not None:
-                                stack.append(key)
-                                break
-                        else:
-                            raise RuntimeError('%r wanted to resolve the '
-                                               'new state dynamically but'
-                                               ' no group matched' %
-                                               regex)
-                    # direct state name given
-                    else:
-                        stack.append(new_state)
-                    statetokens = self.rules[stack[-1]]
-                # we are still at the same position and no stack change.
-                # this means a loop without break condition, avoid that and
-                # raise error
-                elif pos2 == pos:
-                    raise RuntimeError('%r yielded empty string without '
-                                       'stack change' % regex)
-                # publish new function and start again
-                pos = pos2
-                break
-            # if loop terminated without break we haven't found a single match
-            # either we are at the end of the file or we have a problem
-            else:
-                # end of text
-                if pos >= source_length:
-                    return
-                # something went wrong
-                raise TemplateSyntaxError('unexpected char %r at %d' %
-                                          (source[pos], pos), lineno,
-                                          name, filename)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/loaders.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/loaders.py
deleted file mode 100644
index 4c7979376..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/loaders.py
+++ /dev/null
@@ -1,481 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.loaders
-    ~~~~~~~~~~~~~~
-
-    Jinja loader classes.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import sys
-import weakref
-from types import ModuleType
-from os import path
-from hashlib import sha1
-from jinja2.exceptions import TemplateNotFound
-from jinja2.utils import open_if_exists, internalcode
-from jinja2._compat import string_types, iteritems
-
-
-def split_template_path(template):
-    """Split a path into segments and perform a sanity check.  If it detects
-    '..' in the path it will raise a `TemplateNotFound` error.
-    """
-    pieces = []
-    for piece in template.split('/'):
-        if path.sep in piece \
-           or (path.altsep and path.altsep in piece) or \
-           piece == path.pardir:
-            raise TemplateNotFound(template)
-        elif piece and piece != '.':
-            pieces.append(piece)
-    return pieces
-
-
-class BaseLoader(object):
-    """Baseclass for all loaders.  Subclass this and override `get_source` to
-    implement a custom loading mechanism.  The environment provides a
-    `get_template` method that calls the loader's `load` method to get the
-    :class:`Template` object.
-
-    A very basic example for a loader that looks up templates on the file
-    system could look like this::
-
-        from jinja2 import BaseLoader, TemplateNotFound
-        from os.path import join, exists, getmtime
-
-        class MyLoader(BaseLoader):
-
-            def __init__(self, path):
-                self.path = path
-
-            def get_source(self, environment, template):
-                path = join(self.path, template)
-                if not exists(path):
-                    raise TemplateNotFound(template)
-                mtime = getmtime(path)
-                with file(path) as f:
-                    source = f.read().decode('utf-8')
-                return source, path, lambda: mtime == getmtime(path)
-    """
-
-    #: if set to `False` it indicates that the loader cannot provide access
-    #: to the source of templates.
-    #:
-    #: .. versionadded:: 2.4
-    has_source_access = True
-
-    def get_source(self, environment, template):
-        """Get the template source, filename and reload helper for a template.
-        It's passed the environment and template name and has to return a
-        tuple in the form ``(source, filename, uptodate)`` or raise a
-        `TemplateNotFound` error if it can't locate the template.
-
-        The source part of the returned tuple must be the source of the
-        template as unicode string or a ASCII bytestring.  The filename should
-        be the name of the file on the filesystem if it was loaded from there,
-        otherwise `None`.  The filename is used by python for the tracebacks
-        if no loader extension is used.
-
-        The last item in the tuple is the `uptodate` function.  If auto
-        reloading is enabled it's always called to check if the template
-        changed.  No arguments are passed so the function must store the
-        old state somewhere (for example in a closure).  If it returns `False`
-        the template will be reloaded.
-        """
-        if not self.has_source_access:
-            raise RuntimeError('%s cannot provide access to the source' %
-                               self.__class__.__name__)
-        raise TemplateNotFound(template)
-
-    def list_templates(self):
-        """Iterates over all templates.  If the loader does not support that
-        it should raise a :exc:`TypeError` which is the default behavior.
-        """
-        raise TypeError('this loader cannot iterate over all templates')
-
-    @internalcode
-    def load(self, environment, name, globals=None):
-        """Loads a template.  This method looks up the template in the cache
-        or loads one by calling :meth:`get_source`.  Subclasses should not
-        override this method as loaders working on collections of other
-        loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
-        will not call this method but `get_source` directly.
-        """
-        code = None
-        if globals is None:
-            globals = {}
-
-        # first we try to get the source for this template together
-        # with the filename and the uptodate function.
-        source, filename, uptodate = self.get_source(environment, name)
-
-        # try to load the code from the bytecode cache if there is a
-        # bytecode cache configured.
-        bcc = environment.bytecode_cache
-        if bcc is not None:
-            bucket = bcc.get_bucket(environment, name, filename, source)
-            code = bucket.code
-
-        # if we don't have code so far (not cached, no longer up to
-        # date) etc. we compile the template
-        if code is None:
-            code = environment.compile(source, name, filename)
-
-        # if the bytecode cache is available and the bucket doesn't
-        # have a code so far, we give the bucket the new code and put
-        # it back to the bytecode cache.
-        if bcc is not None and bucket.code is None:
-            bucket.code = code
-            bcc.set_bucket(bucket)
-
-        return environment.template_class.from_code(environment, code,
-                                                    globals, uptodate)
-
-
-class FileSystemLoader(BaseLoader):
-    """Loads templates from the file system.  This loader can find templates
-    in folders on the file system and is the preferred way to load them.
-
-    The loader takes the path to the templates as string, or if multiple
-    locations are wanted a list of them which is then looked up in the
-    given order::
-
-    >>> loader = FileSystemLoader('/path/to/templates')
-    >>> loader = FileSystemLoader(['/path/to/templates', '/other/path'])
-
-    Per default the template encoding is ``'utf-8'`` which can be changed
-    by setting the `encoding` parameter to something else.
-
-    To follow symbolic links, set the *followlinks* parameter to ``True``::
-
-    >>> loader = FileSystemLoader('/path/to/templates', followlinks=True)
-
-    .. versionchanged:: 2.8+
-       The *followlinks* parameter was added.
-    """
-
-    def __init__(self, searchpath, encoding='utf-8', followlinks=False):
-        if isinstance(searchpath, string_types):
-            searchpath = [searchpath]
-        self.searchpath = list(searchpath)
-        self.encoding = encoding
-        self.followlinks = followlinks
-
-    def get_source(self, environment, template):
-        pieces = split_template_path(template)
-        for searchpath in self.searchpath:
-            filename = path.join(searchpath, *pieces)
-            f = open_if_exists(filename)
-            if f is None:
-                continue
-            try:
-                contents = f.read().decode(self.encoding)
-            finally:
-                f.close()
-
-            mtime = path.getmtime(filename)
-
-            def uptodate():
-                try:
-                    return path.getmtime(filename) == mtime
-                except OSError:
-                    return False
-            return contents, filename, uptodate
-        raise TemplateNotFound(template)
-
-    def list_templates(self):
-        found = set()
-        for searchpath in self.searchpath:
-            walk_dir = os.walk(searchpath, followlinks=self.followlinks)
-            for dirpath, dirnames, filenames in walk_dir:
-                for filename in filenames:
-                    template = os.path.join(dirpath, filename) \
-                        [len(searchpath):].strip(os.path.sep) \
-                                          .replace(os.path.sep, '/')
-                    if template[:2] == './':
-                        template = template[2:]
-                    if template not in found:
-                        found.add(template)
-        return sorted(found)
-
-
-class PackageLoader(BaseLoader):
-    """Load templates from python eggs or packages.  It is constructed with
-    the name of the python package and the path to the templates in that
-    package::
-
-        loader = PackageLoader('mypackage', 'views')
-
-    If the package path is not given, ``'templates'`` is assumed.
-
-    Per default the template encoding is ``'utf-8'`` which can be changed
-    by setting the `encoding` parameter to something else.  Due to the nature
-    of eggs it's only possible to reload templates if the package was loaded
-    from the file system and not a zip file.
-    """
-
-    def __init__(self, package_name, package_path='templates',
-                 encoding='utf-8'):
-        from pkg_resources import DefaultProvider, ResourceManager, \
-                                  get_provider
-        provider = get_provider(package_name)
-        self.encoding = encoding
-        self.manager = ResourceManager()
-        self.filesystem_bound = isinstance(provider, DefaultProvider)
-        self.provider = provider
-        self.package_path = package_path
-
-    def get_source(self, environment, template):
-        pieces = split_template_path(template)
-        p = '/'.join((self.package_path,) + tuple(pieces))
-        if not self.provider.has_resource(p):
-            raise TemplateNotFound(template)
-
-        filename = uptodate = None
-        if self.filesystem_bound:
-            filename = self.provider.get_resource_filename(self.manager, p)
-            mtime = path.getmtime(filename)
-            def uptodate():
-                try:
-                    return path.getmtime(filename) == mtime
-                except OSError:
-                    return False
-
-        source = self.provider.get_resource_string(self.manager, p)
-        return source.decode(self.encoding), filename, uptodate
-
-    def list_templates(self):
-        path = self.package_path
-        if path[:2] == './':
-            path = path[2:]
-        elif path == '.':
-            path = ''
-        offset = len(path)
-        results = []
-        def _walk(path):
-            for filename in self.provider.resource_listdir(path):
-                fullname = path + '/' + filename
-                if self.provider.resource_isdir(fullname):
-                    _walk(fullname)
-                else:
-                    results.append(fullname[offset:].lstrip('/'))
-        _walk(path)
-        results.sort()
-        return results
-
-
-class DictLoader(BaseLoader):
-    """Loads a template from a python dict.  It's passed a dict of unicode
-    strings bound to template names.  This loader is useful for unittesting:
-
-    >>> loader = DictLoader({'index.html': 'source here'})
-
-    Because auto reloading is rarely useful this is disabled per default.
-    """
-
-    def __init__(self, mapping):
-        self.mapping = mapping
-
-    def get_source(self, environment, template):
-        if template in self.mapping:
-            source = self.mapping[template]
-            return source, None, lambda: source == self.mapping.get(template)
-        raise TemplateNotFound(template)
-
-    def list_templates(self):
-        return sorted(self.mapping)
-
-
-class FunctionLoader(BaseLoader):
-    """A loader that is passed a function which does the loading.  The
-    function receives the name of the template and has to return either
-    an unicode string with the template source, a tuple in the form ``(source,
-    filename, uptodatefunc)`` or `None` if the template does not exist.
-
-    >>> def load_template(name):
-    ...     if name == 'index.html':
-    ...         return '...'
-    ...
-    >>> loader = FunctionLoader(load_template)
-
-    The `uptodatefunc` is a function that is called if autoreload is enabled
-    and has to return `True` if the template is still up to date.  For more
-    details have a look at :meth:`BaseLoader.get_source` which has the same
-    return value.
-    """
-
-    def __init__(self, load_func):
-        self.load_func = load_func
-
-    def get_source(self, environment, template):
-        rv = self.load_func(template)
-        if rv is None:
-            raise TemplateNotFound(template)
-        elif isinstance(rv, string_types):
-            return rv, None, None
-        return rv
-
-
-class PrefixLoader(BaseLoader):
-    """A loader that is passed a dict of loaders where each loader is bound
-    to a prefix.  The prefix is delimited from the template by a slash per
-    default, which can be changed by setting the `delimiter` argument to
-    something else::
-
-        loader = PrefixLoader({
-            'app1':     PackageLoader('mypackage.app1'),
-            'app2':     PackageLoader('mypackage.app2')
-        })
-
-    By loading ``'app1/index.html'`` the file from the app1 package is loaded,
-    by loading ``'app2/index.html'`` the file from the second.
-    """
-
-    def __init__(self, mapping, delimiter='/'):
-        self.mapping = mapping
-        self.delimiter = delimiter
-
-    def get_loader(self, template):
-        try:
-            prefix, name = template.split(self.delimiter, 1)
-            loader = self.mapping[prefix]
-        except (ValueError, KeyError):
-            raise TemplateNotFound(template)
-        return loader, name
-
-    def get_source(self, environment, template):
-        loader, name = self.get_loader(template)
-        try:
-            return loader.get_source(environment, name)
-        except TemplateNotFound:
-            # re-raise the exception with the correct filename here.
-            # (the one that includes the prefix)
-            raise TemplateNotFound(template)
-
-    @internalcode
-    def load(self, environment, name, globals=None):
-        loader, local_name = self.get_loader(name)
-        try:
-            return loader.load(environment, local_name, globals)
-        except TemplateNotFound:
-            # re-raise the exception with the correct filename here.
-            # (the one that includes the prefix)
-            raise TemplateNotFound(name)
-
-    def list_templates(self):
-        result = []
-        for prefix, loader in iteritems(self.mapping):
-            for template in loader.list_templates():
-                result.append(prefix + self.delimiter + template)
-        return result
-
-
-class ChoiceLoader(BaseLoader):
-    """This loader works like the `PrefixLoader` just that no prefix is
-    specified.  If a template could not be found by one loader the next one
-    is tried.
-
-    >>> loader = ChoiceLoader([
-    ...     FileSystemLoader('/path/to/user/templates'),
-    ...     FileSystemLoader('/path/to/system/templates')
-    ... ])
-
-    This is useful if you want to allow users to override builtin templates
-    from a different location.
-    """
-
-    def __init__(self, loaders):
-        self.loaders = loaders
-
-    def get_source(self, environment, template):
-        for loader in self.loaders:
-            try:
-                return loader.get_source(environment, template)
-            except TemplateNotFound:
-                pass
-        raise TemplateNotFound(template)
-
-    @internalcode
-    def load(self, environment, name, globals=None):
-        for loader in self.loaders:
-            try:
-                return loader.load(environment, name, globals)
-            except TemplateNotFound:
-                pass
-        raise TemplateNotFound(name)
-
-    def list_templates(self):
-        found = set()
-        for loader in self.loaders:
-            found.update(loader.list_templates())
-        return sorted(found)
-
-
-class _TemplateModule(ModuleType):
-    """Like a normal module but with support for weak references"""
-
-
-class ModuleLoader(BaseLoader):
-    """This loader loads templates from precompiled templates.
-
-    Example usage:
-
-    >>> loader = ChoiceLoader([
-    ...     ModuleLoader('/path/to/compiled/templates'),
-    ...     FileSystemLoader('/path/to/templates')
-    ... ])
-
-    Templates can be precompiled with :meth:`Environment.compile_templates`.
-    """
-
-    has_source_access = False
-
-    def __init__(self, path):
-        package_name = '_jinja2_module_templates_%x' % id(self)
-
-        # create a fake module that looks for the templates in the
-        # path given.
-        mod = _TemplateModule(package_name)
-        if isinstance(path, string_types):
-            path = [path]
-        else:
-            path = list(path)
-        mod.__path__ = path
-
-        sys.modules[package_name] = weakref.proxy(mod,
-            lambda x: sys.modules.pop(package_name, None))
-
-        # the only strong reference, the sys.modules entry is weak
-        # so that the garbage collector can remove it once the
-        # loader that created it goes out of business.
-        self.module = mod
-        self.package_name = package_name
-
-    @staticmethod
-    def get_template_key(name):
-        return 'tmpl_' + sha1(name.encode('utf-8')).hexdigest()
-
-    @staticmethod
-    def get_module_filename(name):
-        return ModuleLoader.get_template_key(name) + '.py'
-
-    @internalcode
-    def load(self, environment, name, globals=None):
-        key = self.get_template_key(name)
-        module = '%s.%s' % (self.package_name, key)
-        mod = getattr(self.module, module, None)
-        if mod is None:
-            try:
-                mod = __import__(module, None, None, ['root'])
-            except ImportError:
-                raise TemplateNotFound(name)
-
-            # remove the entry from sys.modules, we only want the attribute
-            # on the module object we have stored on the loader.
-            sys.modules.pop(module, None)
-
-        return environment.template_class.from_module_dict(
-            environment, mod.__dict__, globals)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/meta.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/meta.py
deleted file mode 100644
index 7421914f7..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/meta.py
+++ /dev/null
@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.meta
-    ~~~~~~~~~~~
-
-    This module implements various functions that exposes information about
-    templates that might be interesting for various kinds of applications.
-
-    :copyright: (c) 2017 by the Jinja Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from jinja2 import nodes
-from jinja2.compiler import CodeGenerator
-from jinja2._compat import string_types, iteritems
-
-
-class TrackingCodeGenerator(CodeGenerator):
-    """We abuse the code generator for introspection."""
-
-    def __init__(self, environment):
-        CodeGenerator.__init__(self, environment, '<introspection>',
-                               '<introspection>')
-        self.undeclared_identifiers = set()
-
-    def write(self, x):
-        """Don't write."""
-
-    def enter_frame(self, frame):
-        """Remember all undeclared identifiers."""
-        CodeGenerator.enter_frame(self, frame)
-        for _, (action, param) in iteritems(frame.symbols.loads):
-            if action == 'resolve':
-                self.undeclared_identifiers.add(param)
-
-
-def find_undeclared_variables(ast):
-    """Returns a set of all variables in the AST that will be looked up from
-    the context at runtime.  Because at compile time it's not known which
-    variables will be used depending on the path the execution takes at
-    runtime, all variables are returned.
-
-    >>> from jinja2 import Environment, meta
-    >>> env = Environment()
-    >>> ast = env.parse('{% set foo = 42 %}{{ bar + foo }}')
-    >>> meta.find_undeclared_variables(ast) == set(['bar'])
-    True
-
-    .. admonition:: Implementation
-
-       Internally the code generator is used for finding undeclared variables.
-       This is good to know because the code generator might raise a
-       :exc:`TemplateAssertionError` during compilation and as a matter of
-       fact this function can currently raise that exception as well.
-    """
-    codegen = TrackingCodeGenerator(ast.environment)
-    codegen.visit(ast)
-    return codegen.undeclared_identifiers
-
-
-def find_referenced_templates(ast):
-    """Finds all the referenced templates from the AST.  This will return an
-    iterator over all the hardcoded template extensions, inclusions and
-    imports.  If dynamic inheritance or inclusion is used, `None` will be
-    yielded.
-
-    >>> from jinja2 import Environment, meta
-    >>> env = Environment()
-    >>> ast = env.parse('{% extends "layout.html" %}{% include helper %}')
-    >>> list(meta.find_referenced_templates(ast))
-    ['layout.html', None]
-
-    This function is useful for dependency tracking.  For example if you want
-    to rebuild parts of the website after a layout template has changed.
-    """
-    for node in ast.find_all((nodes.Extends, nodes.FromImport, nodes.Import,
-                              nodes.Include)):
-        if not isinstance(node.template, nodes.Const):
-            # a tuple with some non consts in there
-            if isinstance(node.template, (nodes.Tuple, nodes.List)):
-                for template_name in node.template.items:
-                    # something const, only yield the strings and ignore
-                    # non-string consts that really just make no sense
-                    if isinstance(template_name, nodes.Const):
-                        if isinstance(template_name.value, string_types):
-                            yield template_name.value
-                    # something dynamic in there
-                    else:
-                        yield None
-            # something dynamic we don't know about here
-            else:
-                yield None
-            continue
-        # constant is a basestring, direct template name
-        if isinstance(node.template.value, string_types):
-            yield node.template.value
-        # a tuple or list (latter *should* not happen) made of consts,
-        # yield the consts that are strings.  We could warn here for
-        # non string values
-        elif isinstance(node, nodes.Include) and \
-             isinstance(node.template.value, (tuple, list)):
-            for template_name in node.template.value:
-                if isinstance(template_name, string_types):
-                    yield template_name
-        # something else we don't care about, we could warn here
-        else:
-            yield None
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nativetypes.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nativetypes.py
deleted file mode 100644
index fe17e4138..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nativetypes.py
+++ /dev/null
@@ -1,220 +0,0 @@
-import sys
-from ast import literal_eval
-from itertools import islice, chain
-from jinja2 import nodes
-from jinja2._compat import text_type
-from jinja2.compiler import CodeGenerator, has_safe_repr
-from jinja2.environment import Environment, Template
-from jinja2.utils import concat, escape
-
-
-def native_concat(nodes):
-    """Return a native Python type from the list of compiled nodes. If the
-    result is a single node, its value is returned. Otherwise, the nodes are
-    concatenated as strings. If the result can be parsed with
-    :func:`ast.literal_eval`, the parsed value is returned. Otherwise, the
-    string is returned.
-    """
-    head = list(islice(nodes, 2))
-
-    if not head:
-        return None
-
-    if len(head) == 1:
-        out = head[0]
-    else:
-        out = u''.join([text_type(v) for v in chain(head, nodes)])
-
-    try:
-        return literal_eval(out)
-    except (ValueError, SyntaxError, MemoryError):
-        return out
-
-
-class NativeCodeGenerator(CodeGenerator):
-    """A code generator which avoids injecting ``to_string()`` calls around the
-    internal code Jinja uses to render templates.
-    """
-
-    def visit_Output(self, node, frame):
-        """Same as :meth:`CodeGenerator.visit_Output`, but do not call
-        ``to_string`` on output nodes in generated code.
-        """
-        if self.has_known_extends and frame.require_output_check:
-            return
-
-        finalize = self.environment.finalize
-        finalize_context = getattr(finalize, 'contextfunction', False)
-        finalize_eval = getattr(finalize, 'evalcontextfunction', False)
-        finalize_env = getattr(finalize, 'environmentfunction', False)
-
-        if finalize is not None:
-            if finalize_context or finalize_eval:
-                const_finalize = None
-            elif finalize_env:
-                def const_finalize(x):
-                    return finalize(self.environment, x)
-            else:
-                const_finalize = finalize
-        else:
-            def const_finalize(x):
-                return x
-
-        # If we are inside a frame that requires output checking, we do so.
-        outdent_later = False
-
-        if frame.require_output_check:
-            self.writeline('if parent_template is None:')
-            self.indent()
-            outdent_later = True
-
-        # Try to evaluate as many chunks as possible into a static string at
-        # compile time.
-        body = []
-
-        for child in node.nodes:
-            try:
-                if const_finalize is None:
-                    raise nodes.Impossible()
-
-                const = child.as_const(frame.eval_ctx)
-                if not has_safe_repr(const):
-                    raise nodes.Impossible()
-            except nodes.Impossible:
-                body.append(child)
-                continue
-
-            # the frame can't be volatile here, because otherwise the as_const
-            # function would raise an Impossible exception at that point
-            try:
-                if frame.eval_ctx.autoescape:
-                    if hasattr(const, '__html__'):
-                        const = const.__html__()
-                    else:
-                        const = escape(const)
-
-                const = const_finalize(const)
-            except Exception:
-                # if something goes wrong here we evaluate the node at runtime
-                # for easier debugging
-                body.append(child)
-                continue
-
-            if body and isinstance(body[-1], list):
-                body[-1].append(const)
-            else:
-                body.append([const])
-
-        # if we have less than 3 nodes or a buffer we yield or extend/append
-        if len(body) < 3 or frame.buffer is not None:
-            if frame.buffer is not None:
-                # for one item we append, for more we extend
-                if len(body) == 1:
-                    self.writeline('%s.append(' % frame.buffer)
-                else:
-                    self.writeline('%s.extend((' % frame.buffer)
-
-                self.indent()
-
-            for item in body:
-                if isinstance(item, list):
-                    val = repr(native_concat(item))
-
-                    if frame.buffer is None:
-                        self.writeline('yield ' + val)
-                    else:
-                        self.writeline(val + ',')
-                else:
-                    if frame.buffer is None:
-                        self.writeline('yield ', item)
-                    else:
-                        self.newline(item)
-
-                    close = 0
-
-                    if finalize is not None:
-                        self.write('environment.finalize(')
-
-                        if finalize_context:
-                            self.write('context, ')
-
-                        close += 1
-
-                    self.visit(item, frame)
-
-                    if close > 0:
-                        self.write(')' * close)
-
-                    if frame.buffer is not None:
-                        self.write(',')
-
-            if frame.buffer is not None:
-                # close the open parentheses
-                self.outdent()
-                self.writeline(len(body) == 1 and ')' or '))')
-
-        # otherwise we create a format string as this is faster in that case
-        else:
-            format = []
-            arguments = []
-
-            for item in body:
-                if isinstance(item, list):
-                    format.append(native_concat(item).replace('%', '%%'))
-                else:
-                    format.append('%s')
-                    arguments.append(item)
-
-            self.writeline('yield ')
-            self.write(repr(concat(format)) + ' % (')
-            self.indent()
-
-            for argument in arguments:
-                self.newline(argument)
-                close = 0
-
-                if finalize is not None:
-                    self.write('environment.finalize(')
-
-                    if finalize_context:
-                        self.write('context, ')
-                    elif finalize_eval:
-                        self.write('context.eval_ctx, ')
-                    elif finalize_env:
-                        self.write('environment, ')
-
-                    close += 1
-
-                self.visit(argument, frame)
-                self.write(')' * close + ', ')
-
-            self.outdent()
-            self.writeline(')')
-
-        if outdent_later:
-            self.outdent()
-
-
-class NativeTemplate(Template):
-    def render(self, *args, **kwargs):
-        """Render the template to produce a native Python type. If the result
-        is a single node, its value is returned. Otherwise, the nodes are
-        concatenated as strings. If the result can be parsed with
-        :func:`ast.literal_eval`, the parsed value is returned. Otherwise, the
-        string is returned.
-        """
-        vars = dict(*args, **kwargs)
-
-        try:
-            return native_concat(self.root_render_func(self.new_context(vars)))
-        except Exception:
-            exc_info = sys.exc_info()
-
-        return self.environment.handle_exception(exc_info, True)
-
-
-class NativeEnvironment(Environment):
-    """An environment that renders templates to native Python types."""
-
-    code_generator_class = NativeCodeGenerator
-    template_class = NativeTemplate
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nodes.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nodes.py
deleted file mode 100644
index 4d9a01ad8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/nodes.py
+++ /dev/null
@@ -1,999 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.nodes
-    ~~~~~~~~~~~~
-
-    This module implements additional nodes derived from the ast base node.
-
-    It also provides some node tree helper functions like `in_lineno` and
-    `get_nodes` used by the parser and translator in order to normalize
-    python and jinja nodes.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import types
-import operator
-
-from collections import deque
-from jinja2.utils import Markup
-from jinja2._compat import izip, with_metaclass, text_type, PY2
-
-
-#: the types we support for context functions
-_context_function_types = (types.FunctionType, types.MethodType)
-
-
-_binop_to_func = {
-    '*':        operator.mul,
-    '/':        operator.truediv,
-    '//':       operator.floordiv,
-    '**':       operator.pow,
-    '%':        operator.mod,
-    '+':        operator.add,
-    '-':        operator.sub
-}
-
-_uaop_to_func = {
-    'not':      operator.not_,
-    '+':        operator.pos,
-    '-':        operator.neg
-}
-
-_cmpop_to_func = {
-    'eq':       operator.eq,
-    'ne':       operator.ne,
-    'gt':       operator.gt,
-    'gteq':     operator.ge,
-    'lt':       operator.lt,
-    'lteq':     operator.le,
-    'in':       lambda a, b: a in b,
-    'notin':    lambda a, b: a not in b
-}
-
-
-class Impossible(Exception):
-    """Raised if the node could not perform a requested action."""
-
-
-class NodeType(type):
-    """A metaclass for nodes that handles the field and attribute
-    inheritance.  fields and attributes from the parent class are
-    automatically forwarded to the child."""
-
-    def __new__(cls, name, bases, d):
-        for attr in 'fields', 'attributes':
-            storage = []
-            storage.extend(getattr(bases[0], attr, ()))
-            storage.extend(d.get(attr, ()))
-            assert len(bases) == 1, 'multiple inheritance not allowed'
-            assert len(storage) == len(set(storage)), 'layout conflict'
-            d[attr] = tuple(storage)
-        d.setdefault('abstract', False)
-        return type.__new__(cls, name, bases, d)
-
-
-class EvalContext(object):
-    """Holds evaluation time information.  Custom attributes can be attached
-    to it in extensions.
-    """
-
-    def __init__(self, environment, template_name=None):
-        self.environment = environment
-        if callable(environment.autoescape):
-            self.autoescape = environment.autoescape(template_name)
-        else:
-            self.autoescape = environment.autoescape
-        self.volatile = False
-
-    def save(self):
-        return self.__dict__.copy()
-
-    def revert(self, old):
-        self.__dict__.clear()
-        self.__dict__.update(old)
-
-
-def get_eval_context(node, ctx):
-    if ctx is None:
-        if node.environment is None:
-            raise RuntimeError('if no eval context is passed, the '
-                               'node must have an attached '
-                               'environment.')
-        return EvalContext(node.environment)
-    return ctx
-
-
-class Node(with_metaclass(NodeType, object)):
-    """Baseclass for all Jinja2 nodes.  There are a number of nodes available
-    of different types.  There are four major types:
-
-    -   :class:`Stmt`: statements
-    -   :class:`Expr`: expressions
-    -   :class:`Helper`: helper nodes
-    -   :class:`Template`: the outermost wrapper node
-
-    All nodes have fields and attributes.  Fields may be other nodes, lists,
-    or arbitrary values.  Fields are passed to the constructor as regular
-    positional arguments, attributes as keyword arguments.  Each node has
-    two attributes: `lineno` (the line number of the node) and `environment`.
-    The `environment` attribute is set at the end of the parsing process for
-    all nodes automatically.
-    """
-    fields = ()
-    attributes = ('lineno', 'environment')
-    abstract = True
-
-    def __init__(self, *fields, **attributes):
-        if self.abstract:
-            raise TypeError('abstract nodes are not instanciable')
-        if fields:
-            if len(fields) != len(self.fields):
-                if not self.fields:
-                    raise TypeError('%r takes 0 arguments' %
-                                    self.__class__.__name__)
-                raise TypeError('%r takes 0 or %d argument%s' % (
-                    self.__class__.__name__,
-                    len(self.fields),
-                    len(self.fields) != 1 and 's' or ''
-                ))
-            for name, arg in izip(self.fields, fields):
-                setattr(self, name, arg)
-        for attr in self.attributes:
-            setattr(self, attr, attributes.pop(attr, None))
-        if attributes:
-            raise TypeError('unknown attribute %r' %
-                            next(iter(attributes)))
-
-    def iter_fields(self, exclude=None, only=None):
-        """This method iterates over all fields that are defined and yields
-        ``(key, value)`` tuples.  Per default all fields are returned, but
-        it's possible to limit that to some fields by providing the `only`
-        parameter or to exclude some using the `exclude` parameter.  Both
-        should be sets or tuples of field names.
-        """
-        for name in self.fields:
-            if (exclude is only is None) or \
-               (exclude is not None and name not in exclude) or \
-               (only is not None and name in only):
-                try:
-                    yield name, getattr(self, name)
-                except AttributeError:
-                    pass
-
-    def iter_child_nodes(self, exclude=None, only=None):
-        """Iterates over all direct child nodes of the node.  This iterates
-        over all fields and yields the values of they are nodes.  If the value
-        of a field is a list all the nodes in that list are returned.
-        """
-        for field, item in self.iter_fields(exclude, only):
-            if isinstance(item, list):
-                for n in item:
-                    if isinstance(n, Node):
-                        yield n
-            elif isinstance(item, Node):
-                yield item
-
-    def find(self, node_type):
-        """Find the first node of a given type.  If no such node exists the
-        return value is `None`.
-        """
-        for result in self.find_all(node_type):
-            return result
-
-    def find_all(self, node_type):
-        """Find all the nodes of a given type.  If the type is a tuple,
-        the check is performed for any of the tuple items.
-        """
-        for child in self.iter_child_nodes():
-            if isinstance(child, node_type):
-                yield child
-            for result in child.find_all(node_type):
-                yield result
-
-    def set_ctx(self, ctx):
-        """Reset the context of a node and all child nodes.  Per default the
-        parser will all generate nodes that have a 'load' context as it's the
-        most common one.  This method is used in the parser to set assignment
-        targets and other nodes to a store context.
-        """
-        todo = deque([self])
-        while todo:
-            node = todo.popleft()
-            if 'ctx' in node.fields:
-                node.ctx = ctx
-            todo.extend(node.iter_child_nodes())
-        return self
-
-    def set_lineno(self, lineno, override=False):
-        """Set the line numbers of the node and children."""
-        todo = deque([self])
-        while todo:
-            node = todo.popleft()
-            if 'lineno' in node.attributes:
-                if node.lineno is None or override:
-                    node.lineno = lineno
-            todo.extend(node.iter_child_nodes())
-        return self
-
-    def set_environment(self, environment):
-        """Set the environment for all nodes."""
-        todo = deque([self])
-        while todo:
-            node = todo.popleft()
-            node.environment = environment
-            todo.extend(node.iter_child_nodes())
-        return self
-
-    def __eq__(self, other):
-        return type(self) is type(other) and \
-               tuple(self.iter_fields()) == tuple(other.iter_fields())
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    # Restore Python 2 hashing behavior on Python 3
-    __hash__ = object.__hash__
-
-    def __repr__(self):
-        return '%s(%s)' % (
-            self.__class__.__name__,
-            ', '.join('%s=%r' % (arg, getattr(self, arg, None)) for
-                      arg in self.fields)
-        )
-
-    def dump(self):
-        def _dump(node):
-            if not isinstance(node, Node):
-                buf.append(repr(node))
-                return
-
-            buf.append('nodes.%s(' % node.__class__.__name__)
-            if not node.fields:
-                buf.append(')')
-                return
-            for idx, field in enumerate(node.fields):
-                if idx:
-                    buf.append(', ')
-                value = getattr(node, field)
-                if isinstance(value, list):
-                    buf.append('[')
-                    for idx, item in enumerate(value):
-                        if idx:
-                            buf.append(', ')
-                        _dump(item)
-                    buf.append(']')
-                else:
-                    _dump(value)
-            buf.append(')')
-        buf = []
-        _dump(self)
-        return ''.join(buf)
-
-
-
-class Stmt(Node):
-    """Base node for all statements."""
-    abstract = True
-
-
-class Helper(Node):
-    """Nodes that exist in a specific context only."""
-    abstract = True
-
-
-class Template(Node):
-    """Node that represents a template.  This must be the outermost node that
-    is passed to the compiler.
-    """
-    fields = ('body',)
-
-
-class Output(Stmt):
-    """A node that holds multiple expressions which are then printed out.
-    This is used both for the `print` statement and the regular template data.
-    """
-    fields = ('nodes',)
-
-
-class Extends(Stmt):
-    """Represents an extends statement."""
-    fields = ('template',)
-
-
-class For(Stmt):
-    """The for loop.  `target` is the target for the iteration (usually a
-    :class:`Name` or :class:`Tuple`), `iter` the iterable.  `body` is a list
-    of nodes that are used as loop-body, and `else_` a list of nodes for the
-    `else` block.  If no else node exists it has to be an empty list.
-
-    For filtered nodes an expression can be stored as `test`, otherwise `None`.
-    """
-    fields = ('target', 'iter', 'body', 'else_', 'test', 'recursive')
-
-
-class If(Stmt):
-    """If `test` is true, `body` is rendered, else `else_`."""
-    fields = ('test', 'body', 'elif_', 'else_')
-
-
-class Macro(Stmt):
-    """A macro definition.  `name` is the name of the macro, `args` a list of
-    arguments and `defaults` a list of defaults if there are any.  `body` is
-    a list of nodes for the macro body.
-    """
-    fields = ('name', 'args', 'defaults', 'body')
-
-
-class CallBlock(Stmt):
-    """Like a macro without a name but a call instead.  `call` is called with
-    the unnamed macro as `caller` argument this node holds.
-    """
-    fields = ('call', 'args', 'defaults', 'body')
-
-
-class FilterBlock(Stmt):
-    """Node for filter sections."""
-    fields = ('body', 'filter')
-
-
-class With(Stmt):
-    """Specific node for with statements.  In older versions of Jinja the
-    with statement was implemented on the base of the `Scope` node instead.
-
-    .. versionadded:: 2.9.3
-    """
-    fields = ('targets', 'values', 'body')
-
-
-class Block(Stmt):
-    """A node that represents a block."""
-    fields = ('name', 'body', 'scoped')
-
-
-class Include(Stmt):
-    """A node that represents the include tag."""
-    fields = ('template', 'with_context', 'ignore_missing')
-
-
-class Import(Stmt):
-    """A node that represents the import tag."""
-    fields = ('template', 'target', 'with_context')
-
-
-class FromImport(Stmt):
-    """A node that represents the from import tag.  It's important to not
-    pass unsafe names to the name attribute.  The compiler translates the
-    attribute lookups directly into getattr calls and does *not* use the
-    subscript callback of the interface.  As exported variables may not
-    start with double underscores (which the parser asserts) this is not a
-    problem for regular Jinja code, but if this node is used in an extension
-    extra care must be taken.
-
-    The list of names may contain tuples if aliases are wanted.
-    """
-    fields = ('template', 'names', 'with_context')
-
-
-class ExprStmt(Stmt):
-    """A statement that evaluates an expression and discards the result."""
-    fields = ('node',)
-
-
-class Assign(Stmt):
-    """Assigns an expression to a target."""
-    fields = ('target', 'node')
-
-
-class AssignBlock(Stmt):
-    """Assigns a block to a target."""
-    fields = ('target', 'filter', 'body')
-
-
-class Expr(Node):
-    """Baseclass for all expressions."""
-    abstract = True
-
-    def as_const(self, eval_ctx=None):
-        """Return the value of the expression as constant or raise
-        :exc:`Impossible` if this was not possible.
-
-        An :class:`EvalContext` can be provided, if none is given
-        a default context is created which requires the nodes to have
-        an attached environment.
-
-        .. versionchanged:: 2.4
-           the `eval_ctx` parameter was added.
-        """
-        raise Impossible()
-
-    def can_assign(self):
-        """Check if it's possible to assign something to this node."""
-        return False
-
-
-class BinExpr(Expr):
-    """Baseclass for all binary expressions."""
-    fields = ('left', 'right')
-    operator = None
-    abstract = True
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        # intercepted operators cannot be folded at compile time
-        if self.environment.sandboxed and \
-           self.operator in self.environment.intercepted_binops:
-            raise Impossible()
-        f = _binop_to_func[self.operator]
-        try:
-            return f(self.left.as_const(eval_ctx), self.right.as_const(eval_ctx))
-        except Exception:
-            raise Impossible()
-
-
-class UnaryExpr(Expr):
-    """Baseclass for all unary expressions."""
-    fields = ('node',)
-    operator = None
-    abstract = True
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        # intercepted operators cannot be folded at compile time
-        if self.environment.sandboxed and \
-           self.operator in self.environment.intercepted_unops:
-            raise Impossible()
-        f = _uaop_to_func[self.operator]
-        try:
-            return f(self.node.as_const(eval_ctx))
-        except Exception:
-            raise Impossible()
-
-
-class Name(Expr):
-    """Looks up a name or stores a value in a name.
-    The `ctx` of the node can be one of the following values:
-
-    -   `store`: store a value in the name
-    -   `load`: load that name
-    -   `param`: like `store` but if the name was defined as function parameter.
-    """
-    fields = ('name', 'ctx')
-
-    def can_assign(self):
-        return self.name not in ('true', 'false', 'none',
-                                 'True', 'False', 'None')
-
-
-class NSRef(Expr):
-    """Reference to a namespace value assignment"""
-    fields = ('name', 'attr')
-
-    def can_assign(self):
-        # We don't need any special checks here; NSRef assignments have a
-        # runtime check to ensure the target is a namespace object which will
-        # have been checked already as it is created using a normal assignment
-        # which goes through a `Name` node.
-        return True
-
-
-class Literal(Expr):
-    """Baseclass for literals."""
-    abstract = True
-
-
-class Const(Literal):
-    """All constant values.  The parser will return this node for simple
-    constants such as ``42`` or ``"foo"`` but it can be used to store more
-    complex values such as lists too.  Only constants with a safe
-    representation (objects where ``eval(repr(x)) == x`` is true).
-    """
-    fields = ('value',)
-
-    def as_const(self, eval_ctx=None):
-        rv = self.value
-        if PY2 and type(rv) is text_type and \
-           self.environment.policies['compiler.ascii_str']:
-            try:
-                rv = rv.encode('ascii')
-            except UnicodeError:
-                pass
-        return rv
-
-    @classmethod
-    def from_untrusted(cls, value, lineno=None, environment=None):
-        """Return a const object if the value is representable as
-        constant value in the generated code, otherwise it will raise
-        an `Impossible` exception.
-        """
-        from .compiler import has_safe_repr
-        if not has_safe_repr(value):
-            raise Impossible()
-        return cls(value, lineno=lineno, environment=environment)
-
-
-class TemplateData(Literal):
-    """A constant template string."""
-    fields = ('data',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        if eval_ctx.volatile:
-            raise Impossible()
-        if eval_ctx.autoescape:
-            return Markup(self.data)
-        return self.data
-
-
-class Tuple(Literal):
-    """For loop unpacking and some other things like multiple arguments
-    for subscripts.  Like for :class:`Name` `ctx` specifies if the tuple
-    is used for loading the names or storing.
-    """
-    fields = ('items', 'ctx')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return tuple(x.as_const(eval_ctx) for x in self.items)
-
-    def can_assign(self):
-        for item in self.items:
-            if not item.can_assign():
-                return False
-        return True
-
-
-class List(Literal):
-    """Any list literal such as ``[1, 2, 3]``"""
-    fields = ('items',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return [x.as_const(eval_ctx) for x in self.items]
-
-
-class Dict(Literal):
-    """Any dict literal such as ``{1: 2, 3: 4}``.  The items must be a list of
-    :class:`Pair` nodes.
-    """
-    fields = ('items',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return dict(x.as_const(eval_ctx) for x in self.items)
-
-
-class Pair(Helper):
-    """A key, value pair for dicts."""
-    fields = ('key', 'value')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return self.key.as_const(eval_ctx), self.value.as_const(eval_ctx)
-
-
-class Keyword(Helper):
-    """A key, value pair for keyword arguments where key is a string."""
-    fields = ('key', 'value')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return self.key, self.value.as_const(eval_ctx)
-
-
-class CondExpr(Expr):
-    """A conditional expression (inline if expression).  (``{{
-    foo if bar else baz }}``)
-    """
-    fields = ('test', 'expr1', 'expr2')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        if self.test.as_const(eval_ctx):
-            return self.expr1.as_const(eval_ctx)
-
-        # if we evaluate to an undefined object, we better do that at runtime
-        if self.expr2 is None:
-            raise Impossible()
-
-        return self.expr2.as_const(eval_ctx)
-
-
-def args_as_const(node, eval_ctx):
-    args = [x.as_const(eval_ctx) for x in node.args]
-    kwargs = dict(x.as_const(eval_ctx) for x in node.kwargs)
-
-    if node.dyn_args is not None:
-        try:
-            args.extend(node.dyn_args.as_const(eval_ctx))
-        except Exception:
-            raise Impossible()
-
-    if node.dyn_kwargs is not None:
-        try:
-            kwargs.update(node.dyn_kwargs.as_const(eval_ctx))
-        except Exception:
-            raise Impossible()
-
-    return args, kwargs
-
-
-class Filter(Expr):
-    """This node applies a filter on an expression.  `name` is the name of
-    the filter, the rest of the fields are the same as for :class:`Call`.
-
-    If the `node` of a filter is `None` the contents of the last buffer are
-    filtered.  Buffers are created by macros and filter blocks.
-    """
-
-    fields = ('node', 'name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-
-        if eval_ctx.volatile or self.node is None:
-            raise Impossible()
-
-        # we have to be careful here because we call filter_ below.
-        # if this variable would be called filter, 2to3 would wrap the
-        # call in a list beause it is assuming we are talking about the
-        # builtin filter function here which no longer returns a list in
-        # python 3.  because of that, do not rename filter_ to filter!
-        filter_ = self.environment.filters.get(self.name)
-
-        if filter_ is None or getattr(filter_, 'contextfilter', False):
-            raise Impossible()
-
-        # We cannot constant handle async filters, so we need to make sure
-        # to not go down this path.
-        if (
-            eval_ctx.environment.is_async
-            and getattr(filter_, 'asyncfiltervariant', False)
-        ):
-            raise Impossible()
-
-        args, kwargs = args_as_const(self, eval_ctx)
-        args.insert(0, self.node.as_const(eval_ctx))
-
-        if getattr(filter_, 'evalcontextfilter', False):
-            args.insert(0, eval_ctx)
-        elif getattr(filter_, 'environmentfilter', False):
-            args.insert(0, self.environment)
-
-        try:
-            return filter_(*args, **kwargs)
-        except Exception:
-            raise Impossible()
-
-
-class Test(Expr):
-    """Applies a test on an expression.  `name` is the name of the test, the
-    rest of the fields are the same as for :class:`Call`.
-    """
-
-    fields = ('node', 'name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
-
-    def as_const(self, eval_ctx=None):
-        test = self.environment.tests.get(self.name)
-
-        if test is None:
-            raise Impossible()
-
-        eval_ctx = get_eval_context(self, eval_ctx)
-        args, kwargs = args_as_const(self, eval_ctx)
-        args.insert(0, self.node.as_const(eval_ctx))
-
-        try:
-            return test(*args, **kwargs)
-        except Exception:
-            raise Impossible()
-
-
-class Call(Expr):
-    """Calls an expression.  `args` is a list of arguments, `kwargs` a list
-    of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
-    and `dyn_kwargs` has to be either `None` or a node that is used as
-    node for dynamic positional (``*args``) or keyword (``**kwargs``)
-    arguments.
-    """
-    fields = ('node', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
-
-
-class Getitem(Expr):
-    """Get an attribute or item from an expression and prefer the item."""
-    fields = ('node', 'arg', 'ctx')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        if self.ctx != 'load':
-            raise Impossible()
-        try:
-            return self.environment.getitem(self.node.as_const(eval_ctx),
-                                            self.arg.as_const(eval_ctx))
-        except Exception:
-            raise Impossible()
-
-    def can_assign(self):
-        return False
-
-
-class Getattr(Expr):
-    """Get an attribute or item from an expression that is a ascii-only
-    bytestring and prefer the attribute.
-    """
-    fields = ('node', 'attr', 'ctx')
-
-    def as_const(self, eval_ctx=None):
-        if self.ctx != 'load':
-            raise Impossible()
-        try:
-            eval_ctx = get_eval_context(self, eval_ctx)
-            return self.environment.getattr(self.node.as_const(eval_ctx),
-                                            self.attr)
-        except Exception:
-            raise Impossible()
-
-    def can_assign(self):
-        return False
-
-
-class Slice(Expr):
-    """Represents a slice object.  This must only be used as argument for
-    :class:`Subscript`.
-    """
-    fields = ('start', 'stop', 'step')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        def const(obj):
-            if obj is None:
-                return None
-            return obj.as_const(eval_ctx)
-        return slice(const(self.start), const(self.stop), const(self.step))
-
-
-class Concat(Expr):
-    """Concatenates the list of expressions provided after converting them to
-    unicode.
-    """
-    fields = ('nodes',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return ''.join(text_type(x.as_const(eval_ctx)) for x in self.nodes)
-
-
-class Compare(Expr):
-    """Compares an expression with some other expressions.  `ops` must be a
-    list of :class:`Operand`\\s.
-    """
-    fields = ('expr', 'ops')
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        result = value = self.expr.as_const(eval_ctx)
-        try:
-            for op in self.ops:
-                new_value = op.expr.as_const(eval_ctx)
-                result = _cmpop_to_func[op.op](value, new_value)
-                value = new_value
-        except Exception:
-            raise Impossible()
-        return result
-
-
-class Operand(Helper):
-    """Holds an operator and an expression."""
-    fields = ('op', 'expr')
-
-if __debug__:
-    Operand.__doc__ += '\nThe following operators are available: ' + \
-        ', '.join(sorted('``%s``' % x for x in set(_binop_to_func) |
-                  set(_uaop_to_func) | set(_cmpop_to_func)))
-
-
-class Mul(BinExpr):
-    """Multiplies the left with the right node."""
-    operator = '*'
-
-
-class Div(BinExpr):
-    """Divides the left by the right node."""
-    operator = '/'
-
-
-class FloorDiv(BinExpr):
-    """Divides the left by the right node and truncates conver the
-    result into an integer by truncating.
-    """
-    operator = '//'
-
-
-class Add(BinExpr):
-    """Add the left to the right node."""
-    operator = '+'
-
-
-class Sub(BinExpr):
-    """Subtract the right from the left node."""
-    operator = '-'
-
-
-class Mod(BinExpr):
-    """Left modulo right."""
-    operator = '%'
-
-
-class Pow(BinExpr):
-    """Left to the power of right."""
-    operator = '**'
-
-
-class And(BinExpr):
-    """Short circuited AND."""
-    operator = 'and'
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return self.left.as_const(eval_ctx) and self.right.as_const(eval_ctx)
-
-
-class Or(BinExpr):
-    """Short circuited OR."""
-    operator = 'or'
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return self.left.as_const(eval_ctx) or self.right.as_const(eval_ctx)
-
-
-class Not(UnaryExpr):
-    """Negate the expression."""
-    operator = 'not'
-
-
-class Neg(UnaryExpr):
-    """Make the expression negative."""
-    operator = '-'
-
-
-class Pos(UnaryExpr):
-    """Make the expression positive (noop for most expressions)"""
-    operator = '+'
-
-
-# Helpers for extensions
-
-
-class EnvironmentAttribute(Expr):
-    """Loads an attribute from the environment object.  This is useful for
-    extensions that want to call a callback stored on the environment.
-    """
-    fields = ('name',)
-
-
-class ExtensionAttribute(Expr):
-    """Returns the attribute of an extension bound to the environment.
-    The identifier is the identifier of the :class:`Extension`.
-
-    This node is usually constructed by calling the
-    :meth:`~jinja2.ext.Extension.attr` method on an extension.
-    """
-    fields = ('identifier', 'name')
-
-
-class ImportedName(Expr):
-    """If created with an import name the import name is returned on node
-    access.  For example ``ImportedName('cgi.escape')`` returns the `escape`
-    function from the cgi module on evaluation.  Imports are optimized by the
-    compiler so there is no need to assign them to local variables.
-    """
-    fields = ('importname',)
-
-
-class InternalName(Expr):
-    """An internal name in the compiler.  You cannot create these nodes
-    yourself but the parser provides a
-    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
-    a new identifier for you.  This identifier is not available from the
-    template and is not threated specially by the compiler.
-    """
-    fields = ('name',)
-
-    def __init__(self):
-        raise TypeError('Can\'t create internal names.  Use the '
-                        '`free_identifier` method on a parser.')
-
-
-class MarkSafe(Expr):
-    """Mark the wrapped expression as safe (wrap it as `Markup`)."""
-    fields = ('expr',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        return Markup(self.expr.as_const(eval_ctx))
-
-
-class MarkSafeIfAutoescape(Expr):
-    """Mark the wrapped expression as safe (wrap it as `Markup`) but
-    only if autoescaping is active.
-
-    .. versionadded:: 2.5
-    """
-    fields = ('expr',)
-
-    def as_const(self, eval_ctx=None):
-        eval_ctx = get_eval_context(self, eval_ctx)
-        if eval_ctx.volatile:
-            raise Impossible()
-        expr = self.expr.as_const(eval_ctx)
-        if eval_ctx.autoescape:
-            return Markup(expr)
-        return expr
-
-
-class ContextReference(Expr):
-    """Returns the current template context.  It can be used like a
-    :class:`Name` node, with a ``'load'`` ctx and will return the
-    current :class:`~jinja2.runtime.Context` object.
-
-    Here an example that assigns the current template name to a
-    variable named `foo`::
-
-        Assign(Name('foo', ctx='store'),
-               Getattr(ContextReference(), 'name'))
-    """
-
-
-class Continue(Stmt):
-    """Continue a loop."""
-
-
-class Break(Stmt):
-    """Break a loop."""
-
-
-class Scope(Stmt):
-    """An artificial scope."""
-    fields = ('body',)
-
-
-class OverlayScope(Stmt):
-    """An overlay scope for extensions.  This is a largely unoptimized scope
-    that however can be used to introduce completely arbitrary variables into
-    a sub scope from a dictionary or dictionary like object.  The `context`
-    field has to evaluate to a dictionary object.
-
-    Example usage::
-
-        OverlayScope(context=self.call_method('get_context'),
-                     body=[...])
-
-    .. versionadded:: 2.10
-    """
-    fields = ('context', 'body')
-
-
-class EvalContextModifier(Stmt):
-    """Modifies the eval context.  For each option that should be modified,
-    a :class:`Keyword` has to be added to the :attr:`options` list.
-
-    Example to change the `autoescape` setting::
-
-        EvalContextModifier(options=[Keyword('autoescape', Const(True))])
-    """
-    fields = ('options',)
-
-
-class ScopedEvalContextModifier(EvalContextModifier):
-    """Modifies the eval context and reverts it later.  Works exactly like
-    :class:`EvalContextModifier` but will only modify the
-    :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
-    """
-    fields = ('body',)
-
-
-# make sure nobody creates custom nodes
-def _failing_new(*args, **kwargs):
-    raise TypeError('can\'t create custom node types')
-NodeType.__new__ = staticmethod(_failing_new); del _failing_new
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/optimizer.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/optimizer.py
deleted file mode 100644
index 65ab3ceb7..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/optimizer.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.optimizer
-    ~~~~~~~~~~~~~~~~
-
-    The jinja optimizer is currently trying to constant fold a few expressions
-    and modify the AST in place so that it should be easier to evaluate it.
-
-    Because the AST does not contain all the scoping information and the
-    compiler has to find that out, we cannot do all the optimizations we
-    want.  For example loop unrolling doesn't work because unrolled loops would
-    have a different scoping.
-
-    The solution would be a second syntax tree that has the scoping rules stored.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-from jinja2 import nodes
-from jinja2.visitor import NodeTransformer
-
-
-def optimize(node, environment):
-    """The context hint can be used to perform an static optimization
-    based on the context given."""
-    optimizer = Optimizer(environment)
-    return optimizer.visit(node)
-
-
-class Optimizer(NodeTransformer):
-
-    def __init__(self, environment):
-        self.environment = environment
-
-    def fold(self, node, eval_ctx=None):
-        """Do constant folding."""
-        node = self.generic_visit(node)
-        try:
-            return nodes.Const.from_untrusted(node.as_const(eval_ctx),
-                                              lineno=node.lineno,
-                                              environment=self.environment)
-        except nodes.Impossible:
-            return node
-
-    visit_Add = visit_Sub = visit_Mul = visit_Div = visit_FloorDiv = \
-    visit_Pow = visit_Mod = visit_And = visit_Or = visit_Pos = visit_Neg = \
-    visit_Not = visit_Compare = visit_Getitem = visit_Getattr = visit_Call = \
-    visit_Filter = visit_Test = visit_CondExpr = fold
-    del fold
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/parser.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/parser.py
deleted file mode 100644
index ed00d9708..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/parser.py
+++ /dev/null
@@ -1,903 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.parser
-    ~~~~~~~~~~~~~
-
-    Implements the template parser.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-from jinja2 import nodes
-from jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError
-from jinja2.lexer import describe_token, describe_token_expr
-from jinja2._compat import imap
-
-
-_statement_keywords = frozenset(['for', 'if', 'block', 'extends', 'print',
-                                 'macro', 'include', 'from', 'import',
-                                 'set', 'with', 'autoescape'])
-_compare_operators = frozenset(['eq', 'ne', 'lt', 'lteq', 'gt', 'gteq'])
-
-_math_nodes = {
-    'add': nodes.Add,
-    'sub': nodes.Sub,
-    'mul': nodes.Mul,
-    'div': nodes.Div,
-    'floordiv': nodes.FloorDiv,
-    'mod': nodes.Mod,
-}
-
-
-class Parser(object):
-    """This is the central parsing class Jinja2 uses.  It's passed to
-    extensions and can be used to parse expressions or statements.
-    """
-
-    def __init__(self, environment, source, name=None, filename=None,
-                 state=None):
-        self.environment = environment
-        self.stream = environment._tokenize(source, name, filename, state)
-        self.name = name
-        self.filename = filename
-        self.closed = False
-        self.extensions = {}
-        for extension in environment.iter_extensions():
-            for tag in extension.tags:
-                self.extensions[tag] = extension.parse
-        self._last_identifier = 0
-        self._tag_stack = []
-        self._end_token_stack = []
-
-    def fail(self, msg, lineno=None, exc=TemplateSyntaxError):
-        """Convenience method that raises `exc` with the message, passed
-        line number or last line number as well as the current name and
-        filename.
-        """
-        if lineno is None:
-            lineno = self.stream.current.lineno
-        raise exc(msg, lineno, self.name, self.filename)
-
-    def _fail_ut_eof(self, name, end_token_stack, lineno):
-        expected = []
-        for exprs in end_token_stack:
-            expected.extend(imap(describe_token_expr, exprs))
-        if end_token_stack:
-            currently_looking = ' or '.join(
-                "'%s'" % describe_token_expr(expr)
-                for expr in end_token_stack[-1])
-        else:
-            currently_looking = None
-
-        if name is None:
-            message = ['Unexpected end of template.']
-        else:
-            message = ['Encountered unknown tag \'%s\'.' % name]
-
-        if currently_looking:
-            if name is not None and name in expected:
-                message.append('You probably made a nesting mistake. Jinja '
-                               'is expecting this tag, but currently looking '
-                               'for %s.' % currently_looking)
-            else:
-                message.append('Jinja was looking for the following tags: '
-                               '%s.' % currently_looking)
-
-        if self._tag_stack:
-            message.append('The innermost block that needs to be '
-                           'closed is \'%s\'.' % self._tag_stack[-1])
-
-        self.fail(' '.join(message), lineno)
-
-    def fail_unknown_tag(self, name, lineno=None):
-        """Called if the parser encounters an unknown tag.  Tries to fail
-        with a human readable error message that could help to identify
-        the problem.
-        """
-        return self._fail_ut_eof(name, self._end_token_stack, lineno)
-
-    def fail_eof(self, end_tokens=None, lineno=None):
-        """Like fail_unknown_tag but for end of template situations."""
-        stack = list(self._end_token_stack)
-        if end_tokens is not None:
-            stack.append(end_tokens)
-        return self._fail_ut_eof(None, stack, lineno)
-
-    def is_tuple_end(self, extra_end_rules=None):
-        """Are we at the end of a tuple?"""
-        if self.stream.current.type in ('variable_end', 'block_end', 'rparen'):
-            return True
-        elif extra_end_rules is not None:
-            return self.stream.current.test_any(extra_end_rules)
-        return False
-
-    def free_identifier(self, lineno=None):
-        """Return a new free identifier as :class:`~jinja2.nodes.InternalName`."""
-        self._last_identifier += 1
-        rv = object.__new__(nodes.InternalName)
-        nodes.Node.__init__(rv, 'fi%d' % self._last_identifier, lineno=lineno)
-        return rv
-
-    def parse_statement(self):
-        """Parse a single statement."""
-        token = self.stream.current
-        if token.type != 'name':
-            self.fail('tag name expected', token.lineno)
-        self._tag_stack.append(token.value)
-        pop_tag = True
-        try:
-            if token.value in _statement_keywords:
-                return getattr(self, 'parse_' + self.stream.current.value)()
-            if token.value == 'call':
-                return self.parse_call_block()
-            if token.value == 'filter':
-                return self.parse_filter_block()
-            ext = self.extensions.get(token.value)
-            if ext is not None:
-                return ext(self)
-
-            # did not work out, remove the token we pushed by accident
-            # from the stack so that the unknown tag fail function can
-            # produce a proper error message.
-            self._tag_stack.pop()
-            pop_tag = False
-            self.fail_unknown_tag(token.value, token.lineno)
-        finally:
-            if pop_tag:
-                self._tag_stack.pop()
-
-    def parse_statements(self, end_tokens, drop_needle=False):
-        """Parse multiple statements into a list until one of the end tokens
-        is reached.  This is used to parse the body of statements as it also
-        parses template data if appropriate.  The parser checks first if the
-        current token is a colon and skips it if there is one.  Then it checks
-        for the block end and parses until if one of the `end_tokens` is
-        reached.  Per default the active token in the stream at the end of
-        the call is the matched end token.  If this is not wanted `drop_needle`
-        can be set to `True` and the end token is removed.
-        """
-        # the first token may be a colon for python compatibility
-        self.stream.skip_if('colon')
-
-        # in the future it would be possible to add whole code sections
-        # by adding some sort of end of statement token and parsing those here.
-        self.stream.expect('block_end')
-        result = self.subparse(end_tokens)
-
-        # we reached the end of the template too early, the subparser
-        # does not check for this, so we do that now
-        if self.stream.current.type == 'eof':
-            self.fail_eof(end_tokens)
-
-        if drop_needle:
-            next(self.stream)
-        return result
-
-    def parse_set(self):
-        """Parse an assign statement."""
-        lineno = next(self.stream).lineno
-        target = self.parse_assign_target(with_namespace=True)
-        if self.stream.skip_if('assign'):
-            expr = self.parse_tuple()
-            return nodes.Assign(target, expr, lineno=lineno)
-        filter_node = self.parse_filter(None)
-        body = self.parse_statements(('name:endset',),
-                                     drop_needle=True)
-        return nodes.AssignBlock(target, filter_node, body, lineno=lineno)
-
-    def parse_for(self):
-        """Parse a for loop."""
-        lineno = self.stream.expect('name:for').lineno
-        target = self.parse_assign_target(extra_end_rules=('name:in',))
-        self.stream.expect('name:in')
-        iter = self.parse_tuple(with_condexpr=False,
-                                extra_end_rules=('name:recursive',))
-        test = None
-        if self.stream.skip_if('name:if'):
-            test = self.parse_expression()
-        recursive = self.stream.skip_if('name:recursive')
-        body = self.parse_statements(('name:endfor', 'name:else'))
-        if next(self.stream).value == 'endfor':
-            else_ = []
-        else:
-            else_ = self.parse_statements(('name:endfor',), drop_needle=True)
-        return nodes.For(target, iter, body, else_, test,
-                         recursive, lineno=lineno)
-
-    def parse_if(self):
-        """Parse an if construct."""
-        node = result = nodes.If(lineno=self.stream.expect('name:if').lineno)
-        while 1:
-            node.test = self.parse_tuple(with_condexpr=False)
-            node.body = self.parse_statements(('name:elif', 'name:else',
-                                               'name:endif'))
-            node.elif_ = []
-            node.else_ = []
-            token = next(self.stream)
-            if token.test('name:elif'):
-                node = nodes.If(lineno=self.stream.current.lineno)
-                result.elif_.append(node)
-                continue
-            elif token.test('name:else'):
-                result.else_ = self.parse_statements(('name:endif',),
-                                                     drop_needle=True)
-            break
-        return result
-
-    def parse_with(self):
-        node = nodes.With(lineno=next(self.stream).lineno)
-        targets = []
-        values = []
-        while self.stream.current.type != 'block_end':
-            lineno = self.stream.current.lineno
-            if targets:
-                self.stream.expect('comma')
-            target = self.parse_assign_target()
-            target.set_ctx('param')
-            targets.append(target)
-            self.stream.expect('assign')
-            values.append(self.parse_expression())
-        node.targets = targets
-        node.values = values
-        node.body = self.parse_statements(('name:endwith',),
-                                          drop_needle=True)
-        return node
-
-    def parse_autoescape(self):
-        node = nodes.ScopedEvalContextModifier(lineno=next(self.stream).lineno)
-        node.options = [
-            nodes.Keyword('autoescape', self.parse_expression())
-        ]
-        node.body = self.parse_statements(('name:endautoescape',),
-                                            drop_needle=True)
-        return nodes.Scope([node])
-
-    def parse_block(self):
-        node = nodes.Block(lineno=next(self.stream).lineno)
-        node.name = self.stream.expect('name').value
-        node.scoped = self.stream.skip_if('name:scoped')
-
-        # common problem people encounter when switching from django
-        # to jinja.  we do not support hyphens in block names, so let's
-        # raise a nicer error message in that case.
-        if self.stream.current.type == 'sub':
-            self.fail('Block names in Jinja have to be valid Python '
-                      'identifiers and may not contain hyphens, use an '
-                      'underscore instead.')
-
-        node.body = self.parse_statements(('name:endblock',), drop_needle=True)
-        self.stream.skip_if('name:' + node.name)
-        return node
-
-    def parse_extends(self):
-        node = nodes.Extends(lineno=next(self.stream).lineno)
-        node.template = self.parse_expression()
-        return node
-
-    def parse_import_context(self, node, default):
-        if self.stream.current.test_any('name:with', 'name:without') and \
-           self.stream.look().test('name:context'):
-            node.with_context = next(self.stream).value == 'with'
-            self.stream.skip()
-        else:
-            node.with_context = default
-        return node
-
-    def parse_include(self):
-        node = nodes.Include(lineno=next(self.stream).lineno)
-        node.template = self.parse_expression()
-        if self.stream.current.test('name:ignore') and \
-           self.stream.look().test('name:missing'):
-            node.ignore_missing = True
-            self.stream.skip(2)
-        else:
-            node.ignore_missing = False
-        return self.parse_import_context(node, True)
-
-    def parse_import(self):
-        node = nodes.Import(lineno=next(self.stream).lineno)
-        node.template = self.parse_expression()
-        self.stream.expect('name:as')
-        node.target = self.parse_assign_target(name_only=True).name
-        return self.parse_import_context(node, False)
-
-    def parse_from(self):
-        node = nodes.FromImport(lineno=next(self.stream).lineno)
-        node.template = self.parse_expression()
-        self.stream.expect('name:import')
-        node.names = []
-
-        def parse_context():
-            if self.stream.current.value in ('with', 'without') and \
-               self.stream.look().test('name:context'):
-                node.with_context = next(self.stream).value == 'with'
-                self.stream.skip()
-                return True
-            return False
-
-        while 1:
-            if node.names:
-                self.stream.expect('comma')
-            if self.stream.current.type == 'name':
-                if parse_context():
-                    break
-                target = self.parse_assign_target(name_only=True)
-                if target.name.startswith('_'):
-                    self.fail('names starting with an underline can not '
-                              'be imported', target.lineno,
-                              exc=TemplateAssertionError)
-                if self.stream.skip_if('name:as'):
-                    alias = self.parse_assign_target(name_only=True)
-                    node.names.append((target.name, alias.name))
-                else:
-                    node.names.append(target.name)
-                if parse_context() or self.stream.current.type != 'comma':
-                    break
-            else:
-                self.stream.expect('name')
-        if not hasattr(node, 'with_context'):
-            node.with_context = False
-        return node
-
-    def parse_signature(self, node):
-        node.args = args = []
-        node.defaults = defaults = []
-        self.stream.expect('lparen')
-        while self.stream.current.type != 'rparen':
-            if args:
-                self.stream.expect('comma')
-            arg = self.parse_assign_target(name_only=True)
-            arg.set_ctx('param')
-            if self.stream.skip_if('assign'):
-                defaults.append(self.parse_expression())
-            elif defaults:
-                self.fail('non-default argument follows default argument')
-            args.append(arg)
-        self.stream.expect('rparen')
-
-    def parse_call_block(self):
-        node = nodes.CallBlock(lineno=next(self.stream).lineno)
-        if self.stream.current.type == 'lparen':
-            self.parse_signature(node)
-        else:
-            node.args = []
-            node.defaults = []
-
-        node.call = self.parse_expression()
-        if not isinstance(node.call, nodes.Call):
-            self.fail('expected call', node.lineno)
-        node.body = self.parse_statements(('name:endcall',), drop_needle=True)
-        return node
-
-    def parse_filter_block(self):
-        node = nodes.FilterBlock(lineno=next(self.stream).lineno)
-        node.filter = self.parse_filter(None, start_inline=True)
-        node.body = self.parse_statements(('name:endfilter',),
-                                          drop_needle=True)
-        return node
-
-    def parse_macro(self):
-        node = nodes.Macro(lineno=next(self.stream).lineno)
-        node.name = self.parse_assign_target(name_only=True).name
-        self.parse_signature(node)
-        node.body = self.parse_statements(('name:endmacro',),
-                                          drop_needle=True)
-        return node
-
-    def parse_print(self):
-        node = nodes.Output(lineno=next(self.stream).lineno)
-        node.nodes = []
-        while self.stream.current.type != 'block_end':
-            if node.nodes:
-                self.stream.expect('comma')
-            node.nodes.append(self.parse_expression())
-        return node
-
-    def parse_assign_target(self, with_tuple=True, name_only=False,
-                            extra_end_rules=None, with_namespace=False):
-        """Parse an assignment target.  As Jinja2 allows assignments to
-        tuples, this function can parse all allowed assignment targets.  Per
-        default assignments to tuples are parsed, that can be disable however
-        by setting `with_tuple` to `False`.  If only assignments to names are
-        wanted `name_only` can be set to `True`.  The `extra_end_rules`
-        parameter is forwarded to the tuple parsing function.  If
-        `with_namespace` is enabled, a namespace assignment may be parsed.
-        """
-        if with_namespace and self.stream.look().type == 'dot':
-            token = self.stream.expect('name')
-            next(self.stream)  # dot
-            attr = self.stream.expect('name')
-            target = nodes.NSRef(token.value, attr.value, lineno=token.lineno)
-        elif name_only:
-            token = self.stream.expect('name')
-            target = nodes.Name(token.value, 'store', lineno=token.lineno)
-        else:
-            if with_tuple:
-                target = self.parse_tuple(simplified=True,
-                                          extra_end_rules=extra_end_rules)
-            else:
-                target = self.parse_primary()
-            target.set_ctx('store')
-        if not target.can_assign():
-            self.fail('can\'t assign to %r' % target.__class__.
-                      __name__.lower(), target.lineno)
-        return target
-
-    def parse_expression(self, with_condexpr=True):
-        """Parse an expression.  Per default all expressions are parsed, if
-        the optional `with_condexpr` parameter is set to `False` conditional
-        expressions are not parsed.
-        """
-        if with_condexpr:
-            return self.parse_condexpr()
-        return self.parse_or()
-
-    def parse_condexpr(self):
-        lineno = self.stream.current.lineno
-        expr1 = self.parse_or()
-        while self.stream.skip_if('name:if'):
-            expr2 = self.parse_or()
-            if self.stream.skip_if('name:else'):
-                expr3 = self.parse_condexpr()
-            else:
-                expr3 = None
-            expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return expr1
-
-    def parse_or(self):
-        lineno = self.stream.current.lineno
-        left = self.parse_and()
-        while self.stream.skip_if('name:or'):
-            right = self.parse_and()
-            left = nodes.Or(left, right, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return left
-
-    def parse_and(self):
-        lineno = self.stream.current.lineno
-        left = self.parse_not()
-        while self.stream.skip_if('name:and'):
-            right = self.parse_not()
-            left = nodes.And(left, right, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return left
-
-    def parse_not(self):
-        if self.stream.current.test('name:not'):
-            lineno = next(self.stream).lineno
-            return nodes.Not(self.parse_not(), lineno=lineno)
-        return self.parse_compare()
-
-    def parse_compare(self):
-        lineno = self.stream.current.lineno
-        expr = self.parse_math1()
-        ops = []
-        while 1:
-            token_type = self.stream.current.type
-            if token_type in _compare_operators:
-                next(self.stream)
-                ops.append(nodes.Operand(token_type, self.parse_math1()))
-            elif self.stream.skip_if('name:in'):
-                ops.append(nodes.Operand('in', self.parse_math1()))
-            elif (self.stream.current.test('name:not') and
-                  self.stream.look().test('name:in')):
-                self.stream.skip(2)
-                ops.append(nodes.Operand('notin', self.parse_math1()))
-            else:
-                break
-            lineno = self.stream.current.lineno
-        if not ops:
-            return expr
-        return nodes.Compare(expr, ops, lineno=lineno)
-
-    def parse_math1(self):
-        lineno = self.stream.current.lineno
-        left = self.parse_concat()
-        while self.stream.current.type in ('add', 'sub'):
-            cls = _math_nodes[self.stream.current.type]
-            next(self.stream)
-            right = self.parse_concat()
-            left = cls(left, right, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return left
-
-    def parse_concat(self):
-        lineno = self.stream.current.lineno
-        args = [self.parse_math2()]
-        while self.stream.current.type == 'tilde':
-            next(self.stream)
-            args.append(self.parse_math2())
-        if len(args) == 1:
-            return args[0]
-        return nodes.Concat(args, lineno=lineno)
-
-    def parse_math2(self):
-        lineno = self.stream.current.lineno
-        left = self.parse_pow()
-        while self.stream.current.type in ('mul', 'div', 'floordiv', 'mod'):
-            cls = _math_nodes[self.stream.current.type]
-            next(self.stream)
-            right = self.parse_pow()
-            left = cls(left, right, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return left
-
-    def parse_pow(self):
-        lineno = self.stream.current.lineno
-        left = self.parse_unary()
-        while self.stream.current.type == 'pow':
-            next(self.stream)
-            right = self.parse_unary()
-            left = nodes.Pow(left, right, lineno=lineno)
-            lineno = self.stream.current.lineno
-        return left
-
-    def parse_unary(self, with_filter=True):
-        token_type = self.stream.current.type
-        lineno = self.stream.current.lineno
-        if token_type == 'sub':
-            next(self.stream)
-            node = nodes.Neg(self.parse_unary(False), lineno=lineno)
-        elif token_type == 'add':
-            next(self.stream)
-            node = nodes.Pos(self.parse_unary(False), lineno=lineno)
-        else:
-            node = self.parse_primary()
-        node = self.parse_postfix(node)
-        if with_filter:
-            node = self.parse_filter_expr(node)
-        return node
-
-    def parse_primary(self):
-        token = self.stream.current
-        if token.type == 'name':
-            if token.value in ('true', 'false', 'True', 'False'):
-                node = nodes.Const(token.value in ('true', 'True'),
-                                   lineno=token.lineno)
-            elif token.value in ('none', 'None'):
-                node = nodes.Const(None, lineno=token.lineno)
-            else:
-                node = nodes.Name(token.value, 'load', lineno=token.lineno)
-            next(self.stream)
-        elif token.type == 'string':
-            next(self.stream)
-            buf = [token.value]
-            lineno = token.lineno
-            while self.stream.current.type == 'string':
-                buf.append(self.stream.current.value)
-                next(self.stream)
-            node = nodes.Const(''.join(buf), lineno=lineno)
-        elif token.type in ('integer', 'float'):
-            next(self.stream)
-            node = nodes.Const(token.value, lineno=token.lineno)
-        elif token.type == 'lparen':
-            next(self.stream)
-            node = self.parse_tuple(explicit_parentheses=True)
-            self.stream.expect('rparen')
-        elif token.type == 'lbracket':
-            node = self.parse_list()
-        elif token.type == 'lbrace':
-            node = self.parse_dict()
-        else:
-            self.fail("unexpected '%s'" % describe_token(token), token.lineno)
-        return node
-
-    def parse_tuple(self, simplified=False, with_condexpr=True,
-                    extra_end_rules=None, explicit_parentheses=False):
-        """Works like `parse_expression` but if multiple expressions are
-        delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
-        This method could also return a regular expression instead of a tuple
-        if no commas where found.
-
-        The default parsing mode is a full tuple.  If `simplified` is `True`
-        only names and literals are parsed.  The `no_condexpr` parameter is
-        forwarded to :meth:`parse_expression`.
-
-        Because tuples do not require delimiters and may end in a bogus comma
-        an extra hint is needed that marks the end of a tuple.  For example
-        for loops support tuples between `for` and `in`.  In that case the
-        `extra_end_rules` is set to ``['name:in']``.
-
-        `explicit_parentheses` is true if the parsing was triggered by an
-        expression in parentheses.  This is used to figure out if an empty
-        tuple is a valid expression or not.
-        """
-        lineno = self.stream.current.lineno
-        if simplified:
-            parse = self.parse_primary
-        elif with_condexpr:
-            parse = self.parse_expression
-        else:
-            parse = lambda: self.parse_expression(with_condexpr=False)
-        args = []
-        is_tuple = False
-        while 1:
-            if args:
-                self.stream.expect('comma')
-            if self.is_tuple_end(extra_end_rules):
-                break
-            args.append(parse())
-            if self.stream.current.type == 'comma':
-                is_tuple = True
-            else:
-                break
-            lineno = self.stream.current.lineno
-
-        if not is_tuple:
-            if args:
-                return args[0]
-
-            # if we don't have explicit parentheses, an empty tuple is
-            # not a valid expression.  This would mean nothing (literally
-            # nothing) in the spot of an expression would be an empty
-            # tuple.
-            if not explicit_parentheses:
-                self.fail('Expected an expression, got \'%s\'' %
-                          describe_token(self.stream.current))
-
-        return nodes.Tuple(args, 'load', lineno=lineno)
-
-    def parse_list(self):
-        token = self.stream.expect('lbracket')
-        items = []
-        while self.stream.current.type != 'rbracket':
-            if items:
-                self.stream.expect('comma')
-            if self.stream.current.type == 'rbracket':
-                break
-            items.append(self.parse_expression())
-        self.stream.expect('rbracket')
-        return nodes.List(items, lineno=token.lineno)
-
-    def parse_dict(self):
-        token = self.stream.expect('lbrace')
-        items = []
-        while self.stream.current.type != 'rbrace':
-            if items:
-                self.stream.expect('comma')
-            if self.stream.current.type == 'rbrace':
-                break
-            key = self.parse_expression()
-            self.stream.expect('colon')
-            value = self.parse_expression()
-            items.append(nodes.Pair(key, value, lineno=key.lineno))
-        self.stream.expect('rbrace')
-        return nodes.Dict(items, lineno=token.lineno)
-
-    def parse_postfix(self, node):
-        while 1:
-            token_type = self.stream.current.type
-            if token_type == 'dot' or token_type == 'lbracket':
-                node = self.parse_subscript(node)
-            # calls are valid both after postfix expressions (getattr
-            # and getitem) as well as filters and tests
-            elif token_type == 'lparen':
-                node = self.parse_call(node)
-            else:
-                break
-        return node
-
-    def parse_filter_expr(self, node):
-        while 1:
-            token_type = self.stream.current.type
-            if token_type == 'pipe':
-                node = self.parse_filter(node)
-            elif token_type == 'name' and self.stream.current.value == 'is':
-                node = self.parse_test(node)
-            # calls are valid both after postfix expressions (getattr
-            # and getitem) as well as filters and tests
-            elif token_type == 'lparen':
-                node = self.parse_call(node)
-            else:
-                break
-        return node
-
-    def parse_subscript(self, node):
-        token = next(self.stream)
-        if token.type == 'dot':
-            attr_token = self.stream.current
-            next(self.stream)
-            if attr_token.type == 'name':
-                return nodes.Getattr(node, attr_token.value, 'load',
-                                     lineno=token.lineno)
-            elif attr_token.type != 'integer':
-                self.fail('expected name or number', attr_token.lineno)
-            arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
-            return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
-        if token.type == 'lbracket':
-            args = []
-            while self.stream.current.type != 'rbracket':
-                if args:
-                    self.stream.expect('comma')
-                args.append(self.parse_subscribed())
-            self.stream.expect('rbracket')
-            if len(args) == 1:
-                arg = args[0]
-            else:
-                arg = nodes.Tuple(args, 'load', lineno=token.lineno)
-            return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
-        self.fail('expected subscript expression', self.lineno)
-
-    def parse_subscribed(self):
-        lineno = self.stream.current.lineno
-
-        if self.stream.current.type == 'colon':
-            next(self.stream)
-            args = [None]
-        else:
-            node = self.parse_expression()
-            if self.stream.current.type != 'colon':
-                return node
-            next(self.stream)
-            args = [node]
-
-        if self.stream.current.type == 'colon':
-            args.append(None)
-        elif self.stream.current.type not in ('rbracket', 'comma'):
-            args.append(self.parse_expression())
-        else:
-            args.append(None)
-
-        if self.stream.current.type == 'colon':
-            next(self.stream)
-            if self.stream.current.type not in ('rbracket', 'comma'):
-                args.append(self.parse_expression())
-            else:
-                args.append(None)
-        else:
-            args.append(None)
-
-        return nodes.Slice(lineno=lineno, *args)
-
-    def parse_call(self, node):
-        token = self.stream.expect('lparen')
-        args = []
-        kwargs = []
-        dyn_args = dyn_kwargs = None
-        require_comma = False
-
-        def ensure(expr):
-            if not expr:
-                self.fail('invalid syntax for function call expression',
-                          token.lineno)
-
-        while self.stream.current.type != 'rparen':
-            if require_comma:
-                self.stream.expect('comma')
-                # support for trailing comma
-                if self.stream.current.type == 'rparen':
-                    break
-            if self.stream.current.type == 'mul':
-                ensure(dyn_args is None and dyn_kwargs is None)
-                next(self.stream)
-                dyn_args = self.parse_expression()
-            elif self.stream.current.type == 'pow':
-                ensure(dyn_kwargs is None)
-                next(self.stream)
-                dyn_kwargs = self.parse_expression()
-            else:
-                ensure(dyn_args is None and dyn_kwargs is None)
-                if self.stream.current.type == 'name' and \
-                   self.stream.look().type == 'assign':
-                    key = self.stream.current.value
-                    self.stream.skip(2)
-                    value = self.parse_expression()
-                    kwargs.append(nodes.Keyword(key, value,
-                                                lineno=value.lineno))
-                else:
-                    ensure(not kwargs)
-                    args.append(self.parse_expression())
-
-            require_comma = True
-        self.stream.expect('rparen')
-
-        if node is None:
-            return args, kwargs, dyn_args, dyn_kwargs
-        return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs,
-                          lineno=token.lineno)
-
-    def parse_filter(self, node, start_inline=False):
-        while self.stream.current.type == 'pipe' or start_inline:
-            if not start_inline:
-                next(self.stream)
-            token = self.stream.expect('name')
-            name = token.value
-            while self.stream.current.type == 'dot':
-                next(self.stream)
-                name += '.' + self.stream.expect('name').value
-            if self.stream.current.type == 'lparen':
-                args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
-            else:
-                args = []
-                kwargs = []
-                dyn_args = dyn_kwargs = None
-            node = nodes.Filter(node, name, args, kwargs, dyn_args,
-                                dyn_kwargs, lineno=token.lineno)
-            start_inline = False
-        return node
-
-    def parse_test(self, node):
-        token = next(self.stream)
-        if self.stream.current.test('name:not'):
-            next(self.stream)
-            negated = True
-        else:
-            negated = False
-        name = self.stream.expect('name').value
-        while self.stream.current.type == 'dot':
-            next(self.stream)
-            name += '.' + self.stream.expect('name').value
-        dyn_args = dyn_kwargs = None
-        kwargs = []
-        if self.stream.current.type == 'lparen':
-            args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
-        elif (self.stream.current.type in ('name', 'string', 'integer',
-                                           'float', 'lparen', 'lbracket',
-                                           'lbrace') and not
-              self.stream.current.test_any('name:else', 'name:or',
-                                           'name:and')):
-            if self.stream.current.test('name:is'):
-                self.fail('You cannot chain multiple tests with is')
-            args = [self.parse_primary()]
-        else:
-            args = []
-        node = nodes.Test(node, name, args, kwargs, dyn_args,
-                          dyn_kwargs, lineno=token.lineno)
-        if negated:
-            node = nodes.Not(node, lineno=token.lineno)
-        return node
-
-    def subparse(self, end_tokens=None):
-        body = []
-        data_buffer = []
-        add_data = data_buffer.append
-
-        if end_tokens is not None:
-            self._end_token_stack.append(end_tokens)
-
-        def flush_data():
-            if data_buffer:
-                lineno = data_buffer[0].lineno
-                body.append(nodes.Output(data_buffer[:], lineno=lineno))
-                del data_buffer[:]
-
-        try:
-            while self.stream:
-                token = self.stream.current
-                if token.type == 'data':
-                    if token.value:
-                        add_data(nodes.TemplateData(token.value,
-                                                    lineno=token.lineno))
-                    next(self.stream)
-                elif token.type == 'variable_begin':
-                    next(self.stream)
-                    add_data(self.parse_tuple(with_condexpr=True))
-                    self.stream.expect('variable_end')
-                elif token.type == 'block_begin':
-                    flush_data()
-                    next(self.stream)
-                    if end_tokens is not None and \
-                       self.stream.current.test_any(*end_tokens):
-                        return body
-                    rv = self.parse_statement()
-                    if isinstance(rv, list):
-                        body.extend(rv)
-                    else:
-                        body.append(rv)
-                    self.stream.expect('block_end')
-                else:
-                    raise AssertionError('internal parsing error')
-
-            flush_data()
-        finally:
-            if end_tokens is not None:
-                self._end_token_stack.pop()
-
-        return body
-
-    def parse(self):
-        """Parse the whole template into a `Template` node."""
-        result = nodes.Template(self.subparse(), lineno=1)
-        result.set_environment(self.environment)
-        return result
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/runtime.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/runtime.py
deleted file mode 100644
index f9d7a6806..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/runtime.py
+++ /dev/null
@@ -1,813 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.runtime
-    ~~~~~~~~~~~~~~
-
-    Runtime helpers.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-import sys
-
-from itertools import chain
-from types import MethodType
-
-from jinja2.nodes import EvalContext, _context_function_types
-from jinja2.utils import Markup, soft_unicode, escape, missing, concat, \
-     internalcode, object_type_repr, evalcontextfunction, Namespace
-from jinja2.exceptions import UndefinedError, TemplateRuntimeError, \
-     TemplateNotFound
-from jinja2._compat import imap, text_type, iteritems, \
-     implements_iterator, implements_to_string, string_types, PY2, \
-     with_metaclass
-
-
-# these variables are exported to the template runtime
-__all__ = ['LoopContext', 'TemplateReference', 'Macro', 'Markup',
-           'TemplateRuntimeError', 'missing', 'concat', 'escape',
-           'markup_join', 'unicode_join', 'to_string', 'identity',
-           'TemplateNotFound', 'Namespace']
-
-#: the name of the function that is used to convert something into
-#: a string.  We can just use the text type here.
-to_string = text_type
-
-#: the identity function.  Useful for certain things in the environment
-identity = lambda x: x
-
-_first_iteration = object()
-_last_iteration = object()
-
-
-def markup_join(seq):
-    """Concatenation that escapes if necessary and converts to unicode."""
-    buf = []
-    iterator = imap(soft_unicode, seq)
-    for arg in iterator:
-        buf.append(arg)
-        if hasattr(arg, '__html__'):
-            return Markup(u'').join(chain(buf, iterator))
-    return concat(buf)
-
-
-def unicode_join(seq):
-    """Simple args to unicode conversion and concatenation."""
-    return concat(imap(text_type, seq))
-
-
-def new_context(environment, template_name, blocks, vars=None,
-                shared=None, globals=None, locals=None):
-    """Internal helper to for context creation."""
-    if vars is None:
-        vars = {}
-    if shared:
-        parent = vars
-    else:
-        parent = dict(globals or (), **vars)
-    if locals:
-        # if the parent is shared a copy should be created because
-        # we don't want to modify the dict passed
-        if shared:
-            parent = dict(parent)
-        for key, value in iteritems(locals):
-            if value is not missing:
-                parent[key] = value
-    return environment.context_class(environment, parent, template_name,
-                                     blocks)
-
-
-class TemplateReference(object):
-    """The `self` in templates."""
-
-    def __init__(self, context):
-        self.__context = context
-
-    def __getitem__(self, name):
-        blocks = self.__context.blocks[name]
-        return BlockReference(name, self.__context, blocks, 0)
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self.__context.name
-        )
-
-
-def _get_func(x):
-    return getattr(x, '__func__', x)
-
-
-class ContextMeta(type):
-
-    def __new__(cls, name, bases, d):
-        rv = type.__new__(cls, name, bases, d)
-        if bases == ():
-            return rv
-
-        resolve = _get_func(rv.resolve)
-        default_resolve = _get_func(Context.resolve)
-        resolve_or_missing = _get_func(rv.resolve_or_missing)
-        default_resolve_or_missing = _get_func(Context.resolve_or_missing)
-
-        # If we have a changed resolve but no changed default or missing
-        # resolve we invert the call logic.
-        if resolve is not default_resolve and \
-           resolve_or_missing is default_resolve_or_missing:
-            rv._legacy_resolve_mode = True
-        elif resolve is default_resolve and \
-             resolve_or_missing is default_resolve_or_missing:
-            rv._fast_resolve_mode = True
-
-        return rv
-
-
-def resolve_or_missing(context, key, missing=missing):
-    if key in context.vars:
-        return context.vars[key]
-    if key in context.parent:
-        return context.parent[key]
-    return missing
-
-
-class Context(with_metaclass(ContextMeta)):
-    """The template context holds the variables of a template.  It stores the
-    values passed to the template and also the names the template exports.
-    Creating instances is neither supported nor useful as it's created
-    automatically at various stages of the template evaluation and should not
-    be created by hand.
-
-    The context is immutable.  Modifications on :attr:`parent` **must not**
-    happen and modifications on :attr:`vars` are allowed from generated
-    template code only.  Template filters and global functions marked as
-    :func:`contextfunction`\\s get the active context passed as first argument
-    and are allowed to access the context read-only.
-
-    The template context supports read only dict operations (`get`,
-    `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
-    `__getitem__`, `__contains__`).  Additionally there is a :meth:`resolve`
-    method that doesn't fail with a `KeyError` but returns an
-    :class:`Undefined` object for missing variables.
-    """
-    # XXX: we want to eventually make this be a deprecation warning and
-    # remove it.
-    _legacy_resolve_mode = False
-    _fast_resolve_mode = False
-
-    def __init__(self, environment, parent, name, blocks):
-        self.parent = parent
-        self.vars = {}
-        self.environment = environment
-        self.eval_ctx = EvalContext(self.environment, name)
-        self.exported_vars = set()
-        self.name = name
-
-        # create the initial mapping of blocks.  Whenever template inheritance
-        # takes place the runtime will update this mapping with the new blocks
-        # from the template.
-        self.blocks = dict((k, [v]) for k, v in iteritems(blocks))
-
-        # In case we detect the fast resolve mode we can set up an alias
-        # here that bypasses the legacy code logic.
-        if self._fast_resolve_mode:
-            self.resolve_or_missing = MethodType(resolve_or_missing, self)
-
-    def super(self, name, current):
-        """Render a parent block."""
-        try:
-            blocks = self.blocks[name]
-            index = blocks.index(current) + 1
-            blocks[index]
-        except LookupError:
-            return self.environment.undefined('there is no parent block '
-                                              'called %r.' % name,
-                                              name='super')
-        return BlockReference(name, self, blocks, index)
-
-    def get(self, key, default=None):
-        """Returns an item from the template context, if it doesn't exist
-        `default` is returned.
-        """
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def resolve(self, key):
-        """Looks up a variable like `__getitem__` or `get` but returns an
-        :class:`Undefined` object with the name of the name looked up.
-        """
-        if self._legacy_resolve_mode:
-            rv = resolve_or_missing(self, key)
-        else:
-            rv = self.resolve_or_missing(key)
-        if rv is missing:
-            return self.environment.undefined(name=key)
-        return rv
-
-    def resolve_or_missing(self, key):
-        """Resolves a variable like :meth:`resolve` but returns the
-        special `missing` value if it cannot be found.
-        """
-        if self._legacy_resolve_mode:
-            rv = self.resolve(key)
-            if isinstance(rv, Undefined):
-                rv = missing
-            return rv
-        return resolve_or_missing(self, key)
-
-    def get_exported(self):
-        """Get a new dict with the exported variables."""
-        return dict((k, self.vars[k]) for k in self.exported_vars)
-
-    def get_all(self):
-        """Return the complete context as dict including the exported
-        variables.  For optimizations reasons this might not return an
-        actual copy so be careful with using it.
-        """
-        if not self.vars:
-            return self.parent
-        if not self.parent:
-            return self.vars
-        return dict(self.parent, **self.vars)
-
-    @internalcode
-    def call(__self, __obj, *args, **kwargs):
-        """Call the callable with the arguments and keyword arguments
-        provided but inject the active context or environment as first
-        argument if the callable is a :func:`contextfunction` or
-        :func:`environmentfunction`.
-        """
-        if __debug__:
-            __traceback_hide__ = True  # noqa
-
-        # Allow callable classes to take a context
-        if hasattr(__obj, '__call__'):
-            fn = __obj.__call__
-            for fn_type in ('contextfunction',
-                            'evalcontextfunction',
-                            'environmentfunction'):
-                if hasattr(fn, fn_type):
-                    __obj = fn
-                    break
-
-        if isinstance(__obj, _context_function_types):
-            if getattr(__obj, 'contextfunction', 0):
-                args = (__self,) + args
-            elif getattr(__obj, 'evalcontextfunction', 0):
-                args = (__self.eval_ctx,) + args
-            elif getattr(__obj, 'environmentfunction', 0):
-                args = (__self.environment,) + args
-        try:
-            return __obj(*args, **kwargs)
-        except StopIteration:
-            return __self.environment.undefined('value was undefined because '
-                                                'a callable raised a '
-                                                'StopIteration exception')
-
-    def derived(self, locals=None):
-        """Internal helper function to create a derived context.  This is
-        used in situations where the system needs a new context in the same
-        template that is independent.
-        """
-        context = new_context(self.environment, self.name, {},
-                              self.get_all(), True, None, locals)
-        context.eval_ctx = self.eval_ctx
-        context.blocks.update((k, list(v)) for k, v in iteritems(self.blocks))
-        return context
-
-    def _all(meth):
-        proxy = lambda self: getattr(self.get_all(), meth)()
-        proxy.__doc__ = getattr(dict, meth).__doc__
-        proxy.__name__ = meth
-        return proxy
-
-    keys = _all('keys')
-    values = _all('values')
-    items = _all('items')
-
-    # not available on python 3
-    if PY2:
-        iterkeys = _all('iterkeys')
-        itervalues = _all('itervalues')
-        iteritems = _all('iteritems')
-    del _all
-
-    def __contains__(self, name):
-        return name in self.vars or name in self.parent
-
-    def __getitem__(self, key):
-        """Lookup a variable or raise `KeyError` if the variable is
-        undefined.
-        """
-        item = self.resolve_or_missing(key)
-        if item is missing:
-            raise KeyError(key)
-        return item
-
-    def __repr__(self):
-        return '<%s %s of %r>' % (
-            self.__class__.__name__,
-            repr(self.get_all()),
-            self.name
-        )
-
-
-# register the context as mapping if possible
-try:
-    from collections import Mapping
-    Mapping.register(Context)
-except ImportError:
-    pass
-
-
-class BlockReference(object):
-    """One block on a template reference."""
-
-    def __init__(self, name, context, stack, depth):
-        self.name = name
-        self._context = context
-        self._stack = stack
-        self._depth = depth
-
-    @property
-    def super(self):
-        """Super the block."""
-        if self._depth + 1 >= len(self._stack):
-            return self._context.environment. \
-                undefined('there is no parent block called %r.' %
-                          self.name, name='super')
-        return BlockReference(self.name, self._context, self._stack,
-                              self._depth + 1)
-
-    @internalcode
-    def __call__(self):
-        rv = concat(self._stack[self._depth](self._context))
-        if self._context.eval_ctx.autoescape:
-            rv = Markup(rv)
-        return rv
-
-
-class LoopContextBase(object):
-    """A loop context for dynamic iteration."""
-
-    _before = _first_iteration
-    _current = _first_iteration
-    _after = _last_iteration
-    _length = None
-
-    def __init__(self, undefined, recurse=None, depth0=0):
-        self._undefined = undefined
-        self._recurse = recurse
-        self.index0 = -1
-        self.depth0 = depth0
-        self._last_checked_value = missing
-
-    def cycle(self, *args):
-        """Cycles among the arguments with the current loop index."""
-        if not args:
-            raise TypeError('no items for cycling given')
-        return args[self.index0 % len(args)]
-
-    def changed(self, *value):
-        """Checks whether the value has changed since the last call."""
-        if self._last_checked_value != value:
-            self._last_checked_value = value
-            return True
-        return False
-
-    first = property(lambda x: x.index0 == 0)
-    last = property(lambda x: x._after is _last_iteration)
-    index = property(lambda x: x.index0 + 1)
-    revindex = property(lambda x: x.length - x.index0)
-    revindex0 = property(lambda x: x.length - x.index)
-    depth = property(lambda x: x.depth0 + 1)
-
-    @property
-    def previtem(self):
-        if self._before is _first_iteration:
-            return self._undefined('there is no previous item')
-        return self._before
-
-    @property
-    def nextitem(self):
-        if self._after is _last_iteration:
-            return self._undefined('there is no next item')
-        return self._after
-
-    def __len__(self):
-        return self.length
-
-    @internalcode
-    def loop(self, iterable):
-        if self._recurse is None:
-            raise TypeError('Tried to call non recursive loop.  Maybe you '
-                            "forgot the 'recursive' modifier.")
-        return self._recurse(iterable, self._recurse, self.depth0 + 1)
-
-    # a nifty trick to enhance the error message if someone tried to call
-    # the the loop without or with too many arguments.
-    __call__ = loop
-    del loop
-
-    def __repr__(self):
-        return '<%s %r/%r>' % (
-            self.__class__.__name__,
-            self.index,
-            self.length
-        )
-
-
-class LoopContext(LoopContextBase):
-
-    def __init__(self, iterable, undefined, recurse=None, depth0=0):
-        LoopContextBase.__init__(self, undefined, recurse, depth0)
-        self._iterator = iter(iterable)
-
-        # try to get the length of the iterable early.  This must be done
-        # here because there are some broken iterators around where there
-        # __len__ is the number of iterations left (i'm looking at your
-        # listreverseiterator!).
-        try:
-            self._length = len(iterable)
-        except (TypeError, AttributeError):
-            self._length = None
-        self._after = self._safe_next()
-
-    @property
-    def length(self):
-        if self._length is None:
-            # if was not possible to get the length of the iterator when
-            # the loop context was created (ie: iterating over a generator)
-            # we have to convert the iterable into a sequence and use the
-            # length of that + the number of iterations so far.
-            iterable = tuple(self._iterator)
-            self._iterator = iter(iterable)
-            iterations_done = self.index0 + 2
-            self._length = len(iterable) + iterations_done
-        return self._length
-
-    def __iter__(self):
-        return LoopContextIterator(self)
-
-    def _safe_next(self):
-        try:
-            return next(self._iterator)
-        except StopIteration:
-            return _last_iteration
-
-
-@implements_iterator
-class LoopContextIterator(object):
-    """The iterator for a loop context."""
-    __slots__ = ('context',)
-
-    def __init__(self, context):
-        self.context = context
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        ctx = self.context
-        ctx.index0 += 1
-        if ctx._after is _last_iteration:
-            raise StopIteration()
-        ctx._before = ctx._current
-        ctx._current = ctx._after
-        ctx._after = ctx._safe_next()
-        return ctx._current, ctx
-
-
-class Macro(object):
-    """Wraps a macro function."""
-
-    def __init__(self, environment, func, name, arguments,
-                 catch_kwargs, catch_varargs, caller,
-                 default_autoescape=None):
-        self._environment = environment
-        self._func = func
-        self._argument_count = len(arguments)
-        self.name = name
-        self.arguments = arguments
-        self.catch_kwargs = catch_kwargs
-        self.catch_varargs = catch_varargs
-        self.caller = caller
-        self.explicit_caller = 'caller' in arguments
-        if default_autoescape is None:
-            default_autoescape = environment.autoescape
-        self._default_autoescape = default_autoescape
-
-    @internalcode
-    @evalcontextfunction
-    def __call__(self, *args, **kwargs):
-        # This requires a bit of explanation,  In the past we used to
-        # decide largely based on compile-time information if a macro is
-        # safe or unsafe.  While there was a volatile mode it was largely
-        # unused for deciding on escaping.  This turns out to be
-        # problemtic for macros because if a macro is safe or not not so
-        # much depends on the escape mode when it was defined but when it
-        # was used.
-        #
-        # Because however we export macros from the module system and
-        # there are historic callers that do not pass an eval context (and
-        # will continue to not pass one), we need to perform an instance
-        # check here.
-        #
-        # This is considered safe because an eval context is not a valid
-        # argument to callables otherwise anwyays.  Worst case here is
-        # that if no eval context is passed we fall back to the compile
-        # time autoescape flag.
-        if args and isinstance(args[0], EvalContext):
-            autoescape = args[0].autoescape
-            args = args[1:]
-        else:
-            autoescape = self._default_autoescape
-
-        # try to consume the positional arguments
-        arguments = list(args[:self._argument_count])
-        off = len(arguments)
-
-        # For information why this is necessary refer to the handling
-        # of caller in the `macro_body` handler in the compiler.
-        found_caller = False
-
-        # if the number of arguments consumed is not the number of
-        # arguments expected we start filling in keyword arguments
-        # and defaults.
-        if off != self._argument_count:
-            for idx, name in enumerate(self.arguments[len(arguments):]):
-                try:
-                    value = kwargs.pop(name)
-                except KeyError:
-                    value = missing
-                if name == 'caller':
-                    found_caller = True
-                arguments.append(value)
-        else:
-            found_caller = self.explicit_caller
-
-        # it's important that the order of these arguments does not change
-        # if not also changed in the compiler's `function_scoping` method.
-        # the order is caller, keyword arguments, positional arguments!
-        if self.caller and not found_caller:
-            caller = kwargs.pop('caller', None)
-            if caller is None:
-                caller = self._environment.undefined('No caller defined',
-                                                     name='caller')
-            arguments.append(caller)
-
-        if self.catch_kwargs:
-            arguments.append(kwargs)
-        elif kwargs:
-            if 'caller' in kwargs:
-                raise TypeError('macro %r was invoked with two values for '
-                                'the special caller argument.  This is '
-                                'most likely a bug.' % self.name)
-            raise TypeError('macro %r takes no keyword argument %r' %
-                            (self.name, next(iter(kwargs))))
-        if self.catch_varargs:
-            arguments.append(args[self._argument_count:])
-        elif len(args) > self._argument_count:
-            raise TypeError('macro %r takes not more than %d argument(s)' %
-                            (self.name, len(self.arguments)))
-
-        return self._invoke(arguments, autoescape)
-
-    def _invoke(self, arguments, autoescape):
-        """This method is being swapped out by the async implementation."""
-        rv = self._func(*arguments)
-        if autoescape:
-            rv = Markup(rv)
-        return rv
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            self.__class__.__name__,
-            self.name is None and 'anonymous' or repr(self.name)
-        )
-
-
-@implements_to_string
-class Undefined(object):
-    """The default undefined type.  This undefined type can be printed and
-    iterated over, but every other access will raise an :exc:`jinja2.exceptions.UndefinedError`:
-
-    >>> foo = Undefined(name='foo')
-    >>> str(foo)
-    ''
-    >>> not foo
-    True
-    >>> foo + 42
-    Traceback (most recent call last):
-      ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
-    """
-    __slots__ = ('_undefined_hint', '_undefined_obj', '_undefined_name',
-                 '_undefined_exception')
-
-    def __init__(self, hint=None, obj=missing, name=None, exc=UndefinedError):
-        self._undefined_hint = hint
-        self._undefined_obj = obj
-        self._undefined_name = name
-        self._undefined_exception = exc
-
-    @internalcode
-    def _fail_with_undefined_error(self, *args, **kwargs):
-        """Regular callback function for undefined objects that raises an
-        `jinja2.exceptions.UndefinedError` on call.
-        """
-        if self._undefined_hint is None:
-            if self._undefined_obj is missing:
-                hint = '%r is undefined' % self._undefined_name
-            elif not isinstance(self._undefined_name, string_types):
-                hint = '%s has no element %r' % (
-                    object_type_repr(self._undefined_obj),
-                    self._undefined_name
-                )
-            else:
-                hint = '%r has no attribute %r' % (
-                    object_type_repr(self._undefined_obj),
-                    self._undefined_name
-                )
-        else:
-            hint = self._undefined_hint
-        raise self._undefined_exception(hint)
-
-    @internalcode
-    def __getattr__(self, name):
-        if name[:2] == '__':
-            raise AttributeError(name)
-        return self._fail_with_undefined_error()
-
-    __add__ = __radd__ = __mul__ = __rmul__ = __div__ = __rdiv__ = \
-        __truediv__ = __rtruediv__ = __floordiv__ = __rfloordiv__ = \
-        __mod__ = __rmod__ = __pos__ = __neg__ = __call__ = \
-        __getitem__ = __lt__ = __le__ = __gt__ = __ge__ = __int__ = \
-        __float__ = __complex__ = __pow__ = __rpow__ = __sub__ = \
-        __rsub__ = _fail_with_undefined_error
-
-    def __eq__(self, other):
-        return type(self) is type(other)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __hash__(self):
-        return id(type(self))
-
-    def __str__(self):
-        return u''
-
-    def __len__(self):
-        return 0
-
-    def __iter__(self):
-        if 0:
-            yield None
-
-    def __nonzero__(self):
-        return False
-    __bool__ = __nonzero__
-
-    def __repr__(self):
-        return 'Undefined'
-
-
-def make_logging_undefined(logger=None, base=None):
-    """Given a logger object this returns a new undefined class that will
-    log certain failures.  It will log iterations and printing.  If no
-    logger is given a default logger is created.
-
-    Example::
-
-        logger = logging.getLogger(__name__)
-        LoggingUndefined = make_logging_undefined(
-            logger=logger,
-            base=Undefined
-        )
-
-    .. versionadded:: 2.8
-
-    :param logger: the logger to use.  If not provided, a default logger
-                   is created.
-    :param base: the base class to add logging functionality to.  This
-                 defaults to :class:`Undefined`.
-    """
-    if logger is None:
-        import logging
-        logger = logging.getLogger(__name__)
-        logger.addHandler(logging.StreamHandler(sys.stderr))
-    if base is None:
-        base = Undefined
-
-    def _log_message(undef):
-        if undef._undefined_hint is None:
-            if undef._undefined_obj is missing:
-                hint = '%s is undefined' % undef._undefined_name
-            elif not isinstance(undef._undefined_name, string_types):
-                hint = '%s has no element %s' % (
-                    object_type_repr(undef._undefined_obj),
-                    undef._undefined_name)
-            else:
-                hint = '%s has no attribute %s' % (
-                    object_type_repr(undef._undefined_obj),
-                    undef._undefined_name)
-        else:
-            hint = undef._undefined_hint
-        logger.warning('Template variable warning: %s', hint)
-
-    class LoggingUndefined(base):
-
-        def _fail_with_undefined_error(self, *args, **kwargs):
-            try:
-                return base._fail_with_undefined_error(self, *args, **kwargs)
-            except self._undefined_exception as e:
-                logger.error('Template variable error: %s', str(e))
-                raise e
-
-        def __str__(self):
-            rv = base.__str__(self)
-            _log_message(self)
-            return rv
-
-        def __iter__(self):
-            rv = base.__iter__(self)
-            _log_message(self)
-            return rv
-
-        if PY2:
-            def __nonzero__(self):
-                rv = base.__nonzero__(self)
-                _log_message(self)
-                return rv
-
-            def __unicode__(self):
-                rv = base.__unicode__(self)
-                _log_message(self)
-                return rv
-        else:
-            def __bool__(self):
-                rv = base.__bool__(self)
-                _log_message(self)
-                return rv
-
-    return LoggingUndefined
-
-
-@implements_to_string
-class DebugUndefined(Undefined):
-    """An undefined that returns the debug info when printed.
-
-    >>> foo = DebugUndefined(name='foo')
-    >>> str(foo)
-    '{{ foo }}'
-    >>> not foo
-    True
-    >>> foo + 42
-    Traceback (most recent call last):
-      ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
-    """
-    __slots__ = ()
-
-    def __str__(self):
-        if self._undefined_hint is None:
-            if self._undefined_obj is missing:
-                return u'{{ %s }}' % self._undefined_name
-            return '{{ no such element: %s[%r] }}' % (
-                object_type_repr(self._undefined_obj),
-                self._undefined_name
-            )
-        return u'{{ undefined value printed: %s }}' % self._undefined_hint
-
-
-@implements_to_string
-class StrictUndefined(Undefined):
-    """An undefined that barks on print and iteration as well as boolean
-    tests and all kinds of comparisons.  In other words: you can do nothing
-    with it except checking if it's defined using the `defined` test.
-
-    >>> foo = StrictUndefined(name='foo')
-    >>> str(foo)
-    Traceback (most recent call last):
-      ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
-    >>> not foo
-    Traceback (most recent call last):
-      ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
-    >>> foo + 42
-    Traceback (most recent call last):
-      ...
-    jinja2.exceptions.UndefinedError: 'foo' is undefined
-    """
-    __slots__ = ()
-    __iter__ = __str__ = __len__ = __nonzero__ = __eq__ = \
-        __ne__ = __bool__ = __hash__ = \
-        Undefined._fail_with_undefined_error
-
-
-# remove remaining slots attributes, after the metaclass did the magic they
-# are unneeded and irritating as they contain wrong data for the subclasses.
-del Undefined.__slots__, DebugUndefined.__slots__, StrictUndefined.__slots__
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/sandbox.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/sandbox.py
deleted file mode 100644
index 93fb9d45f..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/sandbox.py
+++ /dev/null
@@ -1,475 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.sandbox
-    ~~~~~~~~~~~~~~
-
-    Adds a sandbox layer to Jinja as it was the default behavior in the old
-    Jinja 1 releases.  This sandbox is slightly different from Jinja 1 as the
-    default behavior is easier to use.
-
-    The behavior can be changed by subclassing the environment.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-import types
-import operator
-from collections import Mapping
-from jinja2.environment import Environment
-from jinja2.exceptions import SecurityError
-from jinja2._compat import string_types, PY2
-from jinja2.utils import Markup
-
-from markupsafe import EscapeFormatter
-from string import Formatter
-
-
-#: maximum number of items a range may produce
-MAX_RANGE = 100000
-
-#: attributes of function objects that are considered unsafe.
-if PY2:
-    UNSAFE_FUNCTION_ATTRIBUTES = set(['func_closure', 'func_code', 'func_dict',
-                                      'func_defaults', 'func_globals'])
-else:
-    # On versions > python 2 the special attributes on functions are gone,
-    # but they remain on methods and generators for whatever reason.
-    UNSAFE_FUNCTION_ATTRIBUTES = set()
-
-
-#: unsafe method attributes.  function attributes are unsafe for methods too
-UNSAFE_METHOD_ATTRIBUTES = set(['im_class', 'im_func', 'im_self'])
-
-#: unsafe generator attirbutes.
-UNSAFE_GENERATOR_ATTRIBUTES = set(['gi_frame', 'gi_code'])
-
-#: unsafe attributes on coroutines
-UNSAFE_COROUTINE_ATTRIBUTES = set(['cr_frame', 'cr_code'])
-
-#: unsafe attributes on async generators
-UNSAFE_ASYNC_GENERATOR_ATTRIBUTES = set(['ag_code', 'ag_frame'])
-
-import warnings
-
-# make sure we don't warn in python 2.6 about stuff we don't care about
-warnings.filterwarnings('ignore', 'the sets module', DeprecationWarning,
-                        module='jinja2.sandbox')
-
-from collections import deque
-
-_mutable_set_types = (set,)
-_mutable_mapping_types = (dict,)
-_mutable_sequence_types = (list,)
-
-
-# on python 2.x we can register the user collection types
-try:
-    from UserDict import UserDict, DictMixin
-    from UserList import UserList
-    _mutable_mapping_types += (UserDict, DictMixin)
-    _mutable_set_types += (UserList,)
-except ImportError:
-    pass
-
-# if sets is still available, register the mutable set from there as well
-try:
-    from sets import Set
-    _mutable_set_types += (Set,)
-except ImportError:
-    pass
-
-#: register Python 2.6 abstract base classes
-from collections import MutableSet, MutableMapping, MutableSequence
-_mutable_set_types += (MutableSet,)
-_mutable_mapping_types += (MutableMapping,)
-_mutable_sequence_types += (MutableSequence,)
-
-
-_mutable_spec = (
-    (_mutable_set_types, frozenset([
-        'add', 'clear', 'difference_update', 'discard', 'pop', 'remove',
-        'symmetric_difference_update', 'update'
-    ])),
-    (_mutable_mapping_types, frozenset([
-        'clear', 'pop', 'popitem', 'setdefault', 'update'
-    ])),
-    (_mutable_sequence_types, frozenset([
-        'append', 'reverse', 'insert', 'sort', 'extend', 'remove'
-    ])),
-    (deque, frozenset([
-        'append', 'appendleft', 'clear', 'extend', 'extendleft', 'pop',
-        'popleft', 'remove', 'rotate'
-    ]))
-)
-
-
-class _MagicFormatMapping(Mapping):
-    """This class implements a dummy wrapper to fix a bug in the Python
-    standard library for string formatting.
-
-    See https://bugs.python.org/issue13598 for information about why
-    this is necessary.
-    """
-
-    def __init__(self, args, kwargs):
-        self._args = args
-        self._kwargs = kwargs
-        self._last_index = 0
-
-    def __getitem__(self, key):
-        if key == '':
-            idx = self._last_index
-            self._last_index += 1
-            try:
-                return self._args[idx]
-            except LookupError:
-                pass
-            key = str(idx)
-        return self._kwargs[key]
-
-    def __iter__(self):
-        return iter(self._kwargs)
-
-    def __len__(self):
-        return len(self._kwargs)
-
-
-def inspect_format_method(callable):
-    if not isinstance(callable, (types.MethodType,
-                                 types.BuiltinMethodType)) or \
-       callable.__name__ != 'format':
-        return None
-    obj = callable.__self__
-    if isinstance(obj, string_types):
-        return obj
-
-
-def safe_range(*args):
-    """A range that can't generate ranges with a length of more than
-    MAX_RANGE items.
-    """
-    rng = range(*args)
-    if len(rng) > MAX_RANGE:
-        raise OverflowError('range too big, maximum size for range is %d' %
-                            MAX_RANGE)
-    return rng
-
-
-def unsafe(f):
-    """Marks a function or method as unsafe.
-
-    ::
-
-        @unsafe
-        def delete(self):
-            pass
-    """
-    f.unsafe_callable = True
-    return f
-
-
-def is_internal_attribute(obj, attr):
-    """Test if the attribute given is an internal python attribute.  For
-    example this function returns `True` for the `func_code` attribute of
-    python objects.  This is useful if the environment method
-    :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden.
-
-    >>> from jinja2.sandbox import is_internal_attribute
-    >>> is_internal_attribute(str, "mro")
-    True
-    >>> is_internal_attribute(str, "upper")
-    False
-    """
-    if isinstance(obj, types.FunctionType):
-        if attr in UNSAFE_FUNCTION_ATTRIBUTES:
-            return True
-    elif isinstance(obj, types.MethodType):
-        if attr in UNSAFE_FUNCTION_ATTRIBUTES or \
-           attr in UNSAFE_METHOD_ATTRIBUTES:
-            return True
-    elif isinstance(obj, type):
-        if attr == 'mro':
-            return True
-    elif isinstance(obj, (types.CodeType, types.TracebackType, types.FrameType)):
-        return True
-    elif isinstance(obj, types.GeneratorType):
-        if attr in UNSAFE_GENERATOR_ATTRIBUTES:
-            return True
-    elif hasattr(types, 'CoroutineType') and isinstance(obj, types.CoroutineType):
-        if attr in UNSAFE_COROUTINE_ATTRIBUTES:
-            return True
-    elif hasattr(types, 'AsyncGeneratorType') and isinstance(obj, types.AsyncGeneratorType):
-        if attr in UNSAFE_ASYNC_GENERATOR_ATTRIBUTES:
-            return True
-    return attr.startswith('__')
-
-
-def modifies_known_mutable(obj, attr):
-    """This function checks if an attribute on a builtin mutable object
-    (list, dict, set or deque) would modify it if called.  It also supports
-    the "user"-versions of the objects (`sets.Set`, `UserDict.*` etc.) and
-    with Python 2.6 onwards the abstract base classes `MutableSet`,
-    `MutableMapping`, and `MutableSequence`.
-
-    >>> modifies_known_mutable({}, "clear")
-    True
-    >>> modifies_known_mutable({}, "keys")
-    False
-    >>> modifies_known_mutable([], "append")
-    True
-    >>> modifies_known_mutable([], "index")
-    False
-
-    If called with an unsupported object (such as unicode) `False` is
-    returned.
-
-    >>> modifies_known_mutable("foo", "upper")
-    False
-    """
-    for typespec, unsafe in _mutable_spec:
-        if isinstance(obj, typespec):
-            return attr in unsafe
-    return False
-
-
-class SandboxedEnvironment(Environment):
-    """The sandboxed environment.  It works like the regular environment but
-    tells the compiler to generate sandboxed code.  Additionally subclasses of
-    this environment may override the methods that tell the runtime what
-    attributes or functions are safe to access.
-
-    If the template tries to access insecure code a :exc:`SecurityError` is
-    raised.  However also other exceptions may occur during the rendering so
-    the caller has to ensure that all exceptions are caught.
-    """
-    sandboxed = True
-
-    #: default callback table for the binary operators.  A copy of this is
-    #: available on each instance of a sandboxed environment as
-    #: :attr:`binop_table`
-    default_binop_table = {
-        '+':        operator.add,
-        '-':        operator.sub,
-        '*':        operator.mul,
-        '/':        operator.truediv,
-        '//':       operator.floordiv,
-        '**':       operator.pow,
-        '%':        operator.mod
-    }
-
-    #: default callback table for the unary operators.  A copy of this is
-    #: available on each instance of a sandboxed environment as
-    #: :attr:`unop_table`
-    default_unop_table = {
-        '+':        operator.pos,
-        '-':        operator.neg
-    }
-
-    #: a set of binary operators that should be intercepted.  Each operator
-    #: that is added to this set (empty by default) is delegated to the
-    #: :meth:`call_binop` method that will perform the operator.  The default
-    #: operator callback is specified by :attr:`binop_table`.
-    #:
-    #: The following binary operators are interceptable:
-    #: ``//``, ``%``, ``+``, ``*``, ``-``, ``/``, and ``**``
-    #:
-    #: The default operation form the operator table corresponds to the
-    #: builtin function.  Intercepted calls are always slower than the native
-    #: operator call, so make sure only to intercept the ones you are
-    #: interested in.
-    #:
-    #: .. versionadded:: 2.6
-    intercepted_binops = frozenset()
-
-    #: a set of unary operators that should be intercepted.  Each operator
-    #: that is added to this set (empty by default) is delegated to the
-    #: :meth:`call_unop` method that will perform the operator.  The default
-    #: operator callback is specified by :attr:`unop_table`.
-    #:
-    #: The following unary operators are interceptable: ``+``, ``-``
-    #:
-    #: The default operation form the operator table corresponds to the
-    #: builtin function.  Intercepted calls are always slower than the native
-    #: operator call, so make sure only to intercept the ones you are
-    #: interested in.
-    #:
-    #: .. versionadded:: 2.6
-    intercepted_unops = frozenset()
-
-    def intercept_unop(self, operator):
-        """Called during template compilation with the name of a unary
-        operator to check if it should be intercepted at runtime.  If this
-        method returns `True`, :meth:`call_unop` is excuted for this unary
-        operator.  The default implementation of :meth:`call_unop` will use
-        the :attr:`unop_table` dictionary to perform the operator with the
-        same logic as the builtin one.
-
-        The following unary operators are interceptable: ``+`` and ``-``
-
-        Intercepted calls are always slower than the native operator call,
-        so make sure only to intercept the ones you are interested in.
-
-        .. versionadded:: 2.6
-        """
-        return False
-
-
-    def __init__(self, *args, **kwargs):
-        Environment.__init__(self, *args, **kwargs)
-        self.globals['range'] = safe_range
-        self.binop_table = self.default_binop_table.copy()
-        self.unop_table = self.default_unop_table.copy()
-
-    def is_safe_attribute(self, obj, attr, value):
-        """The sandboxed environment will call this method to check if the
-        attribute of an object is safe to access.  Per default all attributes
-        starting with an underscore are considered private as well as the
-        special attributes of internal python objects as returned by the
-        :func:`is_internal_attribute` function.
-        """
-        return not (attr.startswith('_') or is_internal_attribute(obj, attr))
-
-    def is_safe_callable(self, obj):
-        """Check if an object is safely callable.  Per default a function is
-        considered safe unless the `unsafe_callable` attribute exists and is
-        True.  Override this method to alter the behavior, but this won't
-        affect the `unsafe` decorator from this module.
-        """
-        return not (getattr(obj, 'unsafe_callable', False) or
-                    getattr(obj, 'alters_data', False))
-
-    def call_binop(self, context, operator, left, right):
-        """For intercepted binary operator calls (:meth:`intercepted_binops`)
-        this function is executed instead of the builtin operator.  This can
-        be used to fine tune the behavior of certain operators.
-
-        .. versionadded:: 2.6
-        """
-        return self.binop_table[operator](left, right)
-
-    def call_unop(self, context, operator, arg):
-        """For intercepted unary operator calls (:meth:`intercepted_unops`)
-        this function is executed instead of the builtin operator.  This can
-        be used to fine tune the behavior of certain operators.
-
-        .. versionadded:: 2.6
-        """
-        return self.unop_table[operator](arg)
-
-    def getitem(self, obj, argument):
-        """Subscribe an object from sandboxed code."""
-        try:
-            return obj[argument]
-        except (TypeError, LookupError):
-            if isinstance(argument, string_types):
-                try:
-                    attr = str(argument)
-                except Exception:
-                    pass
-                else:
-                    try:
-                        value = getattr(obj, attr)
-                    except AttributeError:
-                        pass
-                    else:
-                        if self.is_safe_attribute(obj, argument, value):
-                            return value
-                        return self.unsafe_undefined(obj, argument)
-        return self.undefined(obj=obj, name=argument)
-
-    def getattr(self, obj, attribute):
-        """Subscribe an object from sandboxed code and prefer the
-        attribute.  The attribute passed *must* be a bytestring.
-        """
-        try:
-            value = getattr(obj, attribute)
-        except AttributeError:
-            try:
-                return obj[attribute]
-            except (TypeError, LookupError):
-                pass
-        else:
-            if self.is_safe_attribute(obj, attribute, value):
-                return value
-            return self.unsafe_undefined(obj, attribute)
-        return self.undefined(obj=obj, name=attribute)
-
-    def unsafe_undefined(self, obj, attribute):
-        """Return an undefined object for unsafe attributes."""
-        return self.undefined('access to attribute %r of %r '
-                              'object is unsafe.' % (
-            attribute,
-            obj.__class__.__name__
-        ), name=attribute, obj=obj, exc=SecurityError)
-
-    def format_string(self, s, args, kwargs):
-        """If a format call is detected, then this is routed through this
-        method so that our safety sandbox can be used for it.
-        """
-        if isinstance(s, Markup):
-            formatter = SandboxedEscapeFormatter(self, s.escape)
-        else:
-            formatter = SandboxedFormatter(self)
-        kwargs = _MagicFormatMapping(args, kwargs)
-        rv = formatter.vformat(s, args, kwargs)
-        return type(s)(rv)
-
-    def call(__self, __context, __obj, *args, **kwargs):
-        """Call an object from sandboxed code."""
-        fmt = inspect_format_method(__obj)
-        if fmt is not None:
-            return __self.format_string(fmt, args, kwargs)
-
-        # the double prefixes are to avoid double keyword argument
-        # errors when proxying the call.
-        if not __self.is_safe_callable(__obj):
-            raise SecurityError('%r is not safely callable' % (__obj,))
-        return __context.call(__obj, *args, **kwargs)
-
-
-class ImmutableSandboxedEnvironment(SandboxedEnvironment):
-    """Works exactly like the regular `SandboxedEnvironment` but does not
-    permit modifications on the builtin mutable objects `list`, `set`, and
-    `dict` by using the :func:`modifies_known_mutable` function.
-    """
-
-    def is_safe_attribute(self, obj, attr, value):
-        if not SandboxedEnvironment.is_safe_attribute(self, obj, attr, value):
-            return False
-        return not modifies_known_mutable(obj, attr)
-
-
-# This really is not a public API apparenlty.
-try:
-    from _string import formatter_field_name_split
-except ImportError:
-    def formatter_field_name_split(field_name):
-        return field_name._formatter_field_name_split()
-
-
-class SandboxedFormatterMixin(object):
-
-    def __init__(self, env):
-        self._env = env
-
-    def get_field(self, field_name, args, kwargs):
-        first, rest = formatter_field_name_split(field_name)
-        obj = self.get_value(first, args, kwargs)
-        for is_attr, i in rest:
-            if is_attr:
-                obj = self._env.getattr(obj, i)
-            else:
-                obj = self._env.getitem(obj, i)
-        return obj, first
-
-class SandboxedFormatter(SandboxedFormatterMixin, Formatter):
-
-    def __init__(self, env):
-        SandboxedFormatterMixin.__init__(self, env)
-        Formatter.__init__(self)
-
-class SandboxedEscapeFormatter(SandboxedFormatterMixin, EscapeFormatter):
-
-    def __init__(self, env, escape):
-        SandboxedFormatterMixin.__init__(self, env)
-        EscapeFormatter.__init__(self, escape)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/tests.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/tests.py
deleted file mode 100644
index 0adc3d4db..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/tests.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.tests
-    ~~~~~~~~~~~~
-
-    Jinja test functions. Used with the "is" operator.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import operator
-import re
-from collections import Mapping
-from jinja2.runtime import Undefined
-from jinja2._compat import text_type, string_types, integer_types
-import decimal
-
-number_re = re.compile(r'^-?\d+(\.\d+)?$')
-regex_type = type(number_re)
-
-
-test_callable = callable
-
-
-def test_odd(value):
-    """Return true if the variable is odd."""
-    return value % 2 == 1
-
-
-def test_even(value):
-    """Return true if the variable is even."""
-    return value % 2 == 0
-
-
-def test_divisibleby(value, num):
-    """Check if a variable is divisible by a number."""
-    return value % num == 0
-
-
-def test_defined(value):
-    """Return true if the variable is defined:
-
-    .. sourcecode:: jinja
-
-        {% if variable is defined %}
-            value of variable: {{ variable }}
-        {% else %}
-            variable is not defined
-        {% endif %}
-
-    See the :func:`default` filter for a simple way to set undefined
-    variables.
-    """
-    return not isinstance(value, Undefined)
-
-
-def test_undefined(value):
-    """Like :func:`defined` but the other way round."""
-    return isinstance(value, Undefined)
-
-
-def test_none(value):
-    """Return true if the variable is none."""
-    return value is None
-
-
-def test_lower(value):
-    """Return true if the variable is lowercased."""
-    return text_type(value).islower()
-
-
-def test_upper(value):
-    """Return true if the variable is uppercased."""
-    return text_type(value).isupper()
-
-
-def test_string(value):
-    """Return true if the object is a string."""
-    return isinstance(value, string_types)
-
-
-def test_mapping(value):
-    """Return true if the object is a mapping (dict etc.).
-
-    .. versionadded:: 2.6
-    """
-    return isinstance(value, Mapping)
-
-
-def test_number(value):
-    """Return true if the variable is a number."""
-    return isinstance(value, integer_types + (float, complex, decimal.Decimal))
-
-
-def test_sequence(value):
-    """Return true if the variable is a sequence. Sequences are variables
-    that are iterable.
-    """
-    try:
-        len(value)
-        value.__getitem__
-    except:
-        return False
-    return True
-
-
-def test_sameas(value, other):
-    """Check if an object points to the same memory address than another
-    object:
-
-    .. sourcecode:: jinja
-
-        {% if foo.attribute is sameas false %}
-            the foo attribute really is the `False` singleton
-        {% endif %}
-    """
-    return value is other
-
-
-def test_iterable(value):
-    """Check if it's possible to iterate over an object."""
-    try:
-        iter(value)
-    except TypeError:
-        return False
-    return True
-
-
-def test_escaped(value):
-    """Check if the value is escaped."""
-    return hasattr(value, '__html__')
-
-
-def test_in(value, seq):
-    """Check if value is in seq.
-
-    .. versionadded:: 2.10
-    """
-    return value in seq
-
-
-TESTS = {
-    'odd':              test_odd,
-    'even':             test_even,
-    'divisibleby':      test_divisibleby,
-    'defined':          test_defined,
-    'undefined':        test_undefined,
-    'none':             test_none,
-    'lower':            test_lower,
-    'upper':            test_upper,
-    'string':           test_string,
-    'mapping':          test_mapping,
-    'number':           test_number,
-    'sequence':         test_sequence,
-    'iterable':         test_iterable,
-    'callable':         test_callable,
-    'sameas':           test_sameas,
-    'escaped':          test_escaped,
-    'in':               test_in,
-    '==':               operator.eq,
-    'eq':               operator.eq,
-    'equalto':          operator.eq,
-    '!=':               operator.ne,
-    'ne':               operator.ne,
-    '>':                operator.gt,
-    'gt':               operator.gt,
-    'greaterthan':      operator.gt,
-    'ge':               operator.ge,
-    '>=':               operator.ge,
-    '<':                operator.lt,
-    'lt':               operator.lt,
-    'lessthan':         operator.lt,
-    '<=':               operator.le,
-    'le':               operator.le,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/utils.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/utils.py
deleted file mode 100644
index 502a311c0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/utils.py
+++ /dev/null
@@ -1,647 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.utils
-    ~~~~~~~~~~~~
-
-    Utility functions.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import json
-import errno
-from collections import deque
-from threading import Lock
-from jinja2._compat import text_type, string_types, implements_iterator, \
-     url_quote
-
-
-_word_split_re = re.compile(r'(\s+)')
-_punctuation_re = re.compile(
-    '^(?P<lead>(?:%s)*)(?P<middle>.*?)(?P<trail>(?:%s)*)$' % (
-        '|'.join(map(re.escape, ('(', '<', '&lt;'))),
-        '|'.join(map(re.escape, ('.', ',', ')', '>', '\n', '&gt;')))
-    )
-)
-_simple_email_re = re.compile(r'^\S+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9._-]+$')
-_striptags_re = re.compile(r'(<!--.*?-->|<[^>]*>)')
-_entity_re = re.compile(r'&([^;]+);')
-_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-_digits = '0123456789'
-
-# special singleton representing missing values for the runtime
-missing = type('MissingType', (), {'__repr__': lambda x: 'missing'})()
-
-# internal code
-internal_code = set()
-
-concat = u''.join
-
-_slash_escape = '\\/' not in json.dumps('/')
-
-
-def contextfunction(f):
-    """This decorator can be used to mark a function or method context callable.
-    A context callable is passed the active :class:`Context` as first argument when
-    called from the template.  This is useful if a function wants to get access
-    to the context or functions provided on the context object.  For example
-    a function that returns a sorted list of template variables the current
-    template exports could look like this::
-
-        @contextfunction
-        def get_exported_names(context):
-            return sorted(context.exported_vars)
-    """
-    f.contextfunction = True
-    return f
-
-
-def evalcontextfunction(f):
-    """This decorator can be used to mark a function or method as an eval
-    context callable.  This is similar to the :func:`contextfunction`
-    but instead of passing the context, an evaluation context object is
-    passed.  For more information about the eval context, see
-    :ref:`eval-context`.
-
-    .. versionadded:: 2.4
-    """
-    f.evalcontextfunction = True
-    return f
-
-
-def environmentfunction(f):
-    """This decorator can be used to mark a function or method as environment
-    callable.  This decorator works exactly like the :func:`contextfunction`
-    decorator just that the first argument is the active :class:`Environment`
-    and not context.
-    """
-    f.environmentfunction = True
-    return f
-
-
-def internalcode(f):
-    """Marks the function as internally used"""
-    internal_code.add(f.__code__)
-    return f
-
-
-def is_undefined(obj):
-    """Check if the object passed is undefined.  This does nothing more than
-    performing an instance check against :class:`Undefined` but looks nicer.
-    This can be used for custom filters or tests that want to react to
-    undefined variables.  For example a custom default filter can look like
-    this::
-
-        def default(var, default=''):
-            if is_undefined(var):
-                return default
-            return var
-    """
-    from jinja2.runtime import Undefined
-    return isinstance(obj, Undefined)
-
-
-def consume(iterable):
-    """Consumes an iterable without doing anything with it."""
-    for event in iterable:
-        pass
-
-
-def clear_caches():
-    """Jinja2 keeps internal caches for environments and lexers.  These are
-    used so that Jinja2 doesn't have to recreate environments and lexers all
-    the time.  Normally you don't have to care about that but if you are
-    measuring memory consumption you may want to clean the caches.
-    """
-    from jinja2.environment import _spontaneous_environments
-    from jinja2.lexer import _lexer_cache
-    _spontaneous_environments.clear()
-    _lexer_cache.clear()
-
-
-def import_string(import_name, silent=False):
-    """Imports an object based on a string.  This is useful if you want to
-    use import paths as endpoints or something similar.  An import path can
-    be specified either in dotted notation (``xml.sax.saxutils.escape``)
-    or with a colon as object delimiter (``xml.sax.saxutils:escape``).
-
-    If the `silent` is True the return value will be `None` if the import
-    fails.
-
-    :return: imported object
-    """
-    try:
-        if ':' in import_name:
-            module, obj = import_name.split(':', 1)
-        elif '.' in import_name:
-            items = import_name.split('.')
-            module = '.'.join(items[:-1])
-            obj = items[-1]
-        else:
-            return __import__(import_name)
-        return getattr(__import__(module, None, None, [obj]), obj)
-    except (ImportError, AttributeError):
-        if not silent:
-            raise
-
-
-def open_if_exists(filename, mode='rb'):
-    """Returns a file descriptor for the filename if that file exists,
-    otherwise `None`.
-    """
-    try:
-        return open(filename, mode)
-    except IOError as e:
-        if e.errno not in (errno.ENOENT, errno.EISDIR, errno.EINVAL):
-            raise
-
-
-def object_type_repr(obj):
-    """Returns the name of the object's type.  For some recognized
-    singletons the name of the object is returned instead. (For
-    example for `None` and `Ellipsis`).
-    """
-    if obj is None:
-        return 'None'
-    elif obj is Ellipsis:
-        return 'Ellipsis'
-    # __builtin__ in 2.x, builtins in 3.x
-    if obj.__class__.__module__ in ('__builtin__', 'builtins'):
-        name = obj.__class__.__name__
-    else:
-        name = obj.__class__.__module__ + '.' + obj.__class__.__name__
-    return '%s object' % name
-
-
-def pformat(obj, verbose=False):
-    """Prettyprint an object.  Either use the `pretty` library or the
-    builtin `pprint`.
-    """
-    try:
-        from pretty import pretty
-        return pretty(obj, verbose=verbose)
-    except ImportError:
-        from pprint import pformat
-        return pformat(obj)
-
-
-def urlize(text, trim_url_limit=None, rel=None, target=None):
-    """Converts any URLs in text into clickable links. Works on http://,
-    https:// and www. links. Links can have trailing punctuation (periods,
-    commas, close-parens) and leading punctuation (opening parens) and
-    it'll still do the right thing.
-
-    If trim_url_limit is not None, the URLs in link text will be limited
-    to trim_url_limit characters.
-
-    If nofollow is True, the URLs in link text will get a rel="nofollow"
-    attribute.
-
-    If target is not None, a target attribute will be added to the link.
-    """
-    trim_url = lambda x, limit=trim_url_limit: limit is not None \
-                         and (x[:limit] + (len(x) >=limit and '...'
-                         or '')) or x
-    words = _word_split_re.split(text_type(escape(text)))
-    rel_attr = rel and ' rel="%s"' % text_type(escape(rel)) or ''
-    target_attr = target and ' target="%s"' % escape(target) or ''
-
-    for i, word in enumerate(words):
-        match = _punctuation_re.match(word)
-        if match:
-            lead, middle, trail = match.groups()
-            if middle.startswith('www.') or (
-                '@' not in middle and
-                not middle.startswith('http://') and
-                not middle.startswith('https://') and
-                len(middle) > 0 and
-                middle[0] in _letters + _digits and (
-                    middle.endswith('.org') or
-                    middle.endswith('.net') or
-                    middle.endswith('.com')
-                )):
-                middle = '<a href="http://%s"%s%s>%s</a>' % (middle,
-                    rel_attr, target_attr, trim_url(middle))
-            if middle.startswith('http://') or \
-               middle.startswith('https://'):
-                middle = '<a href="%s"%s%s>%s</a>' % (middle,
-                    rel_attr, target_attr, trim_url(middle))
-            if '@' in middle and not middle.startswith('www.') and \
-               not ':' in middle and _simple_email_re.match(middle):
-                middle = '<a href="mailto:%s">%s</a>' % (middle, middle)
-            if lead + middle + trail != word:
-                words[i] = lead + middle + trail
-    return u''.join(words)
-
-
-def generate_lorem_ipsum(n=5, html=True, min=20, max=100):
-    """Generate some lorem ipsum for the template."""
-    from jinja2.constants import LOREM_IPSUM_WORDS
-    from random import choice, randrange
-    words = LOREM_IPSUM_WORDS.split()
-    result = []
-
-    for _ in range(n):
-        next_capitalized = True
-        last_comma = last_fullstop = 0
-        word = None
-        last = None
-        p = []
-
-        # each paragraph contains out of 20 to 100 words.
-        for idx, _ in enumerate(range(randrange(min, max))):
-            while True:
-                word = choice(words)
-                if word != last:
-                    last = word
-                    break
-            if next_capitalized:
-                word = word.capitalize()
-                next_capitalized = False
-            # add commas
-            if idx - randrange(3, 8) > last_comma:
-                last_comma = idx
-                last_fullstop += 2
-                word += ','
-            # add end of sentences
-            if idx - randrange(10, 20) > last_fullstop:
-                last_comma = last_fullstop = idx
-                word += '.'
-                next_capitalized = True
-            p.append(word)
-
-        # ensure that the paragraph ends with a dot.
-        p = u' '.join(p)
-        if p.endswith(','):
-            p = p[:-1] + '.'
-        elif not p.endswith('.'):
-            p += '.'
-        result.append(p)
-
-    if not html:
-        return u'\n\n'.join(result)
-    return Markup(u'\n'.join(u'<p>%s</p>' % escape(x) for x in result))
-
-
-def unicode_urlencode(obj, charset='utf-8', for_qs=False):
-    """URL escapes a single bytestring or unicode string with the
-    given charset if applicable to URL safe quoting under all rules
-    that need to be considered under all supported Python versions.
-
-    If non strings are provided they are converted to their unicode
-    representation first.
-    """
-    if not isinstance(obj, string_types):
-        obj = text_type(obj)
-    if isinstance(obj, text_type):
-        obj = obj.encode(charset)
-    safe = not for_qs and b'/' or b''
-    rv = text_type(url_quote(obj, safe))
-    if for_qs:
-        rv = rv.replace('%20', '+')
-    return rv
-
-
-class LRUCache(object):
-    """A simple LRU Cache implementation."""
-
-    # this is fast for small capacities (something below 1000) but doesn't
-    # scale.  But as long as it's only used as storage for templates this
-    # won't do any harm.
-
-    def __init__(self, capacity):
-        self.capacity = capacity
-        self._mapping = {}
-        self._queue = deque()
-        self._postinit()
-
-    def _postinit(self):
-        # alias all queue methods for faster lookup
-        self._popleft = self._queue.popleft
-        self._pop = self._queue.pop
-        self._remove = self._queue.remove
-        self._wlock = Lock()
-        self._append = self._queue.append
-
-    def __getstate__(self):
-        return {
-            'capacity':     self.capacity,
-            '_mapping':     self._mapping,
-            '_queue':       self._queue
-        }
-
-    def __setstate__(self, d):
-        self.__dict__.update(d)
-        self._postinit()
-
-    def __getnewargs__(self):
-        return (self.capacity,)
-
-    def copy(self):
-        """Return a shallow copy of the instance."""
-        rv = self.__class__(self.capacity)
-        rv._mapping.update(self._mapping)
-        rv._queue = deque(self._queue)
-        return rv
-
-    def get(self, key, default=None):
-        """Return an item from the cache dict or `default`"""
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def setdefault(self, key, default=None):
-        """Set `default` if the key is not in the cache otherwise
-        leave unchanged. Return the value of this key.
-        """
-        self._wlock.acquire()
-        try:
-            try:
-                return self[key]
-            except KeyError:
-                self[key] = default
-                return default
-        finally:
-            self._wlock.release()
-
-    def clear(self):
-        """Clear the cache."""
-        self._wlock.acquire()
-        try:
-            self._mapping.clear()
-            self._queue.clear()
-        finally:
-            self._wlock.release()
-
-    def __contains__(self, key):
-        """Check if a key exists in this cache."""
-        return key in self._mapping
-
-    def __len__(self):
-        """Return the current size of the cache."""
-        return len(self._mapping)
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self._mapping
-        )
-
-    def __getitem__(self, key):
-        """Get an item from the cache. Moves the item up so that it has the
-        highest priority then.
-
-        Raise a `KeyError` if it does not exist.
-        """
-        self._wlock.acquire()
-        try:
-            rv = self._mapping[key]
-            if self._queue[-1] != key:
-                try:
-                    self._remove(key)
-                except ValueError:
-                    # if something removed the key from the container
-                    # when we read, ignore the ValueError that we would
-                    # get otherwise.
-                    pass
-                self._append(key)
-            return rv
-        finally:
-            self._wlock.release()
-
-    def __setitem__(self, key, value):
-        """Sets the value for an item. Moves the item up so that it
-        has the highest priority then.
-        """
-        self._wlock.acquire()
-        try:
-            if key in self._mapping:
-                self._remove(key)
-            elif len(self._mapping) == self.capacity:
-                del self._mapping[self._popleft()]
-            self._append(key)
-            self._mapping[key] = value
-        finally:
-            self._wlock.release()
-
-    def __delitem__(self, key):
-        """Remove an item from the cache dict.
-        Raise a `KeyError` if it does not exist.
-        """
-        self._wlock.acquire()
-        try:
-            del self._mapping[key]
-            try:
-                self._remove(key)
-            except ValueError:
-                # __getitem__ is not locked, it might happen
-                pass
-        finally:
-            self._wlock.release()
-
-    def items(self):
-        """Return a list of items."""
-        result = [(key, self._mapping[key]) for key in list(self._queue)]
-        result.reverse()
-        return result
-
-    def iteritems(self):
-        """Iterate over all items."""
-        return iter(self.items())
-
-    def values(self):
-        """Return a list of all values."""
-        return [x[1] for x in self.items()]
-
-    def itervalue(self):
-        """Iterate over all values."""
-        return iter(self.values())
-
-    def keys(self):
-        """Return a list of all keys ordered by most recent usage."""
-        return list(self)
-
-    def iterkeys(self):
-        """Iterate over all keys in the cache dict, ordered by
-        the most recent usage.
-        """
-        return reversed(tuple(self._queue))
-
-    __iter__ = iterkeys
-
-    def __reversed__(self):
-        """Iterate over the values in the cache dict, oldest items
-        coming first.
-        """
-        return iter(tuple(self._queue))
-
-    __copy__ = copy
-
-
-# register the LRU cache as mutable mapping if possible
-try:
-    from collections import MutableMapping
-    MutableMapping.register(LRUCache)
-except ImportError:
-    pass
-
-
-def select_autoescape(enabled_extensions=('html', 'htm', 'xml'),
-                      disabled_extensions=(),
-                      default_for_string=True,
-                      default=False):
-    """Intelligently sets the initial value of autoescaping based on the
-    filename of the template.  This is the recommended way to configure
-    autoescaping if you do not want to write a custom function yourself.
-
-    If you want to enable it for all templates created from strings or
-    for all templates with `.html` and `.xml` extensions::
-
-        from jinja2 import Environment, select_autoescape
-        env = Environment(autoescape=select_autoescape(
-            enabled_extensions=('html', 'xml'),
-            default_for_string=True,
-        ))
-
-    Example configuration to turn it on at all times except if the template
-    ends with `.txt`::
-
-        from jinja2 import Environment, select_autoescape
-        env = Environment(autoescape=select_autoescape(
-            disabled_extensions=('txt',),
-            default_for_string=True,
-            default=True,
-        ))
-
-    The `enabled_extensions` is an iterable of all the extensions that
-    autoescaping should be enabled for.  Likewise `disabled_extensions` is
-    a list of all templates it should be disabled for.  If a template is
-    loaded from a string then the default from `default_for_string` is used.
-    If nothing matches then the initial value of autoescaping is set to the
-    value of `default`.
-
-    For security reasons this function operates case insensitive.
-
-    .. versionadded:: 2.9
-    """
-    enabled_patterns = tuple('.' + x.lstrip('.').lower()
-                             for x in enabled_extensions)
-    disabled_patterns = tuple('.' + x.lstrip('.').lower()
-                              for x in disabled_extensions)
-    def autoescape(template_name):
-        if template_name is None:
-            return default_for_string
-        template_name = template_name.lower()
-        if template_name.endswith(enabled_patterns):
-            return True
-        if template_name.endswith(disabled_patterns):
-            return False
-        return default
-    return autoescape
-
-
-def htmlsafe_json_dumps(obj, dumper=None, **kwargs):
-    """Works exactly like :func:`dumps` but is safe for use in ``<script>``
-    tags.  It accepts the same arguments and returns a JSON string.  Note that
-    this is available in templates through the ``|tojson`` filter which will
-    also mark the result as safe.  Due to how this function escapes certain
-    characters this is safe even if used outside of ``<script>`` tags.
-
-    The following characters are escaped in strings:
-
-    -   ``<``
-    -   ``>``
-    -   ``&``
-    -   ``'``
-
-    This makes it safe to embed such strings in any place in HTML with the
-    notable exception of double quoted attributes.  In that case single
-    quote your attributes or HTML escape it in addition.
-    """
-    if dumper is None:
-        dumper = json.dumps
-    rv = dumper(obj, **kwargs) \
-        .replace(u'<', u'\\u003c') \
-        .replace(u'>', u'\\u003e') \
-        .replace(u'&', u'\\u0026') \
-        .replace(u"'", u'\\u0027')
-    return Markup(rv)
-
-
-@implements_iterator
-class Cycler(object):
-    """A cycle helper for templates."""
-
-    def __init__(self, *items):
-        if not items:
-            raise RuntimeError('at least one item has to be provided')
-        self.items = items
-        self.reset()
-
-    def reset(self):
-        """Resets the cycle."""
-        self.pos = 0
-
-    @property
-    def current(self):
-        """Returns the current item."""
-        return self.items[self.pos]
-
-    def next(self):
-        """Goes one item ahead and returns it."""
-        rv = self.current
-        self.pos = (self.pos + 1) % len(self.items)
-        return rv
-
-    __next__ = next
-
-
-class Joiner(object):
-    """A joining helper for templates."""
-
-    def __init__(self, sep=u', '):
-        self.sep = sep
-        self.used = False
-
-    def __call__(self):
-        if not self.used:
-            self.used = True
-            return u''
-        return self.sep
-
-
-class Namespace(object):
-    """A namespace object that can hold arbitrary attributes.  It may be
-    initialized from a dictionary or with keyword argments."""
-
-    def __init__(*args, **kwargs):
-        self, args = args[0], args[1:]
-        self.__attrs = dict(*args, **kwargs)
-
-    def __getattribute__(self, name):
-        if name == '_Namespace__attrs':
-            return object.__getattribute__(self, name)
-        try:
-            return self.__attrs[name]
-        except KeyError:
-            raise AttributeError(name)
-
-    def __setitem__(self, name, value):
-        self.__attrs[name] = value
-
-    def __repr__(self):
-        return '<Namespace %r>' % self.__attrs
-
-
-# does this python version support async for in and async generators?
-try:
-    exec('async def _():\n async for _ in ():\n  yield _')
-    have_async_gen = True
-except SyntaxError:
-    have_async_gen = False
-
-
-# Imported here because that's where it was in the past
-from markupsafe import Markup, escape, soft_unicode
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/visitor.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/visitor.py
deleted file mode 100644
index ba526dfac..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/jinja2/visitor.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    jinja2.visitor
-    ~~~~~~~~~~~~~~
-
-    This module implements a visitor for the nodes.
-
-    :copyright: (c) 2017 by the Jinja Team.
-    :license: BSD.
-"""
-from jinja2.nodes import Node
-
-
-class NodeVisitor(object):
-    """Walks the abstract syntax tree and call visitor functions for every
-    node found.  The visitor functions may return values which will be
-    forwarded by the `visit` method.
-
-    Per default the visitor functions for the nodes are ``'visit_'`` +
-    class name of the node.  So a `TryFinally` node visit function would
-    be `visit_TryFinally`.  This behavior can be changed by overriding
-    the `get_visitor` function.  If no visitor function exists for a node
-    (return value `None`) the `generic_visit` visitor is used instead.
-    """
-
-    def get_visitor(self, node):
-        """Return the visitor function for this node or `None` if no visitor
-        exists for this node.  In that case the generic visit function is
-        used instead.
-        """
-        method = 'visit_' + node.__class__.__name__
-        return getattr(self, method, None)
-
-    def visit(self, node, *args, **kwargs):
-        """Visit a node."""
-        f = self.get_visitor(node)
-        if f is not None:
-            return f(node, *args, **kwargs)
-        return self.generic_visit(node, *args, **kwargs)
-
-    def generic_visit(self, node, *args, **kwargs):
-        """Called if no explicit visitor function exists for a node."""
-        for node in node.iter_child_nodes():
-            self.visit(node, *args, **kwargs)
-
-
-class NodeTransformer(NodeVisitor):
-    """Walks the abstract syntax tree and allows modifications of nodes.
-
-    The `NodeTransformer` will walk the AST and use the return value of the
-    visitor functions to replace or remove the old node.  If the return
-    value of the visitor function is `None` the node will be removed
-    from the previous location otherwise it's replaced with the return
-    value.  The return value may be the original node in which case no
-    replacement takes place.
-    """
-
-    def generic_visit(self, node, *args, **kwargs):
-        for field, old_value in node.iter_fields():
-            if isinstance(old_value, list):
-                new_values = []
-                for value in old_value:
-                    if isinstance(value, Node):
-                        value = self.visit(value, *args, **kwargs)
-                        if value is None:
-                            continue
-                        elif not isinstance(value, Node):
-                            new_values.extend(value)
-                            continue
-                    new_values.append(value)
-                old_value[:] = new_values
-            elif isinstance(old_value, Node):
-                new_node = self.visit(old_value, *args, **kwargs)
-                if new_node is None:
-                    delattr(node, field)
-                else:
-                    setattr(node, field, new_node)
-        return node
-
-    def visit_list(self, node, *args, **kwargs):
-        """As transformers may return lists in some places this method
-        can be used to enforce a list as return value.
-        """
-        rv = self.visit(node, *args, **kwargs)
-        if not isinstance(rv, list):
-            rv = [rv]
-        return rv
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__init__.py
deleted file mode 100644
index 5e0952563..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__init__.py
+++ /dev/null
@@ -1,327 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-markupsafe
-~~~~~~~~~~
-
-Implements an escape function and a Markup string to replace HTML
-special characters with safe representations.
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-import re
-import string
-
-from ._compat import int_types
-from ._compat import iteritems
-from ._compat import Mapping
-from ._compat import PY2
-from ._compat import string_types
-from ._compat import text_type
-from ._compat import unichr
-
-__version__ = "1.1.0"
-
-__all__ = ["Markup", "soft_unicode", "escape", "escape_silent"]
-
-_striptags_re = re.compile(r"(<!--.*?-->|<[^>]*>)")
-_entity_re = re.compile(r"&([^& ;]+);")
-
-
-class Markup(text_type):
-    """A string that is ready to be safely inserted into an HTML or XML
-    document, either because it was escaped or because it was marked
-    safe.
-
-    Passing an object to the constructor converts it to text and wraps
-    it to mark it safe without escaping. To escape the text, use the
-    :meth:`escape` class method instead.
-
-    >>> Markup('Hello, <em>World</em>!')
-    Markup('Hello, <em>World</em>!')
-    >>> Markup(42)
-    Markup('42')
-    >>> Markup.escape('Hello, <em>World</em>!')
-    Markup('Hello &lt;em&gt;World&lt;/em&gt;!')
-
-    This implements the ``__html__()`` interface that some frameworks
-    use. Passing an object that implements ``__html__()`` will wrap the
-    output of that method, marking it safe.
-
-    >>> class Foo:
-    ...     def __html__(self):
-    ...         return '<a href="/foo">foo</a>'
-    ...
-    >>> Markup(Foo())
-    Markup('<a href="/foo">foo</a>')
-
-    This is a subclass of the text type (``str`` in Python 3,
-    ``unicode`` in Python 2). It has the same methods as that type, but
-    all methods escape their arguments and return a ``Markup`` instance.
-
-    >>> Markup('<em>%s</em>') % 'foo & bar'
-    Markup('<em>foo &amp; bar</em>')
-    >>> Markup('<em>Hello</em> ') + '<foo>'
-    Markup('<em>Hello</em> &lt;foo&gt;')
-    """
-
-    __slots__ = ()
-
-    def __new__(cls, base=u"", encoding=None, errors="strict"):
-        if hasattr(base, "__html__"):
-            base = base.__html__()
-        if encoding is None:
-            return text_type.__new__(cls, base)
-        return text_type.__new__(cls, base, encoding, errors)
-
-    def __html__(self):
-        return self
-
-    def __add__(self, other):
-        if isinstance(other, string_types) or hasattr(other, "__html__"):
-            return self.__class__(super(Markup, self).__add__(self.escape(other)))
-        return NotImplemented
-
-    def __radd__(self, other):
-        if hasattr(other, "__html__") or isinstance(other, string_types):
-            return self.escape(other).__add__(self)
-        return NotImplemented
-
-    def __mul__(self, num):
-        if isinstance(num, int_types):
-            return self.__class__(text_type.__mul__(self, num))
-        return NotImplemented
-
-    __rmul__ = __mul__
-
-    def __mod__(self, arg):
-        if isinstance(arg, tuple):
-            arg = tuple(_MarkupEscapeHelper(x, self.escape) for x in arg)
-        else:
-            arg = _MarkupEscapeHelper(arg, self.escape)
-        return self.__class__(text_type.__mod__(self, arg))
-
-    def __repr__(self):
-        return "%s(%s)" % (self.__class__.__name__, text_type.__repr__(self))
-
-    def join(self, seq):
-        return self.__class__(text_type.join(self, map(self.escape, seq)))
-
-    join.__doc__ = text_type.join.__doc__
-
-    def split(self, *args, **kwargs):
-        return list(map(self.__class__, text_type.split(self, *args, **kwargs)))
-
-    split.__doc__ = text_type.split.__doc__
-
-    def rsplit(self, *args, **kwargs):
-        return list(map(self.__class__, text_type.rsplit(self, *args, **kwargs)))
-
-    rsplit.__doc__ = text_type.rsplit.__doc__
-
-    def splitlines(self, *args, **kwargs):
-        return list(map(self.__class__, text_type.splitlines(self, *args, **kwargs)))
-
-    splitlines.__doc__ = text_type.splitlines.__doc__
-
-    def unescape(self):
-        """Convert escaped markup back into a text string. This replaces
-        HTML entities with the characters they represent.
-
-        >>> Markup('Main &raquo; <em>About</em>').unescape()
-        'Main » <em>About</em>'
-        """
-        from ._constants import HTML_ENTITIES
-
-        def handle_match(m):
-            name = m.group(1)
-            if name in HTML_ENTITIES:
-                return unichr(HTML_ENTITIES[name])
-            try:
-                if name[:2] in ("#x", "#X"):
-                    return unichr(int(name[2:], 16))
-                elif name.startswith("#"):
-                    return unichr(int(name[1:]))
-            except ValueError:
-                pass
-            # Don't modify unexpected input.
-            return m.group()
-
-        return _entity_re.sub(handle_match, text_type(self))
-
-    def striptags(self):
-        """:meth:`unescape` the markup, remove tags, and normalize
-        whitespace to single spaces.
-
-        >>> Markup('Main &raquo;\t<em>About</em>').striptags()
-        'Main » About'
-        """
-        stripped = u" ".join(_striptags_re.sub("", self).split())
-        return Markup(stripped).unescape()
-
-    @classmethod
-    def escape(cls, s):
-        """Escape a string. Calls :func:`escape` and ensures that for
-        subclasses the correct type is returned.
-        """
-        rv = escape(s)
-        if rv.__class__ is not cls:
-            return cls(rv)
-        return rv
-
-    def make_simple_escaping_wrapper(name):  # noqa: B902
-        orig = getattr(text_type, name)
-
-        def func(self, *args, **kwargs):
-            args = _escape_argspec(list(args), enumerate(args), self.escape)
-            _escape_argspec(kwargs, iteritems(kwargs), self.escape)
-            return self.__class__(orig(self, *args, **kwargs))
-
-        func.__name__ = orig.__name__
-        func.__doc__ = orig.__doc__
-        return func
-
-    for method in (
-        "__getitem__",
-        "capitalize",
-        "title",
-        "lower",
-        "upper",
-        "replace",
-        "ljust",
-        "rjust",
-        "lstrip",
-        "rstrip",
-        "center",
-        "strip",
-        "translate",
-        "expandtabs",
-        "swapcase",
-        "zfill",
-    ):
-        locals()[method] = make_simple_escaping_wrapper(method)
-
-    def partition(self, sep):
-        return tuple(map(self.__class__, text_type.partition(self, self.escape(sep))))
-
-    def rpartition(self, sep):
-        return tuple(map(self.__class__, text_type.rpartition(self, self.escape(sep))))
-
-    def format(self, *args, **kwargs):
-        formatter = EscapeFormatter(self.escape)
-        kwargs = _MagicFormatMapping(args, kwargs)
-        return self.__class__(formatter.vformat(self, args, kwargs))
-
-    def __html_format__(self, format_spec):
-        if format_spec:
-            raise ValueError("Unsupported format specification " "for Markup.")
-        return self
-
-    # not in python 3
-    if hasattr(text_type, "__getslice__"):
-        __getslice__ = make_simple_escaping_wrapper("__getslice__")
-
-    del method, make_simple_escaping_wrapper
-
-
-class _MagicFormatMapping(Mapping):
-    """This class implements a dummy wrapper to fix a bug in the Python
-    standard library for string formatting.
-
-    See http://bugs.python.org/issue13598 for information about why
-    this is necessary.
-    """
-
-    def __init__(self, args, kwargs):
-        self._args = args
-        self._kwargs = kwargs
-        self._last_index = 0
-
-    def __getitem__(self, key):
-        if key == "":
-            idx = self._last_index
-            self._last_index += 1
-            try:
-                return self._args[idx]
-            except LookupError:
-                pass
-            key = str(idx)
-        return self._kwargs[key]
-
-    def __iter__(self):
-        return iter(self._kwargs)
-
-    def __len__(self):
-        return len(self._kwargs)
-
-
-if hasattr(text_type, "format"):
-
-    class EscapeFormatter(string.Formatter):
-        def __init__(self, escape):
-            self.escape = escape
-
-        def format_field(self, value, format_spec):
-            if hasattr(value, "__html_format__"):
-                rv = value.__html_format__(format_spec)
-            elif hasattr(value, "__html__"):
-                if format_spec:
-                    raise ValueError(
-                        "Format specifier {0} given, but {1} does not"
-                        " define __html_format__. A class that defines"
-                        " __html__ must define __html_format__ to work"
-                        " with format specifiers.".format(format_spec, type(value))
-                    )
-                rv = value.__html__()
-            else:
-                # We need to make sure the format spec is unicode here as
-                # otherwise the wrong callback methods are invoked.  For
-                # instance a byte string there would invoke __str__ and
-                # not __unicode__.
-                rv = string.Formatter.format_field(self, value, text_type(format_spec))
-            return text_type(self.escape(rv))
-
-
-def _escape_argspec(obj, iterable, escape):
-    """Helper for various string-wrapped functions."""
-    for key, value in iterable:
-        if hasattr(value, "__html__") or isinstance(value, string_types):
-            obj[key] = escape(value)
-    return obj
-
-
-class _MarkupEscapeHelper(object):
-    """Helper for Markup.__mod__"""
-
-    def __init__(self, obj, escape):
-        self.obj = obj
-        self.escape = escape
-
-    def __getitem__(self, item):
-        return _MarkupEscapeHelper(self.obj[item], self.escape)
-
-    def __str__(self):
-        return text_type(self.escape(self.obj))
-
-    __unicode__ = __str__
-
-    def __repr__(self):
-        return str(self.escape(repr(self.obj)))
-
-    def __int__(self):
-        return int(self.obj)
-
-    def __float__(self):
-        return float(self.obj)
-
-
-# we have to import it down here as the speedups and native
-# modules imports the markup type which is define above.
-try:
-    from ._speedups import escape, escape_silent, soft_unicode
-except ImportError:
-    from ._native import escape, escape_silent, soft_unicode
-
-if not PY2:
-    soft_str = soft_unicode
-    __all__.append("soft_str")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index d48674e21..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index 0da5b6bd3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_constants.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_constants.cpython-35.pyc
deleted file mode 100644
index 3be60c816..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_constants.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_native.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_native.cpython-35.pyc
deleted file mode 100644
index dd265741b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/__pycache__/_native.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_compat.py
deleted file mode 100644
index e51d57dd5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_compat.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-markupsafe._compat
-~~~~~~~~~~~~~~~~~~
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-import sys
-
-PY2 = sys.version_info[0] == 2
-
-if not PY2:
-    text_type = str
-    string_types = (str,)
-    unichr = chr
-    int_types = (int,)
-
-    def iteritems(x):
-        return iter(x.items())
-
-    from collections.abc import Mapping
-
-else:
-    text_type = unicode
-    string_types = (str, unicode)
-    unichr = unichr
-    int_types = (int, long)
-
-    def iteritems(x):
-        return x.iteritems()
-
-    from collections import Mapping
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_constants.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_constants.py
deleted file mode 100644
index 83670cb04..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_constants.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-markupsafe._constants
-~~~~~~~~~~~~~~~~~~~~~
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-
-HTML_ENTITIES = {
-    "AElig": 198,
-    "Aacute": 193,
-    "Acirc": 194,
-    "Agrave": 192,
-    "Alpha": 913,
-    "Aring": 197,
-    "Atilde": 195,
-    "Auml": 196,
-    "Beta": 914,
-    "Ccedil": 199,
-    "Chi": 935,
-    "Dagger": 8225,
-    "Delta": 916,
-    "ETH": 208,
-    "Eacute": 201,
-    "Ecirc": 202,
-    "Egrave": 200,
-    "Epsilon": 917,
-    "Eta": 919,
-    "Euml": 203,
-    "Gamma": 915,
-    "Iacute": 205,
-    "Icirc": 206,
-    "Igrave": 204,
-    "Iota": 921,
-    "Iuml": 207,
-    "Kappa": 922,
-    "Lambda": 923,
-    "Mu": 924,
-    "Ntilde": 209,
-    "Nu": 925,
-    "OElig": 338,
-    "Oacute": 211,
-    "Ocirc": 212,
-    "Ograve": 210,
-    "Omega": 937,
-    "Omicron": 927,
-    "Oslash": 216,
-    "Otilde": 213,
-    "Ouml": 214,
-    "Phi": 934,
-    "Pi": 928,
-    "Prime": 8243,
-    "Psi": 936,
-    "Rho": 929,
-    "Scaron": 352,
-    "Sigma": 931,
-    "THORN": 222,
-    "Tau": 932,
-    "Theta": 920,
-    "Uacute": 218,
-    "Ucirc": 219,
-    "Ugrave": 217,
-    "Upsilon": 933,
-    "Uuml": 220,
-    "Xi": 926,
-    "Yacute": 221,
-    "Yuml": 376,
-    "Zeta": 918,
-    "aacute": 225,
-    "acirc": 226,
-    "acute": 180,
-    "aelig": 230,
-    "agrave": 224,
-    "alefsym": 8501,
-    "alpha": 945,
-    "amp": 38,
-    "and": 8743,
-    "ang": 8736,
-    "apos": 39,
-    "aring": 229,
-    "asymp": 8776,
-    "atilde": 227,
-    "auml": 228,
-    "bdquo": 8222,
-    "beta": 946,
-    "brvbar": 166,
-    "bull": 8226,
-    "cap": 8745,
-    "ccedil": 231,
-    "cedil": 184,
-    "cent": 162,
-    "chi": 967,
-    "circ": 710,
-    "clubs": 9827,
-    "cong": 8773,
-    "copy": 169,
-    "crarr": 8629,
-    "cup": 8746,
-    "curren": 164,
-    "dArr": 8659,
-    "dagger": 8224,
-    "darr": 8595,
-    "deg": 176,
-    "delta": 948,
-    "diams": 9830,
-    "divide": 247,
-    "eacute": 233,
-    "ecirc": 234,
-    "egrave": 232,
-    "empty": 8709,
-    "emsp": 8195,
-    "ensp": 8194,
-    "epsilon": 949,
-    "equiv": 8801,
-    "eta": 951,
-    "eth": 240,
-    "euml": 235,
-    "euro": 8364,
-    "exist": 8707,
-    "fnof": 402,
-    "forall": 8704,
-    "frac12": 189,
-    "frac14": 188,
-    "frac34": 190,
-    "frasl": 8260,
-    "gamma": 947,
-    "ge": 8805,
-    "gt": 62,
-    "hArr": 8660,
-    "harr": 8596,
-    "hearts": 9829,
-    "hellip": 8230,
-    "iacute": 237,
-    "icirc": 238,
-    "iexcl": 161,
-    "igrave": 236,
-    "image": 8465,
-    "infin": 8734,
-    "int": 8747,
-    "iota": 953,
-    "iquest": 191,
-    "isin": 8712,
-    "iuml": 239,
-    "kappa": 954,
-    "lArr": 8656,
-    "lambda": 955,
-    "lang": 9001,
-    "laquo": 171,
-    "larr": 8592,
-    "lceil": 8968,
-    "ldquo": 8220,
-    "le": 8804,
-    "lfloor": 8970,
-    "lowast": 8727,
-    "loz": 9674,
-    "lrm": 8206,
-    "lsaquo": 8249,
-    "lsquo": 8216,
-    "lt": 60,
-    "macr": 175,
-    "mdash": 8212,
-    "micro": 181,
-    "middot": 183,
-    "minus": 8722,
-    "mu": 956,
-    "nabla": 8711,
-    "nbsp": 160,
-    "ndash": 8211,
-    "ne": 8800,
-    "ni": 8715,
-    "not": 172,
-    "notin": 8713,
-    "nsub": 8836,
-    "ntilde": 241,
-    "nu": 957,
-    "oacute": 243,
-    "ocirc": 244,
-    "oelig": 339,
-    "ograve": 242,
-    "oline": 8254,
-    "omega": 969,
-    "omicron": 959,
-    "oplus": 8853,
-    "or": 8744,
-    "ordf": 170,
-    "ordm": 186,
-    "oslash": 248,
-    "otilde": 245,
-    "otimes": 8855,
-    "ouml": 246,
-    "para": 182,
-    "part": 8706,
-    "permil": 8240,
-    "perp": 8869,
-    "phi": 966,
-    "pi": 960,
-    "piv": 982,
-    "plusmn": 177,
-    "pound": 163,
-    "prime": 8242,
-    "prod": 8719,
-    "prop": 8733,
-    "psi": 968,
-    "quot": 34,
-    "rArr": 8658,
-    "radic": 8730,
-    "rang": 9002,
-    "raquo": 187,
-    "rarr": 8594,
-    "rceil": 8969,
-    "rdquo": 8221,
-    "real": 8476,
-    "reg": 174,
-    "rfloor": 8971,
-    "rho": 961,
-    "rlm": 8207,
-    "rsaquo": 8250,
-    "rsquo": 8217,
-    "sbquo": 8218,
-    "scaron": 353,
-    "sdot": 8901,
-    "sect": 167,
-    "shy": 173,
-    "sigma": 963,
-    "sigmaf": 962,
-    "sim": 8764,
-    "spades": 9824,
-    "sub": 8834,
-    "sube": 8838,
-    "sum": 8721,
-    "sup": 8835,
-    "sup1": 185,
-    "sup2": 178,
-    "sup3": 179,
-    "supe": 8839,
-    "szlig": 223,
-    "tau": 964,
-    "there4": 8756,
-    "theta": 952,
-    "thetasym": 977,
-    "thinsp": 8201,
-    "thorn": 254,
-    "tilde": 732,
-    "times": 215,
-    "trade": 8482,
-    "uArr": 8657,
-    "uacute": 250,
-    "uarr": 8593,
-    "ucirc": 251,
-    "ugrave": 249,
-    "uml": 168,
-    "upsih": 978,
-    "upsilon": 965,
-    "uuml": 252,
-    "weierp": 8472,
-    "xi": 958,
-    "yacute": 253,
-    "yen": 165,
-    "yuml": 255,
-    "zeta": 950,
-    "zwj": 8205,
-    "zwnj": 8204,
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_native.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_native.py
deleted file mode 100644
index 245f03ae1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_native.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-markupsafe._native
-~~~~~~~~~~~~~~~~~~
-
-Native Python implementation used when the C module is not compiled.
-
-:copyright: © 2010 by the Pallets team.
-:license: BSD, see LICENSE for more details.
-"""
-from . import Markup
-from ._compat import text_type
-
-
-def escape(s):
-    """Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in
-    the string with HTML-safe sequences. Use this if you need to display
-    text that might contain such characters in HTML.
-
-    If the object has an ``__html__`` method, it is called and the
-    return value is assumed to already be safe for HTML.
-
-    :param s: An object to be converted to a string and escaped.
-    :return: A :class:`Markup` string with the escaped text.
-    """
-    if hasattr(s, "__html__"):
-        return Markup(s.__html__())
-    return Markup(
-        text_type(s)
-        .replace("&", "&amp;")
-        .replace(">", "&gt;")
-        .replace("<", "&lt;")
-        .replace("'", "&#39;")
-        .replace('"', "&#34;")
-    )
-
-
-def escape_silent(s):
-    """Like :func:`escape` but treats ``None`` as the empty string.
-    Useful with optional values, as otherwise you get the string
-    ``'None'`` when the value is ``None``.
-
-    >>> escape(None)
-    Markup('None')
-    >>> escape_silent(None)
-    Markup('')
-    """
-    if s is None:
-        return Markup()
-    return escape(s)
-
-
-def soft_unicode(s):
-    """Convert an object to a string if it isn't already. This preserves
-    a :class:`Markup` string rather than converting it back to a basic
-    string, so it will still be marked as safe and won't be escaped
-    again.
-
-    >>> value = escape('<User 1>')
-    >>> value
-    Markup('&lt;User 1&gt;')
-    >>> escape(str(value))
-    Markup('&amp;lt;User 1&amp;gt;')
-    >>> escape(soft_unicode(value))
-    Markup('&lt;User 1&gt;')
-    """
-    if not isinstance(s, text_type):
-        s = text_type(s)
-    return s
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.c b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.c
deleted file mode 100644
index 22a604de1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.c
+++ /dev/null
@@ -1,420 +0,0 @@
-/**
- * markupsafe._speedups
- * ~~~~~~~~~~~~~~~~~~~~
- *
- * C implementation of escaping for better performance. Used instead of
- * the native Python implementation when compiled.
- *
- * :copyright: © 2010 by the Pallets team.
- * :license: BSD, see LICENSE for more details.
- */
-#include <Python.h>
-
-#if PY_MAJOR_VERSION < 3
-#define ESCAPED_CHARS_TABLE_SIZE 63
-#define UNICHR(x) (PyUnicode_AS_UNICODE((PyUnicodeObject*)PyUnicode_DecodeASCII(x, strlen(x), NULL)));
-
-static Py_ssize_t escaped_chars_delta_len[ESCAPED_CHARS_TABLE_SIZE];
-static Py_UNICODE *escaped_chars_repl[ESCAPED_CHARS_TABLE_SIZE];
-#endif
-
-static PyObject* markup;
-
-static int
-init_constants(void)
-{
-	PyObject *module;
-
-#if PY_MAJOR_VERSION < 3
-	/* mapping of characters to replace */
-	escaped_chars_repl['"'] = UNICHR("&#34;");
-	escaped_chars_repl['\''] = UNICHR("&#39;");
-	escaped_chars_repl['&'] = UNICHR("&amp;");
-	escaped_chars_repl['<'] = UNICHR("&lt;");
-	escaped_chars_repl['>'] = UNICHR("&gt;");
-
-	/* lengths of those characters when replaced - 1 */
-	memset(escaped_chars_delta_len, 0, sizeof (escaped_chars_delta_len));
-	escaped_chars_delta_len['"'] = escaped_chars_delta_len['\''] = \
-		escaped_chars_delta_len['&'] = 4;
-	escaped_chars_delta_len['<'] = escaped_chars_delta_len['>'] = 3;
-#endif
-
-	/* import markup type so that we can mark the return value */
-	module = PyImport_ImportModule("markupsafe");
-	if (!module)
-		return 0;
-	markup = PyObject_GetAttrString(module, "Markup");
-	Py_DECREF(module);
-
-	return 1;
-}
-
-#if PY_MAJOR_VERSION < 3
-static PyObject*
-escape_unicode(PyUnicodeObject *in)
-{
-	PyUnicodeObject *out;
-	Py_UNICODE *inp = PyUnicode_AS_UNICODE(in);
-	const Py_UNICODE *inp_end = PyUnicode_AS_UNICODE(in) + PyUnicode_GET_SIZE(in);
-	Py_UNICODE *next_escp;
-	Py_UNICODE *outp;
-	Py_ssize_t delta=0, erepl=0, delta_len=0;
-
-	/* First we need to figure out how long the escaped string will be */
-	while (*(inp) || inp < inp_end) {
-		if (*inp < ESCAPED_CHARS_TABLE_SIZE) {
-			delta += escaped_chars_delta_len[*inp];
-			erepl += !!escaped_chars_delta_len[*inp];
-		}
-		++inp;
-	}
-
-	/* Do we need to escape anything at all? */
-	if (!erepl) {
-		Py_INCREF(in);
-		return (PyObject*)in;
-	}
-
-	out = (PyUnicodeObject*)PyUnicode_FromUnicode(NULL, PyUnicode_GET_SIZE(in) + delta);
-	if (!out)
-		return NULL;
-
-	outp = PyUnicode_AS_UNICODE(out);
-	inp = PyUnicode_AS_UNICODE(in);
-	while (erepl-- > 0) {
-		/* look for the next substitution */
-		next_escp = inp;
-		while (next_escp < inp_end) {
-			if (*next_escp < ESCAPED_CHARS_TABLE_SIZE &&
-			    (delta_len = escaped_chars_delta_len[*next_escp])) {
-				++delta_len;
-				break;
-			}
-			++next_escp;
-		}
-
-		if (next_escp > inp) {
-			/* copy unescaped chars between inp and next_escp */
-			Py_UNICODE_COPY(outp, inp, next_escp-inp);
-			outp += next_escp - inp;
-		}
-
-		/* escape 'next_escp' */
-		Py_UNICODE_COPY(outp, escaped_chars_repl[*next_escp], delta_len);
-		outp += delta_len;
-
-		inp = next_escp + 1;
-	}
-	if (inp < inp_end)
-		Py_UNICODE_COPY(outp, inp, PyUnicode_GET_SIZE(in) - (inp - PyUnicode_AS_UNICODE(in)));
-
-	return (PyObject*)out;
-}
-#else /* PY_MAJOR_VERSION < 3 */
-
-#define GET_DELTA(inp, inp_end, delta) \
-	while (inp < inp_end) {	 \
-		switch (*inp++) {	   \
-		case '"':			   \
-		case '\'':			  \
-		case '&':			   \
-			delta += 4;		 \
-			break;			  \
-		case '<':			   \
-		case '>':			   \
-			delta += 3;		 \
-			break;			  \
-		}					   \
-	}
-
-#define DO_ESCAPE(inp, inp_end, outp) \
-	{  \
-		Py_ssize_t ncopy = 0;  \
-		while (inp < inp_end) {  \
-			switch (*inp) {  \
-			case '"':  \
-				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-				outp += ncopy; ncopy = 0; \
-				*outp++ = '&';  \
-				*outp++ = '#';  \
-				*outp++ = '3';  \
-				*outp++ = '4';  \
-				*outp++ = ';';  \
-				break;  \
-			case '\'':  \
-				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-				outp += ncopy; ncopy = 0; \
-				*outp++ = '&';  \
-				*outp++ = '#';  \
-				*outp++ = '3';  \
-				*outp++ = '9';  \
-				*outp++ = ';';  \
-				break;  \
-			case '&':  \
-				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-				outp += ncopy; ncopy = 0; \
-				*outp++ = '&';  \
-				*outp++ = 'a';  \
-				*outp++ = 'm';  \
-				*outp++ = 'p';  \
-				*outp++ = ';';  \
-				break;  \
-			case '<':  \
-				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-				outp += ncopy; ncopy = 0; \
-				*outp++ = '&';  \
-				*outp++ = 'l';  \
-				*outp++ = 't';  \
-				*outp++ = ';';  \
-				break;  \
-			case '>':  \
-				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-				outp += ncopy; ncopy = 0; \
-				*outp++ = '&';  \
-				*outp++ = 'g';  \
-				*outp++ = 't';  \
-				*outp++ = ';';  \
-				break;  \
-			default:  \
-				ncopy++; \
-			}  \
-            inp++; \
-		}  \
-		memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
-	}
-
-static PyObject*
-escape_unicode_kind1(PyUnicodeObject *in)
-{
-	Py_UCS1 *inp = PyUnicode_1BYTE_DATA(in);
-	Py_UCS1 *inp_end = inp + PyUnicode_GET_LENGTH(in);
-	Py_UCS1 *outp;
-	PyObject *out;
-	Py_ssize_t delta = 0;
-
-	GET_DELTA(inp, inp_end, delta);
-	if (!delta) {
-		Py_INCREF(in);
-		return (PyObject*)in;
-	}
-
-	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta,
-						PyUnicode_IS_ASCII(in) ? 127 : 255);
-	if (!out)
-		return NULL;
-
-	inp = PyUnicode_1BYTE_DATA(in);
-	outp = PyUnicode_1BYTE_DATA(out);
-	DO_ESCAPE(inp, inp_end, outp);
-	return out;
-}
-
-static PyObject*
-escape_unicode_kind2(PyUnicodeObject *in)
-{
-	Py_UCS2 *inp = PyUnicode_2BYTE_DATA(in);
-	Py_UCS2 *inp_end = inp + PyUnicode_GET_LENGTH(in);
-	Py_UCS2 *outp;
-	PyObject *out;
-	Py_ssize_t delta = 0;
-
-	GET_DELTA(inp, inp_end, delta);
-	if (!delta) {
-		Py_INCREF(in);
-		return (PyObject*)in;
-	}
-
-	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 65535);
-	if (!out)
-		return NULL;
-
-	inp = PyUnicode_2BYTE_DATA(in);
-	outp = PyUnicode_2BYTE_DATA(out);
-	DO_ESCAPE(inp, inp_end, outp);
-	return out;
-}
-
-
-static PyObject*
-escape_unicode_kind4(PyUnicodeObject *in)
-{
-	Py_UCS4 *inp = PyUnicode_4BYTE_DATA(in);
-	Py_UCS4 *inp_end = inp + PyUnicode_GET_LENGTH(in);
-	Py_UCS4 *outp;
-	PyObject *out;
-	Py_ssize_t delta = 0;
-
-	GET_DELTA(inp, inp_end, delta);
-	if (!delta) {
-		Py_INCREF(in);
-		return (PyObject*)in;
-	}
-
-	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 1114111);
-	if (!out)
-		return NULL;
-
-	inp = PyUnicode_4BYTE_DATA(in);
-	outp = PyUnicode_4BYTE_DATA(out);
-	DO_ESCAPE(inp, inp_end, outp);
-	return out;
-}
-
-static PyObject*
-escape_unicode(PyUnicodeObject *in)
-{
-	if (PyUnicode_READY(in))
-		return NULL;
-
-	switch (PyUnicode_KIND(in)) {
-	case PyUnicode_1BYTE_KIND:
-		return escape_unicode_kind1(in);
-	case PyUnicode_2BYTE_KIND:
-		return escape_unicode_kind2(in);
-	case PyUnicode_4BYTE_KIND:
-		return escape_unicode_kind4(in);
-	}
-	assert(0);  /* shouldn't happen */
-	return NULL;
-}
-#endif /* PY_MAJOR_VERSION < 3 */
-
-static PyObject*
-escape(PyObject *self, PyObject *text)
-{
-	static PyObject *id_html;
-	PyObject *s = NULL, *rv = NULL, *html;
-
-	if (id_html == NULL) {
-#if PY_MAJOR_VERSION < 3
-		id_html = PyString_InternFromString("__html__");
-#else
-		id_html = PyUnicode_InternFromString("__html__");
-#endif
-		if (id_html == NULL) {
-			return NULL;
-		}
-	}
-
-	/* we don't have to escape integers, bools or floats */
-	if (PyLong_CheckExact(text) ||
-#if PY_MAJOR_VERSION < 3
-	    PyInt_CheckExact(text) ||
-#endif
-	    PyFloat_CheckExact(text) || PyBool_Check(text) ||
-	    text == Py_None)
-		return PyObject_CallFunctionObjArgs(markup, text, NULL);
-
-	/* if the object has an __html__ method that performs the escaping */
-	html = PyObject_GetAttr(text ,id_html);
-	if (html) {
-		s = PyObject_CallObject(html, NULL);
-		Py_DECREF(html);
-		/* Convert to Markup object */
-		rv = PyObject_CallFunctionObjArgs(markup, (PyObject*)s, NULL);
-		Py_DECREF(s);
-		return rv;
-	}
-
-	/* otherwise make the object unicode if it isn't, then escape */
-	PyErr_Clear();
-	if (!PyUnicode_Check(text)) {
-#if PY_MAJOR_VERSION < 3
-		PyObject *unicode = PyObject_Unicode(text);
-#else
-		PyObject *unicode = PyObject_Str(text);
-#endif
-		if (!unicode)
-			return NULL;
-		s = escape_unicode((PyUnicodeObject*)unicode);
-		Py_DECREF(unicode);
-	}
-	else
-		s = escape_unicode((PyUnicodeObject*)text);
-
-	/* convert the unicode string into a markup object. */
-	rv = PyObject_CallFunctionObjArgs(markup, (PyObject*)s, NULL);
-	Py_DECREF(s);
-	return rv;
-}
-
-
-static PyObject*
-escape_silent(PyObject *self, PyObject *text)
-{
-	if (text != Py_None)
-		return escape(self, text);
-	return PyObject_CallFunctionObjArgs(markup, NULL);
-}
-
-
-static PyObject*
-soft_unicode(PyObject *self, PyObject *s)
-{
-	if (!PyUnicode_Check(s))
-#if PY_MAJOR_VERSION < 3
-		return PyObject_Unicode(s);
-#else
-		return PyObject_Str(s);
-#endif
-	Py_INCREF(s);
-	return s;
-}
-
-
-static PyMethodDef module_methods[] = {
-	{"escape", (PyCFunction)escape, METH_O,
-	 "escape(s) -> markup\n\n"
-	 "Convert the characters &, <, >, ', and \" in string s to HTML-safe\n"
-	 "sequences.  Use this if you need to display text that might contain\n"
-	 "such characters in HTML.  Marks return value as markup string."},
-	{"escape_silent", (PyCFunction)escape_silent, METH_O,
-	 "escape_silent(s) -> markup\n\n"
-	 "Like escape but converts None to an empty string."},
-	{"soft_unicode", (PyCFunction)soft_unicode, METH_O,
-	 "soft_unicode(object) -> string\n\n"
-         "Make a string unicode if it isn't already.  That way a markup\n"
-         "string is not converted back to unicode."},
-	{NULL, NULL, 0, NULL}		/* Sentinel */
-};
-
-
-#if PY_MAJOR_VERSION < 3
-
-#ifndef PyMODINIT_FUNC	/* declarations for DLL import/export */
-#define PyMODINIT_FUNC void
-#endif
-PyMODINIT_FUNC
-init_speedups(void)
-{
-	if (!init_constants())
-		return;
-
-	Py_InitModule3("markupsafe._speedups", module_methods, "");
-}
-
-#else /* Python 3.x module initialization */
-
-static struct PyModuleDef module_definition = {
-        PyModuleDef_HEAD_INIT,
-	"markupsafe._speedups",
-	NULL,
-	-1,
-	module_methods,
-	NULL,
-	NULL,
-	NULL,
-	NULL
-};
-
-PyMODINIT_FUNC
-PyInit__speedups(void)
-{
-	if (!init_constants())
-		return NULL;
-
-	return PyModule_Create(&module_definition);
-}
-
-#endif
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.cpython-35m-arm-linux-gnueabihf.so b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.cpython-35m-arm-linux-gnueabihf.so
deleted file mode 100755
index 4fdc6d2f6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/markupsafe/_speedups.cpython-35m-arm-linux-gnueabihf.so and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/DESCRIPTION.rst
deleted file mode 100644
index 8ef94c438..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,39 +0,0 @@
-pip
-===
-
-The `PyPA recommended
-<https://packaging.python.org/en/latest/current/>`_
-tool for installing Python packages.
-
-* `Installation <https://pip.pypa.io/en/stable/installing.html>`_
-* `Documentation <https://pip.pypa.io/>`_
-* `Changelog <https://pip.pypa.io/en/stable/news.html>`_
-* `Github Page <https://github.com/pypa/pip>`_
-* `Issue Tracking <https://github.com/pypa/pip/issues>`_
-* `User mailing list <http://groups.google.com/group/python-virtualenv>`_
-* `Dev mailing list <http://groups.google.com/group/pypa-dev>`_
-* User IRC: #pypa on Freenode.
-* Dev IRC: #pypa-dev on Freenode.
-
-
-.. image:: https://img.shields.io/pypi/v/pip.svg
-   :target: https://pypi.python.org/pypi/pip
-
-.. image:: https://img.shields.io/travis/pypa/pip/master.svg
-   :target: http://travis-ci.org/pypa/pip
-
-.. image:: https://img.shields.io/appveyor/ci/pypa/pip.svg
-   :target: https://ci.appveyor.com/project/pypa/pip/history
-
-.. image:: https://readthedocs.org/projects/pip/badge/?version=stable
-   :target: https://pip.pypa.io/en/stable
-
-Code of Conduct
----------------
-
-Everyone interacting in the pip project's codebases, issue trackers, chat
-rooms, and mailing lists is expected to follow the `PyPA Code of Conduct`_.
-
-.. _PyPA Code of Conduct: https://www.pypa.io/en/latest/code-of-conduct/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/METADATA
deleted file mode 100644
index 600a90590..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/METADATA
+++ /dev/null
@@ -1,69 +0,0 @@
-Metadata-Version: 2.0
-Name: pip
-Version: 9.0.1
-Summary: The PyPA recommended tool for installing Python packages.
-Home-page: https://pip.pypa.io/
-Author: The pip developers
-Author-email: python-virtualenv@groups.google.com
-License: MIT
-Keywords: easy_install distutils setuptools egg virtualenv
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Topic :: Software Development :: Build Tools
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=2.6,!=3.0.*,!=3.1.*,!=3.2.*
-Provides-Extra: testing
-Requires-Dist: mock; extra == 'testing'
-Requires-Dist: pretend; extra == 'testing'
-Requires-Dist: pytest; extra == 'testing'
-Requires-Dist: scripttest (>=1.3); extra == 'testing'
-Requires-Dist: virtualenv (>=1.10); extra == 'testing'
-
-pip
-===
-
-The `PyPA recommended
-<https://packaging.python.org/en/latest/current/>`_
-tool for installing Python packages.
-
-* `Installation <https://pip.pypa.io/en/stable/installing.html>`_
-* `Documentation <https://pip.pypa.io/>`_
-* `Changelog <https://pip.pypa.io/en/stable/news.html>`_
-* `Github Page <https://github.com/pypa/pip>`_
-* `Issue Tracking <https://github.com/pypa/pip/issues>`_
-* `User mailing list <http://groups.google.com/group/python-virtualenv>`_
-* `Dev mailing list <http://groups.google.com/group/pypa-dev>`_
-* User IRC: #pypa on Freenode.
-* Dev IRC: #pypa-dev on Freenode.
-
-
-.. image:: https://img.shields.io/pypi/v/pip.svg
-   :target: https://pypi.python.org/pypi/pip
-
-.. image:: https://img.shields.io/travis/pypa/pip/master.svg
-   :target: http://travis-ci.org/pypa/pip
-
-.. image:: https://img.shields.io/appveyor/ci/pypa/pip.svg
-   :target: https://ci.appveyor.com/project/pypa/pip/history
-
-.. image:: https://readthedocs.org/projects/pip/badge/?version=stable
-   :target: https://pip.pypa.io/en/stable
-
-Code of Conduct
----------------
-
-Everyone interacting in the pip project's codebases, issue trackers, chat
-rooms, and mailing lists is expected to follow the `PyPA Code of Conduct`_.
-
-.. _PyPA Code of Conduct: https://www.pypa.io/en/latest/code-of-conduct/
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/RECORD
deleted file mode 100644
index a43460f57..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/RECORD
+++ /dev/null
@@ -1,123 +0,0 @@
-pip/__init__.py,sha256=00QWSreEBjb8Y8sPs8HeqgLXSB-3UrONJxo4J5APxEc,11348
-pip/__main__.py,sha256=V6Kh-IEDEFpt1cahRE6MajUF_14qJR_Qsvn4MjWZXzE,584
-pip/basecommand.py,sha256=TTlmZesQ4Vuxcto2KqwZGmgmN5ioHEl_DeFev9ie_SA,11910
-pip/baseparser.py,sha256=AKMOeF3fTrRroiv0DmTQbdiLW0DQux2KqGC_dJJB9d0,10465
-pip/cmdoptions.py,sha256=pRptFz05iFEfSW4Flg3x1_P92sYlFvq7elhnwujikNY,16473
-pip/download.py,sha256=rA0wbmqC2n9ejX481YJSidmKgQqQDjdaxkHkHlAN68k,32171
-pip/exceptions.py,sha256=BvqH-Jw3tP2b-2IJ2kjrQemOAPMqKrQMLRIZHZQpJXk,8121
-pip/index.py,sha256=L6UhtAEZc2qw7BqfQrkPQcw2gCgEw3GukLRSA95BNyI,39950
-pip/locations.py,sha256=9rJRlgonC6QC2zGDIn_7mXaoZ9_tF_IHM2BQhWVRgbo,5626
-pip/pep425tags.py,sha256=q3kec4f6NHszuGYIhGIbVvs896D06uJAnKFgJ_wce44,10980
-pip/status_codes.py,sha256=F6uDG6Gj7RNKQJUDnd87QKqI16Us-t-B0wPF_4QMpWc,156
-pip/wheel.py,sha256=QSWmGs2ui-n4UMWm0JUY6aMCcwNKungVzbWsxI9KlJQ,32010
-pip/_vendor/__init__.py,sha256=L-0x9jj0HSZen1Fm2U0GUbxfjfwQPIXc4XJ4IAxy8D8,4804
-pip/commands/__init__.py,sha256=2Uq3HCdjchJD9FL1LB7rd5v6UySVAVizX0W3EX3hIoE,2244
-pip/commands/check.py,sha256=-A7GI1-WZBh9a4P6UoH_aR-J7I8Lz8ly7m3wnCjmevs,1382
-pip/commands/completion.py,sha256=kkPgVX7SUcJ_8Juw5GkgWaxHN9_45wmAr9mGs1zXEEs,2453
-pip/commands/download.py,sha256=8RuuPmSYgAq3iEDTqZY_1PDXRqREdUULHNjWJeAv7Mo,7810
-pip/commands/freeze.py,sha256=h6-yFMpjCjbNj8-gOm5UuoF6cg14N5rPV4TCi3_CeuI,2835
-pip/commands/hash.py,sha256=MCt4jEFyfoce0lVeNEz1x49uaTY-VDkKiBvvxrVcHkw,1597
-pip/commands/help.py,sha256=84HWkEdnGP_AEBHnn8gJP2Te0XTXRKFoXqXopbOZTNo,982
-pip/commands/install.py,sha256=o-CR1TKf-b1qaFv47nNlawqsIfDjXyIzv_iJUw1Trag,18069
-pip/commands/list.py,sha256=93bCiFyt2Qut_YHkYHJMZHpXladmxsjS-yOtZeb3uqI,11369
-pip/commands/search.py,sha256=oTs9QNdefnrmCV_JeftG0PGiMuYVmiEDF1OUaYsmDao,4502
-pip/commands/show.py,sha256=ZYM57_7U8KP9MQIIyHKQdZxmiEZByy-DRzB697VFoTY,5891
-pip/commands/uninstall.py,sha256=tz8cXz4WdpUdnt3RvpdQwH6_SNMB50egBIZWa1dwfcc,2884
-pip/commands/wheel.py,sha256=z5SEhws2YRMb0Ml1IEkg6jFZMLRpLl86bHCrQbYt5zo,7729
-pip/compat/__init__.py,sha256=2Xs_IpsmdRgHbQgQO0c8_lPvHJnQXHyGWxPbLbYJL4c,4672
-pip/compat/dictconfig.py,sha256=dRrelPDWrceDSzFT51RTEVY2GuM7UDyc5Igh_tn4Fvk,23096
-pip/models/__init__.py,sha256=0Rs7_RA4DxeOkWT5Cq4CQzDrSEhvYcN3TH2cazr72PE,71
-pip/models/index.py,sha256=pUfbO__v3mD9j-2n_ClwPS8pVyx4l2wIwyvWt8GMCRA,487
-pip/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pip/operations/check.py,sha256=uwUN9cs1sPo7c0Sj6pRrSv7b22Pk29SXUImTelVchMQ,1590
-pip/operations/freeze.py,sha256=k-7w7LsM-RpPv7ERBzHiPpYkH-GuYfHLyR-Cp_1VPL0,5194
-pip/req/__init__.py,sha256=vFwZY8_Vc1WU1zFAespg1My_r_AT3n7cN0W9eX0EFqk,276
-pip/req/req_file.py,sha256=fG9MDsXUNPhmGwxUiwrIXEynyD8Q7s3L47-hLZPDXq0,11926
-pip/req/req_install.py,sha256=gYrH-lwQMmt55VVbav_EtRIPu94cQbHFHm_Kq6AeHbg,46487
-pip/req/req_set.py,sha256=jHspXqcA2FxcF05dgUIAZ5huYPv6bn0wRUX0Z7PKmaA,34462
-pip/req/req_uninstall.py,sha256=fdH2VgCjEC8NRYDS7fRu3ZJaBBUEy-N5muwxDX5MBNM,6897
-pip/utils/__init__.py,sha256=zk1vF2EzHZX1ZKPwgeC9I6yKvs8IJ6NZEfXgp2IP8hI,27912
-pip/utils/appdirs.py,sha256=kj2LK-I2fC5QnEh_A_v-ev_IQMcXaWWF5DE39sNvCLQ,8811
-pip/utils/build.py,sha256=4smLRrfSCmXmjEnVnMFh2tBEpNcSLRe6J0ejZJ-wWJE,1312
-pip/utils/deprecation.py,sha256=X_FMjtDbMJqfqEkdRrki-mYyIdPB6I6DHUTCA_ChY6M,2232
-pip/utils/encoding.py,sha256=NQxGiFS5GbeAveLZTnx92t5r0PYqvt0iRnP2u9SGG1w,971
-pip/utils/filesystem.py,sha256=ZEVBuYM3fqr2_lgOESh4Y7fPFszGD474zVm_M3Mb5Tk,899
-pip/utils/glibc.py,sha256=jcQYjt_oJLPKVZB28Kauy4Sw70zS-wawxoU1HHX36_0,2939
-pip/utils/hashes.py,sha256=oMk7cd3PbJgzpSQyXq1MytMud5f6H5Oa2YY5hYuCq6I,2866
-pip/utils/logging.py,sha256=7yWu4gZw-Qclj7X80QVdpGWkdTWGKT4LiUVKcE04pro,3327
-pip/utils/outdated.py,sha256=fNwOCL5r2EftPGhgCYGMKu032HC8cV-JAr9lp0HmToM,5455
-pip/utils/packaging.py,sha256=qhmli14odw6DIhWJgQYS2Q0RrSbr8nXNcG48f5yTRms,2080
-pip/utils/setuptools_build.py,sha256=0blfscmNJW_iZ5DcswJeDB_PbtTEjfK9RL1R1WEDW2E,278
-pip/utils/ui.py,sha256=pbDkSAeumZ6jdZcOJ2yAbx8iBgeP2zfpqNnLJK1gskQ,11597
-pip/vcs/__init__.py,sha256=WafFliUTHMmsSISV8PHp1M5EXDNSWyJr78zKaQmPLdY,12374
-pip/vcs/bazaar.py,sha256=tYTwc4b4off8mr0O2o8SiGejqBDJxcbDBMSMd9-ISYc,3803
-pip/vcs/git.py,sha256=5LfWryi78A-2ULjEZJvCTarJ_3l8venwXASlwm8hiug,11197
-pip/vcs/mercurial.py,sha256=xG6rDiwHCRytJEs23SIHBXl_SwQo2jkkdD_6rVVP5h4,3472
-pip/vcs/subversion.py,sha256=GAuX2Sk7IZvJyEzENKcVld_wGBrQ3fpXDlXjapZEYdI,9350
-pip-9.0.1.dist-info/DESCRIPTION.rst,sha256=Va8Wj1XBpTbVQ2Z41mZRJdALEeziiS_ZewWn1H2ecY4,1287
-pip-9.0.1.dist-info/METADATA,sha256=mvs_tLoKAbECXY_6QHiVWQsagSL-1UjolQTpScT8JSk,2529
-pip-9.0.1.dist-info/RECORD,,
-pip-9.0.1.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
-pip-9.0.1.dist-info/entry_points.txt,sha256=GWc-Wb9WUKZ1EuVWNz-G0l3BeIpbNJLx0OJbZ61AAV0,68
-pip-9.0.1.dist-info/metadata.json,sha256=aqvkETDy4mHUBob-2Fn5WWlXORi_M2OSfQ2HQCUU_Fk,1565
-pip-9.0.1.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-../../../bin/pip,sha256=BAa5C89XQLb5LJChTIM5Xmr_s-1sJQi0C9e5zaAUono,243
-../../../bin/pip3,sha256=BAa5C89XQLb5LJChTIM5Xmr_s-1sJQi0C9e5zaAUono,243
-../../../bin/pip3.5,sha256=BAa5C89XQLb5LJChTIM5Xmr_s-1sJQi0C9e5zaAUono,243
-pip-9.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-pip/__pycache__/__main__.cpython-35.pyc,,
-pip/vcs/__pycache__/git.cpython-35.pyc,,
-pip/__pycache__/exceptions.cpython-35.pyc,,
-pip/utils/__pycache__/ui.cpython-35.pyc,,
-pip/__pycache__/cmdoptions.cpython-35.pyc,,
-pip/operations/__pycache__/freeze.cpython-35.pyc,,
-pip/req/__pycache__/req_install.cpython-35.pyc,,
-pip/utils/__pycache__/build.cpython-35.pyc,,
-pip/operations/__pycache__/check.cpython-35.pyc,,
-pip/utils/__pycache__/filesystem.cpython-35.pyc,,
-pip/commands/__pycache__/download.cpython-35.pyc,,
-pip/commands/__pycache__/hash.cpython-35.pyc,,
-pip/__pycache__/status_codes.cpython-35.pyc,,
-pip/utils/__pycache__/deprecation.cpython-35.pyc,,
-pip/compat/__pycache__/dictconfig.cpython-35.pyc,,
-pip/_vendor/__pycache__/__init__.cpython-35.pyc,,
-pip/utils/__pycache__/glibc.cpython-35.pyc,,
-pip/commands/__pycache__/wheel.cpython-35.pyc,,
-pip/commands/__pycache__/check.cpython-35.pyc,,
-pip/req/__pycache__/req_uninstall.cpython-35.pyc,,
-pip/__pycache__/index.cpython-35.pyc,,
-pip/__pycache__/basecommand.cpython-35.pyc,,
-pip/__pycache__/locations.cpython-35.pyc,,
-pip/commands/__pycache__/show.cpython-35.pyc,,
-pip/utils/__pycache__/setuptools_build.cpython-35.pyc,,
-pip/__pycache__/wheel.cpython-35.pyc,,
-pip/models/__pycache__/__init__.cpython-35.pyc,,
-pip/operations/__pycache__/__init__.cpython-35.pyc,,
-pip/vcs/__pycache__/bazaar.cpython-35.pyc,,
-pip/req/__pycache__/req_file.cpython-35.pyc,,
-pip/utils/__pycache__/packaging.cpython-35.pyc,,
-pip/utils/__pycache__/logging.cpython-35.pyc,,
-pip/commands/__pycache__/search.cpython-35.pyc,,
-pip/vcs/__pycache__/mercurial.cpython-35.pyc,,
-pip/vcs/__pycache__/subversion.cpython-35.pyc,,
-pip/__pycache__/download.cpython-35.pyc,,
-pip/commands/__pycache__/completion.cpython-35.pyc,,
-pip/commands/__pycache__/__init__.cpython-35.pyc,,
-pip/__pycache__/__init__.cpython-35.pyc,,
-pip/compat/__pycache__/__init__.cpython-35.pyc,,
-pip/vcs/__pycache__/__init__.cpython-35.pyc,,
-pip/commands/__pycache__/uninstall.cpython-35.pyc,,
-pip/__pycache__/pep425tags.cpython-35.pyc,,
-pip/utils/__pycache__/encoding.cpython-35.pyc,,
-pip/utils/__pycache__/outdated.cpython-35.pyc,,
-pip/commands/__pycache__/install.cpython-35.pyc,,
-pip/commands/__pycache__/help.cpython-35.pyc,,
-pip/models/__pycache__/index.cpython-35.pyc,,
-pip/utils/__pycache__/hashes.cpython-35.pyc,,
-pip/__pycache__/baseparser.cpython-35.pyc,,
-pip/utils/__pycache__/appdirs.cpython-35.pyc,,
-pip/utils/__pycache__/__init__.cpython-35.pyc,,
-pip/commands/__pycache__/freeze.cpython-35.pyc,,
-pip/req/__pycache__/__init__.cpython-35.pyc,,
-pip/req/__pycache__/req_set.cpython-35.pyc,,
-pip/commands/__pycache__/list.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/WHEEL
deleted file mode 100644
index 8b6dd1b5a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.29.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/entry_points.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/entry_points.txt
deleted file mode 100644
index c02a8d573..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/entry_points.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-[console_scripts]
-pip = pip:main
-pip3 = pip:main
-pip3.5 = pip:main
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/metadata.json
deleted file mode 100644
index 9eae02c56..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Topic :: Software Development :: Build Tools", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: Implementation :: PyPy"], "extensions": {"python.commands": {"wrap_console": {"pip": "pip:main", "pip3": "pip:main", "pip3.5": "pip:main"}}, "python.details": {"contacts": [{"email": "python-virtualenv@groups.google.com", "name": "The pip developers", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://pip.pypa.io/"}}, "python.exports": {"console_scripts": {"pip": "pip:main", "pip3": "pip:main", "pip3.5": "pip:main"}}}, "extras": ["testing"], "generator": "bdist_wheel (0.29.0)", "keywords": ["easy_install", "distutils", "setuptools", "egg", "virtualenv"], "license": "MIT", "metadata_version": "2.0", "name": "pip", "requires_python": ">=2.6,!=3.0.*,!=3.1.*,!=3.2.*", "run_requires": [{"extra": "testing", "requires": ["mock", "pretend", "pytest", "scripttest (>=1.3)", "virtualenv (>=1.10)"]}], "summary": "The PyPA recommended tool for installing Python packages.", "test_requires": [{"requires": ["mock", "pretend", "pytest", "scripttest (>=1.3)", "virtualenv (>=1.10)"]}], "version": "9.0.1"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/top_level.txt
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip-9.0.1.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__init__.py
deleted file mode 100644
index 9c1d8f96d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__init__.py
+++ /dev/null
@@ -1,331 +0,0 @@
-#!/usr/bin/env python
-from __future__ import absolute_import
-
-import locale
-import logging
-import os
-import optparse
-import warnings
-
-import sys
-import re
-
-# 2016-06-17 barry@debian.org: urllib3 1.14 added optional support for socks,
-# but if invoked (i.e. imported), it will issue a warning to stderr if socks
-# isn't available.  requests unconditionally imports urllib3's socks contrib
-# module, triggering this warning.  The warning breaks DEP-8 tests (because of
-# the stderr output) and is just plain annoying in normal usage.  I don't want
-# to add socks as yet another dependency for pip, nor do I want to allow-stder
-# in the DEP-8 tests, so just suppress the warning.  pdb tells me this has to
-# be done before the import of pip.vcs.
-from pip._vendor.requests.packages.urllib3.exceptions import DependencyWarning
-warnings.filterwarnings("ignore", category=DependencyWarning)  # noqa
-
-
-from pip.exceptions import InstallationError, CommandError, PipError
-from pip.utils import get_installed_distributions, get_prog
-from pip.utils import deprecation, dist_is_editable
-from pip.vcs import git, mercurial, subversion, bazaar  # noqa
-from pip.baseparser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
-from pip.commands import get_summaries, get_similar_commands
-from pip.commands import commands_dict
-from pip._vendor.requests.packages.urllib3.exceptions import (
-    InsecureRequestWarning,
-)
-
-
-# assignment for flake8 to be happy
-
-# This fixes a peculiarity when importing via __import__ - as we are
-# initialising the pip module, "from pip import cmdoptions" is recursive
-# and appears not to work properly in that situation.
-import pip.cmdoptions
-cmdoptions = pip.cmdoptions
-
-# The version as used in the setup.py and the docs conf.py
-__version__ = "9.0.1"
-
-
-logger = logging.getLogger(__name__)
-
-# Hide the InsecureRequestWarning from urllib3
-warnings.filterwarnings("ignore", category=InsecureRequestWarning)
-
-
-def autocomplete():
-    """Command and option completion for the main option parser (and options)
-    and its subcommands (and options).
-
-    Enable by sourcing one of the completion shell scripts (bash, zsh or fish).
-    """
-    # Don't complete if user hasn't sourced bash_completion file.
-    if 'PIP_AUTO_COMPLETE' not in os.environ:
-        return
-    cwords = os.environ['COMP_WORDS'].split()[1:]
-    cword = int(os.environ['COMP_CWORD'])
-    try:
-        current = cwords[cword - 1]
-    except IndexError:
-        current = ''
-
-    subcommands = [cmd for cmd, summary in get_summaries()]
-    options = []
-    # subcommand
-    try:
-        subcommand_name = [w for w in cwords if w in subcommands][0]
-    except IndexError:
-        subcommand_name = None
-
-    parser = create_main_parser()
-    # subcommand options
-    if subcommand_name:
-        # special case: 'help' subcommand has no options
-        if subcommand_name == 'help':
-            sys.exit(1)
-        # special case: list locally installed dists for uninstall command
-        if subcommand_name == 'uninstall' and not current.startswith('-'):
-            installed = []
-            lc = current.lower()
-            for dist in get_installed_distributions(local_only=True):
-                if dist.key.startswith(lc) and dist.key not in cwords[1:]:
-                    installed.append(dist.key)
-            # if there are no dists installed, fall back to option completion
-            if installed:
-                for dist in installed:
-                    print(dist)
-                sys.exit(1)
-
-        subcommand = commands_dict[subcommand_name]()
-        options += [(opt.get_opt_string(), opt.nargs)
-                    for opt in subcommand.parser.option_list_all
-                    if opt.help != optparse.SUPPRESS_HELP]
-
-        # filter out previously specified options from available options
-        prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
-        options = [(x, v) for (x, v) in options if x not in prev_opts]
-        # filter options by current input
-        options = [(k, v) for k, v in options if k.startswith(current)]
-        for option in options:
-            opt_label = option[0]
-            # append '=' to options which require args
-            if option[1]:
-                opt_label += '='
-            print(opt_label)
-    else:
-        # show main parser options only when necessary
-        if current.startswith('-') or current.startswith('--'):
-            opts = [i.option_list for i in parser.option_groups]
-            opts.append(parser.option_list)
-            opts = (o for it in opts for o in it)
-
-            subcommands += [i.get_opt_string() for i in opts
-                            if i.help != optparse.SUPPRESS_HELP]
-
-        print(' '.join([x for x in subcommands if x.startswith(current)]))
-    sys.exit(1)
-
-
-def create_main_parser():
-    parser_kw = {
-        'usage': '\n%prog <command> [options]',
-        'add_help_option': False,
-        'formatter': UpdatingDefaultsHelpFormatter(),
-        'name': 'global',
-        'prog': get_prog(),
-    }
-
-    parser = ConfigOptionParser(**parser_kw)
-    parser.disable_interspersed_args()
-
-    pip_pkg_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    parser.version = 'pip %s from %s (python %s)' % (
-        __version__, pip_pkg_dir, sys.version[:3])
-
-    # add the general options
-    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
-    parser.add_option_group(gen_opts)
-
-    parser.main = True  # so the help formatter knows
-
-    # create command listing for description
-    command_summaries = get_summaries()
-    description = [''] + ['%-27s %s' % (i, j) for i, j in command_summaries]
-    parser.description = '\n'.join(description)
-
-    return parser
-
-
-def parseopts(args):
-    parser = create_main_parser()
-
-    # Note: parser calls disable_interspersed_args(), so the result of this
-    # call is to split the initial args into the general options before the
-    # subcommand and everything else.
-    # For example:
-    #  args: ['--timeout=5', 'install', '--user', 'INITools']
-    #  general_options: ['--timeout==5']
-    #  args_else: ['install', '--user', 'INITools']
-    general_options, args_else = parser.parse_args(args)
-
-    # --version
-    if general_options.version:
-        sys.stdout.write(parser.version)
-        sys.stdout.write(os.linesep)
-        sys.exit()
-
-    # pip || pip help -> print_help()
-    if not args_else or (args_else[0] == 'help' and len(args_else) == 1):
-        parser.print_help()
-        sys.exit()
-
-    # the subcommand name
-    cmd_name = args_else[0]
-
-    if cmd_name not in commands_dict:
-        guess = get_similar_commands(cmd_name)
-
-        msg = ['unknown command "%s"' % cmd_name]
-        if guess:
-            msg.append('maybe you meant "%s"' % guess)
-
-        raise CommandError(' - '.join(msg))
-
-    # all the args without the subcommand
-    cmd_args = args[:]
-    cmd_args.remove(cmd_name)
-
-    return cmd_name, cmd_args
-
-
-def check_isolated(args):
-    isolated = False
-
-    if "--isolated" in args:
-        isolated = True
-
-    return isolated
-
-
-def main(args=None):
-    if args is None:
-        args = sys.argv[1:]
-
-    # Configure our deprecation warnings to be sent through loggers
-    deprecation.install_warning_logger()
-
-    autocomplete()
-
-    try:
-        cmd_name, cmd_args = parseopts(args)
-    except PipError as exc:
-        sys.stderr.write("ERROR: %s" % exc)
-        sys.stderr.write(os.linesep)
-        sys.exit(1)
-
-    # Needed for locale.getpreferredencoding(False) to work
-    # in pip.utils.encoding.auto_decode
-    try:
-        locale.setlocale(locale.LC_ALL, '')
-    except locale.Error as e:
-        # setlocale can apparently crash if locale are uninitialized
-        logger.debug("Ignoring error %s when setting locale", e)
-    command = commands_dict[cmd_name](isolated=check_isolated(cmd_args))
-    return command.main(cmd_args)
-
-
-# ###########################################################
-# # Writing freeze files
-
-class FrozenRequirement(object):
-
-    def __init__(self, name, req, editable, comments=()):
-        self.name = name
-        self.req = req
-        self.editable = editable
-        self.comments = comments
-
-    _rev_re = re.compile(r'-r(\d+)$')
-    _date_re = re.compile(r'-(20\d\d\d\d\d\d)$')
-
-    @classmethod
-    def from_dist(cls, dist, dependency_links):
-        location = os.path.normcase(os.path.abspath(dist.location))
-        comments = []
-        from pip.vcs import vcs, get_src_requirement
-        if dist_is_editable(dist) and vcs.get_backend_name(location):
-            editable = True
-            try:
-                req = get_src_requirement(dist, location)
-            except InstallationError as exc:
-                logger.warning(
-                    "Error when trying to get requirement for VCS system %s, "
-                    "falling back to uneditable format", exc
-                )
-                req = None
-            if req is None:
-                logger.warning(
-                    'Could not determine repository location of %s', location
-                )
-                comments.append(
-                    '## !! Could not determine repository location'
-                )
-                req = dist.as_requirement()
-                editable = False
-        else:
-            editable = False
-            req = dist.as_requirement()
-            specs = req.specs
-            assert len(specs) == 1 and specs[0][0] in ["==", "==="], \
-                'Expected 1 spec with == or ===; specs = %r; dist = %r' % \
-                (specs, dist)
-            version = specs[0][1]
-            ver_match = cls._rev_re.search(version)
-            date_match = cls._date_re.search(version)
-            if ver_match or date_match:
-                svn_backend = vcs.get_backend('svn')
-                if svn_backend:
-                    svn_location = svn_backend().get_location(
-                        dist,
-                        dependency_links,
-                    )
-                if not svn_location:
-                    logger.warning(
-                        'Warning: cannot find svn location for %s', req)
-                    comments.append(
-                        '## FIXME: could not find svn URL in dependency_links '
-                        'for this package:'
-                    )
-                else:
-                    comments.append(
-                        '# Installing as editable to satisfy requirement %s:' %
-                        req
-                    )
-                    if ver_match:
-                        rev = ver_match.group(1)
-                    else:
-                        rev = '{%s}' % date_match.group(1)
-                    editable = True
-                    req = '%s@%s#egg=%s' % (
-                        svn_location,
-                        rev,
-                        cls.egg_name(dist)
-                    )
-        return cls(dist.project_name, req, editable, comments)
-
-    @staticmethod
-    def egg_name(dist):
-        name = dist.egg_name()
-        match = re.search(r'-py\d\.\d$', name)
-        if match:
-            name = name[:match.start()]
-        return name
-
-    def __str__(self):
-        req = self.req
-        if self.editable:
-            req = '-e %s' % req
-        return '\n'.join(list(self.comments) + [str(req)]) + '\n'
-
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__main__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__main__.py
deleted file mode 100644
index 5556539cb..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__main__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from __future__ import absolute_import
-
-import os
-import sys
-
-# If we are running from a wheel, add the wheel to sys.path
-# This allows the usage python pip-*.whl/pip install pip-*.whl
-if __package__ == '':
-    # __file__ is pip-*.whl/pip/__main__.py
-    # first dirname call strips of '/__main__.py', second strips off '/pip'
-    # Resulting path is the name of the wheel itself
-    # Add that to sys.path so we can import pip
-    path = os.path.dirname(os.path.dirname(__file__))
-    sys.path.insert(0, path)
-
-import pip  # noqa
-
-if __name__ == '__main__':
-    sys.exit(pip.main())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 370ffdada..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__main__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__main__.cpython-35.pyc
deleted file mode 100644
index cc8de1cbe..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/__main__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/basecommand.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/basecommand.cpython-35.pyc
deleted file mode 100644
index a988c913f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/basecommand.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/baseparser.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/baseparser.cpython-35.pyc
deleted file mode 100644
index 5f306264c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/baseparser.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/cmdoptions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/cmdoptions.cpython-35.pyc
deleted file mode 100644
index 5f8ff72f3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/cmdoptions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/download.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/download.cpython-35.pyc
deleted file mode 100644
index 5aba59450..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/download.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/exceptions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/exceptions.cpython-35.pyc
deleted file mode 100644
index b265ed4ee..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/exceptions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/index.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/index.cpython-35.pyc
deleted file mode 100644
index 0336cc0ba..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/index.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/locations.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/locations.cpython-35.pyc
deleted file mode 100644
index 6794b5716..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/locations.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/pep425tags.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/pep425tags.cpython-35.pyc
deleted file mode 100644
index 195ddbf0e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/pep425tags.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/status_codes.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/status_codes.cpython-35.pyc
deleted file mode 100644
index aa3ba17fc..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/status_codes.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/wheel.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/wheel.cpython-35.pyc
deleted file mode 100644
index 5480dd246..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/__pycache__/wheel.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__init__.py
deleted file mode 100644
index 8e76ab825..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__init__.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""
-pip._vendor is for vendoring dependencies of pip to prevent needing pip to
-depend on something external.
-
-Files inside of pip._vendor should be considered immutable and should only be
-updated to versions from upstream.
-"""
-from __future__ import absolute_import
-
-import glob
-import os.path
-import sys
-
-# Downstream redistributors which have debundled our dependencies should also
-# patch this value to be true. This will trigger the additional patching
-# to cause things like "six" to be available as pip.
-DEBUNDLED = True
-
-# By default, look in this directory for a bunch of .whl files which we will
-# add to the beginning of sys.path before attempting to import anything. This
-# is done to support downstream re-distributors like Debian and Fedora who
-# wish to create their own Wheels for our dependencies to aid in debundling.
-WHEEL_DIR = os.path.abspath(os.path.join(sys.prefix, 'share', 'python-wheels'))
-
-
-# Define a small helper function to alias our vendored modules to the real ones
-# if the vendored ones do not exist. This idea of this was taken from
-# https://github.com/kennethreitz/requests/pull/2567.
-def vendored(modulename):
-    vendored_name = "{0}.{1}".format(__name__, modulename)
-
-    try:
-        __import__(vendored_name, globals(), locals(), level=0)
-    except ImportError:
-        try:
-            __import__(modulename, globals(), locals(), level=0)
-        except ImportError:
-            # We can just silently allow import failures to pass here. If we
-            # got to this point it means that ``import pip._vendor.whatever``
-            # failed and so did ``import whatever``. Since we're importing this
-            # upfront in an attempt to alias imports, not erroring here will
-            # just mean we get a regular import error whenever pip *actually*
-            # tries to import one of these modules to use it, which actually
-            # gives us a better error message than we would have otherwise
-            # gotten.
-            pass
-        else:
-            sys.modules[vendored_name] = sys.modules[modulename]
-            base, head = vendored_name.rsplit(".", 1)
-            setattr(sys.modules[base], head, sys.modules[modulename])
-
-
-# If we're operating in a debundled setup, then we want to go ahead and trigger
-# the aliasing of our vendored libraries as well as looking for wheels to add
-# to our sys.path. This will cause all of this code to be a no-op typically
-# however downstream redistributors can enable it in a consistent way across
-# all platforms.
-if DEBUNDLED:
-    # Actually look inside of WHEEL_DIR to find .whl files and add them to the
-    # front of our sys.path.
-    sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, "*.whl")) + sys.path
-
-    # Actually alias all of our vendored dependencies.
-    vendored("cachecontrol")
-    vendored("colorama")
-    vendored("distlib")
-    vendored("distro")
-    vendored("html5lib")
-    vendored("lockfile")
-    vendored("six")
-    vendored("six.moves")
-    vendored("six.moves.urllib")
-    vendored("packaging")
-    vendored("packaging.version")
-    vendored("packaging.specifiers")
-    vendored("pkg_resources")
-    vendored("progress")
-    vendored("retrying")
-    vendored("requests")
-    vendored("requests.packages")
-    vendored("requests.packages.urllib3")
-    vendored("requests.packages.urllib3._collections")
-    vendored("requests.packages.urllib3.connection")
-    vendored("requests.packages.urllib3.connectionpool")
-    vendored("requests.packages.urllib3.contrib")
-    vendored("requests.packages.urllib3.contrib.ntlmpool")
-    vendored("requests.packages.urllib3.contrib.pyopenssl")
-    vendored("requests.packages.urllib3.exceptions")
-    vendored("requests.packages.urllib3.fields")
-    vendored("requests.packages.urllib3.filepost")
-    vendored("requests.packages.urllib3.packages")
-    try:
-        vendored("requests.packages.urllib3.packages.ordered_dict")
-        vendored("requests.packages.urllib3.packages.six")
-    except ImportError:
-        # Debian already unbundles these from requests.
-        pass
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname")
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname."
-             "_implementation")
-    vendored("requests.packages.urllib3.poolmanager")
-    vendored("requests.packages.urllib3.request")
-    vendored("requests.packages.urllib3.response")
-    vendored("requests.packages.urllib3.util")
-    vendored("requests.packages.urllib3.util.connection")
-    vendored("requests.packages.urllib3.util.request")
-    vendored("requests.packages.urllib3.util.response")
-    vendored("requests.packages.urllib3.util.retry")
-    vendored("requests.packages.urllib3.util.ssl_")
-    vendored("requests.packages.urllib3.util.timeout")
-    vendored("requests.packages.urllib3.util.url")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 59a3332a6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/_vendor/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/basecommand.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/basecommand.py
deleted file mode 100644
index 54c670672..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/basecommand.py
+++ /dev/null
@@ -1,337 +0,0 @@
-"""Base Command class, and related routines"""
-from __future__ import absolute_import
-
-import logging
-import os
-import sys
-import optparse
-import warnings
-
-from pip import cmdoptions
-from pip.index import PackageFinder
-from pip.locations import running_under_virtualenv
-from pip.download import PipSession
-from pip.exceptions import (BadCommand, InstallationError, UninstallationError,
-                            CommandError, PreviousBuildDirError)
-
-from pip.compat import logging_dictConfig
-from pip.baseparser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
-from pip.req import InstallRequirement, parse_requirements
-from pip.status_codes import (
-    SUCCESS, ERROR, UNKNOWN_ERROR, VIRTUALENV_NOT_FOUND,
-    PREVIOUS_BUILD_DIR_ERROR,
-)
-from pip.utils import deprecation, get_prog, normalize_path
-from pip.utils.logging import IndentingFormatter
-from pip.utils.outdated import pip_version_check
-
-
-__all__ = ['Command']
-
-
-logger = logging.getLogger(__name__)
-
-
-class Command(object):
-    name = None
-    usage = None
-    hidden = False
-    log_streams = ("ext://sys.stdout", "ext://sys.stderr")
-
-    def __init__(self, isolated=False):
-        parser_kw = {
-            'usage': self.usage,
-            'prog': '%s %s' % (get_prog(), self.name),
-            'formatter': UpdatingDefaultsHelpFormatter(),
-            'add_help_option': False,
-            'name': self.name,
-            'description': self.__doc__,
-            'isolated': isolated,
-        }
-
-        self.parser = ConfigOptionParser(**parser_kw)
-
-        # Commands should add options to this option group
-        optgroup_name = '%s Options' % self.name.capitalize()
-        self.cmd_opts = optparse.OptionGroup(self.parser, optgroup_name)
-
-        # Add the general options
-        gen_opts = cmdoptions.make_option_group(
-            cmdoptions.general_group,
-            self.parser,
-        )
-        self.parser.add_option_group(gen_opts)
-
-    def _build_session(self, options, retries=None, timeout=None):
-        session = PipSession(
-            cache=(
-                normalize_path(os.path.join(options.cache_dir, "http"))
-                if options.cache_dir else None
-            ),
-            retries=retries if retries is not None else options.retries,
-            insecure_hosts=options.trusted_hosts,
-        )
-
-        # Handle custom ca-bundles from the user
-        if options.cert:
-            session.verify = options.cert
-
-        # Handle SSL client certificate
-        if options.client_cert:
-            session.cert = options.client_cert
-
-        # Handle timeouts
-        if options.timeout or timeout:
-            session.timeout = (
-                timeout if timeout is not None else options.timeout
-            )
-
-        # Handle configured proxies
-        if options.proxy:
-            session.proxies = {
-                "http": options.proxy,
-                "https": options.proxy,
-            }
-
-        # Determine if we can prompt the user for authentication or not
-        session.auth.prompting = not options.no_input
-
-        return session
-
-    def parse_args(self, args):
-        # factored out for testability
-        return self.parser.parse_args(args)
-
-    def main(self, args):
-        options, args = self.parse_args(args)
-
-        if options.quiet:
-            if options.quiet == 1:
-                level = "WARNING"
-            if options.quiet == 2:
-                level = "ERROR"
-            else:
-                level = "CRITICAL"
-        elif options.verbose:
-            level = "DEBUG"
-        else:
-            level = "INFO"
-
-        # The root logger should match the "console" level *unless* we
-        # specified "--log" to send debug logs to a file.
-        root_level = level
-        if options.log:
-            root_level = "DEBUG"
-
-        logging_dictConfig({
-            "version": 1,
-            "disable_existing_loggers": False,
-            "filters": {
-                "exclude_warnings": {
-                    "()": "pip.utils.logging.MaxLevelFilter",
-                    "level": logging.WARNING,
-                },
-            },
-            "formatters": {
-                "indent": {
-                    "()": IndentingFormatter,
-                    "format": "%(message)s",
-                },
-            },
-            "handlers": {
-                "console": {
-                    "level": level,
-                    "class": "pip.utils.logging.ColorizedStreamHandler",
-                    "stream": self.log_streams[0],
-                    "filters": ["exclude_warnings"],
-                    "formatter": "indent",
-                },
-                "console_errors": {
-                    "level": "WARNING",
-                    "class": "pip.utils.logging.ColorizedStreamHandler",
-                    "stream": self.log_streams[1],
-                    "formatter": "indent",
-                },
-                "user_log": {
-                    "level": "DEBUG",
-                    "class": "pip.utils.logging.BetterRotatingFileHandler",
-                    "filename": options.log or "/dev/null",
-                    "delay": True,
-                    "formatter": "indent",
-                },
-            },
-            "root": {
-                "level": root_level,
-                "handlers": list(filter(None, [
-                    "console",
-                    "console_errors",
-                    "user_log" if options.log else None,
-                ])),
-            },
-            # Disable any logging besides WARNING unless we have DEBUG level
-            # logging enabled. These use both pip._vendor and the bare names
-            # for the case where someone unbundles our libraries.
-            "loggers": dict(
-                (
-                    name,
-                    {
-                        "level": (
-                            "WARNING"
-                            if level in ["INFO", "ERROR"]
-                            else "DEBUG"
-                        ),
-                    },
-                )
-                for name in ["pip._vendor", "distlib", "requests", "urllib3"]
-            ),
-        })
-
-        if sys.version_info[:2] == (2, 6):
-            warnings.warn(
-                "Python 2.6 is no longer supported by the Python core team, "
-                "please upgrade your Python. A future version of pip will "
-                "drop support for Python 2.6",
-                deprecation.Python26DeprecationWarning
-            )
-
-        # TODO: try to get these passing down from the command?
-        #      without resorting to os.environ to hold these.
-
-        if options.no_input:
-            os.environ['PIP_NO_INPUT'] = '1'
-
-        if options.exists_action:
-            os.environ['PIP_EXISTS_ACTION'] = ' '.join(options.exists_action)
-
-        if options.require_venv:
-            # If a venv is required check if it can really be found
-            if not running_under_virtualenv():
-                logger.critical(
-                    'Could not find an activated virtualenv (required).'
-                )
-                sys.exit(VIRTUALENV_NOT_FOUND)
-
-        try:
-            status = self.run(options, args)
-            # FIXME: all commands should return an exit status
-            # and when it is done, isinstance is not needed anymore
-            if isinstance(status, int):
-                return status
-        except PreviousBuildDirError as exc:
-            logger.critical(str(exc))
-            logger.debug('Exception information:', exc_info=True)
-
-            return PREVIOUS_BUILD_DIR_ERROR
-        except (InstallationError, UninstallationError, BadCommand) as exc:
-            logger.critical(str(exc))
-            logger.debug('Exception information:', exc_info=True)
-
-            return ERROR
-        except CommandError as exc:
-            logger.critical('ERROR: %s', exc)
-            logger.debug('Exception information:', exc_info=True)
-
-            return ERROR
-        except KeyboardInterrupt:
-            logger.critical('Operation cancelled by user')
-            logger.debug('Exception information:', exc_info=True)
-
-            return ERROR
-        except:
-            logger.critical('Exception:', exc_info=True)
-
-            return UNKNOWN_ERROR
-        finally:
-            # Check if we're using the latest version of pip available
-            if (not options.disable_pip_version_check and not
-                    getattr(options, "no_index", False)):
-                with self._build_session(
-                        options,
-                        retries=0,
-                        timeout=min(5, options.timeout)) as session:
-                    pip_version_check(session)
-
-        return SUCCESS
-
-
-class RequirementCommand(Command):
-
-    @staticmethod
-    def populate_requirement_set(requirement_set, args, options, finder,
-                                 session, name, wheel_cache):
-        """
-        Marshal cmd line args into a requirement set.
-        """
-        for filename in options.constraints:
-            for req in parse_requirements(
-                    filename,
-                    constraint=True, finder=finder, options=options,
-                    session=session, wheel_cache=wheel_cache):
-                requirement_set.add_requirement(req)
-
-        for req in args:
-            requirement_set.add_requirement(
-                InstallRequirement.from_line(
-                    req, None, isolated=options.isolated_mode,
-                    wheel_cache=wheel_cache
-                )
-            )
-
-        for req in options.editables:
-            requirement_set.add_requirement(
-                InstallRequirement.from_editable(
-                    req,
-                    default_vcs=options.default_vcs,
-                    isolated=options.isolated_mode,
-                    wheel_cache=wheel_cache
-                )
-            )
-
-        found_req_in_file = False
-        for filename in options.requirements:
-            for req in parse_requirements(
-                    filename,
-                    finder=finder, options=options, session=session,
-                    wheel_cache=wheel_cache):
-                found_req_in_file = True
-                requirement_set.add_requirement(req)
-        # If --require-hashes was a line in a requirements file, tell
-        # RequirementSet about it:
-        requirement_set.require_hashes = options.require_hashes
-
-        if not (args or options.editables or found_req_in_file):
-            opts = {'name': name}
-            if options.find_links:
-                msg = ('You must give at least one requirement to '
-                       '%(name)s (maybe you meant "pip %(name)s '
-                       '%(links)s"?)' %
-                       dict(opts, links=' '.join(options.find_links)))
-            else:
-                msg = ('You must give at least one requirement '
-                       'to %(name)s (see "pip help %(name)s")' % opts)
-            logger.warning(msg)
-
-    def _build_package_finder(self, options, session,
-                              platform=None, python_versions=None,
-                              abi=None, implementation=None):
-        """
-        Create a package finder appropriate to this requirement command.
-        """
-        index_urls = [options.index_url] + options.extra_index_urls
-        if options.no_index:
-            logger.debug('Ignoring indexes: %s', ','.join(index_urls))
-            index_urls = []
-
-        return PackageFinder(
-            find_links=options.find_links,
-            format_control=options.format_control,
-            index_urls=index_urls,
-            trusted_hosts=options.trusted_hosts,
-            allow_all_prereleases=options.pre,
-            process_dependency_links=options.process_dependency_links,
-            session=session,
-            platform=platform,
-            versions=python_versions,
-            abi=abi,
-            implementation=implementation,
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/baseparser.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/baseparser.py
deleted file mode 100644
index 2dd453301..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/baseparser.py
+++ /dev/null
@@ -1,293 +0,0 @@
-"""Base option parser setup"""
-from __future__ import absolute_import
-
-import sys
-import optparse
-import os
-import re
-import textwrap
-from distutils.util import strtobool
-
-from pip._vendor.six import string_types
-from pip._vendor.six.moves import configparser
-from pip.locations import (
-    legacy_config_file, config_basename, running_under_virtualenv,
-    site_config_files
-)
-from pip.utils import appdirs, get_terminal_size
-
-
-_environ_prefix_re = re.compile(r"^PIP_", re.I)
-
-
-class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
-    """A prettier/less verbose help formatter for optparse."""
-
-    def __init__(self, *args, **kwargs):
-        # help position must be aligned with __init__.parseopts.description
-        kwargs['max_help_position'] = 30
-        kwargs['indent_increment'] = 1
-        kwargs['width'] = get_terminal_size()[0] - 2
-        optparse.IndentedHelpFormatter.__init__(self, *args, **kwargs)
-
-    def format_option_strings(self, option):
-        return self._format_option_strings(option, ' <%s>', ', ')
-
-    def _format_option_strings(self, option, mvarfmt=' <%s>', optsep=', '):
-        """
-        Return a comma-separated list of option strings and metavars.
-
-        :param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')
-        :param mvarfmt: metavar format string - evaluated as mvarfmt % metavar
-        :param optsep:  separator
-        """
-        opts = []
-
-        if option._short_opts:
-            opts.append(option._short_opts[0])
-        if option._long_opts:
-            opts.append(option._long_opts[0])
-        if len(opts) > 1:
-            opts.insert(1, optsep)
-
-        if option.takes_value():
-            metavar = option.metavar or option.dest.lower()
-            opts.append(mvarfmt % metavar.lower())
-
-        return ''.join(opts)
-
-    def format_heading(self, heading):
-        if heading == 'Options':
-            return ''
-        return heading + ':\n'
-
-    def format_usage(self, usage):
-        """
-        Ensure there is only one newline between usage and the first heading
-        if there is no description.
-        """
-        msg = '\nUsage: %s\n' % self.indent_lines(textwrap.dedent(usage), "  ")
-        return msg
-
-    def format_description(self, description):
-        # leave full control over description to us
-        if description:
-            if hasattr(self.parser, 'main'):
-                label = 'Commands'
-            else:
-                label = 'Description'
-            # some doc strings have initial newlines, some don't
-            description = description.lstrip('\n')
-            # some doc strings have final newlines and spaces, some don't
-            description = description.rstrip()
-            # dedent, then reindent
-            description = self.indent_lines(textwrap.dedent(description), "  ")
-            description = '%s:\n%s\n' % (label, description)
-            return description
-        else:
-            return ''
-
-    def format_epilog(self, epilog):
-        # leave full control over epilog to us
-        if epilog:
-            return epilog
-        else:
-            return ''
-
-    def indent_lines(self, text, indent):
-        new_lines = [indent + line for line in text.split('\n')]
-        return "\n".join(new_lines)
-
-
-class UpdatingDefaultsHelpFormatter(PrettyHelpFormatter):
-    """Custom help formatter for use in ConfigOptionParser.
-
-    This is updates the defaults before expanding them, allowing
-    them to show up correctly in the help listing.
-    """
-
-    def expand_default(self, option):
-        if self.parser is not None:
-            self.parser._update_defaults(self.parser.defaults)
-        return optparse.IndentedHelpFormatter.expand_default(self, option)
-
-
-class CustomOptionParser(optparse.OptionParser):
-
-    def insert_option_group(self, idx, *args, **kwargs):
-        """Insert an OptionGroup at a given position."""
-        group = self.add_option_group(*args, **kwargs)
-
-        self.option_groups.pop()
-        self.option_groups.insert(idx, group)
-
-        return group
-
-    @property
-    def option_list_all(self):
-        """Get a list of all options, including those in option groups."""
-        res = self.option_list[:]
-        for i in self.option_groups:
-            res.extend(i.option_list)
-
-        return res
-
-
-class ConfigOptionParser(CustomOptionParser):
-    """Custom option parser which updates its defaults by checking the
-    configuration files and environmental variables"""
-
-    isolated = False
-
-    def __init__(self, *args, **kwargs):
-        self.config = configparser.RawConfigParser()
-        self.name = kwargs.pop('name')
-        self.isolated = kwargs.pop("isolated", False)
-        self.files = self.get_config_files()
-        if self.files:
-            self.config.read(self.files)
-        assert self.name
-        optparse.OptionParser.__init__(self, *args, **kwargs)
-
-    def get_config_files(self):
-        # the files returned by this method will be parsed in order with the
-        # first files listed being overridden by later files in standard
-        # ConfigParser fashion
-        config_file = os.environ.get('PIP_CONFIG_FILE', False)
-        if config_file == os.devnull:
-            return []
-
-        # at the base we have any site-wide configuration
-        files = list(site_config_files)
-
-        # per-user configuration next
-        if not self.isolated:
-            if config_file and os.path.exists(config_file):
-                files.append(config_file)
-            else:
-                # This is the legacy config file, we consider it to be a lower
-                # priority than the new file location.
-                files.append(legacy_config_file)
-
-                # This is the new config file, we consider it to be a higher
-                # priority than the legacy file.
-                files.append(
-                    os.path.join(
-                        appdirs.user_config_dir("pip"),
-                        config_basename,
-                    )
-                )
-
-        # finally virtualenv configuration first trumping others
-        if running_under_virtualenv():
-            venv_config_file = os.path.join(
-                sys.prefix,
-                config_basename,
-            )
-            if os.path.exists(venv_config_file):
-                files.append(venv_config_file)
-
-        return files
-
-    def check_default(self, option, key, val):
-        try:
-            return option.check_value(key, val)
-        except optparse.OptionValueError as exc:
-            print("An error occurred during configuration: %s" % exc)
-            sys.exit(3)
-
-    def _update_defaults(self, defaults):
-        """Updates the given defaults with values from the config files and
-        the environ. Does a little special handling for certain types of
-        options (lists)."""
-        # Then go and look for the other sources of configuration:
-        config = {}
-        # 1. config files
-        for section in ('global', self.name):
-            config.update(
-                self.normalize_keys(self.get_config_section(section))
-            )
-        # 2. environmental variables
-        if not self.isolated:
-            config.update(self.normalize_keys(self.get_environ_vars()))
-        # Accumulate complex default state.
-        self.values = optparse.Values(self.defaults)
-        late_eval = set()
-        # Then set the options with those values
-        for key, val in config.items():
-            # ignore empty values
-            if not val:
-                continue
-
-            option = self.get_option(key)
-            # Ignore options not present in this parser. E.g. non-globals put
-            # in [global] by users that want them to apply to all applicable
-            # commands.
-            if option is None:
-                continue
-
-            if option.action in ('store_true', 'store_false', 'count'):
-                val = strtobool(val)
-            elif option.action == 'append':
-                val = val.split()
-                val = [self.check_default(option, key, v) for v in val]
-            elif option.action == 'callback':
-                late_eval.add(option.dest)
-                opt_str = option.get_opt_string()
-                val = option.convert_value(opt_str, val)
-                # From take_action
-                args = option.callback_args or ()
-                kwargs = option.callback_kwargs or {}
-                option.callback(option, opt_str, val, self, *args, **kwargs)
-            else:
-                val = self.check_default(option, key, val)
-
-            defaults[option.dest] = val
-
-        for key in late_eval:
-            defaults[key] = getattr(self.values, key)
-        self.values = None
-        return defaults
-
-    def normalize_keys(self, items):
-        """Return a config dictionary with normalized keys regardless of
-        whether the keys were specified in environment variables or in config
-        files"""
-        normalized = {}
-        for key, val in items:
-            key = key.replace('_', '-')
-            if not key.startswith('--'):
-                key = '--%s' % key  # only prefer long opts
-            normalized[key] = val
-        return normalized
-
-    def get_config_section(self, name):
-        """Get a section of a configuration"""
-        if self.config.has_section(name):
-            return self.config.items(name)
-        return []
-
-    def get_environ_vars(self):
-        """Returns a generator with all environmental vars with prefix PIP_"""
-        for key, val in os.environ.items():
-            if _environ_prefix_re.search(key):
-                yield (_environ_prefix_re.sub("", key).lower(), val)
-
-    def get_default_values(self):
-        """Overriding to make updating the defaults after instantiation of
-        the option parser possible, _update_defaults() does the dirty work."""
-        if not self.process_default_values:
-            # Old, pre-Optik 1.5 behaviour.
-            return optparse.Values(self.defaults)
-
-        defaults = self._update_defaults(self.defaults.copy())  # ours
-        for option in self._get_all_options():
-            default = defaults.get(option.dest)
-            if isinstance(default, string_types):
-                opt_str = option.get_opt_string()
-                defaults[option.dest] = option.check_value(opt_str, default)
-        return optparse.Values(defaults)
-
-    def error(self, msg):
-        self.print_usage(sys.stderr)
-        self.exit(2, "%s\n" % msg)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/cmdoptions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/cmdoptions.py
deleted file mode 100644
index f75c0930d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/cmdoptions.py
+++ /dev/null
@@ -1,633 +0,0 @@
-"""
-shared options and groups
-
-The principle here is to define options once, but *not* instantiate them
-globally. One reason being that options with action='append' can carry state
-between parses. pip parses general options twice internally, and shouldn't
-pass on state. To be consistent, all options will follow this design.
-
-"""
-from __future__ import absolute_import
-
-from functools import partial
-from optparse import OptionGroup, SUPPRESS_HELP, Option
-import warnings
-
-from pip.index import (
-    FormatControl, fmt_ctl_handle_mutual_exclude, fmt_ctl_no_binary,
-    fmt_ctl_no_use_wheel)
-from pip.models import PyPI
-from pip.locations import USER_CACHE_DIR, src_prefix
-from pip.utils.hashes import STRONG_HASHES
-
-
-def make_option_group(group, parser):
-    """
-    Return an OptionGroup object
-    group  -- assumed to be dict with 'name' and 'options' keys
-    parser -- an optparse Parser
-    """
-    option_group = OptionGroup(parser, group['name'])
-    for option in group['options']:
-        option_group.add_option(option())
-    return option_group
-
-
-def resolve_wheel_no_use_binary(options):
-    if not options.use_wheel:
-        control = options.format_control
-        fmt_ctl_no_use_wheel(control)
-
-
-def check_install_build_global(options, check_options=None):
-    """Disable wheels if per-setup.py call options are set.
-
-    :param options: The OptionParser options to update.
-    :param check_options: The options to check, if not supplied defaults to
-        options.
-    """
-    if check_options is None:
-        check_options = options
-
-    def getname(n):
-        return getattr(check_options, n, None)
-    names = ["build_options", "global_options", "install_options"]
-    if any(map(getname, names)):
-        control = options.format_control
-        fmt_ctl_no_binary(control)
-        warnings.warn(
-            'Disabling all use of wheels due to the use of --build-options '
-            '/ --global-options / --install-options.', stacklevel=2)
-
-
-###########
-# options #
-###########
-
-help_ = partial(
-    Option,
-    '-h', '--help',
-    dest='help',
-    action='help',
-    help='Show help.')
-
-isolated_mode = partial(
-    Option,
-    "--isolated",
-    dest="isolated_mode",
-    action="store_true",
-    default=False,
-    help=(
-        "Run pip in an isolated mode, ignoring environment variables and user "
-        "configuration."
-    ),
-)
-
-require_virtualenv = partial(
-    Option,
-    # Run only if inside a virtualenv, bail if not.
-    '--require-virtualenv', '--require-venv',
-    dest='require_venv',
-    action='store_true',
-    default=False,
-    help=SUPPRESS_HELP)
-
-verbose = partial(
-    Option,
-    '-v', '--verbose',
-    dest='verbose',
-    action='count',
-    default=0,
-    help='Give more output. Option is additive, and can be used up to 3 times.'
-)
-
-version = partial(
-    Option,
-    '-V', '--version',
-    dest='version',
-    action='store_true',
-    help='Show version and exit.')
-
-quiet = partial(
-    Option,
-    '-q', '--quiet',
-    dest='quiet',
-    action='count',
-    default=0,
-    help=('Give less output. Option is additive, and can be used up to 3'
-          ' times (corresponding to WARNING, ERROR, and CRITICAL logging'
-          ' levels).')
-)
-
-log = partial(
-    Option,
-    "--log", "--log-file", "--local-log",
-    dest="log",
-    metavar="path",
-    help="Path to a verbose appending log."
-)
-
-no_input = partial(
-    Option,
-    # Don't ask for input
-    '--no-input',
-    dest='no_input',
-    action='store_true',
-    default=False,
-    help=SUPPRESS_HELP)
-
-proxy = partial(
-    Option,
-    '--proxy',
-    dest='proxy',
-    type='str',
-    default='',
-    help="Specify a proxy in the form [user:passwd@]proxy.server:port.")
-
-retries = partial(
-    Option,
-    '--retries',
-    dest='retries',
-    type='int',
-    default=5,
-    help="Maximum number of retries each connection should attempt "
-         "(default %default times).")
-
-timeout = partial(
-    Option,
-    '--timeout', '--default-timeout',
-    metavar='sec',
-    dest='timeout',
-    type='float',
-    default=15,
-    help='Set the socket timeout (default %default seconds).')
-
-default_vcs = partial(
-    Option,
-    # The default version control system for editables, e.g. 'svn'
-    '--default-vcs',
-    dest='default_vcs',
-    type='str',
-    default='',
-    help=SUPPRESS_HELP)
-
-skip_requirements_regex = partial(
-    Option,
-    # A regex to be used to skip requirements
-    '--skip-requirements-regex',
-    dest='skip_requirements_regex',
-    type='str',
-    default='',
-    help=SUPPRESS_HELP)
-
-
-def exists_action():
-    return Option(
-        # Option when path already exist
-        '--exists-action',
-        dest='exists_action',
-        type='choice',
-        choices=['s', 'i', 'w', 'b', 'a'],
-        default=[],
-        action='append',
-        metavar='action',
-        help="Default action when a path already exists: "
-        "(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.")
-
-
-cert = partial(
-    Option,
-    '--cert',
-    dest='cert',
-    type='str',
-    metavar='path',
-    help="Path to alternate CA bundle.")
-
-client_cert = partial(
-    Option,
-    '--client-cert',
-    dest='client_cert',
-    type='str',
-    default=None,
-    metavar='path',
-    help="Path to SSL client certificate, a single file containing the "
-         "private key and the certificate in PEM format.")
-
-index_url = partial(
-    Option,
-    '-i', '--index-url', '--pypi-url',
-    dest='index_url',
-    metavar='URL',
-    default=PyPI.simple_url,
-    help="Base URL of Python Package Index (default %default). "
-         "This should point to a repository compliant with PEP 503 "
-         "(the simple repository API) or a local directory laid out "
-         "in the same format.")
-
-
-def extra_index_url():
-    return Option(
-        '--extra-index-url',
-        dest='extra_index_urls',
-        metavar='URL',
-        action='append',
-        default=[],
-        help="Extra URLs of package indexes to use in addition to "
-             "--index-url. Should follow the same rules as "
-             "--index-url."
-    )
-
-
-no_index = partial(
-    Option,
-    '--no-index',
-    dest='no_index',
-    action='store_true',
-    default=False,
-    help='Ignore package index (only looking at --find-links URLs instead).')
-
-
-def find_links():
-    return Option(
-        '-f', '--find-links',
-        dest='find_links',
-        action='append',
-        default=[],
-        metavar='url',
-        help="If a url or path to an html file, then parse for links to "
-             "archives. If a local path or file:// url that's a directory, "
-             "then look for archives in the directory listing.")
-
-
-def allow_external():
-    return Option(
-        "--allow-external",
-        dest="allow_external",
-        action="append",
-        default=[],
-        metavar="PACKAGE",
-        help=SUPPRESS_HELP,
-    )
-
-
-allow_all_external = partial(
-    Option,
-    "--allow-all-external",
-    dest="allow_all_external",
-    action="store_true",
-    default=False,
-    help=SUPPRESS_HELP,
-)
-
-
-def trusted_host():
-    return Option(
-        "--trusted-host",
-        dest="trusted_hosts",
-        action="append",
-        metavar="HOSTNAME",
-        default=[],
-        help="Mark this host as trusted, even though it does not have valid "
-             "or any HTTPS.",
-    )
-
-
-# Remove after 7.0
-no_allow_external = partial(
-    Option,
-    "--no-allow-external",
-    dest="allow_all_external",
-    action="store_false",
-    default=False,
-    help=SUPPRESS_HELP,
-)
-
-
-# Remove --allow-insecure after 7.0
-def allow_unsafe():
-    return Option(
-        "--allow-unverified", "--allow-insecure",
-        dest="allow_unverified",
-        action="append",
-        default=[],
-        metavar="PACKAGE",
-        help=SUPPRESS_HELP,
-    )
-
-# Remove after 7.0
-no_allow_unsafe = partial(
-    Option,
-    "--no-allow-insecure",
-    dest="allow_all_insecure",
-    action="store_false",
-    default=False,
-    help=SUPPRESS_HELP
-)
-
-# Remove after 1.5
-process_dependency_links = partial(
-    Option,
-    "--process-dependency-links",
-    dest="process_dependency_links",
-    action="store_true",
-    default=False,
-    help="Enable the processing of dependency links.",
-)
-
-
-def constraints():
-    return Option(
-        '-c', '--constraint',
-        dest='constraints',
-        action='append',
-        default=[],
-        metavar='file',
-        help='Constrain versions using the given constraints file. '
-        'This option can be used multiple times.')
-
-
-def requirements():
-    return Option(
-        '-r', '--requirement',
-        dest='requirements',
-        action='append',
-        default=[],
-        metavar='file',
-        help='Install from the given requirements file. '
-        'This option can be used multiple times.')
-
-
-def editable():
-    return Option(
-        '-e', '--editable',
-        dest='editables',
-        action='append',
-        default=[],
-        metavar='path/url',
-        help=('Install a project in editable mode (i.e. setuptools '
-              '"develop mode") from a local project path or a VCS url.'),
-    )
-
-src = partial(
-    Option,
-    '--src', '--source', '--source-dir', '--source-directory',
-    dest='src_dir',
-    metavar='dir',
-    default=src_prefix,
-    help='Directory to check out editable projects into. '
-    'The default in a virtualenv is "<venv path>/src". '
-    'The default for global installs is "<current dir>/src".'
-)
-
-# XXX: deprecated, remove in 9.0
-use_wheel = partial(
-    Option,
-    '--use-wheel',
-    dest='use_wheel',
-    action='store_true',
-    default=True,
-    help=SUPPRESS_HELP,
-)
-
-# XXX: deprecated, remove in 9.0
-no_use_wheel = partial(
-    Option,
-    '--no-use-wheel',
-    dest='use_wheel',
-    action='store_false',
-    default=True,
-    help=('Do not Find and prefer wheel archives when searching indexes and '
-          'find-links locations. DEPRECATED in favour of --no-binary.'),
-)
-
-
-def _get_format_control(values, option):
-    """Get a format_control object."""
-    return getattr(values, option.dest)
-
-
-def _handle_no_binary(option, opt_str, value, parser):
-    existing = getattr(parser.values, option.dest)
-    fmt_ctl_handle_mutual_exclude(
-        value, existing.no_binary, existing.only_binary)
-
-
-def _handle_only_binary(option, opt_str, value, parser):
-    existing = getattr(parser.values, option.dest)
-    fmt_ctl_handle_mutual_exclude(
-        value, existing.only_binary, existing.no_binary)
-
-
-def no_binary():
-    return Option(
-        "--no-binary", dest="format_control", action="callback",
-        callback=_handle_no_binary, type="str",
-        default=FormatControl(set(), set()),
-        help="Do not use binary packages. Can be supplied multiple times, and "
-             "each time adds to the existing value. Accepts either :all: to "
-             "disable all binary packages, :none: to empty the set, or one or "
-             "more package names with commas between them. Note that some "
-             "packages are tricky to compile and may fail to install when "
-             "this option is used on them.")
-
-
-def only_binary():
-    return Option(
-        "--only-binary", dest="format_control", action="callback",
-        callback=_handle_only_binary, type="str",
-        default=FormatControl(set(), set()),
-        help="Do not use source packages. Can be supplied multiple times, and "
-             "each time adds to the existing value. Accepts either :all: to "
-             "disable all source packages, :none: to empty the set, or one or "
-             "more package names with commas between them. Packages without "
-             "binary distributions will fail to install when this option is "
-             "used on them.")
-
-
-cache_dir = partial(
-    Option,
-    "--cache-dir",
-    dest="cache_dir",
-    default=USER_CACHE_DIR,
-    metavar="dir",
-    help="Store the cache data in <dir>."
-)
-
-no_cache = partial(
-    Option,
-    "--no-cache-dir",
-    dest="cache_dir",
-    action="store_false",
-    help="Disable the cache.",
-)
-
-no_deps = partial(
-    Option,
-    '--no-deps', '--no-dependencies',
-    dest='ignore_dependencies',
-    action='store_true',
-    default=False,
-    help="Don't install package dependencies.")
-
-build_dir = partial(
-    Option,
-    '-b', '--build', '--build-dir', '--build-directory',
-    dest='build_dir',
-    metavar='dir',
-    help='Directory to unpack packages into and build in.'
-)
-
-ignore_requires_python = partial(
-    Option,
-    '--ignore-requires-python',
-    dest='ignore_requires_python',
-    action='store_true',
-    help='Ignore the Requires-Python information.')
-
-install_options = partial(
-    Option,
-    '--install-option',
-    dest='install_options',
-    action='append',
-    metavar='options',
-    help="Extra arguments to be supplied to the setup.py install "
-         "command (use like --install-option=\"--install-scripts=/usr/local/"
-         "bin\"). Use multiple --install-option options to pass multiple "
-         "options to setup.py install. If you are using an option with a "
-         "directory path, be sure to use absolute path.")
-
-global_options = partial(
-    Option,
-    '--global-option',
-    dest='global_options',
-    action='append',
-    metavar='options',
-    help="Extra global options to be supplied to the setup.py "
-         "call before the install command.")
-
-no_clean = partial(
-    Option,
-    '--no-clean',
-    action='store_true',
-    default=False,
-    help="Don't clean up build directories.")
-
-pre = partial(
-    Option,
-    '--pre',
-    action='store_true',
-    default=False,
-    help="Include pre-release and development versions. By default, "
-         "pip only finds stable versions.")
-
-disable_pip_version_check = partial(
-    Option,
-    "--disable-pip-version-check",
-    dest="disable_pip_version_check",
-    action="store_true",
-    default=True,
-    help="Don't periodically check PyPI to determine whether a new version "
-         "of pip is available for download. Implied with --no-index.")
-
-# Deprecated, Remove later
-always_unzip = partial(
-    Option,
-    '-Z', '--always-unzip',
-    dest='always_unzip',
-    action='store_true',
-    help=SUPPRESS_HELP,
-)
-
-
-def _merge_hash(option, opt_str, value, parser):
-    """Given a value spelled "algo:digest", append the digest to a list
-    pointed to in a dict by the algo name."""
-    if not parser.values.hashes:
-        parser.values.hashes = {}
-    try:
-        algo, digest = value.split(':', 1)
-    except ValueError:
-        parser.error('Arguments to %s must be a hash name '
-                     'followed by a value, like --hash=sha256:abcde...' %
-                     opt_str)
-    if algo not in STRONG_HASHES:
-        parser.error('Allowed hash algorithms for %s are %s.' %
-                     (opt_str, ', '.join(STRONG_HASHES)))
-    parser.values.hashes.setdefault(algo, []).append(digest)
-
-
-hash = partial(
-    Option,
-    '--hash',
-    # Hash values eventually end up in InstallRequirement.hashes due to
-    # __dict__ copying in process_line().
-    dest='hashes',
-    action='callback',
-    callback=_merge_hash,
-    type='string',
-    help="Verify that the package's archive matches this "
-         'hash before installing. Example: --hash=sha256:abcdef...')
-
-
-require_hashes = partial(
-    Option,
-    '--require-hashes',
-    dest='require_hashes',
-    action='store_true',
-    default=False,
-    help='Require a hash to check each requirement against, for '
-         'repeatable installs. This option is implied when any package in a '
-         'requirements file has a --hash option.')
-
-
-##########
-# groups #
-##########
-
-general_group = {
-    'name': 'General Options',
-    'options': [
-        help_,
-        isolated_mode,
-        require_virtualenv,
-        verbose,
-        version,
-        quiet,
-        log,
-        no_input,
-        proxy,
-        retries,
-        timeout,
-        default_vcs,
-        skip_requirements_regex,
-        exists_action,
-        trusted_host,
-        cert,
-        client_cert,
-        cache_dir,
-        no_cache,
-        disable_pip_version_check,
-    ]
-}
-
-non_deprecated_index_group = {
-    'name': 'Package Index Options',
-    'options': [
-        index_url,
-        extra_index_url,
-        no_index,
-        find_links,
-        process_dependency_links,
-    ]
-}
-
-index_group = {
-    'name': 'Package Index Options (including deprecated options)',
-    'options': non_deprecated_index_group['options'] + [
-        allow_external,
-        allow_all_external,
-        no_allow_external,
-        allow_unsafe,
-        no_allow_unsafe,
-    ]
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__init__.py
deleted file mode 100644
index 62c64ebed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__init__.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""
-Package containing all pip commands
-"""
-from __future__ import absolute_import
-
-from pip.commands.completion import CompletionCommand
-from pip.commands.download import DownloadCommand
-from pip.commands.freeze import FreezeCommand
-from pip.commands.hash import HashCommand
-from pip.commands.help import HelpCommand
-from pip.commands.list import ListCommand
-from pip.commands.check import CheckCommand
-from pip.commands.search import SearchCommand
-from pip.commands.show import ShowCommand
-from pip.commands.install import InstallCommand
-from pip.commands.uninstall import UninstallCommand
-from pip.commands.wheel import WheelCommand
-
-
-commands_dict = {
-    CompletionCommand.name: CompletionCommand,
-    FreezeCommand.name: FreezeCommand,
-    HashCommand.name: HashCommand,
-    HelpCommand.name: HelpCommand,
-    SearchCommand.name: SearchCommand,
-    ShowCommand.name: ShowCommand,
-    InstallCommand.name: InstallCommand,
-    UninstallCommand.name: UninstallCommand,
-    DownloadCommand.name: DownloadCommand,
-    ListCommand.name: ListCommand,
-    CheckCommand.name: CheckCommand,
-    WheelCommand.name: WheelCommand,
-}
-
-
-commands_order = [
-    InstallCommand,
-    DownloadCommand,
-    UninstallCommand,
-    FreezeCommand,
-    ListCommand,
-    ShowCommand,
-    CheckCommand,
-    SearchCommand,
-    WheelCommand,
-    HashCommand,
-    CompletionCommand,
-    HelpCommand,
-]
-
-
-def get_summaries(ordered=True):
-    """Yields sorted (command name, command summary) tuples."""
-
-    if ordered:
-        cmditems = _sort_commands(commands_dict, commands_order)
-    else:
-        cmditems = commands_dict.items()
-
-    for name, command_class in cmditems:
-        yield (name, command_class.summary)
-
-
-def get_similar_commands(name):
-    """Command name auto-correct."""
-    from difflib import get_close_matches
-
-    name = name.lower()
-
-    close_commands = get_close_matches(name, commands_dict.keys())
-
-    if close_commands:
-        return close_commands[0]
-    else:
-        return False
-
-
-def _sort_commands(cmddict, order):
-    def keyfn(key):
-        try:
-            return order.index(key[1])
-        except ValueError:
-            # unordered items should come last
-            return 0xff
-
-    return sorted(cmddict.items(), key=keyfn)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 4a41ad799..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/check.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/check.cpython-35.pyc
deleted file mode 100644
index c17460cd8..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/check.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/completion.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/completion.cpython-35.pyc
deleted file mode 100644
index 9c166d2c3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/completion.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/download.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/download.cpython-35.pyc
deleted file mode 100644
index a5aa8c82d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/download.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/freeze.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/freeze.cpython-35.pyc
deleted file mode 100644
index dbf11a51e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/freeze.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/hash.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/hash.cpython-35.pyc
deleted file mode 100644
index d53d45f44..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/hash.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/help.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/help.cpython-35.pyc
deleted file mode 100644
index bee844aa4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/help.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/install.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/install.cpython-35.pyc
deleted file mode 100644
index bc6b6dbce..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/install.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/list.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/list.cpython-35.pyc
deleted file mode 100644
index 2e02bc850..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/list.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/search.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/search.cpython-35.pyc
deleted file mode 100644
index b76801714..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/search.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/show.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/show.cpython-35.pyc
deleted file mode 100644
index b4944fc41..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/show.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/uninstall.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/uninstall.cpython-35.pyc
deleted file mode 100644
index 4a68c85ed..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/uninstall.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/wheel.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/wheel.cpython-35.pyc
deleted file mode 100644
index 52c7c9cd8..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/__pycache__/wheel.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/check.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/check.py
deleted file mode 100644
index 70458adf4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/check.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import logging
-
-from pip.basecommand import Command
-from pip.operations.check import check_requirements
-from pip.utils import get_installed_distributions
-
-
-logger = logging.getLogger(__name__)
-
-
-class CheckCommand(Command):
-    """Verify installed packages have compatible dependencies."""
-    name = 'check'
-    usage = """
-      %prog [options]"""
-    summary = 'Verify installed packages have compatible dependencies.'
-
-    def run(self, options, args):
-        dists = get_installed_distributions(local_only=False, skip=())
-        missing_reqs_dict, incompatible_reqs_dict = check_requirements(dists)
-
-        for dist in dists:
-            key = '%s==%s' % (dist.project_name, dist.version)
-
-            for requirement in missing_reqs_dict.get(key, []):
-                logger.info(
-                    "%s %s requires %s, which is not installed.",
-                    dist.project_name, dist.version, requirement.project_name)
-
-            for requirement, actual in incompatible_reqs_dict.get(key, []):
-                logger.info(
-                    "%s %s has requirement %s, but you have %s %s.",
-                    dist.project_name, dist.version, requirement,
-                    actual.project_name, actual.version)
-
-        if missing_reqs_dict or incompatible_reqs_dict:
-            return 1
-        else:
-            logger.info("No broken requirements found.")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/completion.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/completion.py
deleted file mode 100644
index 66e41a679..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/completion.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from __future__ import absolute_import
-
-import sys
-from pip.basecommand import Command
-
-BASE_COMPLETION = """
-# pip %(shell)s completion start%(script)s# pip %(shell)s completion end
-"""
-
-COMPLETION_SCRIPTS = {
-    'bash': """
-_pip_completion()
-{
-    COMPREPLY=( $( COMP_WORDS="${COMP_WORDS[*]}" \\
-                   COMP_CWORD=$COMP_CWORD \\
-                   PIP_AUTO_COMPLETE=1 $1 ) )
-}
-complete -o default -F _pip_completion pip
-""", 'zsh': """
-function _pip_completion {
-  local words cword
-  read -Ac words
-  read -cn cword
-  reply=( $( COMP_WORDS="$words[*]" \\
-             COMP_CWORD=$(( cword-1 )) \\
-             PIP_AUTO_COMPLETE=1 $words[1] ) )
-}
-compctl -K _pip_completion pip
-""", 'fish': """
-function __fish_complete_pip
-    set -lx COMP_WORDS (commandline -o) ""
-    set -lx COMP_CWORD (math (contains -i -- (commandline -t) $COMP_WORDS)-1)
-    set -lx PIP_AUTO_COMPLETE 1
-    string split \  -- (eval $COMP_WORDS[1])
-end
-complete -fa "(__fish_complete_pip)" -c pip
-"""}
-
-
-class CompletionCommand(Command):
-    """A helper command to be used for command completion."""
-    name = 'completion'
-    summary = 'A helper command used for command completion.'
-
-    def __init__(self, *args, **kw):
-        super(CompletionCommand, self).__init__(*args, **kw)
-
-        cmd_opts = self.cmd_opts
-
-        cmd_opts.add_option(
-            '--bash', '-b',
-            action='store_const',
-            const='bash',
-            dest='shell',
-            help='Emit completion code for bash')
-        cmd_opts.add_option(
-            '--zsh', '-z',
-            action='store_const',
-            const='zsh',
-            dest='shell',
-            help='Emit completion code for zsh')
-        cmd_opts.add_option(
-            '--fish', '-f',
-            action='store_const',
-            const='fish',
-            dest='shell',
-            help='Emit completion code for fish')
-
-        self.parser.insert_option_group(0, cmd_opts)
-
-    def run(self, options, args):
-        """Prints the completion code of the given shell"""
-        shells = COMPLETION_SCRIPTS.keys()
-        shell_options = ['--' + shell for shell in sorted(shells)]
-        if options.shell in shells:
-            script = COMPLETION_SCRIPTS.get(options.shell, '')
-            print(BASE_COMPLETION % {'script': script, 'shell': options.shell})
-        else:
-            sys.stderr.write(
-                'ERROR: You must pass %s\n' % ' or '.join(shell_options)
-            )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/download.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/download.py
deleted file mode 100644
index 4bc064087..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/download.py
+++ /dev/null
@@ -1,212 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-
-from pip.exceptions import CommandError
-from pip.index import FormatControl
-from pip.req import RequirementSet
-from pip.basecommand import RequirementCommand
-from pip import cmdoptions
-from pip.utils import ensure_dir, normalize_path
-from pip.utils.build import BuildDirectory
-from pip.utils.filesystem import check_path_owner
-
-
-logger = logging.getLogger(__name__)
-
-
-class DownloadCommand(RequirementCommand):
-    """
-    Download packages from:
-
-    - PyPI (and other indexes) using requirement specifiers.
-    - VCS project urls.
-    - Local project directories.
-    - Local or remote source archives.
-
-    pip also supports downloading from "requirements files", which provide
-    an easy way to specify a whole environment to be downloaded.
-    """
-    name = 'download'
-
-    usage = """
-      %prog [options] <requirement specifier> [package-index-options] ...
-      %prog [options] -r <requirements file> [package-index-options] ...
-      %prog [options] [-e] <vcs project url> ...
-      %prog [options] [-e] <local project path> ...
-      %prog [options] <archive url/path> ..."""
-
-    summary = 'Download packages.'
-
-    def __init__(self, *args, **kw):
-        super(DownloadCommand, self).__init__(*args, **kw)
-
-        cmd_opts = self.cmd_opts
-
-        cmd_opts.add_option(cmdoptions.constraints())
-        cmd_opts.add_option(cmdoptions.editable())
-        cmd_opts.add_option(cmdoptions.requirements())
-        cmd_opts.add_option(cmdoptions.build_dir())
-        cmd_opts.add_option(cmdoptions.no_deps())
-        cmd_opts.add_option(cmdoptions.global_options())
-        cmd_opts.add_option(cmdoptions.no_binary())
-        cmd_opts.add_option(cmdoptions.only_binary())
-        cmd_opts.add_option(cmdoptions.src())
-        cmd_opts.add_option(cmdoptions.pre())
-        cmd_opts.add_option(cmdoptions.no_clean())
-        cmd_opts.add_option(cmdoptions.require_hashes())
-
-        cmd_opts.add_option(
-            '-d', '--dest', '--destination-dir', '--destination-directory',
-            dest='download_dir',
-            metavar='dir',
-            default=os.curdir,
-            help=("Download packages into <dir>."),
-        )
-
-        cmd_opts.add_option(
-            '--platform',
-            dest='platform',
-            metavar='platform',
-            default=None,
-            help=("Only download wheels compatible with <platform>. "
-                  "Defaults to the platform of the running system."),
-        )
-
-        cmd_opts.add_option(
-            '--python-version',
-            dest='python_version',
-            metavar='python_version',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "interpreter version <version>. If not specified, then the "
-                  "current system interpreter minor version is used. A major "
-                  "version (e.g. '2') can be specified to match all "
-                  "minor revs of that major version.  A minor version "
-                  "(e.g. '34') can also be specified."),
-        )
-
-        cmd_opts.add_option(
-            '--implementation',
-            dest='implementation',
-            metavar='implementation',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
-                  " or 'ip'. If not specified, then the current "
-                  "interpreter implementation is used.  Use 'py' to force "
-                  "implementation-agnostic wheels."),
-        )
-
-        cmd_opts.add_option(
-            '--abi',
-            dest='abi',
-            metavar='abi',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "abi <abi>, e.g. 'pypy_41'.  If not specified, then the "
-                  "current interpreter abi tag is used.  Generally "
-                  "you will need to specify --implementation, "
-                  "--platform, and --python-version when using "
-                  "this option."),
-        )
-
-        index_opts = cmdoptions.make_option_group(
-            cmdoptions.non_deprecated_index_group,
-            self.parser,
-        )
-
-        self.parser.insert_option_group(0, index_opts)
-        self.parser.insert_option_group(0, cmd_opts)
-
-    def run(self, options, args):
-        options.ignore_installed = True
-
-        if options.python_version:
-            python_versions = [options.python_version]
-        else:
-            python_versions = None
-
-        dist_restriction_set = any([
-            options.python_version,
-            options.platform,
-            options.abi,
-            options.implementation,
-        ])
-        binary_only = FormatControl(set(), set([':all:']))
-        if dist_restriction_set and options.format_control != binary_only:
-            raise CommandError(
-                "--only-binary=:all: must be set and --no-binary must not "
-                "be set (or must be set to :none:) when restricting platform "
-                "and interpreter constraints using --python-version, "
-                "--platform, --abi, or --implementation."
-            )
-
-        options.src_dir = os.path.abspath(options.src_dir)
-        options.download_dir = normalize_path(options.download_dir)
-
-        ensure_dir(options.download_dir)
-
-        with self._build_session(options) as session:
-            finder = self._build_package_finder(
-                options=options,
-                session=session,
-                platform=options.platform,
-                python_versions=python_versions,
-                abi=options.abi,
-                implementation=options.implementation,
-            )
-            build_delete = (not (options.no_clean or options.build_dir))
-            if options.cache_dir and not check_path_owner(options.cache_dir):
-                logger.warning(
-                    "The directory '%s' or its parent directory is not owned "
-                    "by the current user and caching wheels has been "
-                    "disabled. check the permissions and owner of that "
-                    "directory. If executing pip with sudo, you may want "
-                    "sudo's -H flag.",
-                    options.cache_dir,
-                )
-                options.cache_dir = None
-
-            with BuildDirectory(options.build_dir,
-                                delete=build_delete) as build_dir:
-
-                requirement_set = RequirementSet(
-                    build_dir=build_dir,
-                    src_dir=options.src_dir,
-                    download_dir=options.download_dir,
-                    ignore_installed=True,
-                    ignore_dependencies=options.ignore_dependencies,
-                    session=session,
-                    isolated=options.isolated_mode,
-                    require_hashes=options.require_hashes
-                )
-                self.populate_requirement_set(
-                    requirement_set,
-                    args,
-                    options,
-                    finder,
-                    session,
-                    self.name,
-                    None
-                )
-
-                if not requirement_set.has_requirements:
-                    return
-
-                requirement_set.prepare_files(finder)
-
-                downloaded = ' '.join([
-                    req.name for req in requirement_set.successfully_downloaded
-                ])
-                if downloaded:
-                    logger.info(
-                        'Successfully downloaded %s', downloaded
-                    )
-
-                # Clean up
-                if not options.no_clean:
-                    requirement_set.cleanup_files()
-
-        return requirement_set
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/freeze.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/freeze.py
deleted file mode 100644
index c19879619..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/freeze.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from __future__ import absolute_import
-
-import sys
-
-import pip
-from pip.compat import stdlib_pkgs
-from pip.basecommand import Command
-from pip.operations.freeze import freeze
-from pip.wheel import WheelCache
-
-
-DEV_PKGS = ('pip', 'setuptools', 'distribute', 'wheel')
-
-
-class FreezeCommand(Command):
-    """
-    Output installed packages in requirements format.
-
-    packages are listed in a case-insensitive sorted order.
-    """
-    name = 'freeze'
-    usage = """
-      %prog [options]"""
-    summary = 'Output installed packages in requirements format.'
-    log_streams = ("ext://sys.stderr", "ext://sys.stderr")
-
-    def __init__(self, *args, **kw):
-        super(FreezeCommand, self).__init__(*args, **kw)
-
-        self.cmd_opts.add_option(
-            '-r', '--requirement',
-            dest='requirements',
-            action='append',
-            default=[],
-            metavar='file',
-            help="Use the order in the given requirements file and its "
-                 "comments when generating output. This option can be "
-                 "used multiple times.")
-        self.cmd_opts.add_option(
-            '-f', '--find-links',
-            dest='find_links',
-            action='append',
-            default=[],
-            metavar='URL',
-            help='URL for finding packages, which will be added to the '
-                 'output.')
-        self.cmd_opts.add_option(
-            '-l', '--local',
-            dest='local',
-            action='store_true',
-            default=False,
-            help='If in a virtualenv that has global access, do not output '
-                 'globally-installed packages.')
-        self.cmd_opts.add_option(
-            '--user',
-            dest='user',
-            action='store_true',
-            default=False,
-            help='Only output packages installed in user-site.')
-        self.cmd_opts.add_option(
-            '--all',
-            dest='freeze_all',
-            action='store_true',
-            help='Do not skip these packages in the output:'
-                 ' %s' % ', '.join(DEV_PKGS))
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options, args):
-        format_control = pip.index.FormatControl(set(), set())
-        wheel_cache = WheelCache(options.cache_dir, format_control)
-        skip = set(stdlib_pkgs)
-        if not options.freeze_all:
-            skip.update(DEV_PKGS)
-
-        freeze_kwargs = dict(
-            requirement=options.requirements,
-            find_links=options.find_links,
-            local_only=options.local,
-            user_only=options.user,
-            skip_regex=options.skip_requirements_regex,
-            isolated=options.isolated_mode,
-            wheel_cache=wheel_cache,
-            skip=skip)
-
-        for line in freeze(**freeze_kwargs):
-            sys.stdout.write(line + '\n')
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/hash.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/hash.py
deleted file mode 100644
index 27cca0bfa..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/hash.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from __future__ import absolute_import
-
-import hashlib
-import logging
-import sys
-
-from pip.basecommand import Command
-from pip.status_codes import ERROR
-from pip.utils import read_chunks
-from pip.utils.hashes import FAVORITE_HASH, STRONG_HASHES
-
-
-logger = logging.getLogger(__name__)
-
-
-class HashCommand(Command):
-    """
-    Compute a hash of a local package archive.
-
-    These can be used with --hash in a requirements file to do repeatable
-    installs.
-
-    """
-    name = 'hash'
-    usage = '%prog [options] <file> ...'
-    summary = 'Compute hashes of package archives.'
-
-    def __init__(self, *args, **kw):
-        super(HashCommand, self).__init__(*args, **kw)
-        self.cmd_opts.add_option(
-            '-a', '--algorithm',
-            dest='algorithm',
-            choices=STRONG_HASHES,
-            action='store',
-            default=FAVORITE_HASH,
-            help='The hash algorithm to use: one of %s' %
-                 ', '.join(STRONG_HASHES))
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options, args):
-        if not args:
-            self.parser.print_usage(sys.stderr)
-            return ERROR
-
-        algorithm = options.algorithm
-        for path in args:
-            logger.info('%s:\n--hash=%s:%s',
-                        path, algorithm, _hash_of_file(path, algorithm))
-
-
-def _hash_of_file(path, algorithm):
-    """Return the hash digest of a file."""
-    with open(path, 'rb') as archive:
-        hash = hashlib.new(algorithm)
-        for chunk in read_chunks(archive):
-            hash.update(chunk)
-    return hash.hexdigest()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/help.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/help.py
deleted file mode 100644
index 11722f1e0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/help.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from __future__ import absolute_import
-
-from pip.basecommand import Command, SUCCESS
-from pip.exceptions import CommandError
-
-
-class HelpCommand(Command):
-    """Show help for commands"""
-    name = 'help'
-    usage = """
-      %prog <command>"""
-    summary = 'Show help for commands.'
-
-    def run(self, options, args):
-        from pip.commands import commands_dict, get_similar_commands
-
-        try:
-            # 'pip help' with no args is handled by pip.__init__.parseopt()
-            cmd_name = args[0]  # the command we need help for
-        except IndexError:
-            return SUCCESS
-
-        if cmd_name not in commands_dict:
-            guess = get_similar_commands(cmd_name)
-
-            msg = ['unknown command "%s"' % cmd_name]
-            if guess:
-                msg.append('maybe you meant "%s"' % guess)
-
-            raise CommandError(' - '.join(msg))
-
-        command = commands_dict[cmd_name]()
-        command.parser.print_help()
-
-        return SUCCESS
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/install.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/install.py
deleted file mode 100644
index 39292b117..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/install.py
+++ /dev/null
@@ -1,455 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import operator
-import os
-import tempfile
-import shutil
-import warnings
-try:
-    import wheel
-except ImportError:
-    wheel = None
-
-from pip.req import RequirementSet
-from pip.basecommand import RequirementCommand
-from pip.locations import virtualenv_no_global, distutils_scheme
-from pip.exceptions import (
-    InstallationError, CommandError, PreviousBuildDirError,
-)
-from pip import cmdoptions
-from pip.utils import ensure_dir, get_installed_version
-from pip.utils.build import BuildDirectory
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip.utils.filesystem import check_path_owner
-from pip.wheel import WheelCache, WheelBuilder
-
-from pip.locations import running_under_virtualenv
-
-logger = logging.getLogger(__name__)
-
-
-class InstallCommand(RequirementCommand):
-    """
-    Install packages from:
-
-    - PyPI (and other indexes) using requirement specifiers.
-    - VCS project urls.
-    - Local project directories.
-    - Local or remote source archives.
-
-    pip also supports installing from "requirements files", which provide
-    an easy way to specify a whole environment to be installed.
-    """
-    name = 'install'
-
-    usage = """
-      %prog [options] <requirement specifier> [package-index-options] ...
-      %prog [options] -r <requirements file> [package-index-options] ...
-      %prog [options] [-e] <vcs project url> ...
-      %prog [options] [-e] <local project path> ...
-      %prog [options] <archive url/path> ..."""
-
-    summary = 'Install packages.'
-
-    def __init__(self, *args, **kw):
-        super(InstallCommand, self).__init__(*args, **kw)
-
-        default_user = True
-        if running_under_virtualenv():
-            default_user = False
-        if os.geteuid() == 0:
-            default_user = False
-
-        cmd_opts = self.cmd_opts
-
-        cmd_opts.add_option(cmdoptions.constraints())
-        cmd_opts.add_option(cmdoptions.editable())
-        cmd_opts.add_option(cmdoptions.requirements())
-        cmd_opts.add_option(cmdoptions.build_dir())
-
-        cmd_opts.add_option(
-            '-t', '--target',
-            dest='target_dir',
-            metavar='dir',
-            default=None,
-            help='Install packages into <dir>. '
-                 'By default this will not replace existing files/folders in '
-                 '<dir>. Use --upgrade to replace existing packages in <dir> '
-                 'with new versions.'
-        )
-
-        cmd_opts.add_option(
-            '-d', '--download', '--download-dir', '--download-directory',
-            dest='download_dir',
-            metavar='dir',
-            default=None,
-            help=("Download packages into <dir> instead of installing them, "
-                  "regardless of what's already installed."),
-        )
-
-        cmd_opts.add_option(cmdoptions.src())
-
-        cmd_opts.add_option(
-            '-U', '--upgrade',
-            dest='upgrade',
-            action='store_true',
-            help='Upgrade all specified packages to the newest available '
-                 'version. The handling of dependencies depends on the '
-                 'upgrade-strategy used.'
-        )
-
-        cmd_opts.add_option(
-            '--upgrade-strategy',
-            dest='upgrade_strategy',
-            default='eager',
-            choices=['only-if-needed', 'eager'],
-            help='Determines how dependency upgrading should be handled. '
-                 '"eager" - dependencies are upgraded regardless of '
-                 'whether the currently installed version satisfies the '
-                 'requirements of the upgraded package(s). '
-                 '"only-if-needed" -  are upgraded only when they do not '
-                 'satisfy the requirements of the upgraded package(s).'
-        )
-
-        cmd_opts.add_option(
-            '--force-reinstall',
-            dest='force_reinstall',
-            action='store_true',
-            help='When upgrading, reinstall all packages even if they are '
-                 'already up-to-date.')
-
-        cmd_opts.add_option(
-            '-I', '--ignore-installed',
-            dest='ignore_installed',
-            action='store_true',
-            default=default_user,
-            help='Ignore the installed packages (reinstalling instead).')
-
-        cmd_opts.add_option(cmdoptions.ignore_requires_python())
-        cmd_opts.add_option(cmdoptions.no_deps())
-
-        cmd_opts.add_option(cmdoptions.install_options())
-        cmd_opts.add_option(cmdoptions.global_options())
-
-        cmd_opts.add_option(
-            '--user',
-            dest='use_user_site',
-            action='store_true',
-            default=default_user,
-            help="Install to the Python user install directory for your "
-                 "platform. Typically ~/.local/, or %APPDATA%\Python on "
-                 "Windows. (See the Python documentation for site.USER_BASE "
-                 "for full details.)  On Debian systems, this is the "
-                 "default when running outside of a virtual environment "
-                 "and not as root.")
-
-        cmd_opts.add_option(
-            '--system',
-            dest='use_user_site',
-            action='store_false',
-            help="Install using the system scheme (overrides --user on "
-                 "Debian systems)")
-
-        cmd_opts.add_option(
-            '--egg',
-            dest='as_egg',
-            action='store_true',
-            help="Install packages as eggs, not 'flat', like pip normally "
-                 "does. This option is not about installing *from* eggs. "
-                 "(WARNING: Because this option overrides pip's normal install"
-                 " logic, requirements files may not behave as expected.)")
-
-        cmd_opts.add_option(
-            '--root',
-            dest='root_path',
-            metavar='dir',
-            default=None,
-            help="Install everything relative to this alternate root "
-                 "directory.")
-
-        cmd_opts.add_option(
-            '--prefix',
-            dest='prefix_path',
-            metavar='dir',
-            default=None,
-            help="Installation prefix where lib, bin and other top-level "
-                 "folders are placed")
-
-        cmd_opts.add_option(
-            "--compile",
-            action="store_true",
-            dest="compile",
-            default=True,
-            help="Compile py files to pyc",
-        )
-
-        cmd_opts.add_option(
-            "--no-compile",
-            action="store_false",
-            dest="compile",
-            help="Do not compile py files to pyc",
-        )
-
-        cmd_opts.add_option(cmdoptions.use_wheel())
-        cmd_opts.add_option(cmdoptions.no_use_wheel())
-        cmd_opts.add_option(cmdoptions.no_binary())
-        cmd_opts.add_option(cmdoptions.only_binary())
-        cmd_opts.add_option(cmdoptions.pre())
-        cmd_opts.add_option(cmdoptions.no_clean())
-        cmd_opts.add_option(cmdoptions.require_hashes())
-
-        index_opts = cmdoptions.make_option_group(
-            cmdoptions.index_group,
-            self.parser,
-        )
-
-        self.parser.insert_option_group(0, index_opts)
-        self.parser.insert_option_group(0, cmd_opts)
-
-    def run(self, options, args):
-        cmdoptions.resolve_wheel_no_use_binary(options)
-        cmdoptions.check_install_build_global(options)
-
-        if options.as_egg:
-            warnings.warn(
-                "--egg has been deprecated and will be removed in the future. "
-                "This flag is mutually exclusive with large parts of pip, and "
-                "actually using it invalidates pip's ability to manage the "
-                "installation process.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_external:
-            warnings.warn(
-                "--allow-external has been deprecated and will be removed in "
-                "the future. Due to changes in the repository protocol, it no "
-                "longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_all_external:
-            warnings.warn(
-                "--allow-all-external has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_unverified:
-            warnings.warn(
-                "--allow-unverified has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.download_dir:
-            warnings.warn(
-                "pip install --download has been deprecated and will be "
-                "removed in the future. Pip now has a download command that "
-                "should be used instead.",
-                RemovedInPip10Warning,
-            )
-            options.ignore_installed = True
-
-        if options.build_dir:
-            options.build_dir = os.path.abspath(options.build_dir)
-
-        options.src_dir = os.path.abspath(options.src_dir)
-        install_options = options.install_options or []
-        if options.use_user_site:
-            if options.prefix_path:
-                raise CommandError(
-                    "Can not combine '--user' and '--prefix' as they imply "
-                    "different installation locations"
-                )
-            if virtualenv_no_global():
-                raise InstallationError(
-                    "Can not perform a '--user' install. User site-packages "
-                    "are not visible in this virtualenv."
-                )
-            install_options.append('--user')
-            install_options.append('--prefix=')
-
-        temp_target_dir = None
-        if options.target_dir:
-            options.ignore_installed = True
-            temp_target_dir = tempfile.mkdtemp()
-            options.target_dir = os.path.abspath(options.target_dir)
-            if (os.path.exists(options.target_dir) and not
-                    os.path.isdir(options.target_dir)):
-                raise CommandError(
-                    "Target path exists but is not a directory, will not "
-                    "continue."
-                )
-            install_options.append('--home=' + temp_target_dir)
-
-        global_options = options.global_options or []
-
-        with self._build_session(options) as session:
-
-            finder = self._build_package_finder(options, session)
-            build_delete = (not (options.no_clean or options.build_dir))
-            wheel_cache = WheelCache(options.cache_dir, options.format_control)
-            if options.cache_dir and not check_path_owner(options.cache_dir):
-                logger.warning(
-                    "The directory '%s' or its parent directory is not owned "
-                    "by the current user and caching wheels has been "
-                    "disabled. check the permissions and owner of that "
-                    "directory. If executing pip with sudo, you may want "
-                    "sudo's -H flag.",
-                    options.cache_dir,
-                )
-                options.cache_dir = None
-
-            with BuildDirectory(options.build_dir,
-                                delete=build_delete) as build_dir:
-                requirement_set = RequirementSet(
-                    build_dir=build_dir,
-                    src_dir=options.src_dir,
-                    download_dir=options.download_dir,
-                    upgrade=options.upgrade,
-                    upgrade_strategy=options.upgrade_strategy,
-                    as_egg=options.as_egg,
-                    ignore_installed=options.ignore_installed,
-                    ignore_dependencies=options.ignore_dependencies,
-                    ignore_requires_python=options.ignore_requires_python,
-                    force_reinstall=options.force_reinstall,
-                    use_user_site=options.use_user_site,
-                    target_dir=temp_target_dir,
-                    session=session,
-                    pycompile=options.compile,
-                    isolated=options.isolated_mode,
-                    wheel_cache=wheel_cache,
-                    require_hashes=options.require_hashes,
-                )
-
-                self.populate_requirement_set(
-                    requirement_set, args, options, finder, session, self.name,
-                    wheel_cache
-                )
-
-                if not requirement_set.has_requirements:
-                    return
-
-                try:
-                    if (options.download_dir or not wheel or not
-                            options.cache_dir):
-                        # on -d don't do complex things like building
-                        # wheels, and don't try to build wheels when wheel is
-                        # not installed.
-                        requirement_set.prepare_files(finder)
-                    else:
-                        # build wheels before install.
-                        wb = WheelBuilder(
-                            requirement_set,
-                            finder,
-                            build_options=[],
-                            global_options=[],
-                        )
-                        # Ignore the result: a failed wheel will be
-                        # installed from the sdist/vcs whatever.
-                        wb.build(autobuilding=True)
-
-                    if not options.download_dir:
-                        requirement_set.install(
-                            install_options,
-                            global_options,
-                            root=options.root_path,
-                            prefix=options.prefix_path,
-                        )
-
-                        possible_lib_locations = get_lib_location_guesses(
-                            user=options.use_user_site,
-                            home=temp_target_dir,
-                            root=options.root_path,
-                            prefix=options.prefix_path,
-                            isolated=options.isolated_mode,
-                        )
-                        reqs = sorted(
-                            requirement_set.successfully_installed,
-                            key=operator.attrgetter('name'))
-                        items = []
-                        for req in reqs:
-                            item = req.name
-                            try:
-                                installed_version = get_installed_version(
-                                    req.name, possible_lib_locations
-                                )
-                                if installed_version:
-                                    item += '-' + installed_version
-                            except Exception:
-                                pass
-                            items.append(item)
-                        installed = ' '.join(items)
-                        if installed:
-                            logger.info('Successfully installed %s', installed)
-                    else:
-                        downloaded = ' '.join([
-                            req.name
-                            for req in requirement_set.successfully_downloaded
-                        ])
-                        if downloaded:
-                            logger.info(
-                                'Successfully downloaded %s', downloaded
-                            )
-                except PreviousBuildDirError:
-                    options.no_clean = True
-                    raise
-                finally:
-                    # Clean up
-                    if not options.no_clean:
-                        requirement_set.cleanup_files()
-
-        if options.target_dir:
-            ensure_dir(options.target_dir)
-
-            # Checking both purelib and platlib directories for installed
-            # packages to be moved to target directory
-            lib_dir_list = []
-
-            purelib_dir = distutils_scheme('', home=temp_target_dir)['purelib']
-            platlib_dir = distutils_scheme('', home=temp_target_dir)['platlib']
-
-            if os.path.exists(purelib_dir):
-                lib_dir_list.append(purelib_dir)
-            if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
-                lib_dir_list.append(platlib_dir)
-
-            for lib_dir in lib_dir_list:
-                for item in os.listdir(lib_dir):
-                    target_item_dir = os.path.join(options.target_dir, item)
-                    if os.path.exists(target_item_dir):
-                        if not options.upgrade:
-                            logger.warning(
-                                'Target directory %s already exists. Specify '
-                                '--upgrade to force replacement.',
-                                target_item_dir
-                            )
-                            continue
-                        if os.path.islink(target_item_dir):
-                            logger.warning(
-                                'Target directory %s already exists and is '
-                                'a link. Pip will not automatically replace '
-                                'links, please remove if replacement is '
-                                'desired.',
-                                target_item_dir
-                            )
-                            continue
-                        if os.path.isdir(target_item_dir):
-                            shutil.rmtree(target_item_dir)
-                        else:
-                            os.remove(target_item_dir)
-
-                    shutil.move(
-                        os.path.join(lib_dir, item),
-                        target_item_dir
-                    )
-            shutil.rmtree(temp_target_dir)
-        return requirement_set
-
-
-def get_lib_location_guesses(*args, **kwargs):
-    scheme = distutils_scheme('', *args, **kwargs)
-    return [scheme['purelib'], scheme['platlib']]
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/list.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/list.py
deleted file mode 100644
index 6f6995d70..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/list.py
+++ /dev/null
@@ -1,337 +0,0 @@
-from __future__ import absolute_import
-
-import json
-import logging
-import warnings
-try:
-    from itertools import zip_longest
-except ImportError:
-    from itertools import izip_longest as zip_longest
-
-from pip._vendor import six
-
-from pip.basecommand import Command
-from pip.exceptions import CommandError
-from pip.index import PackageFinder
-from pip.utils import (
-    get_installed_distributions, dist_is_editable)
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip.cmdoptions import make_option_group, index_group
-
-logger = logging.getLogger(__name__)
-
-
-class ListCommand(Command):
-    """
-    List installed packages, including editables.
-
-    Packages are listed in a case-insensitive sorted order.
-    """
-    name = 'list'
-    usage = """
-      %prog [options]"""
-    summary = 'List installed packages.'
-
-    def __init__(self, *args, **kw):
-        super(ListCommand, self).__init__(*args, **kw)
-
-        cmd_opts = self.cmd_opts
-
-        cmd_opts.add_option(
-            '-o', '--outdated',
-            action='store_true',
-            default=False,
-            help='List outdated packages')
-        cmd_opts.add_option(
-            '-u', '--uptodate',
-            action='store_true',
-            default=False,
-            help='List uptodate packages')
-        cmd_opts.add_option(
-            '-e', '--editable',
-            action='store_true',
-            default=False,
-            help='List editable projects.')
-        cmd_opts.add_option(
-            '-l', '--local',
-            action='store_true',
-            default=False,
-            help=('If in a virtualenv that has global access, do not list '
-                  'globally-installed packages.'),
-        )
-        self.cmd_opts.add_option(
-            '--user',
-            dest='user',
-            action='store_true',
-            default=False,
-            help='Only output packages installed in user-site.')
-
-        cmd_opts.add_option(
-            '--pre',
-            action='store_true',
-            default=False,
-            help=("Include pre-release and development versions. By default, "
-                  "pip only finds stable versions."),
-        )
-
-        cmd_opts.add_option(
-            '--format',
-            action='store',
-            dest='list_format',
-            choices=('legacy', 'columns', 'freeze', 'json'),
-            help="Select the output format among: legacy (default), columns, "
-                 "freeze or json.",
-        )
-
-        cmd_opts.add_option(
-            '--not-required',
-            action='store_true',
-            dest='not_required',
-            help="List packages that are not dependencies of "
-                 "installed packages.",
-        )
-
-        index_opts = make_option_group(index_group, self.parser)
-
-        self.parser.insert_option_group(0, index_opts)
-        self.parser.insert_option_group(0, cmd_opts)
-
-    def _build_package_finder(self, options, index_urls, session):
-        """
-        Create a package finder appropriate to this list command.
-        """
-        return PackageFinder(
-            find_links=options.find_links,
-            index_urls=index_urls,
-            allow_all_prereleases=options.pre,
-            trusted_hosts=options.trusted_hosts,
-            process_dependency_links=options.process_dependency_links,
-            session=session,
-        )
-
-    def run(self, options, args):
-        if options.allow_external:
-            warnings.warn(
-                "--allow-external has been deprecated and will be removed in "
-                "the future. Due to changes in the repository protocol, it no "
-                "longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_all_external:
-            warnings.warn(
-                "--allow-all-external has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_unverified:
-            warnings.warn(
-                "--allow-unverified has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.list_format is None:
-            warnings.warn(
-                "The default format will switch to columns in the future. "
-                "You can use --format=(legacy|columns) (or define a "
-                "format=(legacy|columns) in your pip.conf under the [list] "
-                "section) to disable this warning.",
-                RemovedInPip10Warning,
-            )
-
-        if options.outdated and options.uptodate:
-            raise CommandError(
-                "Options --outdated and --uptodate cannot be combined.")
-
-        packages = get_installed_distributions(
-            local_only=options.local,
-            user_only=options.user,
-            editables_only=options.editable,
-        )
-
-        if options.outdated:
-            packages = self.get_outdated(packages, options)
-        elif options.uptodate:
-            packages = self.get_uptodate(packages, options)
-
-        if options.not_required:
-            packages = self.get_not_required(packages, options)
-
-        self.output_package_listing(packages, options)
-
-    def get_outdated(self, packages, options):
-        return [
-            dist for dist in self.iter_packages_latest_infos(packages, options)
-            if dist.latest_version > dist.parsed_version
-        ]
-
-    def get_uptodate(self, packages, options):
-        return [
-            dist for dist in self.iter_packages_latest_infos(packages, options)
-            if dist.latest_version == dist.parsed_version
-        ]
-
-    def get_not_required(self, packages, options):
-        dep_keys = set()
-        for dist in packages:
-            dep_keys.update(requirement.key for requirement in dist.requires())
-        return set(pkg for pkg in packages if pkg.key not in dep_keys)
-
-    def iter_packages_latest_infos(self, packages, options):
-        index_urls = [options.index_url] + options.extra_index_urls
-        if options.no_index:
-            logger.debug('Ignoring indexes: %s', ','.join(index_urls))
-            index_urls = []
-
-        dependency_links = []
-        for dist in packages:
-            if dist.has_metadata('dependency_links.txt'):
-                dependency_links.extend(
-                    dist.get_metadata_lines('dependency_links.txt'),
-                )
-
-        with self._build_session(options) as session:
-            finder = self._build_package_finder(options, index_urls, session)
-            finder.add_dependency_links(dependency_links)
-
-            for dist in packages:
-                typ = 'unknown'
-                all_candidates = finder.find_all_candidates(dist.key)
-                if not options.pre:
-                    # Remove prereleases
-                    all_candidates = [candidate for candidate in all_candidates
-                                      if not candidate.version.is_prerelease]
-
-                if not all_candidates:
-                    continue
-                best_candidate = max(all_candidates,
-                                     key=finder._candidate_sort_key)
-                remote_version = best_candidate.version
-                if best_candidate.location.is_wheel:
-                    typ = 'wheel'
-                else:
-                    typ = 'sdist'
-                # This is dirty but makes the rest of the code much cleaner
-                dist.latest_version = remote_version
-                dist.latest_filetype = typ
-                yield dist
-
-    def output_legacy(self, dist):
-        if dist_is_editable(dist):
-            return '%s (%s, %s)' % (
-                dist.project_name,
-                dist.version,
-                dist.location,
-            )
-        else:
-            return '%s (%s)' % (dist.project_name, dist.version)
-
-    def output_legacy_latest(self, dist):
-        return '%s - Latest: %s [%s]' % (
-            self.output_legacy(dist),
-            dist.latest_version,
-            dist.latest_filetype,
-        )
-
-    def output_package_listing(self, packages, options):
-        packages = sorted(
-            packages,
-            key=lambda dist: dist.project_name.lower(),
-        )
-        if options.list_format == 'columns' and packages:
-            data, header = format_for_columns(packages, options)
-            self.output_package_listing_columns(data, header)
-        elif options.list_format == 'freeze':
-            for dist in packages:
-                logger.info("%s==%s", dist.project_name, dist.version)
-        elif options.list_format == 'json':
-            logger.info(format_for_json(packages, options))
-        else:  # legacy
-            for dist in packages:
-                if options.outdated:
-                    logger.info(self.output_legacy_latest(dist))
-                else:
-                    logger.info(self.output_legacy(dist))
-
-    def output_package_listing_columns(self, data, header):
-        # insert the header first: we need to know the size of column names
-        if len(data) > 0:
-            data.insert(0, header)
-
-        pkg_strings, sizes = tabulate(data)
-
-        # Create and add a separator.
-        if len(data) > 0:
-            pkg_strings.insert(1, " ".join(map(lambda x: '-' * x, sizes)))
-
-        for val in pkg_strings:
-            logger.info(val)
-
-
-def tabulate(vals):
-    # From pfmoore on GitHub:
-    # https://github.com/pypa/pip/issues/3651#issuecomment-216932564
-    assert len(vals) > 0
-
-    sizes = [0] * max(len(x) for x in vals)
-    for row in vals:
-        sizes = [max(s, len(str(c))) for s, c in zip_longest(sizes, row)]
-
-    result = []
-    for row in vals:
-        display = " ".join([str(c).ljust(s) if c is not None else ''
-                            for s, c in zip_longest(sizes, row)])
-        result.append(display)
-
-    return result, sizes
-
-
-def format_for_columns(pkgs, options):
-    """
-    Convert the package data into something usable
-    by output_package_listing_columns.
-    """
-    running_outdated = options.outdated
-    # Adjust the header for the `pip list --outdated` case.
-    if running_outdated:
-        header = ["Package", "Version", "Latest", "Type"]
-    else:
-        header = ["Package", "Version"]
-
-    data = []
-    if any(dist_is_editable(x) for x in pkgs):
-        header.append("Location")
-
-    for proj in pkgs:
-        # if we're working on the 'outdated' list, separate out the
-        # latest_version and type
-        row = [proj.project_name, proj.version]
-
-        if running_outdated:
-            row.append(proj.latest_version)
-            row.append(proj.latest_filetype)
-
-        if dist_is_editable(proj):
-            row.append(proj.location)
-
-        data.append(row)
-
-    return data, header
-
-
-def format_for_json(packages, options):
-    data = []
-    for dist in packages:
-        info = {
-            'name': dist.project_name,
-            'version': six.text_type(dist.version),
-        }
-        if options.outdated:
-            info['latest_version'] = six.text_type(dist.latest_version)
-            info['latest_filetype'] = dist.latest_filetype
-        data.append(info)
-    return json.dumps(data)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/search.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/search.py
deleted file mode 100644
index bd2ea8ad3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/search.py
+++ /dev/null
@@ -1,133 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import sys
-import textwrap
-
-from pip.basecommand import Command, SUCCESS
-from pip.compat import OrderedDict
-from pip.download import PipXmlrpcTransport
-from pip.models import PyPI
-from pip.utils import get_terminal_size
-from pip.utils.logging import indent_log
-from pip.exceptions import CommandError
-from pip.status_codes import NO_MATCHES_FOUND
-from pip._vendor.packaging.version import parse as parse_version
-from pip._vendor import pkg_resources
-from pip._vendor.six.moves import xmlrpc_client
-
-
-logger = logging.getLogger(__name__)
-
-
-class SearchCommand(Command):
-    """Search for PyPI packages whose name or summary contains <query>."""
-    name = 'search'
-    usage = """
-      %prog [options] <query>"""
-    summary = 'Search PyPI for packages.'
-
-    def __init__(self, *args, **kw):
-        super(SearchCommand, self).__init__(*args, **kw)
-        self.cmd_opts.add_option(
-            '-i', '--index',
-            dest='index',
-            metavar='URL',
-            default=PyPI.pypi_url,
-            help='Base URL of Python Package Index (default %default)')
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options, args):
-        if not args:
-            raise CommandError('Missing required argument (search query).')
-        query = args
-        pypi_hits = self.search(query, options)
-        hits = transform_hits(pypi_hits)
-
-        terminal_width = None
-        if sys.stdout.isatty():
-            terminal_width = get_terminal_size()[0]
-
-        print_results(hits, terminal_width=terminal_width)
-        if pypi_hits:
-            return SUCCESS
-        return NO_MATCHES_FOUND
-
-    def search(self, query, options):
-        index_url = options.index
-        with self._build_session(options) as session:
-            transport = PipXmlrpcTransport(index_url, session)
-            pypi = xmlrpc_client.ServerProxy(index_url, transport)
-            hits = pypi.search({'name': query, 'summary': query}, 'or')
-            return hits
-
-
-def transform_hits(hits):
-    """
-    The list from pypi is really a list of versions. We want a list of
-    packages with the list of versions stored inline. This converts the
-    list from pypi into one we can use.
-    """
-    packages = OrderedDict()
-    for hit in hits:
-        name = hit['name']
-        summary = hit['summary']
-        version = hit['version']
-
-        if name not in packages.keys():
-            packages[name] = {
-                'name': name,
-                'summary': summary,
-                'versions': [version],
-            }
-        else:
-            packages[name]['versions'].append(version)
-
-            # if this is the highest version, replace summary and score
-            if version == highest_version(packages[name]['versions']):
-                packages[name]['summary'] = summary
-
-    return list(packages.values())
-
-
-def print_results(hits, name_column_width=None, terminal_width=None):
-    if not hits:
-        return
-    if name_column_width is None:
-        name_column_width = max([
-            len(hit['name']) + len(hit.get('versions', ['-'])[-1])
-            for hit in hits
-        ]) + 4
-
-    installed_packages = [p.project_name for p in pkg_resources.working_set]
-    for hit in hits:
-        name = hit['name']
-        summary = hit['summary'] or ''
-        version = hit.get('versions', ['-'])[-1]
-        if terminal_width is not None:
-            target_width = terminal_width - name_column_width - 5
-            if target_width > 10:
-                # wrap and indent summary to fit terminal
-                summary = textwrap.wrap(summary, target_width)
-                summary = ('\n' + ' ' * (name_column_width + 3)).join(summary)
-
-        line = '%-*s - %s' % (name_column_width,
-                              '%s (%s)' % (name, version), summary)
-        try:
-            logger.info(line)
-            if name in installed_packages:
-                dist = pkg_resources.get_distribution(name)
-                with indent_log():
-                    latest = highest_version(hit['versions'])
-                    if dist.version == latest:
-                        logger.info('INSTALLED: %s (latest)', dist.version)
-                    else:
-                        logger.info('INSTALLED: %s', dist.version)
-                        logger.info('LATEST:    %s', latest)
-        except UnicodeEncodeError:
-            pass
-
-
-def highest_version(versions):
-    return max(versions, key=parse_version)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/show.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/show.py
deleted file mode 100644
index 111c16d1a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/show.py
+++ /dev/null
@@ -1,154 +0,0 @@
-from __future__ import absolute_import
-
-from email.parser import FeedParser
-import logging
-import os
-
-from pip.basecommand import Command
-from pip.status_codes import SUCCESS, ERROR
-from pip._vendor import pkg_resources
-from pip._vendor.packaging.utils import canonicalize_name
-
-
-logger = logging.getLogger(__name__)
-
-
-class ShowCommand(Command):
-    """Show information about one or more installed packages."""
-    name = 'show'
-    usage = """
-      %prog [options] <package> ..."""
-    summary = 'Show information about installed packages.'
-
-    def __init__(self, *args, **kw):
-        super(ShowCommand, self).__init__(*args, **kw)
-        self.cmd_opts.add_option(
-            '-f', '--files',
-            dest='files',
-            action='store_true',
-            default=False,
-            help='Show the full list of installed files for each package.')
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options, args):
-        if not args:
-            logger.warning('ERROR: Please provide a package name or names.')
-            return ERROR
-        query = args
-
-        results = search_packages_info(query)
-        if not print_results(
-                results, list_files=options.files, verbose=options.verbose):
-            return ERROR
-        return SUCCESS
-
-
-def search_packages_info(query):
-    """
-    Gather details from installed distributions. Print distribution name,
-    version, location, and installed files. Installed files requires a
-    pip generated 'installed-files.txt' in the distributions '.egg-info'
-    directory.
-    """
-    installed = {}
-    for p in pkg_resources.working_set:
-        installed[canonicalize_name(p.project_name)] = p
-
-    query_names = [canonicalize_name(name) for name in query]
-
-    for dist in [installed[pkg] for pkg in query_names if pkg in installed]:
-        package = {
-            'name': dist.project_name,
-            'version': dist.version,
-            'location': dist.location,
-            'requires': [dep.project_name for dep in dist.requires()],
-        }
-        file_list = None
-        metadata = None
-        if isinstance(dist, pkg_resources.DistInfoDistribution):
-            # RECORDs should be part of .dist-info metadatas
-            if dist.has_metadata('RECORD'):
-                lines = dist.get_metadata_lines('RECORD')
-                paths = [l.split(',')[0] for l in lines]
-                paths = [os.path.join(dist.location, p) for p in paths]
-                file_list = [os.path.relpath(p, dist.location) for p in paths]
-
-            if dist.has_metadata('METADATA'):
-                metadata = dist.get_metadata('METADATA')
-        else:
-            # Otherwise use pip's log for .egg-info's
-            if dist.has_metadata('installed-files.txt'):
-                paths = dist.get_metadata_lines('installed-files.txt')
-                paths = [os.path.join(dist.egg_info, p) for p in paths]
-                file_list = [os.path.relpath(p, dist.location) for p in paths]
-
-            if dist.has_metadata('PKG-INFO'):
-                metadata = dist.get_metadata('PKG-INFO')
-
-        if dist.has_metadata('entry_points.txt'):
-            entry_points = dist.get_metadata_lines('entry_points.txt')
-            package['entry_points'] = entry_points
-
-        if dist.has_metadata('INSTALLER'):
-            for line in dist.get_metadata_lines('INSTALLER'):
-                if line.strip():
-                    package['installer'] = line.strip()
-                    break
-
-        # @todo: Should pkg_resources.Distribution have a
-        # `get_pkg_info` method?
-        feed_parser = FeedParser()
-        feed_parser.feed(metadata)
-        pkg_info_dict = feed_parser.close()
-        for key in ('metadata-version', 'summary',
-                    'home-page', 'author', 'author-email', 'license'):
-            package[key] = pkg_info_dict.get(key)
-
-        # It looks like FeedParser cannot deal with repeated headers
-        classifiers = []
-        for line in metadata.splitlines():
-            if line.startswith('Classifier: '):
-                classifiers.append(line[len('Classifier: '):])
-        package['classifiers'] = classifiers
-
-        if file_list:
-            package['files'] = sorted(file_list)
-        yield package
-
-
-def print_results(distributions, list_files=False, verbose=False):
-    """
-    Print the informations from installed distributions found.
-    """
-    results_printed = False
-    for i, dist in enumerate(distributions):
-        results_printed = True
-        if i > 0:
-            logger.info("---")
-        logger.info("Name: %s", dist.get('name', ''))
-        logger.info("Version: %s", dist.get('version', ''))
-        logger.info("Summary: %s", dist.get('summary', ''))
-        logger.info("Home-page: %s", dist.get('home-page', ''))
-        logger.info("Author: %s", dist.get('author', ''))
-        logger.info("Author-email: %s", dist.get('author-email', ''))
-        logger.info("License: %s", dist.get('license', ''))
-        logger.info("Location: %s", dist.get('location', ''))
-        logger.info("Requires: %s", ', '.join(dist.get('requires', [])))
-        if verbose:
-            logger.info("Metadata-Version: %s",
-                        dist.get('metadata-version', ''))
-            logger.info("Installer: %s", dist.get('installer', ''))
-            logger.info("Classifiers:")
-            for classifier in dist.get('classifiers', []):
-                logger.info("  %s", classifier)
-            logger.info("Entry-points:")
-            for entry in dist.get('entry_points', []):
-                logger.info("  %s", entry.strip())
-        if list_files:
-            logger.info("Files:")
-            for line in dist.get('files', []):
-                logger.info("  %s", line.strip())
-            if "files" not in dist:
-                logger.info("Cannot locate installed-files.txt")
-    return results_printed
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/uninstall.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/uninstall.py
deleted file mode 100644
index 8ba1a7c65..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/uninstall.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from __future__ import absolute_import
-
-import pip
-from pip.wheel import WheelCache
-from pip.req import InstallRequirement, RequirementSet, parse_requirements
-from pip.basecommand import Command
-from pip.exceptions import InstallationError
-
-
-class UninstallCommand(Command):
-    """
-    Uninstall packages.
-
-    pip is able to uninstall most installed packages. Known exceptions are:
-
-    - Pure distutils packages installed with ``python setup.py install``, which
-      leave behind no metadata to determine what files were installed.
-    - Script wrappers installed by ``python setup.py develop``.
-    """
-    name = 'uninstall'
-    usage = """
-      %prog [options] <package> ...
-      %prog [options] -r <requirements file> ..."""
-    summary = 'Uninstall packages.'
-
-    def __init__(self, *args, **kw):
-        super(UninstallCommand, self).__init__(*args, **kw)
-        self.cmd_opts.add_option(
-            '-r', '--requirement',
-            dest='requirements',
-            action='append',
-            default=[],
-            metavar='file',
-            help='Uninstall all the packages listed in the given requirements '
-                 'file.  This option can be used multiple times.',
-        )
-        self.cmd_opts.add_option(
-            '-y', '--yes',
-            dest='yes',
-            action='store_true',
-            help="Don't ask for confirmation of uninstall deletions.")
-
-        self.parser.insert_option_group(0, self.cmd_opts)
-
-    def run(self, options, args):
-        with self._build_session(options) as session:
-            format_control = pip.index.FormatControl(set(), set())
-            wheel_cache = WheelCache(options.cache_dir, format_control)
-            requirement_set = RequirementSet(
-                build_dir=None,
-                src_dir=None,
-                download_dir=None,
-                isolated=options.isolated_mode,
-                session=session,
-                wheel_cache=wheel_cache,
-            )
-            for name in args:
-                requirement_set.add_requirement(
-                    InstallRequirement.from_line(
-                        name, isolated=options.isolated_mode,
-                        wheel_cache=wheel_cache
-                    )
-                )
-            for filename in options.requirements:
-                for req in parse_requirements(
-                        filename,
-                        options=options,
-                        session=session,
-                        wheel_cache=wheel_cache):
-                    requirement_set.add_requirement(req)
-            if not requirement_set.has_requirements:
-                raise InstallationError(
-                    'You must give at least one requirement to %(name)s (see '
-                    '"pip help %(name)s")' % dict(name=self.name)
-                )
-            requirement_set.uninstall(auto_confirm=options.yes)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/wheel.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/wheel.py
deleted file mode 100644
index 70e95eb8e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/commands/wheel.py
+++ /dev/null
@@ -1,208 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-import logging
-import os
-import warnings
-
-from pip.basecommand import RequirementCommand
-from pip.exceptions import CommandError, PreviousBuildDirError
-from pip.req import RequirementSet
-from pip.utils import import_or_raise
-from pip.utils.build import BuildDirectory
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip.wheel import WheelCache, WheelBuilder
-from pip import cmdoptions
-
-
-logger = logging.getLogger(__name__)
-
-
-class WheelCommand(RequirementCommand):
-    """
-    Build Wheel archives for your requirements and dependencies.
-
-    Wheel is a built-package format, and offers the advantage of not
-    recompiling your software during every install. For more details, see the
-    wheel docs: https://wheel.readthedocs.io/en/latest/
-
-    Requirements: setuptools>=0.8, and wheel.
-
-    'pip wheel' uses the bdist_wheel setuptools extension from the wheel
-    package to build individual wheels.
-
-    """
-
-    name = 'wheel'
-    usage = """
-      %prog [options] <requirement specifier> ...
-      %prog [options] -r <requirements file> ...
-      %prog [options] [-e] <vcs project url> ...
-      %prog [options] [-e] <local project path> ...
-      %prog [options] <archive url/path> ..."""
-
-    summary = 'Build wheels from your requirements.'
-
-    def __init__(self, *args, **kw):
-        super(WheelCommand, self).__init__(*args, **kw)
-
-        cmd_opts = self.cmd_opts
-
-        cmd_opts.add_option(
-            '-w', '--wheel-dir',
-            dest='wheel_dir',
-            metavar='dir',
-            default=os.curdir,
-            help=("Build wheels into <dir>, where the default is the "
-                  "current working directory."),
-        )
-        cmd_opts.add_option(cmdoptions.use_wheel())
-        cmd_opts.add_option(cmdoptions.no_use_wheel())
-        cmd_opts.add_option(cmdoptions.no_binary())
-        cmd_opts.add_option(cmdoptions.only_binary())
-        cmd_opts.add_option(
-            '--build-option',
-            dest='build_options',
-            metavar='options',
-            action='append',
-            help="Extra arguments to be supplied to 'setup.py bdist_wheel'.")
-        cmd_opts.add_option(cmdoptions.constraints())
-        cmd_opts.add_option(cmdoptions.editable())
-        cmd_opts.add_option(cmdoptions.requirements())
-        cmd_opts.add_option(cmdoptions.src())
-        cmd_opts.add_option(cmdoptions.ignore_requires_python())
-        cmd_opts.add_option(cmdoptions.no_deps())
-        cmd_opts.add_option(cmdoptions.build_dir())
-
-        cmd_opts.add_option(
-            '--global-option',
-            dest='global_options',
-            action='append',
-            metavar='options',
-            help="Extra global options to be supplied to the setup.py "
-            "call before the 'bdist_wheel' command.")
-
-        cmd_opts.add_option(
-            '--pre',
-            action='store_true',
-            default=False,
-            help=("Include pre-release and development versions. By default, "
-                  "pip only finds stable versions."),
-        )
-
-        cmd_opts.add_option(cmdoptions.no_clean())
-        cmd_opts.add_option(cmdoptions.require_hashes())
-
-        index_opts = cmdoptions.make_option_group(
-            cmdoptions.index_group,
-            self.parser,
-        )
-
-        self.parser.insert_option_group(0, index_opts)
-        self.parser.insert_option_group(0, cmd_opts)
-
-    def check_required_packages(self):
-        import_or_raise(
-            'wheel.bdist_wheel',
-            CommandError,
-            "'pip wheel' requires the 'wheel' package. To fix this, run: "
-            "pip install wheel"
-        )
-        pkg_resources = import_or_raise(
-            'pkg_resources',
-            CommandError,
-            "'pip wheel' requires setuptools >= 0.8 for dist-info support."
-            " To fix this, run: pip install --upgrade setuptools"
-        )
-        if not hasattr(pkg_resources, 'DistInfoDistribution'):
-            raise CommandError(
-                "'pip wheel' requires setuptools >= 0.8 for dist-info "
-                "support. To fix this, run: pip install --upgrade "
-                "setuptools"
-            )
-
-    def run(self, options, args):
-        self.check_required_packages()
-        cmdoptions.resolve_wheel_no_use_binary(options)
-        cmdoptions.check_install_build_global(options)
-
-        if options.allow_external:
-            warnings.warn(
-                "--allow-external has been deprecated and will be removed in "
-                "the future. Due to changes in the repository protocol, it no "
-                "longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_all_external:
-            warnings.warn(
-                "--allow-all-external has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if options.allow_unverified:
-            warnings.warn(
-                "--allow-unverified has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        index_urls = [options.index_url] + options.extra_index_urls
-        if options.no_index:
-            logger.debug('Ignoring indexes: %s', ','.join(index_urls))
-            index_urls = []
-
-        if options.build_dir:
-            options.build_dir = os.path.abspath(options.build_dir)
-
-        options.src_dir = os.path.abspath(options.src_dir)
-
-        with self._build_session(options) as session:
-            finder = self._build_package_finder(options, session)
-            build_delete = (not (options.no_clean or options.build_dir))
-            wheel_cache = WheelCache(options.cache_dir, options.format_control)
-            with BuildDirectory(options.build_dir,
-                                delete=build_delete) as build_dir:
-                requirement_set = RequirementSet(
-                    build_dir=build_dir,
-                    src_dir=options.src_dir,
-                    download_dir=None,
-                    ignore_dependencies=options.ignore_dependencies,
-                    ignore_installed=True,
-                    ignore_requires_python=options.ignore_requires_python,
-                    isolated=options.isolated_mode,
-                    session=session,
-                    wheel_cache=wheel_cache,
-                    wheel_download_dir=options.wheel_dir,
-                    require_hashes=options.require_hashes
-                )
-
-                self.populate_requirement_set(
-                    requirement_set, args, options, finder, session, self.name,
-                    wheel_cache
-                )
-
-                if not requirement_set.has_requirements:
-                    return
-
-                try:
-                    # build wheels
-                    wb = WheelBuilder(
-                        requirement_set,
-                        finder,
-                        build_options=options.build_options or [],
-                        global_options=options.global_options or [],
-                    )
-                    if not wb.build():
-                        raise CommandError(
-                            "Failed to build one or more wheels"
-                        )
-                except PreviousBuildDirError:
-                    options.no_clean = True
-                    raise
-                finally:
-                    if not options.no_clean:
-                        requirement_set.cleanup_files()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__init__.py
deleted file mode 100644
index 099672cd1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__init__.py
+++ /dev/null
@@ -1,164 +0,0 @@
-"""Stuff that differs in different Python versions and platform
-distributions."""
-from __future__ import absolute_import, division
-
-import os
-import sys
-
-from pip._vendor.six import text_type
-
-try:
-    from logging.config import dictConfig as logging_dictConfig
-except ImportError:
-    from pip.compat.dictconfig import dictConfig as logging_dictConfig
-
-try:
-    from collections import OrderedDict
-except ImportError:
-    from pip._vendor.ordereddict import OrderedDict
-
-try:
-    import ipaddress
-except ImportError:
-    try:
-        from pip._vendor import ipaddress
-    except ImportError:
-        import ipaddr as ipaddress
-        ipaddress.ip_address = ipaddress.IPAddress
-        ipaddress.ip_network = ipaddress.IPNetwork
-
-
-try:
-    import sysconfig
-
-    def get_stdlib():
-        paths = [
-            sysconfig.get_path("stdlib"),
-            sysconfig.get_path("platstdlib"),
-        ]
-        return set(filter(bool, paths))
-except ImportError:
-    from distutils import sysconfig
-
-    def get_stdlib():
-        paths = [
-            sysconfig.get_python_lib(standard_lib=True),
-            sysconfig.get_python_lib(standard_lib=True, plat_specific=True),
-        ]
-        return set(filter(bool, paths))
-
-
-__all__ = [
-    "logging_dictConfig", "ipaddress", "uses_pycache", "console_to_str",
-    "native_str", "get_path_uid", "stdlib_pkgs", "WINDOWS", "samefile",
-    "OrderedDict",
-]
-
-
-if sys.version_info >= (3, 4):
-    uses_pycache = True
-    from importlib.util import cache_from_source
-else:
-    import imp
-    uses_pycache = hasattr(imp, 'cache_from_source')
-    if uses_pycache:
-        cache_from_source = imp.cache_from_source
-    else:
-        cache_from_source = None
-
-
-if sys.version_info >= (3,):
-    def console_to_str(s):
-        try:
-            return s.decode(sys.__stdout__.encoding)
-        except UnicodeDecodeError:
-            return s.decode('utf_8')
-
-    def native_str(s, replace=False):
-        if isinstance(s, bytes):
-            return s.decode('utf-8', 'replace' if replace else 'strict')
-        return s
-
-else:
-    def console_to_str(s):
-        return s
-
-    def native_str(s, replace=False):
-        # Replace is ignored -- unicode to UTF-8 can't fail
-        if isinstance(s, text_type):
-            return s.encode('utf-8')
-        return s
-
-
-def total_seconds(td):
-    if hasattr(td, "total_seconds"):
-        return td.total_seconds()
-    else:
-        val = td.microseconds + (td.seconds + td.days * 24 * 3600) * 10 ** 6
-        return val / 10 ** 6
-
-
-def get_path_uid(path):
-    """
-    Return path's uid.
-
-    Does not follow symlinks:
-        https://github.com/pypa/pip/pull/935#discussion_r5307003
-
-    Placed this function in compat due to differences on AIX and
-    Jython, that should eventually go away.
-
-    :raises OSError: When path is a symlink or can't be read.
-    """
-    if hasattr(os, 'O_NOFOLLOW'):
-        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
-        file_uid = os.fstat(fd).st_uid
-        os.close(fd)
-    else:  # AIX and Jython
-        # WARNING: time of check vulnerability, but best we can do w/o NOFOLLOW
-        if not os.path.islink(path):
-            # older versions of Jython don't have `os.fstat`
-            file_uid = os.stat(path).st_uid
-        else:
-            # raise OSError for parity with os.O_NOFOLLOW above
-            raise OSError(
-                "%s is a symlink; Will not return uid for symlinks" % path
-            )
-    return file_uid
-
-
-def expanduser(path):
-    """
-    Expand ~ and ~user constructions.
-
-    Includes a workaround for http://bugs.python.org/issue14768
-    """
-    expanded = os.path.expanduser(path)
-    if path.startswith('~/') and expanded.startswith('//'):
-        expanded = expanded[1:]
-    return expanded
-
-
-# packages in the stdlib that may have installation metadata, but should not be
-# considered 'installed'.  this theoretically could be determined based on
-# dist.location (py27:`sysconfig.get_paths()['stdlib']`,
-# py26:sysconfig.get_config_vars('LIBDEST')), but fear platform variation may
-# make this ineffective, so hard-coding
-stdlib_pkgs = ('python', 'wsgiref')
-if sys.version_info >= (2, 7):
-    stdlib_pkgs += ('argparse',)
-
-
-# windows detection, covers cpython and ironpython
-WINDOWS = (sys.platform.startswith("win") or
-           (sys.platform == 'cli' and os.name == 'nt'))
-
-
-def samefile(file1, file2):
-    """Provide an alternative for os.path.samefile on Windows/Python2"""
-    if hasattr(os.path, 'samefile'):
-        return os.path.samefile(file1, file2)
-    else:
-        path1 = os.path.normcase(os.path.abspath(file1))
-        path2 = os.path.normcase(os.path.abspath(file2))
-        return path1 == path2
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 43f11e0a7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/dictconfig.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/dictconfig.cpython-35.pyc
deleted file mode 100644
index 0f5719add..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/__pycache__/dictconfig.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/dictconfig.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/dictconfig.py
deleted file mode 100644
index ec684aac2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/compat/dictconfig.py
+++ /dev/null
@@ -1,565 +0,0 @@
-# This is a copy of the Python logging.config.dictconfig module,
-# reproduced with permission. It is provided here for backwards
-# compatibility for Python versions prior to 2.7.
-#
-# Copyright 2009-2010 by Vinay Sajip. All Rights Reserved.
-#
-# Permission to use, copy, modify, and distribute this software and its
-# documentation for any purpose and without fee is hereby granted,
-# provided that the above copyright notice appear in all copies and that
-# both that copyright notice and this permission notice appear in
-# supporting documentation, and that the name of Vinay Sajip
-# not be used in advertising or publicity pertaining to distribution
-# of the software without specific, written prior permission.
-# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
-# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
-# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-from __future__ import absolute_import
-
-import logging.handlers
-import re
-import sys
-import types
-
-from pip._vendor import six
-
-# flake8: noqa
-
-IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)
-
-
-def valid_ident(s):
-    m = IDENTIFIER.match(s)
-    if not m:
-        raise ValueError('Not a valid Python identifier: %r' % s)
-    return True
-
-#
-# This function is defined in logging only in recent versions of Python
-#
-try:
-    from logging import _checkLevel
-except ImportError:
-    def _checkLevel(level):
-        if isinstance(level, int):
-            rv = level
-        elif str(level) == level:
-            if level not in logging._levelNames:
-                raise ValueError('Unknown level: %r' % level)
-            rv = logging._levelNames[level]
-        else:
-            raise TypeError('Level not an integer or a '
-                            'valid string: %r' % level)
-        return rv
-
-# The ConvertingXXX classes are wrappers around standard Python containers,
-# and they serve to convert any suitable values in the container. The
-# conversion converts base dicts, lists and tuples to their wrapped
-# equivalents, whereas strings which match a conversion format are converted
-# appropriately.
-#
-# Each wrapper should have a configurator attribute holding the actual
-# configurator to use for conversion.
-
-
-class ConvertingDict(dict):
-    """A converting dictionary wrapper."""
-
-    def __getitem__(self, key):
-        value = dict.__getitem__(self, key)
-        result = self.configurator.convert(value)
-        # If the converted value is different, save for next time
-        if value is not result:
-            self[key] = result
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-                result.key = key
-        return result
-
-    def get(self, key, default=None):
-        value = dict.get(self, key, default)
-        result = self.configurator.convert(value)
-        # If the converted value is different, save for next time
-        if value is not result:
-            self[key] = result
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-                result.key = key
-        return result
-
-    def pop(self, key, default=None):
-        value = dict.pop(self, key, default)
-        result = self.configurator.convert(value)
-        if value is not result:
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-                result.key = key
-        return result
-
-
-class ConvertingList(list):
-    """A converting list wrapper."""
-    def __getitem__(self, key):
-        value = list.__getitem__(self, key)
-        result = self.configurator.convert(value)
-        # If the converted value is different, save for next time
-        if value is not result:
-            self[key] = result
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-                result.key = key
-        return result
-
-    def pop(self, idx=-1):
-        value = list.pop(self, idx)
-        result = self.configurator.convert(value)
-        if value is not result:
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-        return result
-
-
-class ConvertingTuple(tuple):
-    """A converting tuple wrapper."""
-    def __getitem__(self, key):
-        value = tuple.__getitem__(self, key)
-        result = self.configurator.convert(value)
-        if value is not result:
-            if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
-                result.parent = self
-                result.key = key
-        return result
-
-
-class BaseConfigurator(object):
-    """
-    The configurator base class which defines some useful defaults.
-    """
-
-    CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')
-
-    WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
-    DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
-    INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
-    DIGIT_PATTERN = re.compile(r'^\d+$')
-
-    value_converters = {
-        'ext' : 'ext_convert',
-        'cfg' : 'cfg_convert',
-    }
-
-    # We might want to use a different one, e.g. importlib
-    importer = __import__
-
-    def __init__(self, config):
-        self.config = ConvertingDict(config)
-        self.config.configurator = self
-
-    def resolve(self, s):
-        """
-        Resolve strings to objects using standard import and attribute
-        syntax.
-        """
-        name = s.split('.')
-        used = name.pop(0)
-        try:
-            found = self.importer(used)
-            for frag in name:
-                used += '.' + frag
-                try:
-                    found = getattr(found, frag)
-                except AttributeError:
-                    self.importer(used)
-                    found = getattr(found, frag)
-            return found
-        except ImportError:
-            e, tb = sys.exc_info()[1:]
-            v = ValueError('Cannot resolve %r: %s' % (s, e))
-            v.__cause__, v.__traceback__ = e, tb
-            raise v
-
-    def ext_convert(self, value):
-        """Default converter for the ext:// protocol."""
-        return self.resolve(value)
-
-    def cfg_convert(self, value):
-        """Default converter for the cfg:// protocol."""
-        rest = value
-        m = self.WORD_PATTERN.match(rest)
-        if m is None:
-            raise ValueError("Unable to convert %r" % value)
-        else:
-            rest = rest[m.end():]
-            d = self.config[m.groups()[0]]
-            # print d, rest
-            while rest:
-                m = self.DOT_PATTERN.match(rest)
-                if m:
-                    d = d[m.groups()[0]]
-                else:
-                    m = self.INDEX_PATTERN.match(rest)
-                    if m:
-                        idx = m.groups()[0]
-                        if not self.DIGIT_PATTERN.match(idx):
-                            d = d[idx]
-                        else:
-                            try:
-                                n = int(idx)  # try as number first (most likely)
-                                d = d[n]
-                            except TypeError:
-                                d = d[idx]
-                if m:
-                    rest = rest[m.end():]
-                else:
-                    raise ValueError('Unable to convert '
-                                     '%r at %r' % (value, rest))
-        # rest should be empty
-        return d
-
-    def convert(self, value):
-        """
-        Convert values to an appropriate type. dicts, lists and tuples are
-        replaced by their converting alternatives. Strings are checked to
-        see if they have a conversion format and are converted if they do.
-        """
-        if not isinstance(value, ConvertingDict) and isinstance(value, dict):
-            value = ConvertingDict(value)
-            value.configurator = self
-        elif not isinstance(value, ConvertingList) and isinstance(value, list):
-            value = ConvertingList(value)
-            value.configurator = self
-        elif not isinstance(value, ConvertingTuple) and\
-                 isinstance(value, tuple):
-            value = ConvertingTuple(value)
-            value.configurator = self
-        elif isinstance(value, six.string_types):  # str for py3k
-            m = self.CONVERT_PATTERN.match(value)
-            if m:
-                d = m.groupdict()
-                prefix = d['prefix']
-                converter = self.value_converters.get(prefix, None)
-                if converter:
-                    suffix = d['suffix']
-                    converter = getattr(self, converter)
-                    value = converter(suffix)
-        return value
-
-    def configure_custom(self, config):
-        """Configure an object with a user-supplied factory."""
-        c = config.pop('()')
-        if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:
-            c = self.resolve(c)
-        props = config.pop('.', None)
-        # Check for valid identifiers
-        kwargs = dict((k, config[k]) for k in config if valid_ident(k))
-        result = c(**kwargs)
-        if props:
-            for name, value in props.items():
-                setattr(result, name, value)
-        return result
-
-    def as_tuple(self, value):
-        """Utility function which converts lists to tuples."""
-        if isinstance(value, list):
-            value = tuple(value)
-        return value
-
-
-class DictConfigurator(BaseConfigurator):
-    """
-    Configure logging using a dictionary-like object to describe the
-    configuration.
-    """
-
-    def configure(self):
-        """Do the configuration."""
-
-        config = self.config
-        if 'version' not in config:
-            raise ValueError("dictionary doesn't specify a version")
-        if config['version'] != 1:
-            raise ValueError("Unsupported version: %s" % config['version'])
-        incremental = config.pop('incremental', False)
-        EMPTY_DICT = {}
-        logging._acquireLock()
-        try:
-            if incremental:
-                handlers = config.get('handlers', EMPTY_DICT)
-                # incremental handler config only if handler name
-                # ties in to logging._handlers (Python 2.7)
-                if sys.version_info[:2] == (2, 7):
-                    for name in handlers:
-                        if name not in logging._handlers:
-                            raise ValueError('No handler found with '
-                                             'name %r'  % name)
-                        else:
-                            try:
-                                handler = logging._handlers[name]
-                                handler_config = handlers[name]
-                                level = handler_config.get('level', None)
-                                if level:
-                                    handler.setLevel(_checkLevel(level))
-                            except StandardError as e:
-                                raise ValueError('Unable to configure handler '
-                                                 '%r: %s' % (name, e))
-                loggers = config.get('loggers', EMPTY_DICT)
-                for name in loggers:
-                    try:
-                        self.configure_logger(name, loggers[name], True)
-                    except StandardError as e:
-                        raise ValueError('Unable to configure logger '
-                                         '%r: %s' % (name, e))
-                root = config.get('root', None)
-                if root:
-                    try:
-                        self.configure_root(root, True)
-                    except StandardError as e:
-                        raise ValueError('Unable to configure root '
-                                         'logger: %s' % e)
-            else:
-                disable_existing = config.pop('disable_existing_loggers', True)
-
-                logging._handlers.clear()
-                del logging._handlerList[:]
-
-                # Do formatters first - they don't refer to anything else
-                formatters = config.get('formatters', EMPTY_DICT)
-                for name in formatters:
-                    try:
-                        formatters[name] = self.configure_formatter(
-                                                            formatters[name])
-                    except StandardError as e:
-                        raise ValueError('Unable to configure '
-                                         'formatter %r: %s' % (name, e))
-                # Next, do filters - they don't refer to anything else, either
-                filters = config.get('filters', EMPTY_DICT)
-                for name in filters:
-                    try:
-                        filters[name] = self.configure_filter(filters[name])
-                    except StandardError as e:
-                        raise ValueError('Unable to configure '
-                                         'filter %r: %s' % (name, e))
-
-                # Next, do handlers - they refer to formatters and filters
-                # As handlers can refer to other handlers, sort the keys
-                # to allow a deterministic order of configuration
-                handlers = config.get('handlers', EMPTY_DICT)
-                for name in sorted(handlers):
-                    try:
-                        handler = self.configure_handler(handlers[name])
-                        handler.name = name
-                        handlers[name] = handler
-                    except StandardError as e:
-                        raise ValueError('Unable to configure handler '
-                                         '%r: %s' % (name, e))
-                # Next, do loggers - they refer to handlers and filters
-
-                # we don't want to lose the existing loggers,
-                # since other threads may have pointers to them.
-                # existing is set to contain all existing loggers,
-                # and as we go through the new configuration we
-                # remove any which are configured. At the end,
-                # what's left in existing is the set of loggers
-                # which were in the previous configuration but
-                # which are not in the new configuration.
-                root = logging.root
-                existing = list(root.manager.loggerDict)
-                # The list needs to be sorted so that we can
-                # avoid disabling child loggers of explicitly
-                # named loggers. With a sorted list it is easier
-                # to find the child loggers.
-                existing.sort()
-                # We'll keep the list of existing loggers
-                # which are children of named loggers here...
-                child_loggers = []
-                # now set up the new ones...
-                loggers = config.get('loggers', EMPTY_DICT)
-                for name in loggers:
-                    if name in existing:
-                        i = existing.index(name)
-                        prefixed = name + "."
-                        pflen = len(prefixed)
-                        num_existing = len(existing)
-                        i = i + 1  # look at the entry after name
-                        while (i < num_existing) and\
-                              (existing[i][:pflen] == prefixed):
-                            child_loggers.append(existing[i])
-                            i = i + 1
-                        existing.remove(name)
-                    try:
-                        self.configure_logger(name, loggers[name])
-                    except StandardError as e:
-                        raise ValueError('Unable to configure logger '
-                                         '%r: %s' % (name, e))
-
-                # Disable any old loggers. There's no point deleting
-                # them as other threads may continue to hold references
-                # and by disabling them, you stop them doing any logging.
-                # However, don't disable children of named loggers, as that's
-                # probably not what was intended by the user.
-                for log in existing:
-                    logger = root.manager.loggerDict[log]
-                    if log in child_loggers:
-                        logger.level = logging.NOTSET
-                        logger.handlers = []
-                        logger.propagate = True
-                    elif disable_existing:
-                        logger.disabled = True
-
-                # And finally, do the root logger
-                root = config.get('root', None)
-                if root:
-                    try:
-                        self.configure_root(root)
-                    except StandardError as e:
-                        raise ValueError('Unable to configure root '
-                                         'logger: %s' % e)
-        finally:
-            logging._releaseLock()
-
-    def configure_formatter(self, config):
-        """Configure a formatter from a dictionary."""
-        if '()' in config:
-            factory = config['()']  # for use in exception handler
-            try:
-                result = self.configure_custom(config)
-            except TypeError as te:
-                if "'format'" not in str(te):
-                    raise
-                # Name of parameter changed from fmt to format.
-                # Retry with old name.
-                # This is so that code can be used with older Python versions
-                #(e.g. by Django)
-                config['fmt'] = config.pop('format')
-                config['()'] = factory
-                result = self.configure_custom(config)
-        else:
-            fmt = config.get('format', None)
-            dfmt = config.get('datefmt', None)
-            result = logging.Formatter(fmt, dfmt)
-        return result
-
-    def configure_filter(self, config):
-        """Configure a filter from a dictionary."""
-        if '()' in config:
-            result = self.configure_custom(config)
-        else:
-            name = config.get('name', '')
-            result = logging.Filter(name)
-        return result
-
-    def add_filters(self, filterer, filters):
-        """Add filters to a filterer from a list of names."""
-        for f in filters:
-            try:
-                filterer.addFilter(self.config['filters'][f])
-            except StandardError as e:
-                raise ValueError('Unable to add filter %r: %s' % (f, e))
-
-    def configure_handler(self, config):
-        """Configure a handler from a dictionary."""
-        formatter = config.pop('formatter', None)
-        if formatter:
-            try:
-                formatter = self.config['formatters'][formatter]
-            except StandardError as e:
-                raise ValueError('Unable to set formatter '
-                                 '%r: %s' % (formatter, e))
-        level = config.pop('level', None)
-        filters = config.pop('filters', None)
-        if '()' in config:
-            c = config.pop('()')
-            if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType:
-                c = self.resolve(c)
-            factory = c
-        else:
-            klass = self.resolve(config.pop('class'))
-            # Special case for handler which refers to another handler
-            if issubclass(klass, logging.handlers.MemoryHandler) and\
-                'target' in config:
-                try:
-                    config['target'] = self.config['handlers'][config['target']]
-                except StandardError as e:
-                    raise ValueError('Unable to set target handler '
-                                     '%r: %s' % (config['target'], e))
-            elif issubclass(klass, logging.handlers.SMTPHandler) and\
-                'mailhost' in config:
-                config['mailhost'] = self.as_tuple(config['mailhost'])
-            elif issubclass(klass, logging.handlers.SysLogHandler) and\
-                'address' in config:
-                config['address'] = self.as_tuple(config['address'])
-            factory = klass
-        kwargs = dict((k, config[k]) for k in config if valid_ident(k))
-        try:
-            result = factory(**kwargs)
-        except TypeError as te:
-            if "'stream'" not in str(te):
-                raise
-            # The argument name changed from strm to stream
-            # Retry with old name.
-            # This is so that code can be used with older Python versions
-            #(e.g. by Django)
-            kwargs['strm'] = kwargs.pop('stream')
-            result = factory(**kwargs)
-        if formatter:
-            result.setFormatter(formatter)
-        if level is not None:
-            result.setLevel(_checkLevel(level))
-        if filters:
-            self.add_filters(result, filters)
-        return result
-
-    def add_handlers(self, logger, handlers):
-        """Add handlers to a logger from a list of names."""
-        for h in handlers:
-            try:
-                logger.addHandler(self.config['handlers'][h])
-            except StandardError as e:
-                raise ValueError('Unable to add handler %r: %s' % (h, e))
-
-    def common_logger_config(self, logger, config, incremental=False):
-        """
-        Perform configuration which is common to root and non-root loggers.
-        """
-        level = config.get('level', None)
-        if level is not None:
-            logger.setLevel(_checkLevel(level))
-        if not incremental:
-            # Remove any existing handlers
-            for h in logger.handlers[:]:
-                logger.removeHandler(h)
-            handlers = config.get('handlers', None)
-            if handlers:
-                self.add_handlers(logger, handlers)
-            filters = config.get('filters', None)
-            if filters:
-                self.add_filters(logger, filters)
-
-    def configure_logger(self, name, config, incremental=False):
-        """Configure a non-root logger from a dictionary."""
-        logger = logging.getLogger(name)
-        self.common_logger_config(logger, config, incremental)
-        propagate = config.get('propagate', None)
-        if propagate is not None:
-            logger.propagate = propagate
-
-    def configure_root(self, config, incremental=False):
-        """Configure a root logger from a dictionary."""
-        root = logging.getLogger()
-        self.common_logger_config(root, config, incremental)
-
-dictConfigClass = DictConfigurator
-
-
-def dictConfig(config):
-    """Configure logging using a dictionary."""
-    dictConfigClass(config).configure()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/download.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/download.py
deleted file mode 100644
index 54d3131df..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/download.py
+++ /dev/null
@@ -1,906 +0,0 @@
-from __future__ import absolute_import
-
-import cgi
-import email.utils
-import getpass
-import json
-import logging
-import mimetypes
-import os
-import platform
-import re
-import shutil
-import sys
-import tempfile
-
-try:
-    import ssl  # noqa
-    HAS_TLS = True
-except ImportError:
-    HAS_TLS = False
-
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-from pip._vendor.six.moves.urllib import request as urllib_request
-
-import pip
-
-from pip.exceptions import InstallationError, HashMismatch
-from pip.models import PyPI
-from pip.utils import (splitext, rmtree, format_size, display_path,
-                       backup_dir, ask_path_exists, unpack_file,
-                       ARCHIVE_EXTENSIONS, consume, call_subprocess)
-from pip.utils.encoding import auto_decode
-from pip.utils.filesystem import check_path_owner
-from pip.utils.logging import indent_log
-from pip.utils.setuptools_build import SETUPTOOLS_SHIM
-from pip.utils.glibc import libc_ver
-from pip.utils.ui import DownloadProgressBar, DownloadProgressSpinner
-from pip.locations import write_delete_marker_file
-from pip.vcs import vcs
-from pip._vendor import requests, six
-from pip._vendor.requests.adapters import BaseAdapter, HTTPAdapter
-from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
-from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response
-from pip._vendor.requests.utils import get_netrc_auth
-from pip._vendor.requests.structures import CaseInsensitiveDict
-from pip._vendor.requests.packages import urllib3
-from pip._vendor.cachecontrol import CacheControlAdapter
-from pip._vendor.cachecontrol.caches import FileCache
-from pip._vendor.lockfile import LockError
-from pip._vendor.six.moves import xmlrpc_client
-
-
-__all__ = ['get_file_content',
-           'is_url', 'url_to_path', 'path_to_url',
-           'is_archive_file', 'unpack_vcs_link',
-           'unpack_file_url', 'is_vcs_url', 'is_file_url',
-           'unpack_http_url', 'unpack_url']
-
-
-logger = logging.getLogger(__name__)
-
-
-def user_agent():
-    """
-    Return a string representing the user agent.
-    """
-    data = {
-        "installer": {"name": "pip", "version": pip.__version__},
-        "python": platform.python_version(),
-        "implementation": {
-            "name": platform.python_implementation(),
-        },
-    }
-
-    if data["implementation"]["name"] == 'CPython':
-        data["implementation"]["version"] = platform.python_version()
-    elif data["implementation"]["name"] == 'PyPy':
-        if sys.pypy_version_info.releaselevel == 'final':
-            pypy_version_info = sys.pypy_version_info[:3]
-        else:
-            pypy_version_info = sys.pypy_version_info
-        data["implementation"]["version"] = ".".join(
-            [str(x) for x in pypy_version_info]
-        )
-    elif data["implementation"]["name"] == 'Jython':
-        # Complete Guess
-        data["implementation"]["version"] = platform.python_version()
-    elif data["implementation"]["name"] == 'IronPython':
-        # Complete Guess
-        data["implementation"]["version"] = platform.python_version()
-
-    if sys.platform.startswith("linux"):
-        from pip._vendor import distro
-        distro_infos = dict(filter(
-            lambda x: x[1],
-            zip(["name", "version", "id"], distro.linux_distribution()),
-        ))
-        libc = dict(filter(
-            lambda x: x[1],
-            zip(["lib", "version"], libc_ver()),
-        ))
-        if libc:
-            distro_infos["libc"] = libc
-        if distro_infos:
-            data["distro"] = distro_infos
-
-    if sys.platform.startswith("darwin") and platform.mac_ver()[0]:
-        data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]}
-
-    if platform.system():
-        data.setdefault("system", {})["name"] = platform.system()
-
-    if platform.release():
-        data.setdefault("system", {})["release"] = platform.release()
-
-    if platform.machine():
-        data["cpu"] = platform.machine()
-
-    # Python 2.6 doesn't have ssl.OPENSSL_VERSION.
-    if HAS_TLS and sys.version_info[:2] > (2, 6):
-        data["openssl_version"] = ssl.OPENSSL_VERSION
-
-    return "{data[installer][name]}/{data[installer][version]} {json}".format(
-        data=data,
-        json=json.dumps(data, separators=(",", ":"), sort_keys=True),
-    )
-
-
-class MultiDomainBasicAuth(AuthBase):
-
-    def __init__(self, prompting=True):
-        self.prompting = prompting
-        self.passwords = {}
-
-    def __call__(self, req):
-        parsed = urllib_parse.urlparse(req.url)
-
-        # Get the netloc without any embedded credentials
-        netloc = parsed.netloc.rsplit("@", 1)[-1]
-
-        # Set the url of the request to the url without any credentials
-        req.url = urllib_parse.urlunparse(parsed[:1] + (netloc,) + parsed[2:])
-
-        # Use any stored credentials that we have for this netloc
-        username, password = self.passwords.get(netloc, (None, None))
-
-        # Extract credentials embedded in the url if we have none stored
-        if username is None:
-            username, password = self.parse_credentials(parsed.netloc)
-
-        # Get creds from netrc if we still don't have them
-        if username is None and password is None:
-            netrc_auth = get_netrc_auth(req.url)
-            username, password = netrc_auth if netrc_auth else (None, None)
-
-        if username or password:
-            # Store the username and password
-            self.passwords[netloc] = (username, password)
-
-            # Send the basic auth with this request
-            req = HTTPBasicAuth(username or "", password or "")(req)
-
-        # Attach a hook to handle 401 responses
-        req.register_hook("response", self.handle_401)
-
-        return req
-
-    def handle_401(self, resp, **kwargs):
-        # We only care about 401 responses, anything else we want to just
-        #   pass through the actual response
-        if resp.status_code != 401:
-            return resp
-
-        # We are not able to prompt the user so simply return the response
-        if not self.prompting:
-            return resp
-
-        parsed = urllib_parse.urlparse(resp.url)
-
-        # Prompt the user for a new username and password
-        username = six.moves.input("User for %s: " % parsed.netloc)
-        password = getpass.getpass("Password: ")
-
-        # Store the new username and password to use for future requests
-        if username or password:
-            self.passwords[parsed.netloc] = (username, password)
-
-        # Consume content and release the original connection to allow our new
-        #   request to reuse the same one.
-        resp.content
-        resp.raw.release_conn()
-
-        # Add our new username and password to the request
-        req = HTTPBasicAuth(username or "", password or "")(resp.request)
-
-        # Send our new request
-        new_resp = resp.connection.send(req, **kwargs)
-        new_resp.history.append(resp)
-
-        return new_resp
-
-    def parse_credentials(self, netloc):
-        if "@" in netloc:
-            userinfo = netloc.rsplit("@", 1)[0]
-            if ":" in userinfo:
-                return userinfo.split(":", 1)
-            return userinfo, None
-        return None, None
-
-
-class LocalFSAdapter(BaseAdapter):
-
-    def send(self, request, stream=None, timeout=None, verify=None, cert=None,
-             proxies=None):
-        pathname = url_to_path(request.url)
-
-        resp = Response()
-        resp.status_code = 200
-        resp.url = request.url
-
-        try:
-            stats = os.stat(pathname)
-        except OSError as exc:
-            resp.status_code = 404
-            resp.raw = exc
-        else:
-            modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
-            content_type = mimetypes.guess_type(pathname)[0] or "text/plain"
-            resp.headers = CaseInsensitiveDict({
-                "Content-Type": content_type,
-                "Content-Length": stats.st_size,
-                "Last-Modified": modified,
-            })
-
-            resp.raw = open(pathname, "rb")
-            resp.close = resp.raw.close
-
-        return resp
-
-    def close(self):
-        pass
-
-
-class SafeFileCache(FileCache):
-    """
-    A file based cache which is safe to use even when the target directory may
-    not be accessible or writable.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super(SafeFileCache, self).__init__(*args, **kwargs)
-
-        # Check to ensure that the directory containing our cache directory
-        # is owned by the user current executing pip. If it does not exist
-        # we will check the parent directory until we find one that does exist.
-        # If it is not owned by the user executing pip then we will disable
-        # the cache and log a warning.
-        if not check_path_owner(self.directory):
-            logger.warning(
-                "The directory '%s' or its parent directory is not owned by "
-                "the current user and the cache has been disabled. Please "
-                "check the permissions and owner of that directory. If "
-                "executing pip with sudo, you may want sudo's -H flag.",
-                self.directory,
-            )
-
-            # Set our directory to None to disable the Cache
-            self.directory = None
-
-    def get(self, *args, **kwargs):
-        # If we don't have a directory, then the cache should be a no-op.
-        if self.directory is None:
-            return
-
-        try:
-            return super(SafeFileCache, self).get(*args, **kwargs)
-        except (LockError, OSError, IOError):
-            # We intentionally silence this error, if we can't access the cache
-            # then we can just skip caching and process the request as if
-            # caching wasn't enabled.
-            pass
-
-    def set(self, *args, **kwargs):
-        # If we don't have a directory, then the cache should be a no-op.
-        if self.directory is None:
-            return
-
-        try:
-            return super(SafeFileCache, self).set(*args, **kwargs)
-        except (LockError, OSError, IOError):
-            # We intentionally silence this error, if we can't access the cache
-            # then we can just skip caching and process the request as if
-            # caching wasn't enabled.
-            pass
-
-    def delete(self, *args, **kwargs):
-        # If we don't have a directory, then the cache should be a no-op.
-        if self.directory is None:
-            return
-
-        try:
-            return super(SafeFileCache, self).delete(*args, **kwargs)
-        except (LockError, OSError, IOError):
-            # We intentionally silence this error, if we can't access the cache
-            # then we can just skip caching and process the request as if
-            # caching wasn't enabled.
-            pass
-
-
-class InsecureHTTPAdapter(HTTPAdapter):
-
-    def cert_verify(self, conn, url, verify, cert):
-        conn.cert_reqs = 'CERT_NONE'
-        conn.ca_certs = None
-
-
-class PipSession(requests.Session):
-
-    timeout = None
-
-    def __init__(self, *args, **kwargs):
-        retries = kwargs.pop("retries", 0)
-        cache = kwargs.pop("cache", None)
-        insecure_hosts = kwargs.pop("insecure_hosts", [])
-
-        super(PipSession, self).__init__(*args, **kwargs)
-
-        # Attach our User Agent to the request
-        self.headers["User-Agent"] = user_agent()
-
-        # Attach our Authentication handler to the session
-        self.auth = MultiDomainBasicAuth()
-
-        # Create our urllib3.Retry instance which will allow us to customize
-        # how we handle retries.
-        retries = urllib3.Retry(
-            # Set the total number of retries that a particular request can
-            # have.
-            total=retries,
-
-            # A 503 error from PyPI typically means that the Fastly -> Origin
-            # connection got interrupted in some way. A 503 error in general
-            # is typically considered a transient error so we'll go ahead and
-            # retry it.
-            status_forcelist=[503],
-
-            # Add a small amount of back off between failed requests in
-            # order to prevent hammering the service.
-            backoff_factor=0.25,
-        )
-
-        # We want to _only_ cache responses on securely fetched origins. We do
-        # this because we can't validate the response of an insecurely fetched
-        # origin, and we don't want someone to be able to poison the cache and
-        # require manual eviction from the cache to fix it.
-        if cache:
-            secure_adapter = CacheControlAdapter(
-                cache=SafeFileCache(cache, use_dir_lock=True),
-                max_retries=retries,
-            )
-        else:
-            secure_adapter = HTTPAdapter(max_retries=retries)
-
-        # Our Insecure HTTPAdapter disables HTTPS validation. It does not
-        # support caching (see above) so we'll use it for all http:// URLs as
-        # well as any https:// host that we've marked as ignoring TLS errors
-        # for.
-        insecure_adapter = InsecureHTTPAdapter(max_retries=retries)
-
-        self.mount("https://", secure_adapter)
-        self.mount("http://", insecure_adapter)
-
-        # Enable file:// urls
-        self.mount("file://", LocalFSAdapter())
-
-        # We want to use a non-validating adapter for any requests which are
-        # deemed insecure.
-        for host in insecure_hosts:
-            self.mount("https://{0}/".format(host), insecure_adapter)
-
-    def request(self, method, url, *args, **kwargs):
-        # Allow setting a default timeout on a session
-        kwargs.setdefault("timeout", self.timeout)
-
-        # Dispatch the actual request
-        return super(PipSession, self).request(method, url, *args, **kwargs)
-
-
-def get_file_content(url, comes_from=None, session=None):
-    """Gets the content of a file; it may be a filename, file: URL, or
-    http: URL.  Returns (location, content).  Content is unicode."""
-    if session is None:
-        raise TypeError(
-            "get_file_content() missing 1 required keyword argument: 'session'"
-        )
-
-    match = _scheme_re.search(url)
-    if match:
-        scheme = match.group(1).lower()
-        if (scheme == 'file' and comes_from and
-                comes_from.startswith('http')):
-            raise InstallationError(
-                'Requirements file %s references URL %s, which is local'
-                % (comes_from, url))
-        if scheme == 'file':
-            path = url.split(':', 1)[1]
-            path = path.replace('\\', '/')
-            match = _url_slash_drive_re.match(path)
-            if match:
-                path = match.group(1) + ':' + path.split('|', 1)[1]
-            path = urllib_parse.unquote(path)
-            if path.startswith('/'):
-                path = '/' + path.lstrip('/')
-            url = path
-        else:
-            # FIXME: catch some errors
-            resp = session.get(url)
-            resp.raise_for_status()
-            return resp.url, resp.text
-    try:
-        with open(url, 'rb') as f:
-            content = auto_decode(f.read())
-    except IOError as exc:
-        raise InstallationError(
-            'Could not open requirements file: %s' % str(exc)
-        )
-    return url, content
-
-
-_scheme_re = re.compile(r'^(http|https|file):', re.I)
-_url_slash_drive_re = re.compile(r'/*([a-z])\|', re.I)
-
-
-def is_url(name):
-    """Returns true if the name looks like a URL"""
-    if ':' not in name:
-        return False
-    scheme = name.split(':', 1)[0].lower()
-    return scheme in ['http', 'https', 'file', 'ftp'] + vcs.all_schemes
-
-
-def url_to_path(url):
-    """
-    Convert a file: URL to a path.
-    """
-    assert url.startswith('file:'), (
-        "You can only turn file: urls into filenames (not %r)" % url)
-
-    _, netloc, path, _, _ = urllib_parse.urlsplit(url)
-
-    # if we have a UNC path, prepend UNC share notation
-    if netloc:
-        netloc = '\\\\' + netloc
-
-    path = urllib_request.url2pathname(netloc + path)
-    return path
-
-
-def path_to_url(path):
-    """
-    Convert a path to a file: URL.  The path will be made absolute and have
-    quoted path parts.
-    """
-    path = os.path.normpath(os.path.abspath(path))
-    url = urllib_parse.urljoin('file:', urllib_request.pathname2url(path))
-    return url
-
-
-def is_archive_file(name):
-    """Return True if `name` is a considered as an archive file."""
-    ext = splitext(name)[1].lower()
-    if ext in ARCHIVE_EXTENSIONS:
-        return True
-    return False
-
-
-def unpack_vcs_link(link, location):
-    vcs_backend = _get_used_vcs_backend(link)
-    vcs_backend.unpack(location)
-
-
-def _get_used_vcs_backend(link):
-    for backend in vcs.backends:
-        if link.scheme in backend.schemes:
-            vcs_backend = backend(link.url)
-            return vcs_backend
-
-
-def is_vcs_url(link):
-    return bool(_get_used_vcs_backend(link))
-
-
-def is_file_url(link):
-    return link.url.lower().startswith('file:')
-
-
-def is_dir_url(link):
-    """Return whether a file:// Link points to a directory.
-
-    ``link`` must not have any other scheme but file://. Call is_file_url()
-    first.
-
-    """
-    link_path = url_to_path(link.url_without_fragment)
-    return os.path.isdir(link_path)
-
-
-def _progress_indicator(iterable, *args, **kwargs):
-    return iterable
-
-
-def _download_url(resp, link, content_file, hashes):
-    try:
-        total_length = int(resp.headers['content-length'])
-    except (ValueError, KeyError, TypeError):
-        total_length = 0
-
-    cached_resp = getattr(resp, "from_cache", False)
-
-    if logger.getEffectiveLevel() > logging.INFO:
-        show_progress = False
-    elif cached_resp:
-        show_progress = False
-    elif total_length > (40 * 1000):
-        show_progress = True
-    elif not total_length:
-        show_progress = True
-    else:
-        show_progress = False
-
-    show_url = link.show_url
-
-    def resp_read(chunk_size):
-        try:
-            # Special case for urllib3.
-            for chunk in resp.raw.stream(
-                    chunk_size,
-                    # We use decode_content=False here because we don't
-                    # want urllib3 to mess with the raw bytes we get
-                    # from the server. If we decompress inside of
-                    # urllib3 then we cannot verify the checksum
-                    # because the checksum will be of the compressed
-                    # file. This breakage will only occur if the
-                    # server adds a Content-Encoding header, which
-                    # depends on how the server was configured:
-                    # - Some servers will notice that the file isn't a
-                    #   compressible file and will leave the file alone
-                    #   and with an empty Content-Encoding
-                    # - Some servers will notice that the file is
-                    #   already compressed and will leave the file
-                    #   alone and will add a Content-Encoding: gzip
-                    #   header
-                    # - Some servers won't notice anything at all and
-                    #   will take a file that's already been compressed
-                    #   and compress it again and set the
-                    #   Content-Encoding: gzip header
-                    #
-                    # By setting this not to decode automatically we
-                    # hope to eliminate problems with the second case.
-                    decode_content=False):
-                yield chunk
-        except AttributeError:
-            # Standard file-like object.
-            while True:
-                chunk = resp.raw.read(chunk_size)
-                if not chunk:
-                    break
-                yield chunk
-
-    def written_chunks(chunks):
-        for chunk in chunks:
-            content_file.write(chunk)
-            yield chunk
-
-    progress_indicator = _progress_indicator
-
-    if link.netloc == PyPI.netloc:
-        url = show_url
-    else:
-        url = link.url_without_fragment
-
-    if show_progress:  # We don't show progress on cached responses
-        if total_length:
-            logger.info("Downloading %s (%s)", url, format_size(total_length))
-            progress_indicator = DownloadProgressBar(max=total_length).iter
-        else:
-            logger.info("Downloading %s", url)
-            progress_indicator = DownloadProgressSpinner().iter
-    elif cached_resp:
-        logger.info("Using cached %s", url)
-    else:
-        logger.info("Downloading %s", url)
-
-    logger.debug('Downloading from URL %s', link)
-
-    downloaded_chunks = written_chunks(
-        progress_indicator(
-            resp_read(CONTENT_CHUNK_SIZE),
-            CONTENT_CHUNK_SIZE
-        )
-    )
-    if hashes:
-        hashes.check_against_chunks(downloaded_chunks)
-    else:
-        consume(downloaded_chunks)
-
-
-def _copy_file(filename, location, link):
-    copy = True
-    download_location = os.path.join(location, link.filename)
-    if os.path.exists(download_location):
-        response = ask_path_exists(
-            'The file %s exists. (i)gnore, (w)ipe, (b)ackup, (a)abort' %
-            display_path(download_location), ('i', 'w', 'b', 'a'))
-        if response == 'i':
-            copy = False
-        elif response == 'w':
-            logger.warning('Deleting %s', display_path(download_location))
-            os.remove(download_location)
-        elif response == 'b':
-            dest_file = backup_dir(download_location)
-            logger.warning(
-                'Backing up %s to %s',
-                display_path(download_location),
-                display_path(dest_file),
-            )
-            shutil.move(download_location, dest_file)
-        elif response == 'a':
-            sys.exit(-1)
-    if copy:
-        shutil.copy(filename, download_location)
-        logger.info('Saved %s', display_path(download_location))
-
-
-def unpack_http_url(link, location, download_dir=None,
-                    session=None, hashes=None):
-    if session is None:
-        raise TypeError(
-            "unpack_http_url() missing 1 required keyword argument: 'session'"
-        )
-
-    temp_dir = tempfile.mkdtemp('-unpack', 'pip-')
-
-    # If a download dir is specified, is the file already downloaded there?
-    already_downloaded_path = None
-    if download_dir:
-        already_downloaded_path = _check_download_dir(link,
-                                                      download_dir,
-                                                      hashes)
-
-    if already_downloaded_path:
-        from_path = already_downloaded_path
-        content_type = mimetypes.guess_type(from_path)[0]
-    else:
-        # let's download to a tmp dir
-        from_path, content_type = _download_http_url(link,
-                                                     session,
-                                                     temp_dir,
-                                                     hashes)
-
-    # unpack the archive to the build dir location. even when only downloading
-    # archives, they have to be unpacked to parse dependencies
-    unpack_file(from_path, location, content_type, link)
-
-    # a download dir is specified; let's copy the archive there
-    if download_dir and not already_downloaded_path:
-        _copy_file(from_path, download_dir, link)
-
-    if not already_downloaded_path:
-        os.unlink(from_path)
-    rmtree(temp_dir)
-
-
-def unpack_file_url(link, location, download_dir=None, hashes=None):
-    """Unpack link into location.
-
-    If download_dir is provided and link points to a file, make a copy
-    of the link file inside download_dir.
-    """
-    link_path = url_to_path(link.url_without_fragment)
-
-    # If it's a url to a local directory
-    if is_dir_url(link):
-        if os.path.isdir(location):
-            rmtree(location)
-        shutil.copytree(link_path, location, symlinks=True)
-        if download_dir:
-            logger.info('Link is a directory, ignoring download_dir')
-        return
-
-    # If --require-hashes is off, `hashes` is either empty, the
-    # link's embedded hash, or MissingHashes; it is required to
-    # match. If --require-hashes is on, we are satisfied by any
-    # hash in `hashes` matching: a URL-based or an option-based
-    # one; no internet-sourced hash will be in `hashes`.
-    if hashes:
-        hashes.check_against_path(link_path)
-
-    # If a download dir is specified, is the file already there and valid?
-    already_downloaded_path = None
-    if download_dir:
-        already_downloaded_path = _check_download_dir(link,
-                                                      download_dir,
-                                                      hashes)
-
-    if already_downloaded_path:
-        from_path = already_downloaded_path
-    else:
-        from_path = link_path
-
-    content_type = mimetypes.guess_type(from_path)[0]
-
-    # unpack the archive to the build dir location. even when only downloading
-    # archives, they have to be unpacked to parse dependencies
-    unpack_file(from_path, location, content_type, link)
-
-    # a download dir is specified and not already downloaded
-    if download_dir and not already_downloaded_path:
-        _copy_file(from_path, download_dir, link)
-
-
-def _copy_dist_from_dir(link_path, location):
-    """Copy distribution files in `link_path` to `location`.
-
-    Invoked when user requests to install a local directory. E.g.:
-
-        pip install .
-        pip install ~/dev/git-repos/python-prompt-toolkit
-
-    """
-
-    # Note: This is currently VERY SLOW if you have a lot of data in the
-    # directory, because it copies everything with `shutil.copytree`.
-    # What it should really do is build an sdist and install that.
-    # See https://github.com/pypa/pip/issues/2195
-
-    if os.path.isdir(location):
-        rmtree(location)
-
-    # build an sdist
-    setup_py = 'setup.py'
-    sdist_args = [sys.executable]
-    sdist_args.append('-c')
-    sdist_args.append(SETUPTOOLS_SHIM % setup_py)
-    sdist_args.append('sdist')
-    sdist_args += ['--dist-dir', location]
-    logger.info('Running setup.py sdist for %s', link_path)
-
-    with indent_log():
-        call_subprocess(sdist_args, cwd=link_path, show_stdout=False)
-
-    # unpack sdist into `location`
-    sdist = os.path.join(location, os.listdir(location)[0])
-    logger.info('Unpacking sdist %s into %s', sdist, location)
-    unpack_file(sdist, location, content_type=None, link=None)
-
-
-class PipXmlrpcTransport(xmlrpc_client.Transport):
-    """Provide a `xmlrpclib.Transport` implementation via a `PipSession`
-    object.
-    """
-
-    def __init__(self, index_url, session, use_datetime=False):
-        xmlrpc_client.Transport.__init__(self, use_datetime)
-        index_parts = urllib_parse.urlparse(index_url)
-        self._scheme = index_parts.scheme
-        self._session = session
-
-    def request(self, host, handler, request_body, verbose=False):
-        parts = (self._scheme, host, handler, None, None, None)
-        url = urllib_parse.urlunparse(parts)
-        try:
-            headers = {'Content-Type': 'text/xml'}
-            response = self._session.post(url, data=request_body,
-                                          headers=headers, stream=True)
-            response.raise_for_status()
-            self.verbose = verbose
-            return self.parse_response(response.raw)
-        except requests.HTTPError as exc:
-            logger.critical(
-                "HTTP error %s while getting %s",
-                exc.response.status_code, url,
-            )
-            raise
-
-
-def unpack_url(link, location, download_dir=None,
-               only_download=False, session=None, hashes=None):
-    """Unpack link.
-       If link is a VCS link:
-         if only_download, export into download_dir and ignore location
-          else unpack into location
-       for other types of link:
-         - unpack into location
-         - if download_dir, copy the file into download_dir
-         - if only_download, mark location for deletion
-
-    :param hashes: A Hashes object, one of whose embedded hashes must match,
-        or HashMismatch will be raised. If the Hashes is empty, no matches are
-        required, and unhashable types of requirements (like VCS ones, which
-        would ordinarily raise HashUnsupported) are allowed.
-    """
-    # non-editable vcs urls
-    if is_vcs_url(link):
-        unpack_vcs_link(link, location)
-
-    # file urls
-    elif is_file_url(link):
-        unpack_file_url(link, location, download_dir, hashes=hashes)
-
-    # http urls
-    else:
-        if session is None:
-            session = PipSession()
-
-        unpack_http_url(
-            link,
-            location,
-            download_dir,
-            session,
-            hashes=hashes
-        )
-    if only_download:
-        write_delete_marker_file(location)
-
-
-def _download_http_url(link, session, temp_dir, hashes):
-    """Download link url into temp_dir using provided session"""
-    target_url = link.url.split('#', 1)[0]
-    try:
-        resp = session.get(
-            target_url,
-            # We use Accept-Encoding: identity here because requests
-            # defaults to accepting compressed responses. This breaks in
-            # a variety of ways depending on how the server is configured.
-            # - Some servers will notice that the file isn't a compressible
-            #   file and will leave the file alone and with an empty
-            #   Content-Encoding
-            # - Some servers will notice that the file is already
-            #   compressed and will leave the file alone and will add a
-            #   Content-Encoding: gzip header
-            # - Some servers won't notice anything at all and will take
-            #   a file that's already been compressed and compress it again
-            #   and set the Content-Encoding: gzip header
-            # By setting this to request only the identity encoding We're
-            # hoping to eliminate the third case. Hopefully there does not
-            # exist a server which when given a file will notice it is
-            # already compressed and that you're not asking for a
-            # compressed file and will then decompress it before sending
-            # because if that's the case I don't think it'll ever be
-            # possible to make this work.
-            headers={"Accept-Encoding": "identity"},
-            stream=True,
-        )
-        resp.raise_for_status()
-    except requests.HTTPError as exc:
-        logger.critical(
-            "HTTP error %s while getting %s", exc.response.status_code, link,
-        )
-        raise
-
-    content_type = resp.headers.get('content-type', '')
-    filename = link.filename  # fallback
-    # Have a look at the Content-Disposition header for a better guess
-    content_disposition = resp.headers.get('content-disposition')
-    if content_disposition:
-        type, params = cgi.parse_header(content_disposition)
-        # We use ``or`` here because we don't want to use an "empty" value
-        # from the filename param.
-        filename = params.get('filename') or filename
-    ext = splitext(filename)[1]
-    if not ext:
-        ext = mimetypes.guess_extension(content_type)
-        if ext:
-            filename += ext
-    if not ext and link.url != resp.url:
-        ext = os.path.splitext(resp.url)[1]
-        if ext:
-            filename += ext
-    file_path = os.path.join(temp_dir, filename)
-    with open(file_path, 'wb') as content_file:
-        _download_url(resp, link, content_file, hashes)
-    return file_path, content_type
-
-
-def _check_download_dir(link, download_dir, hashes):
-    """ Check download_dir for previously downloaded file with correct hash
-        If a correct file is found return its path else None
-    """
-    download_path = os.path.join(download_dir, link.filename)
-    if os.path.exists(download_path):
-        # If already downloaded, does its hash match?
-        logger.info('File was already downloaded %s', download_path)
-        if hashes:
-            try:
-                hashes.check_against_path(download_path)
-            except HashMismatch:
-                logger.warning(
-                    'Previously-downloaded file %s has bad hash. '
-                    'Re-downloading.',
-                    download_path
-                )
-                os.unlink(download_path)
-                return None
-        return download_path
-    return None
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/exceptions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/exceptions.py
deleted file mode 100644
index 50b527f90..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/exceptions.py
+++ /dev/null
@@ -1,244 +0,0 @@
-"""Exceptions used throughout package"""
-from __future__ import absolute_import
-
-from itertools import chain, groupby, repeat
-
-from pip._vendor.six import iteritems
-
-
-class PipError(Exception):
-    """Base pip exception"""
-
-
-class InstallationError(PipError):
-    """General exception during installation"""
-
-
-class UninstallationError(PipError):
-    """General exception during uninstallation"""
-
-
-class DistributionNotFound(InstallationError):
-    """Raised when a distribution cannot be found to satisfy a requirement"""
-
-
-class RequirementsFileParseError(InstallationError):
-    """Raised when a general error occurs parsing a requirements file line."""
-
-
-class BestVersionAlreadyInstalled(PipError):
-    """Raised when the most up-to-date version of a package is already
-    installed."""
-
-
-class BadCommand(PipError):
-    """Raised when virtualenv or a command is not found"""
-
-
-class CommandError(PipError):
-    """Raised when there is an error in command-line arguments"""
-
-
-class PreviousBuildDirError(PipError):
-    """Raised when there's a previous conflicting build directory"""
-
-
-class InvalidWheelFilename(InstallationError):
-    """Invalid wheel filename."""
-
-
-class UnsupportedWheel(InstallationError):
-    """Unsupported wheel."""
-
-
-class HashErrors(InstallationError):
-    """Multiple HashError instances rolled into one for reporting"""
-
-    def __init__(self):
-        self.errors = []
-
-    def append(self, error):
-        self.errors.append(error)
-
-    def __str__(self):
-        lines = []
-        self.errors.sort(key=lambda e: e.order)
-        for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__):
-            lines.append(cls.head)
-            lines.extend(e.body() for e in errors_of_cls)
-        if lines:
-            return '\n'.join(lines)
-
-    def __nonzero__(self):
-        return bool(self.errors)
-
-    def __bool__(self):
-        return self.__nonzero__()
-
-
-class HashError(InstallationError):
-    """
-    A failure to verify a package against known-good hashes
-
-    :cvar order: An int sorting hash exception classes by difficulty of
-        recovery (lower being harder), so the user doesn't bother fretting
-        about unpinned packages when he has deeper issues, like VCS
-        dependencies, to deal with. Also keeps error reports in a
-        deterministic order.
-    :cvar head: A section heading for display above potentially many
-        exceptions of this kind
-    :ivar req: The InstallRequirement that triggered this error. This is
-        pasted on after the exception is instantiated, because it's not
-        typically available earlier.
-
-    """
-    req = None
-    head = ''
-
-    def body(self):
-        """Return a summary of me for display under the heading.
-
-        This default implementation simply prints a description of the
-        triggering requirement.
-
-        :param req: The InstallRequirement that provoked this error, with
-            populate_link() having already been called
-
-        """
-        return '    %s' % self._requirement_name()
-
-    def __str__(self):
-        return '%s\n%s' % (self.head, self.body())
-
-    def _requirement_name(self):
-        """Return a description of the requirement that triggered me.
-
-        This default implementation returns long description of the req, with
-        line numbers
-
-        """
-        return str(self.req) if self.req else 'unknown package'
-
-
-class VcsHashUnsupported(HashError):
-    """A hash was provided for a version-control-system-based requirement, but
-    we don't have a method for hashing those."""
-
-    order = 0
-    head = ("Can't verify hashes for these requirements because we don't "
-            "have a way to hash version control repositories:")
-
-
-class DirectoryUrlHashUnsupported(HashError):
-    """A hash was provided for a version-control-system-based requirement, but
-    we don't have a method for hashing those."""
-
-    order = 1
-    head = ("Can't verify hashes for these file:// requirements because they "
-            "point to directories:")
-
-
-class HashMissing(HashError):
-    """A hash was needed for a requirement but is absent."""
-
-    order = 2
-    head = ('Hashes are required in --require-hashes mode, but they are '
-            'missing from some requirements. Here is a list of those '
-            'requirements along with the hashes their downloaded archives '
-            'actually had. Add lines like these to your requirements files to '
-            'prevent tampering. (If you did not enable --require-hashes '
-            'manually, note that it turns on automatically when any package '
-            'has a hash.)')
-
-    def __init__(self, gotten_hash):
-        """
-        :param gotten_hash: The hash of the (possibly malicious) archive we
-            just downloaded
-        """
-        self.gotten_hash = gotten_hash
-
-    def body(self):
-        from pip.utils.hashes import FAVORITE_HASH  # Dodge circular import.
-
-        package = None
-        if self.req:
-            # In the case of URL-based requirements, display the original URL
-            # seen in the requirements file rather than the package name,
-            # so the output can be directly copied into the requirements file.
-            package = (self.req.original_link if self.req.original_link
-                       # In case someone feeds something downright stupid
-                       # to InstallRequirement's constructor.
-                       else getattr(self.req, 'req', None))
-        return '    %s --hash=%s:%s' % (package or 'unknown package',
-                                        FAVORITE_HASH,
-                                        self.gotten_hash)
-
-
-class HashUnpinned(HashError):
-    """A requirement had a hash specified but was not pinned to a specific
-    version."""
-
-    order = 3
-    head = ('In --require-hashes mode, all requirements must have their '
-            'versions pinned with ==. These do not:')
-
-
-class HashMismatch(HashError):
-    """
-    Distribution file hash values don't match.
-
-    :ivar package_name: The name of the package that triggered the hash
-        mismatch. Feel free to write to this after the exception is raise to
-        improve its error message.
-
-    """
-    order = 4
-    head = ('THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS '
-            'FILE. If you have updated the package versions, please update '
-            'the hashes. Otherwise, examine the package contents carefully; '
-            'someone may have tampered with them.')
-
-    def __init__(self, allowed, gots):
-        """
-        :param allowed: A dict of algorithm names pointing to lists of allowed
-            hex digests
-        :param gots: A dict of algorithm names pointing to hashes we
-            actually got from the files under suspicion
-        """
-        self.allowed = allowed
-        self.gots = gots
-
-    def body(self):
-        return '    %s:\n%s' % (self._requirement_name(),
-                                self._hash_comparison())
-
-    def _hash_comparison(self):
-        """
-        Return a comparison of actual and expected hash values.
-
-        Example::
-
-               Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
-                            or 123451234512345123451234512345123451234512345
-                    Got        bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef
-
-        """
-        def hash_then_or(hash_name):
-            # For now, all the decent hashes have 6-char names, so we can get
-            # away with hard-coding space literals.
-            return chain([hash_name], repeat('    or'))
-
-        lines = []
-        for hash_name, expecteds in iteritems(self.allowed):
-            prefix = hash_then_or(hash_name)
-            lines.extend(('        Expected %s %s' % (next(prefix), e))
-                         for e in expecteds)
-            lines.append('             Got        %s\n' %
-                         self.gots[hash_name].hexdigest())
-            prefix = '    or'
-        return '\n'.join(lines)
-
-
-class UnsupportedPythonVersion(InstallationError):
-    """Unsupported python version according to Requires-Python package
-    metadata."""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/index.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/index.py
deleted file mode 100644
index f653f6e6a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/index.py
+++ /dev/null
@@ -1,1102 +0,0 @@
-"""Routines related to PyPI, indexes"""
-from __future__ import absolute_import
-
-import logging
-import cgi
-from collections import namedtuple
-import itertools
-import sys
-import os
-import re
-import mimetypes
-import posixpath
-import warnings
-
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-from pip._vendor.six.moves.urllib import request as urllib_request
-
-from pip.compat import ipaddress
-from pip.utils import (
-    cached_property, splitext, normalize_path,
-    ARCHIVE_EXTENSIONS, SUPPORTED_EXTENSIONS,
-)
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip.utils.logging import indent_log
-from pip.utils.packaging import check_requires_python
-from pip.exceptions import (
-    DistributionNotFound, BestVersionAlreadyInstalled, InvalidWheelFilename,
-    UnsupportedWheel,
-)
-from pip.download import HAS_TLS, is_url, path_to_url, url_to_path
-from pip.wheel import Wheel, wheel_ext
-from pip.pep425tags import get_supported
-from pip._vendor import html5lib, requests, six
-from pip._vendor.packaging.version import parse as parse_version
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging import specifiers
-from pip._vendor.requests.exceptions import SSLError
-from pip._vendor.distlib.compat import unescape
-
-
-__all__ = ['FormatControl', 'fmt_ctl_handle_mutual_exclude', 'PackageFinder']
-
-
-SECURE_ORIGINS = [
-    # protocol, hostname, port
-    # Taken from Chrome's list of secure origins (See: http://bit.ly/1qrySKC)
-    ("https", "*", "*"),
-    ("*", "localhost", "*"),
-    ("*", "127.0.0.0/8", "*"),
-    ("*", "::1/128", "*"),
-    ("file", "*", None),
-    # ssh is always secure.
-    ("ssh", "*", "*"),
-]
-
-
-logger = logging.getLogger(__name__)
-
-
-class InstallationCandidate(object):
-
-    def __init__(self, project, version, location):
-        self.project = project
-        self.version = parse_version(version)
-        self.location = location
-        self._key = (self.project, self.version, self.location)
-
-    def __repr__(self):
-        return "<InstallationCandidate({0!r}, {1!r}, {2!r})>".format(
-            self.project, self.version, self.location,
-        )
-
-    def __hash__(self):
-        return hash(self._key)
-
-    def __lt__(self, other):
-        return self._compare(other, lambda s, o: s < o)
-
-    def __le__(self, other):
-        return self._compare(other, lambda s, o: s <= o)
-
-    def __eq__(self, other):
-        return self._compare(other, lambda s, o: s == o)
-
-    def __ge__(self, other):
-        return self._compare(other, lambda s, o: s >= o)
-
-    def __gt__(self, other):
-        return self._compare(other, lambda s, o: s > o)
-
-    def __ne__(self, other):
-        return self._compare(other, lambda s, o: s != o)
-
-    def _compare(self, other, method):
-        if not isinstance(other, InstallationCandidate):
-            return NotImplemented
-
-        return method(self._key, other._key)
-
-
-class PackageFinder(object):
-    """This finds packages.
-
-    This is meant to match easy_install's technique for looking for
-    packages, by reading pages and looking for appropriate links.
-    """
-
-    def __init__(self, find_links, index_urls, allow_all_prereleases=False,
-                 trusted_hosts=None, process_dependency_links=False,
-                 session=None, format_control=None, platform=None,
-                 versions=None, abi=None, implementation=None):
-        """Create a PackageFinder.
-
-        :param format_control: A FormatControl object or None. Used to control
-            the selection of source packages / binary packages when consulting
-            the index and links.
-        :param platform: A string or None. If None, searches for packages
-            that are supported by the current system. Otherwise, will find
-            packages that can be built on the platform passed in. These
-            packages will only be downloaded for distribution: they will
-            not be built locally.
-        :param versions: A list of strings or None. This is passed directly
-            to pep425tags.py in the get_supported() method.
-        :param abi: A string or None. This is passed directly
-            to pep425tags.py in the get_supported() method.
-        :param implementation: A string or None. This is passed directly
-            to pep425tags.py in the get_supported() method.
-        """
-        if session is None:
-            raise TypeError(
-                "PackageFinder() missing 1 required keyword argument: "
-                "'session'"
-            )
-
-        # Build find_links. If an argument starts with ~, it may be
-        # a local file relative to a home directory. So try normalizing
-        # it and if it exists, use the normalized version.
-        # This is deliberately conservative - it might be fine just to
-        # blindly normalize anything starting with a ~...
-        self.find_links = []
-        for link in find_links:
-            if link.startswith('~'):
-                new_link = normalize_path(link)
-                if os.path.exists(new_link):
-                    link = new_link
-            self.find_links.append(link)
-
-        self.index_urls = index_urls
-        self.dependency_links = []
-
-        # These are boring links that have already been logged somehow:
-        self.logged_links = set()
-
-        self.format_control = format_control or FormatControl(set(), set())
-
-        # Domains that we won't emit warnings for when not using HTTPS
-        self.secure_origins = [
-            ("*", host, "*")
-            for host in (trusted_hosts if trusted_hosts else [])
-        ]
-
-        # Do we want to allow _all_ pre-releases?
-        self.allow_all_prereleases = allow_all_prereleases
-
-        # Do we process dependency links?
-        self.process_dependency_links = process_dependency_links
-
-        # The Session we'll use to make requests
-        self.session = session
-
-        # The valid tags to check potential found wheel candidates against
-        self.valid_tags = get_supported(
-            versions=versions,
-            platform=platform,
-            abi=abi,
-            impl=implementation,
-        )
-
-        # If we don't have TLS enabled, then WARN if anyplace we're looking
-        # relies on TLS.
-        if not HAS_TLS:
-            for link in itertools.chain(self.index_urls, self.find_links):
-                parsed = urllib_parse.urlparse(link)
-                if parsed.scheme == "https":
-                    logger.warning(
-                        "pip is configured with locations that require "
-                        "TLS/SSL, however the ssl module in Python is not "
-                        "available."
-                    )
-                    break
-
-    def add_dependency_links(self, links):
-        # # FIXME: this shouldn't be global list this, it should only
-        # # apply to requirements of the package that specifies the
-        # # dependency_links value
-        # # FIXME: also, we should track comes_from (i.e., use Link)
-        if self.process_dependency_links:
-            warnings.warn(
-                "Dependency Links processing has been deprecated and will be "
-                "removed in a future release.",
-                RemovedInPip10Warning,
-            )
-            self.dependency_links.extend(links)
-
-    @staticmethod
-    def _sort_locations(locations, expand_dir=False):
-        """
-        Sort locations into "files" (archives) and "urls", and return
-        a pair of lists (files,urls)
-        """
-        files = []
-        urls = []
-
-        # puts the url for the given file path into the appropriate list
-        def sort_path(path):
-            url = path_to_url(path)
-            if mimetypes.guess_type(url, strict=False)[0] == 'text/html':
-                urls.append(url)
-            else:
-                files.append(url)
-
-        for url in locations:
-
-            is_local_path = os.path.exists(url)
-            is_file_url = url.startswith('file:')
-
-            if is_local_path or is_file_url:
-                if is_local_path:
-                    path = url
-                else:
-                    path = url_to_path(url)
-                if os.path.isdir(path):
-                    if expand_dir:
-                        path = os.path.realpath(path)
-                        for item in os.listdir(path):
-                            sort_path(os.path.join(path, item))
-                    elif is_file_url:
-                        urls.append(url)
-                elif os.path.isfile(path):
-                    sort_path(path)
-                else:
-                    logger.warning(
-                        "Url '%s' is ignored: it is neither a file "
-                        "nor a directory.", url)
-            elif is_url(url):
-                # Only add url with clear scheme
-                urls.append(url)
-            else:
-                logger.warning(
-                    "Url '%s' is ignored. It is either a non-existing "
-                    "path or lacks a specific scheme.", url)
-
-        return files, urls
-
-    def _candidate_sort_key(self, candidate):
-        """
-        Function used to generate link sort key for link tuples.
-        The greater the return value, the more preferred it is.
-        If not finding wheels, then sorted by version only.
-        If finding wheels, then the sort order is by version, then:
-          1. existing installs
-          2. wheels ordered via Wheel.support_index_min(self.valid_tags)
-          3. source archives
-        Note: it was considered to embed this logic into the Link
-              comparison operators, but then different sdist links
-              with the same version, would have to be considered equal
-        """
-        support_num = len(self.valid_tags)
-        if candidate.location.is_wheel:
-            # can raise InvalidWheelFilename
-            wheel = Wheel(candidate.location.filename)
-            if not wheel.supported(self.valid_tags):
-                raise UnsupportedWheel(
-                    "%s is not a supported wheel for this platform. It "
-                    "can't be sorted." % wheel.filename
-                )
-            pri = -(wheel.support_index_min(self.valid_tags))
-        else:  # sdist
-            pri = -(support_num)
-        return (candidate.version, pri)
-
-    def _validate_secure_origin(self, logger, location):
-        # Determine if this url used a secure transport mechanism
-        parsed = urllib_parse.urlparse(str(location))
-        origin = (parsed.scheme, parsed.hostname, parsed.port)
-
-        # The protocol to use to see if the protocol matches.
-        # Don't count the repository type as part of the protocol: in
-        # cases such as "git+ssh", only use "ssh". (I.e., Only verify against
-        # the last scheme.)
-        protocol = origin[0].rsplit('+', 1)[-1]
-
-        # Determine if our origin is a secure origin by looking through our
-        # hardcoded list of secure origins, as well as any additional ones
-        # configured on this PackageFinder instance.
-        for secure_origin in (SECURE_ORIGINS + self.secure_origins):
-            if protocol != secure_origin[0] and secure_origin[0] != "*":
-                continue
-
-            try:
-                # We need to do this decode dance to ensure that we have a
-                # unicode object, even on Python 2.x.
-                addr = ipaddress.ip_address(
-                    origin[1]
-                    if (
-                        isinstance(origin[1], six.text_type) or
-                        origin[1] is None
-                    )
-                    else origin[1].decode("utf8")
-                )
-                network = ipaddress.ip_network(
-                    secure_origin[1]
-                    if isinstance(secure_origin[1], six.text_type)
-                    else secure_origin[1].decode("utf8")
-                )
-            except ValueError:
-                # We don't have both a valid address or a valid network, so
-                # we'll check this origin against hostnames.
-                if (origin[1] and
-                        origin[1].lower() != secure_origin[1].lower() and
-                        secure_origin[1] != "*"):
-                    continue
-            else:
-                # We have a valid address and network, so see if the address
-                # is contained within the network.
-                if addr not in network:
-                    continue
-
-            # Check to see if the port patches
-            if (origin[2] != secure_origin[2] and
-                    secure_origin[2] != "*" and
-                    secure_origin[2] is not None):
-                continue
-
-            # If we've gotten here, then this origin matches the current
-            # secure origin and we should return True
-            return True
-
-        # If we've gotten to this point, then the origin isn't secure and we
-        # will not accept it as a valid location to search. We will however
-        # log a warning that we are ignoring it.
-        logger.warning(
-            "The repository located at %s is not a trusted or secure host and "
-            "is being ignored. If this repository is available via HTTPS it "
-            "is recommended to use HTTPS instead, otherwise you may silence "
-            "this warning and allow it anyways with '--trusted-host %s'.",
-            parsed.hostname,
-            parsed.hostname,
-        )
-
-        return False
-
-    def _get_index_urls_locations(self, project_name):
-        """Returns the locations found via self.index_urls
-
-        Checks the url_name on the main (first in the list) index and
-        use this url_name to produce all locations
-        """
-
-        def mkurl_pypi_url(url):
-            loc = posixpath.join(
-                url,
-                urllib_parse.quote(canonicalize_name(project_name)))
-            # For maximum compatibility with easy_install, ensure the path
-            # ends in a trailing slash.  Although this isn't in the spec
-            # (and PyPI can handle it without the slash) some other index
-            # implementations might break if they relied on easy_install's
-            # behavior.
-            if not loc.endswith('/'):
-                loc = loc + '/'
-            return loc
-
-        return [mkurl_pypi_url(url) for url in self.index_urls]
-
-    def find_all_candidates(self, project_name):
-        """Find all available InstallationCandidate for project_name
-
-        This checks index_urls, find_links and dependency_links.
-        All versions found are returned as an InstallationCandidate list.
-
-        See _link_package_versions for details on which files are accepted
-        """
-        index_locations = self._get_index_urls_locations(project_name)
-        index_file_loc, index_url_loc = self._sort_locations(index_locations)
-        fl_file_loc, fl_url_loc = self._sort_locations(
-            self.find_links, expand_dir=True)
-        dep_file_loc, dep_url_loc = self._sort_locations(self.dependency_links)
-
-        file_locations = (
-            Link(url) for url in itertools.chain(
-                index_file_loc, fl_file_loc, dep_file_loc)
-        )
-
-        # We trust every url that the user has given us whether it was given
-        #   via --index-url or --find-links
-        # We explicitly do not trust links that came from dependency_links
-        # We want to filter out any thing which does not have a secure origin.
-        url_locations = [
-            link for link in itertools.chain(
-                (Link(url) for url in index_url_loc),
-                (Link(url) for url in fl_url_loc),
-                (Link(url) for url in dep_url_loc),
-            )
-            if self._validate_secure_origin(logger, link)
-        ]
-
-        logger.debug('%d location(s) to search for versions of %s:',
-                     len(url_locations), project_name)
-
-        for location in url_locations:
-            logger.debug('* %s', location)
-
-        canonical_name = canonicalize_name(project_name)
-        formats = fmt_ctl_formats(self.format_control, canonical_name)
-        search = Search(project_name, canonical_name, formats)
-        find_links_versions = self._package_versions(
-            # We trust every directly linked archive in find_links
-            (Link(url, '-f') for url in self.find_links),
-            search
-        )
-
-        page_versions = []
-        for page in self._get_pages(url_locations, project_name):
-            logger.debug('Analyzing links from page %s', page.url)
-            with indent_log():
-                page_versions.extend(
-                    self._package_versions(page.links, search)
-                )
-
-        dependency_versions = self._package_versions(
-            (Link(url) for url in self.dependency_links), search
-        )
-        if dependency_versions:
-            logger.debug(
-                'dependency_links found: %s',
-                ', '.join([
-                    version.location.url for version in dependency_versions
-                ])
-            )
-
-        file_versions = self._package_versions(file_locations, search)
-        if file_versions:
-            file_versions.sort(reverse=True)
-            logger.debug(
-                'Local files found: %s',
-                ', '.join([
-                    url_to_path(candidate.location.url)
-                    for candidate in file_versions
-                ])
-            )
-
-        # This is an intentional priority ordering
-        return (
-            file_versions + find_links_versions + page_versions +
-            dependency_versions
-        )
-
-    def find_requirement(self, req, upgrade):
-        """Try to find a Link matching req
-
-        Expects req, an InstallRequirement and upgrade, a boolean
-        Returns a Link if found,
-        Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
-        """
-        all_candidates = self.find_all_candidates(req.name)
-
-        # Filter out anything which doesn't match our specifier
-        compatible_versions = set(
-            req.specifier.filter(
-                # We turn the version object into a str here because otherwise
-                # when we're debundled but setuptools isn't, Python will see
-                # packaging.version.Version and
-                # pkg_resources._vendor.packaging.version.Version as different
-                # types. This way we'll use a str as a common data interchange
-                # format. If we stop using the pkg_resources provided specifier
-                # and start using our own, we can drop the cast to str().
-                [str(c.version) for c in all_candidates],
-                prereleases=(
-                    self.allow_all_prereleases
-                    if self.allow_all_prereleases else None
-                ),
-            )
-        )
-        applicable_candidates = [
-            # Again, converting to str to deal with debundling.
-            c for c in all_candidates if str(c.version) in compatible_versions
-        ]
-
-        if applicable_candidates:
-            best_candidate = max(applicable_candidates,
-                                 key=self._candidate_sort_key)
-        else:
-            best_candidate = None
-
-        if req.satisfied_by is not None:
-            installed_version = parse_version(req.satisfied_by.version)
-        else:
-            installed_version = None
-
-        if installed_version is None and best_candidate is None:
-            logger.critical(
-                'Could not find a version that satisfies the requirement %s '
-                '(from versions: %s)',
-                req,
-                ', '.join(
-                    sorted(
-                        set(str(c.version) for c in all_candidates),
-                        key=parse_version,
-                    )
-                )
-            )
-
-            raise DistributionNotFound(
-                'No matching distribution found for %s' % req
-            )
-
-        best_installed = False
-        if installed_version and (
-                best_candidate is None or
-                best_candidate.version <= installed_version):
-            best_installed = True
-
-        if not upgrade and installed_version is not None:
-            if best_installed:
-                logger.debug(
-                    'Existing installed version (%s) is most up-to-date and '
-                    'satisfies requirement',
-                    installed_version,
-                )
-            else:
-                logger.debug(
-                    'Existing installed version (%s) satisfies requirement '
-                    '(most up-to-date version is %s)',
-                    installed_version,
-                    best_candidate.version,
-                )
-            return None
-
-        if best_installed:
-            # We have an existing version, and its the best version
-            logger.debug(
-                'Installed version (%s) is most up-to-date (past versions: '
-                '%s)',
-                installed_version,
-                ', '.join(sorted(compatible_versions, key=parse_version)) or
-                "none",
-            )
-            raise BestVersionAlreadyInstalled
-
-        logger.debug(
-            'Using version %s (newest of versions: %s)',
-            best_candidate.version,
-            ', '.join(sorted(compatible_versions, key=parse_version))
-        )
-        return best_candidate.location
-
-    def _get_pages(self, locations, project_name):
-        """
-        Yields (page, page_url) from the given locations, skipping
-        locations that have errors.
-        """
-        seen = set()
-        for location in locations:
-            if location in seen:
-                continue
-            seen.add(location)
-
-            page = self._get_page(location)
-            if page is None:
-                continue
-
-            yield page
-
-    _py_version_re = re.compile(r'-py([123]\.?[0-9]?)$')
-
-    def _sort_links(self, links):
-        """
-        Returns elements of links in order, non-egg links first, egg links
-        second, while eliminating duplicates
-        """
-        eggs, no_eggs = [], []
-        seen = set()
-        for link in links:
-            if link not in seen:
-                seen.add(link)
-                if link.egg_fragment:
-                    eggs.append(link)
-                else:
-                    no_eggs.append(link)
-        return no_eggs + eggs
-
-    def _package_versions(self, links, search):
-        result = []
-        for link in self._sort_links(links):
-            v = self._link_package_versions(link, search)
-            if v is not None:
-                result.append(v)
-        return result
-
-    def _log_skipped_link(self, link, reason):
-        if link not in self.logged_links:
-            logger.debug('Skipping link %s; %s', link, reason)
-            self.logged_links.add(link)
-
-    def _link_package_versions(self, link, search):
-        """Return an InstallationCandidate or None"""
-        version = None
-        if link.egg_fragment:
-            egg_info = link.egg_fragment
-            ext = link.ext
-        else:
-            egg_info, ext = link.splitext()
-            if not ext:
-                self._log_skipped_link(link, 'not a file')
-                return
-            if ext not in SUPPORTED_EXTENSIONS:
-                self._log_skipped_link(
-                    link, 'unsupported archive format: %s' % ext)
-                return
-            if "binary" not in search.formats and ext == wheel_ext:
-                self._log_skipped_link(
-                    link, 'No binaries permitted for %s' % search.supplied)
-                return
-            if "macosx10" in link.path and ext == '.zip':
-                self._log_skipped_link(link, 'macosx10 one')
-                return
-            if ext == wheel_ext:
-                try:
-                    wheel = Wheel(link.filename)
-                except InvalidWheelFilename:
-                    self._log_skipped_link(link, 'invalid wheel filename')
-                    return
-                if canonicalize_name(wheel.name) != search.canonical:
-                    self._log_skipped_link(
-                        link, 'wrong project name (not %s)' % search.supplied)
-                    return
-
-                if not wheel.supported(self.valid_tags):
-                    self._log_skipped_link(
-                        link, 'it is not compatible with this Python')
-                    return
-
-                version = wheel.version
-
-        # This should be up by the search.ok_binary check, but see issue 2700.
-        if "source" not in search.formats and ext != wheel_ext:
-            self._log_skipped_link(
-                link, 'No sources permitted for %s' % search.supplied)
-            return
-
-        if not version:
-            version = egg_info_matches(egg_info, search.supplied, link)
-        if version is None:
-            self._log_skipped_link(
-                link, 'wrong project name (not %s)' % search.supplied)
-            return
-
-        match = self._py_version_re.search(version)
-        if match:
-            version = version[:match.start()]
-            py_version = match.group(1)
-            if py_version != sys.version[:3]:
-                self._log_skipped_link(
-                    link, 'Python version is incorrect')
-                return
-        try:
-            support_this_python = check_requires_python(link.requires_python)
-        except specifiers.InvalidSpecifier:
-            logger.debug("Package %s has an invalid Requires-Python entry: %s",
-                         link.filename, link.requires_python)
-            support_this_python = True
-
-        if not support_this_python:
-            logger.debug("The package %s is incompatible with the python"
-                         "version in use. Acceptable python versions are:%s",
-                         link, link.requires_python)
-            return
-        logger.debug('Found link %s, version: %s', link, version)
-
-        return InstallationCandidate(search.supplied, version, link)
-
-    def _get_page(self, link):
-        return HTMLPage.get_page(link, session=self.session)
-
-
-def egg_info_matches(
-        egg_info, search_name, link,
-        _egg_info_re=re.compile(r'([a-z0-9_.]+)-([a-z0-9_.!+-]+)', re.I)):
-    """Pull the version part out of a string.
-
-    :param egg_info: The string to parse. E.g. foo-2.1
-    :param search_name: The name of the package this belongs to. None to
-        infer the name. Note that this cannot unambiguously parse strings
-        like foo-2-2 which might be foo, 2-2 or foo-2, 2.
-    :param link: The link the string came from, for logging on failure.
-    """
-    match = _egg_info_re.search(egg_info)
-    if not match:
-        logger.debug('Could not parse version from link: %s', link)
-        return None
-    if search_name is None:
-        full_match = match.group(0)
-        return full_match[full_match.index('-'):]
-    name = match.group(0).lower()
-    # To match the "safe" name that pkg_resources creates:
-    name = name.replace('_', '-')
-    # project name and version must be separated by a dash
-    look_for = search_name.lower() + "-"
-    if name.startswith(look_for):
-        return match.group(0)[len(look_for):]
-    else:
-        return None
-
-
-class HTMLPage(object):
-    """Represents one page, along with its URL"""
-
-    def __init__(self, content, url, headers=None):
-        # Determine if we have any encoding information in our headers
-        encoding = None
-        if headers and "Content-Type" in headers:
-            content_type, params = cgi.parse_header(headers["Content-Type"])
-
-            if "charset" in params:
-                encoding = params['charset']
-
-        self.content = content
-        self.parsed = html5lib.parse(
-            self.content,
-            transport_encoding=encoding,
-            namespaceHTMLElements=False,
-        )
-        self.url = url
-        self.headers = headers
-
-    def __str__(self):
-        return self.url
-
-    @classmethod
-    def get_page(cls, link, skip_archives=True, session=None):
-        if session is None:
-            raise TypeError(
-                "get_page() missing 1 required keyword argument: 'session'"
-            )
-
-        url = link.url
-        url = url.split('#', 1)[0]
-
-        # Check for VCS schemes that do not support lookup as web pages.
-        from pip.vcs import VcsSupport
-        for scheme in VcsSupport.schemes:
-            if url.lower().startswith(scheme) and url[len(scheme)] in '+:':
-                logger.debug('Cannot look at %s URL %s', scheme, link)
-                return None
-
-        try:
-            if skip_archives:
-                filename = link.filename
-                for bad_ext in ARCHIVE_EXTENSIONS:
-                    if filename.endswith(bad_ext):
-                        content_type = cls._get_content_type(
-                            url, session=session,
-                        )
-                        if content_type.lower().startswith('text/html'):
-                            break
-                        else:
-                            logger.debug(
-                                'Skipping page %s because of Content-Type: %s',
-                                link,
-                                content_type,
-                            )
-                            return
-
-            logger.debug('Getting page %s', url)
-
-            # Tack index.html onto file:// URLs that point to directories
-            (scheme, netloc, path, params, query, fragment) = \
-                urllib_parse.urlparse(url)
-            if (scheme == 'file' and
-                    os.path.isdir(urllib_request.url2pathname(path))):
-                # add trailing slash if not present so urljoin doesn't trim
-                # final segment
-                if not url.endswith('/'):
-                    url += '/'
-                url = urllib_parse.urljoin(url, 'index.html')
-                logger.debug(' file: URL is directory, getting %s', url)
-
-            resp = session.get(
-                url,
-                headers={
-                    "Accept": "text/html",
-                    "Cache-Control": "max-age=600",
-                },
-            )
-            resp.raise_for_status()
-
-            # The check for archives above only works if the url ends with
-            # something that looks like an archive. However that is not a
-            # requirement of an url. Unless we issue a HEAD request on every
-            # url we cannot know ahead of time for sure if something is HTML
-            # or not. However we can check after we've downloaded it.
-            content_type = resp.headers.get('Content-Type', 'unknown')
-            if not content_type.lower().startswith("text/html"):
-                logger.debug(
-                    'Skipping page %s because of Content-Type: %s',
-                    link,
-                    content_type,
-                )
-                return
-
-            inst = cls(resp.content, resp.url, resp.headers)
-        except requests.HTTPError as exc:
-            cls._handle_fail(link, exc, url)
-        except SSLError as exc:
-            reason = ("There was a problem confirming the ssl certificate: "
-                      "%s" % exc)
-            cls._handle_fail(link, reason, url, meth=logger.info)
-        except requests.ConnectionError as exc:
-            cls._handle_fail(link, "connection error: %s" % exc, url)
-        except requests.Timeout:
-            cls._handle_fail(link, "timed out", url)
-        else:
-            return inst
-
-    @staticmethod
-    def _handle_fail(link, reason, url, meth=None):
-        if meth is None:
-            meth = logger.debug
-
-        meth("Could not fetch URL %s: %s - skipping", link, reason)
-
-    @staticmethod
-    def _get_content_type(url, session):
-        """Get the Content-Type of the given url, using a HEAD request"""
-        scheme, netloc, path, query, fragment = urllib_parse.urlsplit(url)
-        if scheme not in ('http', 'https'):
-            # FIXME: some warning or something?
-            # assertion error?
-            return ''
-
-        resp = session.head(url, allow_redirects=True)
-        resp.raise_for_status()
-
-        return resp.headers.get("Content-Type", "")
-
-    @cached_property
-    def base_url(self):
-        bases = [
-            x for x in self.parsed.findall(".//base")
-            if x.get("href") is not None
-        ]
-        if bases and bases[0].get("href"):
-            return bases[0].get("href")
-        else:
-            return self.url
-
-    @property
-    def links(self):
-        """Yields all links in the page"""
-        for anchor in self.parsed.findall(".//a"):
-            if anchor.get("href"):
-                href = anchor.get("href")
-                url = self.clean_link(
-                    urllib_parse.urljoin(self.base_url, href)
-                )
-                pyrequire = anchor.get('data-requires-python')
-                pyrequire = unescape(pyrequire) if pyrequire else None
-                yield Link(url, self, requires_python=pyrequire)
-
-    _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
-
-    def clean_link(self, url):
-        """Makes sure a link is fully encoded.  That is, if a ' ' shows up in
-        the link, it will be rewritten to %20 (while not over-quoting
-        % or other characters)."""
-        return self._clean_re.sub(
-            lambda match: '%%%2x' % ord(match.group(0)), url)
-
-
-class Link(object):
-
-    def __init__(self, url, comes_from=None, requires_python=None):
-        """
-        Object representing a parsed link from https://pypi.python.org/simple/*
-
-        url:
-            url of the resource pointed to (href of the link)
-        comes_from:
-            instance of HTMLPage where the link was found, or string.
-        requires_python:
-            String containing the `Requires-Python` metadata field, specified
-            in PEP 345. This may be specified by a data-requires-python
-            attribute in the HTML link tag, as described in PEP 503.
-        """
-
-        # url can be a UNC windows share
-        if url.startswith('\\\\'):
-            url = path_to_url(url)
-
-        self.url = url
-        self.comes_from = comes_from
-        self.requires_python = requires_python if requires_python else None
-
-    def __str__(self):
-        if self.requires_python:
-            rp = ' (requires-python:%s)' % self.requires_python
-        else:
-            rp = ''
-        if self.comes_from:
-            return '%s (from %s)%s' % (self.url, self.comes_from, rp)
-        else:
-            return str(self.url)
-
-    def __repr__(self):
-        return '<Link %s>' % self
-
-    def __eq__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url == other.url
-
-    def __ne__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url != other.url
-
-    def __lt__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url < other.url
-
-    def __le__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url <= other.url
-
-    def __gt__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url > other.url
-
-    def __ge__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url >= other.url
-
-    def __hash__(self):
-        return hash(self.url)
-
-    @property
-    def filename(self):
-        _, netloc, path, _, _ = urllib_parse.urlsplit(self.url)
-        name = posixpath.basename(path.rstrip('/')) or netloc
-        name = urllib_parse.unquote(name)
-        assert name, ('URL %r produced no filename' % self.url)
-        return name
-
-    @property
-    def scheme(self):
-        return urllib_parse.urlsplit(self.url)[0]
-
-    @property
-    def netloc(self):
-        return urllib_parse.urlsplit(self.url)[1]
-
-    @property
-    def path(self):
-        return urllib_parse.unquote(urllib_parse.urlsplit(self.url)[2])
-
-    def splitext(self):
-        return splitext(posixpath.basename(self.path.rstrip('/')))
-
-    @property
-    def ext(self):
-        return self.splitext()[1]
-
-    @property
-    def url_without_fragment(self):
-        scheme, netloc, path, query, fragment = urllib_parse.urlsplit(self.url)
-        return urllib_parse.urlunsplit((scheme, netloc, path, query, None))
-
-    _egg_fragment_re = re.compile(r'[#&]egg=([^&]*)')
-
-    @property
-    def egg_fragment(self):
-        match = self._egg_fragment_re.search(self.url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _subdirectory_fragment_re = re.compile(r'[#&]subdirectory=([^&]*)')
-
-    @property
-    def subdirectory_fragment(self):
-        match = self._subdirectory_fragment_re.search(self.url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _hash_re = re.compile(
-        r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)'
-    )
-
-    @property
-    def hash(self):
-        match = self._hash_re.search(self.url)
-        if match:
-            return match.group(2)
-        return None
-
-    @property
-    def hash_name(self):
-        match = self._hash_re.search(self.url)
-        if match:
-            return match.group(1)
-        return None
-
-    @property
-    def show_url(self):
-        return posixpath.basename(self.url.split('#', 1)[0].split('?', 1)[0])
-
-    @property
-    def is_wheel(self):
-        return self.ext == wheel_ext
-
-    @property
-    def is_artifact(self):
-        """
-        Determines if this points to an actual artifact (e.g. a tarball) or if
-        it points to an "abstract" thing like a path or a VCS location.
-        """
-        from pip.vcs import vcs
-
-        if self.scheme in vcs.all_schemes:
-            return False
-
-        return True
-
-
-FormatControl = namedtuple('FormatControl', 'no_binary only_binary')
-"""This object has two fields, no_binary and only_binary.
-
-If a field is falsy, it isn't set. If it is {':all:'}, it should match all
-packages except those listed in the other field. Only one field can be set
-to {':all:'} at a time. The rest of the time exact package name matches
-are listed, with any given package only showing up in one field at a time.
-"""
-
-
-def fmt_ctl_handle_mutual_exclude(value, target, other):
-    new = value.split(',')
-    while ':all:' in new:
-        other.clear()
-        target.clear()
-        target.add(':all:')
-        del new[:new.index(':all:') + 1]
-        if ':none:' not in new:
-            # Without a none, we want to discard everything as :all: covers it
-            return
-    for name in new:
-        if name == ':none:':
-            target.clear()
-            continue
-        name = canonicalize_name(name)
-        other.discard(name)
-        target.add(name)
-
-
-def fmt_ctl_formats(fmt_ctl, canonical_name):
-    result = set(["binary", "source"])
-    if canonical_name in fmt_ctl.only_binary:
-        result.discard('source')
-    elif canonical_name in fmt_ctl.no_binary:
-        result.discard('binary')
-    elif ':all:' in fmt_ctl.only_binary:
-        result.discard('source')
-    elif ':all:' in fmt_ctl.no_binary:
-        result.discard('binary')
-    return frozenset(result)
-
-
-def fmt_ctl_no_binary(fmt_ctl):
-    fmt_ctl_handle_mutual_exclude(
-        ':all:', fmt_ctl.no_binary, fmt_ctl.only_binary)
-
-
-def fmt_ctl_no_use_wheel(fmt_ctl):
-    fmt_ctl_no_binary(fmt_ctl)
-    warnings.warn(
-        '--no-use-wheel is deprecated and will be removed in the future. '
-        ' Please use --no-binary :all: instead.', RemovedInPip10Warning,
-        stacklevel=2)
-
-
-Search = namedtuple('Search', 'supplied canonical formats')
-"""Capture key aspects of a search.
-
-:attribute supplied: The user supplied package.
-:attribute canonical: The canonical package name.
-:attribute formats: The formats allowed for this package. Should be a set
-    with 'binary' or 'source' or both in it.
-"""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/locations.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/locations.py
deleted file mode 100644
index e598ef105..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/locations.py
+++ /dev/null
@@ -1,182 +0,0 @@
-"""Locations where we look for configs, install stuff, etc"""
-from __future__ import absolute_import
-
-import os
-import os.path
-import site
-import sys
-
-from distutils import sysconfig
-from distutils.command.install import install, SCHEME_KEYS  # noqa
-
-from pip.compat import WINDOWS, expanduser
-from pip.utils import appdirs
-
-
-# Application Directories
-USER_CACHE_DIR = appdirs.user_cache_dir("pip")
-
-
-DELETE_MARKER_MESSAGE = '''\
-This file is placed here by pip to indicate the source was put
-here by pip.
-
-Once this package is successfully installed this source code will be
-deleted (unless you remove this file).
-'''
-PIP_DELETE_MARKER_FILENAME = 'pip-delete-this-directory.txt'
-
-
-def write_delete_marker_file(directory):
-    """
-    Write the pip delete marker file into this directory.
-    """
-    filepath = os.path.join(directory, PIP_DELETE_MARKER_FILENAME)
-    with open(filepath, 'w') as marker_fp:
-        marker_fp.write(DELETE_MARKER_MESSAGE)
-
-
-def running_under_virtualenv():
-    """
-    Return True if we're running inside a virtualenv, False otherwise.
-
-    """
-    if hasattr(sys, 'real_prefix'):
-        return True
-    elif sys.prefix != getattr(sys, "base_prefix", sys.prefix):
-        return True
-
-    return False
-
-
-def virtualenv_no_global():
-    """
-    Return True if in a venv and no system site packages.
-    """
-    # this mirrors the logic in virtualenv.py for locating the
-    # no-global-site-packages.txt file
-    site_mod_dir = os.path.dirname(os.path.abspath(site.__file__))
-    no_global_file = os.path.join(site_mod_dir, 'no-global-site-packages.txt')
-    if running_under_virtualenv() and os.path.isfile(no_global_file):
-        return True
-
-
-if running_under_virtualenv():
-    src_prefix = os.path.join(sys.prefix, 'src')
-else:
-    # FIXME: keep src in cwd for now (it is not a temporary folder)
-    try:
-        src_prefix = os.path.join(os.getcwd(), 'src')
-    except OSError:
-        # In case the current working directory has been renamed or deleted
-        sys.exit(
-            "The folder you are executing pip from can no longer be found."
-        )
-
-# under macOS + virtualenv sys.prefix is not properly resolved
-# it is something like /path/to/python/bin/..
-# Note: using realpath due to tmp dirs on OSX being symlinks
-src_prefix = os.path.abspath(src_prefix)
-
-# FIXME doesn't account for venv linked to global site-packages
-
-site_packages = sysconfig.get_python_lib()
-user_site = site.USER_SITE
-user_dir = expanduser('~')
-if WINDOWS:
-    bin_py = os.path.join(sys.prefix, 'Scripts')
-    bin_user = os.path.join(user_site, 'Scripts')
-    # buildout uses 'bin' on Windows too?
-    if not os.path.exists(bin_py):
-        bin_py = os.path.join(sys.prefix, 'bin')
-        bin_user = os.path.join(user_site, 'bin')
-
-    config_basename = 'pip.ini'
-
-    legacy_storage_dir = os.path.join(user_dir, 'pip')
-    legacy_config_file = os.path.join(
-        legacy_storage_dir,
-        config_basename,
-    )
-else:
-    bin_py = os.path.join(sys.prefix, 'bin')
-    bin_user = os.path.join(user_site, 'bin')
-
-    config_basename = 'pip.conf'
-
-    legacy_storage_dir = os.path.join(user_dir, '.pip')
-    legacy_config_file = os.path.join(
-        legacy_storage_dir,
-        config_basename,
-    )
-
-    # Forcing to use /usr/local/bin for standard macOS framework installs
-    # Also log to ~/Library/Logs/ for use with the Console.app log viewer
-    if sys.platform[:6] == 'darwin' and sys.prefix[:16] == '/System/Library/':
-        bin_py = '/usr/local/bin'
-
-site_config_files = [
-    os.path.join(path, config_basename)
-    for path in appdirs.site_config_dirs('pip')
-]
-
-
-def distutils_scheme(dist_name, user=False, home=None, root=None,
-                     isolated=False, prefix=None):
-    """
-    Return a distutils install scheme
-    """
-    from distutils.dist import Distribution
-
-    scheme = {}
-
-    if isolated:
-        extra_dist_args = {"script_args": ["--no-user-cfg"]}
-    else:
-        extra_dist_args = {}
-    dist_args = {'name': dist_name}
-    dist_args.update(extra_dist_args)
-
-    d = Distribution(dist_args)
-    d.parse_config_files()
-    i = d.get_command_obj('install', create=True)
-    # NOTE: setting user or home has the side-effect of creating the home dir
-    # or user base for installations during finalize_options()
-    # ideally, we'd prefer a scheme class that has no side-effects.
-    assert not (user and prefix), "user={0} prefix={1}".format(user, prefix)
-    i.user = user or i.user
-    if user:
-        i.prefix = ""
-    i.prefix = prefix or i.prefix
-    i.home = home or i.home
-    i.root = root or i.root
-    i.finalize_options()
-    for key in SCHEME_KEYS:
-        scheme[key] = getattr(i, 'install_' + key)
-
-    # install_lib specified in setup.cfg should install *everything*
-    # into there (i.e. it takes precedence over both purelib and
-    # platlib).  Note, i.install_lib is *always* set after
-    # finalize_options(); we only want to override here if the user
-    # has explicitly requested it hence going back to the config
-    if 'install_lib' in d.get_option_dict('install'):
-        scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib))
-
-    if running_under_virtualenv():
-        scheme['headers'] = os.path.join(
-            sys.prefix,
-            'include',
-            'site',
-            'python' + sys.version[:3],
-            dist_name,
-        )
-
-        if root is not None:
-            path_no_drive = os.path.splitdrive(
-                os.path.abspath(scheme["headers"]))[1]
-            scheme["headers"] = os.path.join(
-                root,
-                path_no_drive[1:],
-            )
-
-    return scheme
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__init__.py
deleted file mode 100644
index 1d727d7ee..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from pip.models.index import Index, PyPI
-
-
-__all__ = ["Index", "PyPI"]
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 10093c4a9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/index.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/index.cpython-35.pyc
deleted file mode 100644
index 07249efe3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/__pycache__/index.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/index.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/index.py
deleted file mode 100644
index be9911988..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/models/index.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-
-
-class Index(object):
-    def __init__(self, url):
-        self.url = url
-        self.netloc = urllib_parse.urlsplit(url).netloc
-        self.simple_url = self.url_to_path('simple')
-        self.pypi_url = self.url_to_path('pypi')
-        self.pip_json_url = self.url_to_path('pypi/pip/json')
-
-    def url_to_path(self, path):
-        return urllib_parse.urljoin(self.url, path)
-
-
-PyPI = Index('https://pypi.python.org/')
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 45fa20854..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/check.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/check.cpython-35.pyc
deleted file mode 100644
index c735bca00..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/check.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/freeze.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/freeze.cpython-35.pyc
deleted file mode 100644
index 63a35b6cb..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/__pycache__/freeze.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/check.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/check.py
deleted file mode 100644
index 2cf67aaea..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/check.py
+++ /dev/null
@@ -1,49 +0,0 @@
-
-
-def check_requirements(installed_dists):
-    missing_reqs_dict = {}
-    incompatible_reqs_dict = {}
-
-    for dist in installed_dists:
-        key = '%s==%s' % (dist.project_name, dist.version)
-
-        missing_reqs = list(get_missing_reqs(dist, installed_dists))
-        if missing_reqs:
-            missing_reqs_dict[key] = missing_reqs
-
-        incompatible_reqs = list(get_incompatible_reqs(
-            dist, installed_dists))
-        if incompatible_reqs:
-            incompatible_reqs_dict[key] = incompatible_reqs
-
-    return (missing_reqs_dict, incompatible_reqs_dict)
-
-
-def get_missing_reqs(dist, installed_dists):
-    """Return all of the requirements of `dist` that aren't present in
-    `installed_dists`.
-
-    """
-    installed_names = set(d.project_name.lower() for d in installed_dists)
-    missing_requirements = set()
-
-    for requirement in dist.requires():
-        if requirement.project_name.lower() not in installed_names:
-            missing_requirements.add(requirement)
-            yield requirement
-
-
-def get_incompatible_reqs(dist, installed_dists):
-    """Return all of the requirements of `dist` that are present in
-    `installed_dists`, but have incompatible versions.
-
-    """
-    installed_dists_by_name = {}
-    for installed_dist in installed_dists:
-        installed_dists_by_name[installed_dist.project_name] = installed_dist
-
-    for requirement in dist.requires():
-        present_dist = installed_dists_by_name.get(requirement.project_name)
-
-        if present_dist and present_dist not in requirement:
-            yield (requirement, present_dist)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/freeze.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/freeze.py
deleted file mode 100644
index 920c2c128..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/operations/freeze.py
+++ /dev/null
@@ -1,132 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import re
-
-import pip
-from pip.req import InstallRequirement
-from pip.req.req_file import COMMENT_RE
-from pip.utils import get_installed_distributions
-from pip._vendor import pkg_resources
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.pkg_resources import RequirementParseError
-
-
-logger = logging.getLogger(__name__)
-
-
-def freeze(
-        requirement=None,
-        find_links=None, local_only=None, user_only=None, skip_regex=None,
-        default_vcs=None,
-        isolated=False,
-        wheel_cache=None,
-        skip=()):
-    find_links = find_links or []
-    skip_match = None
-
-    if skip_regex:
-        skip_match = re.compile(skip_regex).search
-
-    dependency_links = []
-
-    for dist in pkg_resources.working_set:
-        if dist.has_metadata('dependency_links.txt'):
-            dependency_links.extend(
-                dist.get_metadata_lines('dependency_links.txt')
-            )
-    for link in find_links:
-        if '#egg=' in link:
-            dependency_links.append(link)
-    for link in find_links:
-        yield '-f %s' % link
-    installations = {}
-    for dist in get_installed_distributions(local_only=local_only,
-                                            skip=(),
-                                            user_only=user_only):
-        try:
-            req = pip.FrozenRequirement.from_dist(
-                dist,
-                dependency_links
-            )
-        except RequirementParseError:
-            logger.warning(
-                "Could not parse requirement: %s",
-                dist.project_name
-            )
-            continue
-        installations[req.name] = req
-
-    if requirement:
-        # the options that don't get turned into an InstallRequirement
-        # should only be emitted once, even if the same option is in multiple
-        # requirements files, so we need to keep track of what has been emitted
-        # so that we don't emit it again if it's seen again
-        emitted_options = set()
-        for req_file_path in requirement:
-            with open(req_file_path) as req_file:
-                for line in req_file:
-                    if (not line.strip() or
-                            line.strip().startswith('#') or
-                            (skip_match and skip_match(line)) or
-                            line.startswith((
-                                '-r', '--requirement',
-                                '-Z', '--always-unzip',
-                                '-f', '--find-links',
-                                '-i', '--index-url',
-                                '--pre',
-                                '--trusted-host',
-                                '--process-dependency-links',
-                                '--extra-index-url'))):
-                        line = line.rstrip()
-                        if line not in emitted_options:
-                            emitted_options.add(line)
-                            yield line
-                        continue
-
-                    if line.startswith('-e') or line.startswith('--editable'):
-                        if line.startswith('-e'):
-                            line = line[2:].strip()
-                        else:
-                            line = line[len('--editable'):].strip().lstrip('=')
-                        line_req = InstallRequirement.from_editable(
-                            line,
-                            default_vcs=default_vcs,
-                            isolated=isolated,
-                            wheel_cache=wheel_cache,
-                        )
-                    else:
-                        line_req = InstallRequirement.from_line(
-                            COMMENT_RE.sub('', line).strip(),
-                            isolated=isolated,
-                            wheel_cache=wheel_cache,
-                        )
-
-                    if not line_req.name:
-                        logger.info(
-                            "Skipping line in requirement file [%s] because "
-                            "it's not clear what it would install: %s",
-                            req_file_path, line.strip(),
-                        )
-                        logger.info(
-                            "  (add #egg=PackageName to the URL to avoid"
-                            " this warning)"
-                        )
-                    elif line_req.name not in installations:
-                        logger.warning(
-                            "Requirement file [%s] contains %s, but that "
-                            "package is not installed",
-                            req_file_path, COMMENT_RE.sub('', line).strip(),
-                        )
-                    else:
-                        yield str(installations[line_req.name]).rstrip()
-                        del installations[line_req.name]
-
-        yield(
-            '## The following requirements were added by '
-            'pip freeze:'
-        )
-    for installation in sorted(
-            installations.values(), key=lambda x: x.name.lower()):
-        if canonicalize_name(installation.name) not in skip:
-            yield str(installation).rstrip()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/pep425tags.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/pep425tags.py
deleted file mode 100644
index ad202ef31..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/pep425tags.py
+++ /dev/null
@@ -1,324 +0,0 @@
-"""Generate and work with PEP 425 Compatibility Tags."""
-from __future__ import absolute_import
-
-import re
-import sys
-import warnings
-import platform
-import logging
-
-try:
-    import sysconfig
-except ImportError:  # pragma nocover
-    # Python < 2.7
-    import distutils.sysconfig as sysconfig
-import distutils.util
-
-from pip.compat import OrderedDict
-import pip.utils.glibc
-
-logger = logging.getLogger(__name__)
-
-_osx_arch_pat = re.compile(r'(.+)_(\d+)_(\d+)_(.+)')
-
-
-def get_config_var(var):
-    try:
-        return sysconfig.get_config_var(var)
-    except IOError as e:  # Issue #1074
-        warnings.warn("{0}".format(e), RuntimeWarning)
-        return None
-
-
-def get_abbr_impl():
-    """Return abbreviated implementation name."""
-    if hasattr(sys, 'pypy_version_info'):
-        pyimpl = 'pp'
-    elif sys.platform.startswith('java'):
-        pyimpl = 'jy'
-    elif sys.platform == 'cli':
-        pyimpl = 'ip'
-    else:
-        pyimpl = 'cp'
-    return pyimpl
-
-
-def get_impl_ver():
-    """Return implementation version."""
-    impl_ver = get_config_var("py_version_nodot")
-    if not impl_ver or get_abbr_impl() == 'pp':
-        impl_ver = ''.join(map(str, get_impl_version_info()))
-    return impl_ver
-
-
-def get_impl_version_info():
-    """Return sys.version_info-like tuple for use in decrementing the minor
-    version."""
-    if get_abbr_impl() == 'pp':
-        # as per https://github.com/pypa/pip/issues/2882
-        return (sys.version_info[0], sys.pypy_version_info.major,
-                sys.pypy_version_info.minor)
-    else:
-        return sys.version_info[0], sys.version_info[1]
-
-
-def get_impl_tag():
-    """
-    Returns the Tag for this specific implementation.
-    """
-    return "{0}{1}".format(get_abbr_impl(), get_impl_ver())
-
-
-def get_flag(var, fallback, expected=True, warn=True):
-    """Use a fallback method for determining SOABI flags if the needed config
-    var is unset or unavailable."""
-    val = get_config_var(var)
-    if val is None:
-        if warn:
-            logger.debug("Config variable '%s' is unset, Python ABI tag may "
-                         "be incorrect", var)
-        return fallback()
-    return val == expected
-
-
-def get_abi_tag():
-    """Return the ABI tag based on SOABI (if available) or emulate SOABI
-    (CPython 2, PyPy)."""
-    soabi = get_config_var('SOABI')
-    impl = get_abbr_impl()
-    if not soabi and impl in ('cp', 'pp') and hasattr(sys, 'maxunicode'):
-        d = ''
-        m = ''
-        u = ''
-        if get_flag('Py_DEBUG',
-                    lambda: hasattr(sys, 'gettotalrefcount'),
-                    warn=(impl == 'cp')):
-            d = 'd'
-        if get_flag('WITH_PYMALLOC',
-                    lambda: impl == 'cp',
-                    warn=(impl == 'cp')):
-            m = 'm'
-        if get_flag('Py_UNICODE_SIZE',
-                    lambda: sys.maxunicode == 0x10ffff,
-                    expected=4,
-                    warn=(impl == 'cp' and
-                          sys.version_info < (3, 3))) \
-                and sys.version_info < (3, 3):
-            u = 'u'
-        abi = '%s%s%s%s%s' % (impl, get_impl_ver(), d, m, u)
-    elif soabi and soabi.startswith('cpython-'):
-        abi = 'cp' + soabi.split('-')[1]
-    elif soabi:
-        abi = soabi.replace('.', '_').replace('-', '_')
-    else:
-        abi = None
-    return abi
-
-
-def _is_running_32bit():
-    return sys.maxsize == 2147483647
-
-
-def get_platform():
-    """Return our platform name 'win32', 'linux_x86_64'"""
-    if sys.platform == 'darwin':
-        # distutils.util.get_platform() returns the release based on the value
-        # of MACOSX_DEPLOYMENT_TARGET on which Python was built, which may
-        # be significantly older than the user's current machine.
-        release, _, machine = platform.mac_ver()
-        split_ver = release.split('.')
-
-        if machine == "x86_64" and _is_running_32bit():
-            machine = "i386"
-        elif machine == "ppc64" and _is_running_32bit():
-            machine = "ppc"
-
-        return 'macosx_{0}_{1}_{2}'.format(split_ver[0], split_ver[1], machine)
-
-    # XXX remove distutils dependency
-    result = distutils.util.get_platform().replace('.', '_').replace('-', '_')
-    if result == "linux_x86_64" and _is_running_32bit():
-        # 32 bit Python program (running on a 64 bit Linux): pip should only
-        # install and run 32 bit compiled extensions in that case.
-        result = "linux_i686"
-
-    return result
-
-
-def is_manylinux1_compatible():
-    # Only Linux, and only x86-64 / i686
-    if get_platform() not in ("linux_x86_64", "linux_i686"):
-        return False
-
-    # Check for presence of _manylinux module
-    try:
-        import _manylinux
-        return bool(_manylinux.manylinux1_compatible)
-    except (ImportError, AttributeError):
-        # Fall through to heuristic check below
-        pass
-
-    # Check glibc version. CentOS 5 uses glibc 2.5.
-    return pip.utils.glibc.have_compatible_glibc(2, 5)
-
-
-def get_darwin_arches(major, minor, machine):
-    """Return a list of supported arches (including group arches) for
-    the given major, minor and machine architecture of an macOS machine.
-    """
-    arches = []
-
-    def _supports_arch(major, minor, arch):
-        # Looking at the application support for macOS versions in the chart
-        # provided by https://en.wikipedia.org/wiki/OS_X#Versions it appears
-        # our timeline looks roughly like:
-        #
-        # 10.0 - Introduces ppc support.
-        # 10.4 - Introduces ppc64, i386, and x86_64 support, however the ppc64
-        #        and x86_64 support is CLI only, and cannot be used for GUI
-        #        applications.
-        # 10.5 - Extends ppc64 and x86_64 support to cover GUI applications.
-        # 10.6 - Drops support for ppc64
-        # 10.7 - Drops support for ppc
-        #
-        # Given that we do not know if we're installing a CLI or a GUI
-        # application, we must be conservative and assume it might be a GUI
-        # application and behave as if ppc64 and x86_64 support did not occur
-        # until 10.5.
-        #
-        # Note: The above information is taken from the "Application support"
-        #       column in the chart not the "Processor support" since I believe
-        #       that we care about what instruction sets an application can use
-        #       not which processors the OS supports.
-        if arch == 'ppc':
-            return (major, minor) <= (10, 5)
-        if arch == 'ppc64':
-            return (major, minor) == (10, 5)
-        if arch == 'i386':
-            return (major, minor) >= (10, 4)
-        if arch == 'x86_64':
-            return (major, minor) >= (10, 5)
-        if arch in groups:
-            for garch in groups[arch]:
-                if _supports_arch(major, minor, garch):
-                    return True
-        return False
-
-    groups = OrderedDict([
-        ("fat", ("i386", "ppc")),
-        ("intel", ("x86_64", "i386")),
-        ("fat64", ("x86_64", "ppc64")),
-        ("fat32", ("x86_64", "i386", "ppc")),
-    ])
-
-    if _supports_arch(major, minor, machine):
-        arches.append(machine)
-
-    for garch in groups:
-        if machine in groups[garch] and _supports_arch(major, minor, garch):
-            arches.append(garch)
-
-    arches.append('universal')
-
-    return arches
-
-
-def get_supported(versions=None, noarch=False, platform=None,
-                  impl=None, abi=None):
-    """Return a list of supported tags for each version specified in
-    `versions`.
-
-    :param versions: a list of string versions, of the form ["33", "32"],
-        or None. The first version will be assumed to support our ABI.
-    :param platform: specify the exact platform you want valid
-        tags for, or None. If None, use the local system platform.
-    :param impl: specify the exact implementation you want valid
-        tags for, or None. If None, use the local interpreter impl.
-    :param abi: specify the exact abi you want valid
-        tags for, or None. If None, use the local interpreter abi.
-    """
-    supported = []
-
-    # Versions must be given with respect to the preference
-    if versions is None:
-        versions = []
-        version_info = get_impl_version_info()
-        major = version_info[:-1]
-        # Support all previous minor Python versions.
-        for minor in range(version_info[-1], -1, -1):
-            versions.append(''.join(map(str, major + (minor,))))
-
-    impl = impl or get_abbr_impl()
-
-    abis = []
-
-    abi = abi or get_abi_tag()
-    if abi:
-        abis[0:0] = [abi]
-
-    abi3s = set()
-    import imp
-    for suffix in imp.get_suffixes():
-        if suffix[0].startswith('.abi'):
-            abi3s.add(suffix[0].split('.', 2)[1])
-
-    abis.extend(sorted(list(abi3s)))
-
-    abis.append('none')
-
-    if not noarch:
-        arch = platform or get_platform()
-        if arch.startswith('macosx'):
-            # support macosx-10.6-intel on macosx-10.9-x86_64
-            match = _osx_arch_pat.match(arch)
-            if match:
-                name, major, minor, actual_arch = match.groups()
-                tpl = '{0}_{1}_%i_%s'.format(name, major)
-                arches = []
-                for m in reversed(range(int(minor) + 1)):
-                    for a in get_darwin_arches(int(major), m, actual_arch):
-                        arches.append(tpl % (m, a))
-            else:
-                # arch pattern didn't match (?!)
-                arches = [arch]
-        elif platform is None and is_manylinux1_compatible():
-            arches = [arch.replace('linux', 'manylinux1'), arch]
-        else:
-            arches = [arch]
-
-        # Current version, current API (built specifically for our Python):
-        for abi in abis:
-            for arch in arches:
-                supported.append(('%s%s' % (impl, versions[0]), abi, arch))
-
-        # abi3 modules compatible with older version of Python
-        for version in versions[1:]:
-            # abi3 was introduced in Python 3.2
-            if version in ('31', '30'):
-                break
-            for abi in abi3s:   # empty set if not Python 3
-                for arch in arches:
-                    supported.append(("%s%s" % (impl, version), abi, arch))
-
-        # Has binaries, does not use the Python API:
-        for arch in arches:
-            supported.append(('py%s' % (versions[0][0]), 'none', arch))
-
-    # No abi / arch, but requires our implementation:
-    supported.append(('%s%s' % (impl, versions[0]), 'none', 'any'))
-    # Tagged specifically as being cross-version compatible
-    # (with just the major version specified)
-    supported.append(('%s%s' % (impl, versions[0][0]), 'none', 'any'))
-
-    # No abi / arch, generic Python
-    for i, version in enumerate(versions):
-        supported.append(('py%s' % (version,), 'none', 'any'))
-        if i == 0:
-            supported.append(('py%s' % (version[0]), 'none', 'any'))
-
-    return supported
-
-supported_tags = get_supported()
-supported_tags_noarch = get_supported(noarch=True)
-
-implementation_tag = get_impl_tag()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__init__.py
deleted file mode 100644
index 00185a430..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from __future__ import absolute_import
-
-from .req_install import InstallRequirement
-from .req_set import RequirementSet, Requirements
-from .req_file import parse_requirements
-
-__all__ = [
-    "RequirementSet", "Requirements", "InstallRequirement",
-    "parse_requirements",
-]
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index fe6f793ac..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_file.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_file.cpython-35.pyc
deleted file mode 100644
index ab64d171a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_file.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_install.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_install.cpython-35.pyc
deleted file mode 100644
index 43fec796e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_install.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_set.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_set.cpython-35.pyc
deleted file mode 100644
index 19bd5546c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_set.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_uninstall.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_uninstall.cpython-35.pyc
deleted file mode 100644
index b0030ceec..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/__pycache__/req_uninstall.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_file.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_file.py
deleted file mode 100644
index 821df2271..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_file.py
+++ /dev/null
@@ -1,342 +0,0 @@
-"""
-Requirements file parsing
-"""
-
-from __future__ import absolute_import
-
-import os
-import re
-import shlex
-import sys
-import optparse
-import warnings
-
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-from pip._vendor.six.moves import filterfalse
-
-import pip
-from pip.download import get_file_content
-from pip.req.req_install import InstallRequirement
-from pip.exceptions import (RequirementsFileParseError)
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip import cmdoptions
-
-__all__ = ['parse_requirements']
-
-SCHEME_RE = re.compile(r'^(http|https|file):', re.I)
-COMMENT_RE = re.compile(r'(^|\s)+#.*$')
-
-SUPPORTED_OPTIONS = [
-    cmdoptions.constraints,
-    cmdoptions.editable,
-    cmdoptions.requirements,
-    cmdoptions.no_index,
-    cmdoptions.index_url,
-    cmdoptions.find_links,
-    cmdoptions.extra_index_url,
-    cmdoptions.allow_external,
-    cmdoptions.allow_all_external,
-    cmdoptions.no_allow_external,
-    cmdoptions.allow_unsafe,
-    cmdoptions.no_allow_unsafe,
-    cmdoptions.use_wheel,
-    cmdoptions.no_use_wheel,
-    cmdoptions.always_unzip,
-    cmdoptions.no_binary,
-    cmdoptions.only_binary,
-    cmdoptions.pre,
-    cmdoptions.process_dependency_links,
-    cmdoptions.trusted_host,
-    cmdoptions.require_hashes,
-]
-
-# options to be passed to requirements
-SUPPORTED_OPTIONS_REQ = [
-    cmdoptions.install_options,
-    cmdoptions.global_options,
-    cmdoptions.hash,
-]
-
-# the 'dest' string values
-SUPPORTED_OPTIONS_REQ_DEST = [o().dest for o in SUPPORTED_OPTIONS_REQ]
-
-
-def parse_requirements(filename, finder=None, comes_from=None, options=None,
-                       session=None, constraint=False, wheel_cache=None):
-    """Parse a requirements file and yield InstallRequirement instances.
-
-    :param filename:    Path or url of requirements file.
-    :param finder:      Instance of pip.index.PackageFinder.
-    :param comes_from:  Origin description of requirements.
-    :param options:     cli options.
-    :param session:     Instance of pip.download.PipSession.
-    :param constraint:  If true, parsing a constraint file rather than
-        requirements file.
-    :param wheel_cache: Instance of pip.wheel.WheelCache
-    """
-    if session is None:
-        raise TypeError(
-            "parse_requirements() missing 1 required keyword argument: "
-            "'session'"
-        )
-
-    _, content = get_file_content(
-        filename, comes_from=comes_from, session=session
-    )
-
-    lines_enum = preprocess(content, options)
-
-    for line_number, line in lines_enum:
-        req_iter = process_line(line, filename, line_number, finder,
-                                comes_from, options, session, wheel_cache,
-                                constraint=constraint)
-        for req in req_iter:
-            yield req
-
-
-def preprocess(content, options):
-    """Split, filter, and join lines, and return a line iterator
-
-    :param content: the content of the requirements file
-    :param options: cli options
-    """
-    lines_enum = enumerate(content.splitlines(), start=1)
-    lines_enum = join_lines(lines_enum)
-    lines_enum = ignore_comments(lines_enum)
-    lines_enum = skip_regex(lines_enum, options)
-    return lines_enum
-
-
-def process_line(line, filename, line_number, finder=None, comes_from=None,
-                 options=None, session=None, wheel_cache=None,
-                 constraint=False):
-    """Process a single requirements line; This can result in creating/yielding
-    requirements, or updating the finder.
-
-    For lines that contain requirements, the only options that have an effect
-    are from SUPPORTED_OPTIONS_REQ, and they are scoped to the
-    requirement. Other options from SUPPORTED_OPTIONS may be present, but are
-    ignored.
-
-    For lines that do not contain requirements, the only options that have an
-    effect are from SUPPORTED_OPTIONS. Options from SUPPORTED_OPTIONS_REQ may
-    be present, but are ignored. These lines may contain multiple options
-    (although our docs imply only one is supported), and all our parsed and
-    affect the finder.
-
-    :param constraint: If True, parsing a constraints file.
-    :param options: OptionParser options that we may update
-    """
-    parser = build_parser()
-    defaults = parser.get_default_values()
-    defaults.index_url = None
-    if finder:
-        # `finder.format_control` will be updated during parsing
-        defaults.format_control = finder.format_control
-    args_str, options_str = break_args_options(line)
-    if sys.version_info < (2, 7, 3):
-        # Prior to 2.7.3, shlex cannot deal with unicode entries
-        options_str = options_str.encode('utf8')
-    opts, _ = parser.parse_args(shlex.split(options_str), defaults)
-
-    # preserve for the nested code path
-    line_comes_from = '%s %s (line %s)' % (
-        '-c' if constraint else '-r', filename, line_number)
-
-    # yield a line requirement
-    if args_str:
-        isolated = options.isolated_mode if options else False
-        if options:
-            cmdoptions.check_install_build_global(options, opts)
-        # get the options that apply to requirements
-        req_options = {}
-        for dest in SUPPORTED_OPTIONS_REQ_DEST:
-            if dest in opts.__dict__ and opts.__dict__[dest]:
-                req_options[dest] = opts.__dict__[dest]
-        yield InstallRequirement.from_line(
-            args_str, line_comes_from, constraint=constraint,
-            isolated=isolated, options=req_options, wheel_cache=wheel_cache
-        )
-
-    # yield an editable requirement
-    elif opts.editables:
-        isolated = options.isolated_mode if options else False
-        default_vcs = options.default_vcs if options else None
-        yield InstallRequirement.from_editable(
-            opts.editables[0], comes_from=line_comes_from,
-            constraint=constraint, default_vcs=default_vcs, isolated=isolated,
-            wheel_cache=wheel_cache
-        )
-
-    # parse a nested requirements file
-    elif opts.requirements or opts.constraints:
-        if opts.requirements:
-            req_path = opts.requirements[0]
-            nested_constraint = False
-        else:
-            req_path = opts.constraints[0]
-            nested_constraint = True
-        # original file is over http
-        if SCHEME_RE.search(filename):
-            # do a url join so relative paths work
-            req_path = urllib_parse.urljoin(filename, req_path)
-        # original file and nested file are paths
-        elif not SCHEME_RE.search(req_path):
-            # do a join so relative paths work
-            req_path = os.path.join(os.path.dirname(filename), req_path)
-        # TODO: Why not use `comes_from='-r {} (line {})'` here as well?
-        parser = parse_requirements(
-            req_path, finder, comes_from, options, session,
-            constraint=nested_constraint, wheel_cache=wheel_cache
-        )
-        for req in parser:
-            yield req
-
-    # percolate hash-checking option upward
-    elif opts.require_hashes:
-        options.require_hashes = opts.require_hashes
-
-    # set finder options
-    elif finder:
-        if opts.allow_external:
-            warnings.warn(
-                "--allow-external has been deprecated and will be removed in "
-                "the future. Due to changes in the repository protocol, it no "
-                "longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if opts.allow_all_external:
-            warnings.warn(
-                "--allow-all-external has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if opts.allow_unverified:
-            warnings.warn(
-                "--allow-unverified has been deprecated and will be removed "
-                "in the future. Due to changes in the repository protocol, it "
-                "no longer has any effect.",
-                RemovedInPip10Warning,
-            )
-
-        if opts.index_url:
-            finder.index_urls = [opts.index_url]
-        if opts.use_wheel is False:
-            finder.use_wheel = False
-            pip.index.fmt_ctl_no_use_wheel(finder.format_control)
-        if opts.no_index is True:
-            finder.index_urls = []
-        if opts.extra_index_urls:
-            finder.index_urls.extend(opts.extra_index_urls)
-        if opts.find_links:
-            # FIXME: it would be nice to keep track of the source
-            # of the find_links: support a find-links local path
-            # relative to a requirements file.
-            value = opts.find_links[0]
-            req_dir = os.path.dirname(os.path.abspath(filename))
-            relative_to_reqs_file = os.path.join(req_dir, value)
-            if os.path.exists(relative_to_reqs_file):
-                value = relative_to_reqs_file
-            finder.find_links.append(value)
-        if opts.pre:
-            finder.allow_all_prereleases = True
-        if opts.process_dependency_links:
-            finder.process_dependency_links = True
-        if opts.trusted_hosts:
-            finder.secure_origins.extend(
-                ("*", host, "*") for host in opts.trusted_hosts)
-
-
-def break_args_options(line):
-    """Break up the line into an args and options string.  We only want to shlex
-    (and then optparse) the options, not the args.  args can contain markers
-    which are corrupted by shlex.
-    """
-    tokens = line.split(' ')
-    args = []
-    options = tokens[:]
-    for token in tokens:
-        if token.startswith('-') or token.startswith('--'):
-            break
-        else:
-            args.append(token)
-            options.pop(0)
-    return ' '.join(args), ' '.join(options)
-
-
-def build_parser():
-    """
-    Return a parser for parsing requirement lines
-    """
-    parser = optparse.OptionParser(add_help_option=False)
-
-    option_factories = SUPPORTED_OPTIONS + SUPPORTED_OPTIONS_REQ
-    for option_factory in option_factories:
-        option = option_factory()
-        parser.add_option(option)
-
-    # By default optparse sys.exits on parsing errors. We want to wrap
-    # that in our own exception.
-    def parser_exit(self, msg):
-        raise RequirementsFileParseError(msg)
-    parser.exit = parser_exit
-
-    return parser
-
-
-def join_lines(lines_enum):
-    """Joins a line ending in '\' with the previous line (except when following
-    comments).  The joined line takes on the index of the first line.
-    """
-    primary_line_number = None
-    new_line = []
-    for line_number, line in lines_enum:
-        if not line.endswith('\\') or COMMENT_RE.match(line):
-            if COMMENT_RE.match(line):
-                # this ensures comments are always matched later
-                line = ' ' + line
-            if new_line:
-                new_line.append(line)
-                yield primary_line_number, ''.join(new_line)
-                new_line = []
-            else:
-                yield line_number, line
-        else:
-            if not new_line:
-                primary_line_number = line_number
-            new_line.append(line.strip('\\'))
-
-    # last line contains \
-    if new_line:
-        yield primary_line_number, ''.join(new_line)
-
-    # TODO: handle space after '\'.
-
-
-def ignore_comments(lines_enum):
-    """
-    Strips comments and filter empty lines.
-    """
-    for line_number, line in lines_enum:
-        line = COMMENT_RE.sub('', line)
-        line = line.strip()
-        if line:
-            yield line_number, line
-
-
-def skip_regex(lines_enum, options):
-    """
-    Skip lines that match '--skip-requirements-regex' pattern
-
-    Note: the regex pattern is only built once
-    """
-    skip_regex = options.skip_requirements_regex if options else None
-    if skip_regex:
-        pattern = re.compile(skip_regex)
-        lines_enum = filterfalse(
-            lambda e: pattern.search(e[1]),
-            lines_enum)
-    return lines_enum
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_install.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_install.py
deleted file mode 100644
index 1a98f377b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_install.py
+++ /dev/null
@@ -1,1204 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-import re
-import shutil
-import sys
-import tempfile
-import traceback
-import warnings
-import zipfile
-
-from distutils import sysconfig
-from distutils.util import change_root
-from email.parser import FeedParser
-
-from pip._vendor import pkg_resources, six
-from pip._vendor.packaging import specifiers
-from pip._vendor.packaging.markers import Marker
-from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging.version import Version, parse as parse_version
-from pip._vendor.six.moves import configparser
-
-import pip.wheel
-
-from pip.compat import native_str, get_stdlib, WINDOWS
-from pip.download import is_url, url_to_path, path_to_url, is_archive_file
-from pip.exceptions import (
-    InstallationError, UninstallationError,
-)
-from pip.locations import (
-    bin_py, running_under_virtualenv, PIP_DELETE_MARKER_FILENAME, bin_user,
-)
-from pip.utils import (
-    display_path, rmtree, ask_path_exists, backup_dir, is_installable_dir,
-    dist_in_usersite, dist_in_site_packages, egg_link_path,
-    call_subprocess, read_text_file, FakeFile, _make_build_dir, ensure_dir,
-    get_installed_version, normalize_path, dist_is_local,
-)
-
-from pip.utils.hashes import Hashes
-from pip.utils.deprecation import RemovedInPip10Warning
-from pip.utils.logging import indent_log
-from pip.utils.setuptools_build import SETUPTOOLS_SHIM
-from pip.utils.ui import open_spinner
-from pip.req.req_uninstall import UninstallPathSet
-from pip.vcs import vcs
-from pip.wheel import move_wheel_files, Wheel
-
-
-logger = logging.getLogger(__name__)
-
-operators = specifiers.Specifier._operators.keys()
-
-
-def _strip_extras(path):
-    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
-    extras = None
-    if m:
-        path_no_extras = m.group(1)
-        extras = m.group(2)
-    else:
-        path_no_extras = path
-
-    return path_no_extras, extras
-
-
-def _safe_extras(extras):
-    return set(pkg_resources.safe_extra(extra) for extra in extras)
-
-
-class InstallRequirement(object):
-
-    def __init__(self, req, comes_from, source_dir=None, editable=False,
-                 link=None, as_egg=False, update=True,
-                 pycompile=True, markers=None, isolated=False, options=None,
-                 wheel_cache=None, constraint=False):
-        self.extras = ()
-        if isinstance(req, six.string_types):
-            try:
-                req = Requirement(req)
-            except InvalidRequirement:
-                if os.path.sep in req:
-                    add_msg = "It looks like a path. Does it exist ?"
-                elif '=' in req and not any(op in req for op in operators):
-                    add_msg = "= is not a valid operator. Did you mean == ?"
-                else:
-                    add_msg = traceback.format_exc()
-                raise InstallationError(
-                    "Invalid requirement: '%s'\n%s" % (req, add_msg))
-            self.extras = _safe_extras(req.extras)
-
-        self.req = req
-        self.comes_from = comes_from
-        self.constraint = constraint
-        self.source_dir = source_dir
-        self.editable = editable
-
-        self._wheel_cache = wheel_cache
-        self.link = self.original_link = link
-        self.as_egg = as_egg
-        if markers is not None:
-            self.markers = markers
-        else:
-            self.markers = req and req.marker
-        self._egg_info_path = None
-        # This holds the pkg_resources.Distribution object if this requirement
-        # is already available:
-        self.satisfied_by = None
-        # This hold the pkg_resources.Distribution object if this requirement
-        # conflicts with another installed distribution:
-        self.conflicts_with = None
-        # Temporary build location
-        self._temp_build_dir = None
-        # Used to store the global directory where the _temp_build_dir should
-        # have been created. Cf _correct_build_location method.
-        self._ideal_build_dir = None
-        # True if the editable should be updated:
-        self.update = update
-        # Set to True after successful installation
-        self.install_succeeded = None
-        # UninstallPathSet of uninstalled distribution (for possible rollback)
-        self.uninstalled = None
-        # Set True if a legitimate do-nothing-on-uninstall has happened - e.g.
-        # system site packages, stdlib packages.
-        self.nothing_to_uninstall = False
-        self.use_user_site = False
-        self.target_dir = None
-        self.options = options if options else {}
-        self.pycompile = pycompile
-        # Set to True after successful preparation of this requirement
-        self.prepared = False
-
-        self.isolated = isolated
-
-    @classmethod
-    def from_editable(cls, editable_req, comes_from=None, default_vcs=None,
-                      isolated=False, options=None, wheel_cache=None,
-                      constraint=False):
-        from pip.index import Link
-
-        name, url, extras_override = parse_editable(
-            editable_req, default_vcs)
-        if url.startswith('file:'):
-            source_dir = url_to_path(url)
-        else:
-            source_dir = None
-
-        res = cls(name, comes_from, source_dir=source_dir,
-                  editable=True,
-                  link=Link(url),
-                  constraint=constraint,
-                  isolated=isolated,
-                  options=options if options else {},
-                  wheel_cache=wheel_cache)
-
-        if extras_override is not None:
-            res.extras = _safe_extras(extras_override)
-
-        return res
-
-    @classmethod
-    def from_line(
-            cls, name, comes_from=None, isolated=False, options=None,
-            wheel_cache=None, constraint=False):
-        """Creates an InstallRequirement from a name, which might be a
-        requirement, directory containing 'setup.py', filename, or URL.
-        """
-        from pip.index import Link
-
-        if is_url(name):
-            marker_sep = '; '
-        else:
-            marker_sep = ';'
-        if marker_sep in name:
-            name, markers = name.split(marker_sep, 1)
-            markers = markers.strip()
-            if not markers:
-                markers = None
-            else:
-                markers = Marker(markers)
-        else:
-            markers = None
-        name = name.strip()
-        req = None
-        path = os.path.normpath(os.path.abspath(name))
-        link = None
-        extras = None
-
-        if is_url(name):
-            link = Link(name)
-        else:
-            p, extras = _strip_extras(path)
-            if (os.path.isdir(p) and
-                    (os.path.sep in name or name.startswith('.'))):
-
-                if not is_installable_dir(p):
-                    raise InstallationError(
-                        "Directory %r is not installable. File 'setup.py' "
-                        "not found." % name
-                    )
-                link = Link(path_to_url(p))
-            elif is_archive_file(p):
-                if not os.path.isfile(p):
-                    logger.warning(
-                        'Requirement %r looks like a filename, but the '
-                        'file does not exist',
-                        name
-                    )
-                link = Link(path_to_url(p))
-
-        # it's a local file, dir, or url
-        if link:
-            # Handle relative file URLs
-            if link.scheme == 'file' and re.search(r'\.\./', link.url):
-                link = Link(
-                    path_to_url(os.path.normpath(os.path.abspath(link.path))))
-            # wheel file
-            if link.is_wheel:
-                wheel = Wheel(link.filename)  # can raise InvalidWheelFilename
-                req = "%s==%s" % (wheel.name, wheel.version)
-            else:
-                # set the req to the egg fragment.  when it's not there, this
-                # will become an 'unnamed' requirement
-                req = link.egg_fragment
-
-        # a requirement specifier
-        else:
-            req = name
-
-        options = options if options else {}
-        res = cls(req, comes_from, link=link, markers=markers,
-                  isolated=isolated, options=options,
-                  wheel_cache=wheel_cache, constraint=constraint)
-
-        if extras:
-            res.extras = _safe_extras(
-                Requirement('placeholder' + extras).extras)
-
-        return res
-
-    def __str__(self):
-        if self.req:
-            s = str(self.req)
-            if self.link:
-                s += ' from %s' % self.link.url
-        else:
-            s = self.link.url if self.link else None
-        if self.satisfied_by is not None:
-            s += ' in %s' % display_path(self.satisfied_by.location)
-        if self.comes_from:
-            if isinstance(self.comes_from, six.string_types):
-                comes_from = self.comes_from
-            else:
-                comes_from = self.comes_from.from_path()
-            if comes_from:
-                s += ' (from %s)' % comes_from
-        return s
-
-    def __repr__(self):
-        return '<%s object: %s editable=%r>' % (
-            self.__class__.__name__, str(self), self.editable)
-
-    def populate_link(self, finder, upgrade, require_hashes):
-        """Ensure that if a link can be found for this, that it is found.
-
-        Note that self.link may still be None - if Upgrade is False and the
-        requirement is already installed.
-
-        If require_hashes is True, don't use the wheel cache, because cached
-        wheels, always built locally, have different hashes than the files
-        downloaded from the index server and thus throw false hash mismatches.
-        Furthermore, cached wheels at present have undeterministic contents due
-        to file modification times.
-        """
-        if self.link is None:
-            self.link = finder.find_requirement(self, upgrade)
-        if self._wheel_cache is not None and not require_hashes:
-            old_link = self.link
-            self.link = self._wheel_cache.cached_wheel(self.link, self.name)
-            if old_link != self.link:
-                logger.debug('Using cached wheel link: %s', self.link)
-
-    @property
-    def specifier(self):
-        return self.req.specifier
-
-    @property
-    def is_pinned(self):
-        """Return whether I am pinned to an exact version.
-
-        For example, some-package==1.2 is pinned; some-package>1.2 is not.
-        """
-        specifiers = self.specifier
-        return (len(specifiers) == 1 and
-                next(iter(specifiers)).operator in ('==', '==='))
-
-    def from_path(self):
-        if self.req is None:
-            return None
-        s = str(self.req)
-        if self.comes_from:
-            if isinstance(self.comes_from, six.string_types):
-                comes_from = self.comes_from
-            else:
-                comes_from = self.comes_from.from_path()
-            if comes_from:
-                s += '->' + comes_from
-        return s
-
-    def build_location(self, build_dir):
-        if self._temp_build_dir is not None:
-            return self._temp_build_dir
-        if self.req is None:
-            # for requirement via a path to a directory: the name of the
-            # package is not available yet so we create a temp directory
-            # Once run_egg_info will have run, we'll be able
-            # to fix it via _correct_build_location
-            # Some systems have /tmp as a symlink which confuses custom
-            # builds (such as numpy). Thus, we ensure that the real path
-            # is returned.
-            self._temp_build_dir = os.path.realpath(
-                tempfile.mkdtemp('-build', 'pip-')
-            )
-            self._ideal_build_dir = build_dir
-            return self._temp_build_dir
-        if self.editable:
-            name = self.name.lower()
-        else:
-            name = self.name
-        # FIXME: Is there a better place to create the build_dir? (hg and bzr
-        # need this)
-        if not os.path.exists(build_dir):
-            logger.debug('Creating directory %s', build_dir)
-            _make_build_dir(build_dir)
-        return os.path.join(build_dir, name)
-
-    def _correct_build_location(self):
-        """Move self._temp_build_dir to self._ideal_build_dir/self.req.name
-
-        For some requirements (e.g. a path to a directory), the name of the
-        package is not available until we run egg_info, so the build_location
-        will return a temporary directory and store the _ideal_build_dir.
-
-        This is only called by self.egg_info_path to fix the temporary build
-        directory.
-        """
-        if self.source_dir is not None:
-            return
-        assert self.req is not None
-        assert self._temp_build_dir
-        assert self._ideal_build_dir
-        old_location = self._temp_build_dir
-        self._temp_build_dir = None
-        new_location = self.build_location(self._ideal_build_dir)
-        if os.path.exists(new_location):
-            raise InstallationError(
-                'A package already exists in %s; please remove it to continue'
-                % display_path(new_location))
-        logger.debug(
-            'Moving package %s from %s to new location %s',
-            self, display_path(old_location), display_path(new_location),
-        )
-        shutil.move(old_location, new_location)
-        self._temp_build_dir = new_location
-        self._ideal_build_dir = None
-        self.source_dir = new_location
-        self._egg_info_path = None
-
-    @property
-    def name(self):
-        if self.req is None:
-            return None
-        return native_str(pkg_resources.safe_name(self.req.name))
-
-    @property
-    def setup_py_dir(self):
-        return os.path.join(
-            self.source_dir,
-            self.link and self.link.subdirectory_fragment or '')
-
-    @property
-    def setup_py(self):
-        assert self.source_dir, "No source dir for %s" % self
-        try:
-            import setuptools  # noqa
-        except ImportError:
-            if get_installed_version('setuptools') is None:
-                add_msg = "Please install setuptools."
-            else:
-                add_msg = traceback.format_exc()
-            # Setuptools is not available
-            raise InstallationError(
-                "Could not import setuptools which is required to "
-                "install from a source distribution.\n%s" % add_msg
-            )
-
-        setup_py = os.path.join(self.setup_py_dir, 'setup.py')
-
-        # Python2 __file__ should not be unicode
-        if six.PY2 and isinstance(setup_py, six.text_type):
-            setup_py = setup_py.encode(sys.getfilesystemencoding())
-
-        return setup_py
-
-    def run_egg_info(self):
-        assert self.source_dir
-        if self.name:
-            logger.debug(
-                'Running setup.py (path:%s) egg_info for package %s',
-                self.setup_py, self.name,
-            )
-        else:
-            logger.debug(
-                'Running setup.py (path:%s) egg_info for package from %s',
-                self.setup_py, self.link,
-            )
-
-        with indent_log():
-            script = SETUPTOOLS_SHIM % self.setup_py
-            base_cmd = [sys.executable, '-c', script]
-            if self.isolated:
-                base_cmd += ["--no-user-cfg"]
-            egg_info_cmd = base_cmd + ['egg_info']
-            # We can't put the .egg-info files at the root, because then the
-            # source code will be mistaken for an installed egg, causing
-            # problems
-            if self.editable:
-                egg_base_option = []
-            else:
-                egg_info_dir = os.path.join(self.setup_py_dir, 'pip-egg-info')
-                ensure_dir(egg_info_dir)
-                egg_base_option = ['--egg-base', 'pip-egg-info']
-            call_subprocess(
-                egg_info_cmd + egg_base_option,
-                cwd=self.setup_py_dir,
-                show_stdout=False,
-                command_desc='python setup.py egg_info')
-
-        if not self.req:
-            if isinstance(parse_version(self.pkg_info()["Version"]), Version):
-                op = "=="
-            else:
-                op = "==="
-            self.req = Requirement(
-                "".join([
-                    self.pkg_info()["Name"],
-                    op,
-                    self.pkg_info()["Version"],
-                ])
-            )
-            self._correct_build_location()
-        else:
-            metadata_name = canonicalize_name(self.pkg_info()["Name"])
-            if canonicalize_name(self.req.name) != metadata_name:
-                logger.warning(
-                    'Running setup.py (path:%s) egg_info for package %s '
-                    'produced metadata for project name %s. Fix your '
-                    '#egg=%s fragments.',
-                    self.setup_py, self.name, metadata_name, self.name
-                )
-                self.req = Requirement(metadata_name)
-
-    def egg_info_data(self, filename):
-        if self.satisfied_by is not None:
-            if not self.satisfied_by.has_metadata(filename):
-                return None
-            return self.satisfied_by.get_metadata(filename)
-        assert self.source_dir
-        filename = self.egg_info_path(filename)
-        if not os.path.exists(filename):
-            return None
-        data = read_text_file(filename)
-        return data
-
-    def egg_info_path(self, filename):
-        if self._egg_info_path is None:
-            if self.editable:
-                base = self.source_dir
-            else:
-                base = os.path.join(self.setup_py_dir, 'pip-egg-info')
-            filenames = os.listdir(base)
-            if self.editable:
-                filenames = []
-                for root, dirs, files in os.walk(base):
-                    for dir in vcs.dirnames:
-                        if dir in dirs:
-                            dirs.remove(dir)
-                    # Iterate over a copy of ``dirs``, since mutating
-                    # a list while iterating over it can cause trouble.
-                    # (See https://github.com/pypa/pip/pull/462.)
-                    for dir in list(dirs):
-                        # Don't search in anything that looks like a virtualenv
-                        # environment
-                        if (
-                                os.path.lexists(
-                                    os.path.join(root, dir, 'bin', 'python')
-                                ) or
-                                os.path.exists(
-                                    os.path.join(
-                                        root, dir, 'Scripts', 'Python.exe'
-                                    )
-                                )):
-                            dirs.remove(dir)
-                        # Also don't search through tests
-                        elif dir == 'test' or dir == 'tests':
-                            dirs.remove(dir)
-                    filenames.extend([os.path.join(root, dir)
-                                     for dir in dirs])
-                filenames = [f for f in filenames if f.endswith('.egg-info')]
-
-            if not filenames:
-                raise InstallationError(
-                    'No files/directories in %s (from %s)' % (base, filename)
-                )
-            assert filenames, \
-                "No files/directories in %s (from %s)" % (base, filename)
-
-            # if we have more than one match, we pick the toplevel one.  This
-            # can easily be the case if there is a dist folder which contains
-            # an extracted tarball for testing purposes.
-            if len(filenames) > 1:
-                filenames.sort(
-                    key=lambda x: x.count(os.path.sep) +
-                    (os.path.altsep and x.count(os.path.altsep) or 0)
-                )
-            self._egg_info_path = os.path.join(base, filenames[0])
-        return os.path.join(self._egg_info_path, filename)
-
-    def pkg_info(self):
-        p = FeedParser()
-        data = self.egg_info_data('PKG-INFO')
-        if not data:
-            logger.warning(
-                'No PKG-INFO file found in %s',
-                display_path(self.egg_info_path('PKG-INFO')),
-            )
-        p.feed(data or '')
-        return p.close()
-
-    _requirements_section_re = re.compile(r'\[(.*?)\]')
-
-    @property
-    def installed_version(self):
-        return get_installed_version(self.name)
-
-    def assert_source_matches_version(self):
-        assert self.source_dir
-        version = self.pkg_info()['version']
-        if self.req.specifier and version not in self.req.specifier:
-            logger.warning(
-                'Requested %s, but installing version %s',
-                self,
-                self.installed_version,
-            )
-        else:
-            logger.debug(
-                'Source in %s has version %s, which satisfies requirement %s',
-                display_path(self.source_dir),
-                version,
-                self,
-            )
-
-    def update_editable(self, obtain=True):
-        if not self.link:
-            logger.debug(
-                "Cannot update repository at %s; repository location is "
-                "unknown",
-                self.source_dir,
-            )
-            return
-        assert self.editable
-        assert self.source_dir
-        if self.link.scheme == 'file':
-            # Static paths don't get updated
-            return
-        assert '+' in self.link.url, "bad url: %r" % self.link.url
-        if not self.update:
-            return
-        vc_type, url = self.link.url.split('+', 1)
-        backend = vcs.get_backend(vc_type)
-        if backend:
-            vcs_backend = backend(self.link.url)
-            if obtain:
-                vcs_backend.obtain(self.source_dir)
-            else:
-                vcs_backend.export(self.source_dir)
-        else:
-            assert 0, (
-                'Unexpected version control type (in %s): %s'
-                % (self.link, vc_type))
-
-    def uninstall(self, auto_confirm=False):
-        """
-        Uninstall the distribution currently satisfying this requirement.
-
-        Prompts before removing or modifying files unless
-        ``auto_confirm`` is True.
-
-        Refuses to delete or modify files outside of ``sys.prefix`` -
-        thus uninstallation within a virtual environment can only
-        modify that virtual environment, even if the virtualenv is
-        linked to global site-packages.
-
-        """
-        if not self.check_if_exists():
-            raise UninstallationError(
-                "Cannot uninstall requirement %s, not installed" % (self.name,)
-            )
-        dist = self.satisfied_by or self.conflicts_with
-
-        dist_path = normalize_path(dist.location)
-        if not dist_is_local(dist):
-            logger.info(
-                "Not uninstalling %s at %s, outside environment %s",
-                dist.key,
-                dist_path,
-                sys.prefix,
-            )
-            self.nothing_to_uninstall = True
-            return
-
-        if dist_path in get_stdlib():
-            logger.info(
-                "Not uninstalling %s at %s, as it is in the standard library.",
-                dist.key,
-                dist_path,
-            )
-            self.nothing_to_uninstall = True
-            return
-
-        paths_to_remove = UninstallPathSet(dist)
-        develop_egg_link = egg_link_path(dist)
-        develop_egg_link_egg_info = '{0}.egg-info'.format(
-            pkg_resources.to_filename(dist.project_name))
-        egg_info_exists = dist.egg_info and os.path.exists(dist.egg_info)
-        # Special case for distutils installed package
-        distutils_egg_info = getattr(dist._provider, 'path', None)
-
-        # Uninstall cases order do matter as in the case of 2 installs of the
-        # same package, pip needs to uninstall the currently detected version
-        if (egg_info_exists and dist.egg_info.endswith('.egg-info') and
-                not dist.egg_info.endswith(develop_egg_link_egg_info)):
-            # if dist.egg_info.endswith(develop_egg_link_egg_info), we
-            # are in fact in the develop_egg_link case
-            paths_to_remove.add(dist.egg_info)
-            if dist.has_metadata('installed-files.txt'):
-                for installed_file in dist.get_metadata(
-                        'installed-files.txt').splitlines():
-                    path = os.path.normpath(
-                        os.path.join(dist.egg_info, installed_file)
-                    )
-                    paths_to_remove.add(path)
-            # FIXME: need a test for this elif block
-            # occurs with --single-version-externally-managed/--record outside
-            # of pip
-            elif dist.has_metadata('top_level.txt'):
-                if dist.has_metadata('namespace_packages.txt'):
-                    namespaces = dist.get_metadata('namespace_packages.txt')
-                else:
-                    namespaces = []
-                for top_level_pkg in [
-                        p for p
-                        in dist.get_metadata('top_level.txt').splitlines()
-                        if p and p not in namespaces]:
-                    path = os.path.join(dist.location, top_level_pkg)
-                    paths_to_remove.add(path)
-                    paths_to_remove.add(path + '.py')
-                    paths_to_remove.add(path + '.pyc')
-                    paths_to_remove.add(path + '.pyo')
-
-        elif distutils_egg_info:
-            warnings.warn(
-                "Uninstalling a distutils installed project ({0}) has been "
-                "deprecated and will be removed in a future version. This is "
-                "due to the fact that uninstalling a distutils project will "
-                "only partially uninstall the project.".format(self.name),
-                RemovedInPip10Warning,
-            )
-            paths_to_remove.add(distutils_egg_info)
-
-        elif dist.location.endswith('.egg'):
-            # package installed by easy_install
-            # We cannot match on dist.egg_name because it can slightly vary
-            # i.e. setuptools-0.6c11-py2.6.egg vs setuptools-0.6rc11-py2.6.egg
-            paths_to_remove.add(dist.location)
-            easy_install_egg = os.path.split(dist.location)[1]
-            easy_install_pth = os.path.join(os.path.dirname(dist.location),
-                                            'easy-install.pth')
-            paths_to_remove.add_pth(easy_install_pth, './' + easy_install_egg)
-
-        elif egg_info_exists and dist.egg_info.endswith('.dist-info'):
-            for path in pip.wheel.uninstallation_paths(dist):
-                paths_to_remove.add(path)
-
-        elif develop_egg_link:
-            # develop egg
-            with open(develop_egg_link, 'r') as fh:
-                link_pointer = os.path.normcase(fh.readline().strip())
-            assert (link_pointer == dist.location), (
-                'Egg-link %s does not match installed location of %s '
-                '(at %s)' % (link_pointer, self.name, dist.location)
-            )
-            paths_to_remove.add(develop_egg_link)
-            easy_install_pth = os.path.join(os.path.dirname(develop_egg_link),
-                                            'easy-install.pth')
-            paths_to_remove.add_pth(easy_install_pth, dist.location)
-
-        else:
-            logger.debug(
-                'Not sure how to uninstall: %s - Check: %s',
-                dist, dist.location)
-
-        # find distutils scripts= scripts
-        if dist.has_metadata('scripts') and dist.metadata_isdir('scripts'):
-            for script in dist.metadata_listdir('scripts'):
-                if dist_in_usersite(dist):
-                    bin_dir = bin_user
-                else:
-                    bin_dir = bin_py
-                paths_to_remove.add(os.path.join(bin_dir, script))
-                if WINDOWS:
-                    paths_to_remove.add(os.path.join(bin_dir, script) + '.bat')
-
-        # find console_scripts
-        if dist.has_metadata('entry_points.txt'):
-            if six.PY2:
-                options = {}
-            else:
-                options = {"delimiters": ('=', )}
-            config = configparser.SafeConfigParser(**options)
-            config.readfp(
-                FakeFile(dist.get_metadata_lines('entry_points.txt'))
-            )
-            if config.has_section('console_scripts'):
-                for name, value in config.items('console_scripts'):
-                    if dist_in_usersite(dist):
-                        bin_dir = bin_user
-                    else:
-                        bin_dir = bin_py
-                    paths_to_remove.add(os.path.join(bin_dir, name))
-                    if WINDOWS:
-                        paths_to_remove.add(
-                            os.path.join(bin_dir, name) + '.exe'
-                        )
-                        paths_to_remove.add(
-                            os.path.join(bin_dir, name) + '.exe.manifest'
-                        )
-                        paths_to_remove.add(
-                            os.path.join(bin_dir, name) + '-script.py'
-                        )
-
-        paths_to_remove.remove(auto_confirm)
-        self.uninstalled = paths_to_remove
-
-    def rollback_uninstall(self):
-        if self.uninstalled:
-            self.uninstalled.rollback()
-        else:
-            logger.error(
-                "Can't rollback %s, nothing uninstalled.", self.name,
-            )
-
-    def commit_uninstall(self):
-        if self.uninstalled:
-            self.uninstalled.commit()
-        elif not self.nothing_to_uninstall:
-            logger.error(
-                "Can't commit %s, nothing uninstalled.", self.name,
-            )
-
-    def archive(self, build_dir):
-        assert self.source_dir
-        create_archive = True
-        archive_name = '%s-%s.zip' % (self.name, self.pkg_info()["version"])
-        archive_path = os.path.join(build_dir, archive_name)
-        if os.path.exists(archive_path):
-            response = ask_path_exists(
-                'The file %s exists. (i)gnore, (w)ipe, (b)ackup, (a)bort ' %
-                display_path(archive_path), ('i', 'w', 'b', 'a'))
-            if response == 'i':
-                create_archive = False
-            elif response == 'w':
-                logger.warning('Deleting %s', display_path(archive_path))
-                os.remove(archive_path)
-            elif response == 'b':
-                dest_file = backup_dir(archive_path)
-                logger.warning(
-                    'Backing up %s to %s',
-                    display_path(archive_path),
-                    display_path(dest_file),
-                )
-                shutil.move(archive_path, dest_file)
-            elif response == 'a':
-                sys.exit(-1)
-        if create_archive:
-            zip = zipfile.ZipFile(
-                archive_path, 'w', zipfile.ZIP_DEFLATED,
-                allowZip64=True
-            )
-            dir = os.path.normcase(os.path.abspath(self.setup_py_dir))
-            for dirpath, dirnames, filenames in os.walk(dir):
-                if 'pip-egg-info' in dirnames:
-                    dirnames.remove('pip-egg-info')
-                for dirname in dirnames:
-                    dirname = os.path.join(dirpath, dirname)
-                    name = self._clean_zip_name(dirname, dir)
-                    zipdir = zipfile.ZipInfo(self.name + '/' + name + '/')
-                    zipdir.external_attr = 0x1ED << 16  # 0o755
-                    zip.writestr(zipdir, '')
-                for filename in filenames:
-                    if filename == PIP_DELETE_MARKER_FILENAME:
-                        continue
-                    filename = os.path.join(dirpath, filename)
-                    name = self._clean_zip_name(filename, dir)
-                    zip.write(filename, self.name + '/' + name)
-            zip.close()
-            logger.info('Saved %s', display_path(archive_path))
-
-    def _clean_zip_name(self, name, prefix):
-        assert name.startswith(prefix + os.path.sep), (
-            "name %r doesn't start with prefix %r" % (name, prefix)
-        )
-        name = name[len(prefix) + 1:]
-        name = name.replace(os.path.sep, '/')
-        return name
-
-    def match_markers(self, extras_requested=None):
-        if not extras_requested:
-            # Provide an extra to safely evaluate the markers
-            # without matching any extra
-            extras_requested = ('',)
-        if self.markers is not None:
-            return any(
-                self.markers.evaluate({'extra': extra})
-                for extra in extras_requested)
-        else:
-            return True
-
-    def install(self, install_options, global_options=[], root=None,
-                prefix=None):
-        if self.editable:
-            self.install_editable(
-                install_options, global_options, prefix=prefix)
-            return
-        if self.is_wheel:
-            version = pip.wheel.wheel_version(self.source_dir)
-            pip.wheel.check_compatibility(version, self.name)
-
-            self.move_wheel_files(self.source_dir, root=root, prefix=prefix)
-            self.install_succeeded = True
-            return
-
-        # Extend the list of global and install options passed on to
-        # the setup.py call with the ones from the requirements file.
-        # Options specified in requirements file override those
-        # specified on the command line, since the last option given
-        # to setup.py is the one that is used.
-        global_options += self.options.get('global_options', [])
-        install_options += self.options.get('install_options', [])
-
-        if self.isolated:
-            global_options = list(global_options) + ["--no-user-cfg"]
-
-        temp_location = tempfile.mkdtemp('-record', 'pip-')
-        record_filename = os.path.join(temp_location, 'install-record.txt')
-        try:
-            install_args = self.get_install_args(
-                global_options, record_filename, root, prefix)
-            msg = 'Running setup.py install for %s' % (self.name,)
-            with open_spinner(msg) as spinner:
-                with indent_log():
-                    call_subprocess(
-                        install_args + install_options,
-                        cwd=self.setup_py_dir,
-                        show_stdout=False,
-                        spinner=spinner,
-                    )
-
-            if not os.path.exists(record_filename):
-                logger.debug('Record file %s not found', record_filename)
-                return
-            self.install_succeeded = True
-            if self.as_egg:
-                # there's no --always-unzip option we can pass to install
-                # command so we unable to save the installed-files.txt
-                return
-
-            def prepend_root(path):
-                if root is None or not os.path.isabs(path):
-                    return path
-                else:
-                    return change_root(root, path)
-
-            with open(record_filename) as f:
-                for line in f:
-                    directory = os.path.dirname(line)
-                    if directory.endswith('.egg-info'):
-                        egg_info_dir = prepend_root(directory)
-                        break
-                else:
-                    logger.warning(
-                        'Could not find .egg-info directory in install record'
-                        ' for %s',
-                        self,
-                    )
-                    # FIXME: put the record somewhere
-                    # FIXME: should this be an error?
-                    return
-            new_lines = []
-            with open(record_filename) as f:
-                for line in f:
-                    filename = line.strip()
-                    if os.path.isdir(filename):
-                        filename += os.path.sep
-                    new_lines.append(
-                        os.path.relpath(
-                            prepend_root(filename), egg_info_dir)
-                    )
-            inst_files_path = os.path.join(egg_info_dir, 'installed-files.txt')
-            with open(inst_files_path, 'w') as f:
-                f.write('\n'.join(new_lines) + '\n')
-        finally:
-            if os.path.exists(record_filename):
-                os.remove(record_filename)
-            rmtree(temp_location)
-
-    def ensure_has_source_dir(self, parent_dir):
-        """Ensure that a source_dir is set.
-
-        This will create a temporary build dir if the name of the requirement
-        isn't known yet.
-
-        :param parent_dir: The ideal pip parent_dir for the source_dir.
-            Generally src_dir for editables and build_dir for sdists.
-        :return: self.source_dir
-        """
-        if self.source_dir is None:
-            self.source_dir = self.build_location(parent_dir)
-        return self.source_dir
-
-    def get_install_args(self, global_options, record_filename, root, prefix):
-        install_args = [sys.executable, "-u"]
-        install_args.append('-c')
-        install_args.append(SETUPTOOLS_SHIM % self.setup_py)
-        install_args += list(global_options) + \
-            ['install', '--record', record_filename]
-
-        if not self.as_egg:
-            install_args += ['--single-version-externally-managed']
-
-        if root is not None:
-            install_args += ['--root', root]
-        if prefix is not None:
-            install_args += ['--prefix', prefix]
-
-        if self.pycompile:
-            install_args += ["--compile"]
-        else:
-            install_args += ["--no-compile"]
-
-        if running_under_virtualenv():
-            py_ver_str = 'python' + sysconfig.get_python_version()
-            install_args += ['--install-headers',
-                             os.path.join(sys.prefix, 'include', 'site',
-                                          py_ver_str, self.name)]
-
-        return install_args
-
-    def remove_temporary_source(self):
-        """Remove the source files from this requirement, if they are marked
-        for deletion"""
-        if self.source_dir and os.path.exists(
-                os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):
-            logger.debug('Removing source in %s', self.source_dir)
-            rmtree(self.source_dir)
-        self.source_dir = None
-        if self._temp_build_dir and os.path.exists(self._temp_build_dir):
-            rmtree(self._temp_build_dir)
-        self._temp_build_dir = None
-
-    def install_editable(self, install_options,
-                         global_options=(), prefix=None):
-        logger.info('Running setup.py develop for %s', self.name)
-
-        if self.isolated:
-            global_options = list(global_options) + ["--no-user-cfg"]
-
-        if prefix:
-            prefix_param = ['--prefix={0}'.format(prefix)]
-            install_options = list(install_options) + prefix_param
-
-        with indent_log():
-            # FIXME: should we do --install-headers here too?
-            call_subprocess(
-                [
-                    sys.executable,
-                    '-c',
-                    SETUPTOOLS_SHIM % self.setup_py
-                ] +
-                list(global_options) +
-                ['develop', '--no-deps'] +
-                list(install_options),
-
-                cwd=self.setup_py_dir,
-                show_stdout=False)
-
-        self.install_succeeded = True
-
-    def check_if_exists(self):
-        """Find an installed distribution that satisfies or conflicts
-        with this requirement, and set self.satisfied_by or
-        self.conflicts_with appropriately.
-        """
-        if self.req is None:
-            return False
-        try:
-            # get_distribution() will resolve the entire list of requirements
-            # anyway, and we've already determined that we need the requirement
-            # in question, so strip the marker so that we don't try to
-            # evaluate it.
-            no_marker = Requirement(str(self.req))
-            no_marker.marker = None
-            self.satisfied_by = pkg_resources.get_distribution(str(no_marker))
-            if self.editable and self.satisfied_by:
-                self.conflicts_with = self.satisfied_by
-                # when installing editables, nothing pre-existing should ever
-                # satisfy
-                self.satisfied_by = None
-                return True
-        except pkg_resources.DistributionNotFound:
-            return False
-        except pkg_resources.VersionConflict:
-            existing_dist = pkg_resources.get_distribution(
-                self.req.name
-            )
-            if self.use_user_site:
-                if dist_in_usersite(existing_dist):
-                    self.conflicts_with = existing_dist
-                elif (running_under_virtualenv() and
-                        dist_in_site_packages(existing_dist)):
-                    raise InstallationError(
-                        "Will not install to the user site because it will "
-                        "lack sys.path precedence to %s in %s" %
-                        (existing_dist.project_name, existing_dist.location)
-                    )
-            else:
-                self.conflicts_with = existing_dist
-        return True
-
-    @property
-    def is_wheel(self):
-        return self.link and self.link.is_wheel
-
-    def move_wheel_files(self, wheeldir, root=None, prefix=None):
-        move_wheel_files(
-            self.name, self.req, wheeldir,
-            user=self.use_user_site,
-            home=self.target_dir,
-            root=root,
-            prefix=prefix,
-            pycompile=self.pycompile,
-            isolated=self.isolated,
-        )
-
-    def get_dist(self):
-        """Return a pkg_resources.Distribution built from self.egg_info_path"""
-        egg_info = self.egg_info_path('').rstrip('/')
-        base_dir = os.path.dirname(egg_info)
-        metadata = pkg_resources.PathMetadata(base_dir, egg_info)
-        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
-        return pkg_resources.Distribution(
-            os.path.dirname(egg_info),
-            project_name=dist_name,
-            metadata=metadata)
-
-    @property
-    def has_hash_options(self):
-        """Return whether any known-good hashes are specified as options.
-
-        These activate --require-hashes mode; hashes specified as part of a
-        URL do not.
-
-        """
-        return bool(self.options.get('hashes', {}))
-
-    def hashes(self, trust_internet=True):
-        """Return a hash-comparer that considers my option- and URL-based
-        hashes to be known-good.
-
-        Hashes in URLs--ones embedded in the requirements file, not ones
-        downloaded from an index server--are almost peers with ones from
-        flags. They satisfy --require-hashes (whether it was implicitly or
-        explicitly activated) but do not activate it. md5 and sha224 are not
-        allowed in flags, which should nudge people toward good algos. We
-        always OR all hashes together, even ones from URLs.
-
-        :param trust_internet: Whether to trust URL-based (#md5=...) hashes
-            downloaded from the internet, as by populate_link()
-
-        """
-        good_hashes = self.options.get('hashes', {}).copy()
-        link = self.link if trust_internet else self.original_link
-        if link and link.hash:
-            good_hashes.setdefault(link.hash_name, []).append(link.hash)
-        return Hashes(good_hashes)
-
-
-def _strip_postfix(req):
-    """
-        Strip req postfix ( -dev, 0.2, etc )
-    """
-    # FIXME: use package_to_requirement?
-    match = re.search(r'^(.*?)(?:-dev|-\d.*)$', req)
-    if match:
-        # Strip off -dev, -0.2, etc.
-        req = match.group(1)
-    return req
-
-
-def parse_editable(editable_req, default_vcs=None):
-    """Parses an editable requirement into:
-        - a requirement name
-        - an URL
-        - extras
-        - editable options
-    Accepted requirements:
-        svn+http://blahblah@rev#egg=Foobar[baz]&subdirectory=version_subdir
-        .[some_extra]
-    """
-
-    from pip.index import Link
-
-    url = editable_req
-    extras = None
-
-    # If a file path is specified with extras, strip off the extras.
-    m = re.match(r'^(.+)(\[[^\]]+\])$', url)
-    if m:
-        url_no_extras = m.group(1)
-        extras = m.group(2)
-    else:
-        url_no_extras = url
-
-    if os.path.isdir(url_no_extras):
-        if not os.path.exists(os.path.join(url_no_extras, 'setup.py')):
-            raise InstallationError(
-                "Directory %r is not installable. File 'setup.py' not found." %
-                url_no_extras
-            )
-        # Treating it as code that has already been checked out
-        url_no_extras = path_to_url(url_no_extras)
-
-    if url_no_extras.lower().startswith('file:'):
-        package_name = Link(url_no_extras).egg_fragment
-        if extras:
-            return (
-                package_name,
-                url_no_extras,
-                Requirement("placeholder" + extras.lower()).extras,
-            )
-        else:
-            return package_name, url_no_extras, None
-
-    for version_control in vcs:
-        if url.lower().startswith('%s:' % version_control):
-            url = '%s+%s' % (version_control, url)
-            break
-
-    if '+' not in url:
-        if default_vcs:
-            warnings.warn(
-                "--default-vcs has been deprecated and will be removed in "
-                "the future.",
-                RemovedInPip10Warning,
-            )
-            url = default_vcs + '+' + url
-        else:
-            raise InstallationError(
-                '%s should either be a path to a local project or a VCS url '
-                'beginning with svn+, git+, hg+, or bzr+' %
-                editable_req
-            )
-
-    vc_type = url.split('+', 1)[0].lower()
-
-    if not vcs.get_backend(vc_type):
-        error_message = 'For --editable=%s only ' % editable_req + \
-            ', '.join([backend.name + '+URL' for backend in vcs.backends]) + \
-            ' is currently supported'
-        raise InstallationError(error_message)
-
-    package_name = Link(url).egg_fragment
-    if not package_name:
-        raise InstallationError(
-            "Could not detect requirement name, please specify one with #egg="
-        )
-    if not package_name:
-        raise InstallationError(
-            '--editable=%s is not the right format; it must have '
-            '#egg=Package' % editable_req
-        )
-    return _strip_postfix(package_name), url, None
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_set.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_set.py
deleted file mode 100644
index 76aec0616..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_set.py
+++ /dev/null
@@ -1,798 +0,0 @@
-from __future__ import absolute_import
-
-from collections import defaultdict
-from itertools import chain
-import logging
-import os
-
-from pip._vendor import pkg_resources
-from pip._vendor import requests
-
-from pip.compat import expanduser
-from pip.download import (is_file_url, is_dir_url, is_vcs_url, url_to_path,
-                          unpack_url)
-from pip.exceptions import (InstallationError, BestVersionAlreadyInstalled,
-                            DistributionNotFound, PreviousBuildDirError,
-                            HashError, HashErrors, HashUnpinned,
-                            DirectoryUrlHashUnsupported, VcsHashUnsupported,
-                            UnsupportedPythonVersion)
-from pip.req.req_install import InstallRequirement
-from pip.utils import (
-    display_path, dist_in_usersite, ensure_dir, normalize_path)
-from pip.utils.hashes import MissingHashes
-from pip.utils.logging import indent_log
-from pip.utils.packaging import check_dist_requires_python
-from pip.vcs import vcs
-from pip.wheel import Wheel
-
-logger = logging.getLogger(__name__)
-
-
-class Requirements(object):
-
-    def __init__(self):
-        self._keys = []
-        self._dict = {}
-
-    def keys(self):
-        return self._keys
-
-    def values(self):
-        return [self._dict[key] for key in self._keys]
-
-    def __contains__(self, item):
-        return item in self._keys
-
-    def __setitem__(self, key, value):
-        if key not in self._keys:
-            self._keys.append(key)
-        self._dict[key] = value
-
-    def __getitem__(self, key):
-        return self._dict[key]
-
-    def __repr__(self):
-        values = ['%s: %s' % (repr(k), repr(self[k])) for k in self.keys()]
-        return 'Requirements({%s})' % ', '.join(values)
-
-
-class DistAbstraction(object):
-    """Abstracts out the wheel vs non-wheel prepare_files logic.
-
-    The requirements for anything installable are as follows:
-     - we must be able to determine the requirement name
-       (or we can't correctly handle the non-upgrade case).
-     - we must be able to generate a list of run-time dependencies
-       without installing any additional packages (or we would
-       have to either burn time by doing temporary isolated installs
-       or alternatively violate pips 'don't start installing unless
-       all requirements are available' rule - neither of which are
-       desirable).
-     - for packages with setup requirements, we must also be able
-       to determine their requirements without installing additional
-       packages (for the same reason as run-time dependencies)
-     - we must be able to create a Distribution object exposing the
-       above metadata.
-    """
-
-    def __init__(self, req_to_install):
-        self.req_to_install = req_to_install
-
-    def dist(self, finder):
-        """Return a setuptools Dist object."""
-        raise NotImplementedError(self.dist)
-
-    def prep_for_dist(self):
-        """Ensure that we can get a Dist for this requirement."""
-        raise NotImplementedError(self.dist)
-
-
-def make_abstract_dist(req_to_install):
-    """Factory to make an abstract dist object.
-
-    Preconditions: Either an editable req with a source_dir, or satisfied_by or
-    a wheel link, or a non-editable req with a source_dir.
-
-    :return: A concrete DistAbstraction.
-    """
-    if req_to_install.editable:
-        return IsSDist(req_to_install)
-    elif req_to_install.link and req_to_install.link.is_wheel:
-        return IsWheel(req_to_install)
-    else:
-        return IsSDist(req_to_install)
-
-
-class IsWheel(DistAbstraction):
-
-    def dist(self, finder):
-        return list(pkg_resources.find_distributions(
-            self.req_to_install.source_dir))[0]
-
-    def prep_for_dist(self):
-        # FIXME:https://github.com/pypa/pip/issues/1112
-        pass
-
-
-class IsSDist(DistAbstraction):
-
-    def dist(self, finder):
-        dist = self.req_to_install.get_dist()
-        # FIXME: shouldn't be globally added:
-        if dist.has_metadata('dependency_links.txt'):
-            finder.add_dependency_links(
-                dist.get_metadata_lines('dependency_links.txt')
-            )
-        return dist
-
-    def prep_for_dist(self):
-        self.req_to_install.run_egg_info()
-        self.req_to_install.assert_source_matches_version()
-
-
-class Installed(DistAbstraction):
-
-    def dist(self, finder):
-        return self.req_to_install.satisfied_by
-
-    def prep_for_dist(self):
-        pass
-
-
-class RequirementSet(object):
-
-    def __init__(self, build_dir, src_dir, download_dir, upgrade=False,
-                 upgrade_strategy=None, ignore_installed=False, as_egg=False,
-                 target_dir=None, ignore_dependencies=False,
-                 force_reinstall=False, use_user_site=False, session=None,
-                 pycompile=True, isolated=False, wheel_download_dir=None,
-                 wheel_cache=None, require_hashes=False,
-                 ignore_requires_python=False):
-        """Create a RequirementSet.
-
-        :param wheel_download_dir: Where still-packed .whl files should be
-            written to. If None they are written to the download_dir parameter.
-            Separate to download_dir to permit only keeping wheel archives for
-            pip wheel.
-        :param download_dir: Where still packed archives should be written to.
-            If None they are not saved, and are deleted immediately after
-            unpacking.
-        :param wheel_cache: The pip wheel cache, for passing to
-            InstallRequirement.
-        """
-        if session is None:
-            raise TypeError(
-                "RequirementSet() missing 1 required keyword argument: "
-                "'session'"
-            )
-
-        self.build_dir = build_dir
-        self.src_dir = src_dir
-        # XXX: download_dir and wheel_download_dir overlap semantically and may
-        # be combined if we're willing to have non-wheel archives present in
-        # the wheelhouse output by 'pip wheel'.
-        self.download_dir = download_dir
-        self.upgrade = upgrade
-        self.upgrade_strategy = upgrade_strategy
-        self.ignore_installed = ignore_installed
-        self.force_reinstall = force_reinstall
-        self.requirements = Requirements()
-        # Mapping of alias: real_name
-        self.requirement_aliases = {}
-        self.unnamed_requirements = []
-        self.ignore_dependencies = ignore_dependencies
-        self.ignore_requires_python = ignore_requires_python
-        self.successfully_downloaded = []
-        self.successfully_installed = []
-        self.reqs_to_cleanup = []
-        self.as_egg = as_egg
-        self.use_user_site = use_user_site
-        self.target_dir = target_dir  # set from --target option
-        self.session = session
-        self.pycompile = pycompile
-        self.isolated = isolated
-        if wheel_download_dir:
-            wheel_download_dir = normalize_path(wheel_download_dir)
-        self.wheel_download_dir = wheel_download_dir
-        self._wheel_cache = wheel_cache
-        self.require_hashes = require_hashes
-        # Maps from install_req -> dependencies_of_install_req
-        self._dependencies = defaultdict(list)
-
-    def __str__(self):
-        reqs = [req for req in self.requirements.values()
-                if not req.comes_from]
-        reqs.sort(key=lambda req: req.name.lower())
-        return ' '.join([str(req.req) for req in reqs])
-
-    def __repr__(self):
-        reqs = [req for req in self.requirements.values()]
-        reqs.sort(key=lambda req: req.name.lower())
-        reqs_str = ', '.join([str(req.req) for req in reqs])
-        return ('<%s object; %d requirement(s): %s>'
-                % (self.__class__.__name__, len(reqs), reqs_str))
-
-    def add_requirement(self, install_req, parent_req_name=None,
-                        extras_requested=None):
-        """Add install_req as a requirement to install.
-
-        :param parent_req_name: The name of the requirement that needed this
-            added. The name is used because when multiple unnamed requirements
-            resolve to the same name, we could otherwise end up with dependency
-            links that point outside the Requirements set. parent_req must
-            already be added. Note that None implies that this is a user
-            supplied requirement, vs an inferred one.
-        :param extras_requested: an iterable of extras used to evaluate the
-            environement markers.
-        :return: Additional requirements to scan. That is either [] if
-            the requirement is not applicable, or [install_req] if the
-            requirement is applicable and has just been added.
-        """
-        name = install_req.name
-        if not install_req.match_markers(extras_requested):
-            logger.warning("Ignoring %s: markers '%s' don't match your "
-                           "environment", install_req.name,
-                           install_req.markers)
-            return []
-
-        # This check has to come after we filter requirements with the
-        # environment markers.
-        if install_req.link and install_req.link.is_wheel:
-            wheel = Wheel(install_req.link.filename)
-            if not wheel.supported():
-                raise InstallationError(
-                    "%s is not a supported wheel on this platform." %
-                    wheel.filename
-                )
-
-        install_req.as_egg = self.as_egg
-        install_req.use_user_site = self.use_user_site
-        install_req.target_dir = self.target_dir
-        install_req.pycompile = self.pycompile
-        install_req.is_direct = (parent_req_name is None)
-
-        if not name:
-            # url or path requirement w/o an egg fragment
-            self.unnamed_requirements.append(install_req)
-            return [install_req]
-        else:
-            try:
-                existing_req = self.get_requirement(name)
-            except KeyError:
-                existing_req = None
-            if (parent_req_name is None and existing_req and not
-                    existing_req.constraint and
-                    existing_req.extras == install_req.extras and not
-                    existing_req.req.specifier == install_req.req.specifier):
-                raise InstallationError(
-                    'Double requirement given: %s (already in %s, name=%r)'
-                    % (install_req, existing_req, name))
-            if not existing_req:
-                # Add requirement
-                self.requirements[name] = install_req
-                # FIXME: what about other normalizations?  E.g., _ vs. -?
-                if name.lower() != name:
-                    self.requirement_aliases[name.lower()] = name
-                result = [install_req]
-            else:
-                # Assume there's no need to scan, and that we've already
-                # encountered this for scanning.
-                result = []
-                if not install_req.constraint and existing_req.constraint:
-                    if (install_req.link and not (existing_req.link and
-                       install_req.link.path == existing_req.link.path)):
-                        self.reqs_to_cleanup.append(install_req)
-                        raise InstallationError(
-                            "Could not satisfy constraints for '%s': "
-                            "installation from path or url cannot be "
-                            "constrained to a version" % name)
-                    # If we're now installing a constraint, mark the existing
-                    # object for real installation.
-                    existing_req.constraint = False
-                    existing_req.extras = tuple(
-                        sorted(set(existing_req.extras).union(
-                               set(install_req.extras))))
-                    logger.debug("Setting %s extras to: %s",
-                                 existing_req, existing_req.extras)
-                    # And now we need to scan this.
-                    result = [existing_req]
-                # Canonicalise to the already-added object for the backref
-                # check below.
-                install_req = existing_req
-            if parent_req_name:
-                parent_req = self.get_requirement(parent_req_name)
-                self._dependencies[parent_req].append(install_req)
-            return result
-
-    def has_requirement(self, project_name):
-        name = project_name.lower()
-        if (name in self.requirements and
-           not self.requirements[name].constraint or
-           name in self.requirement_aliases and
-           not self.requirements[self.requirement_aliases[name]].constraint):
-            return True
-        return False
-
-    @property
-    def has_requirements(self):
-        return list(req for req in self.requirements.values() if not
-                    req.constraint) or self.unnamed_requirements
-
-    @property
-    def is_download(self):
-        if self.download_dir:
-            self.download_dir = expanduser(self.download_dir)
-            if os.path.exists(self.download_dir):
-                return True
-            else:
-                logger.critical('Could not find download directory')
-                raise InstallationError(
-                    "Could not find or access download directory '%s'"
-                    % display_path(self.download_dir))
-        return False
-
-    def get_requirement(self, project_name):
-        for name in project_name, project_name.lower():
-            if name in self.requirements:
-                return self.requirements[name]
-            if name in self.requirement_aliases:
-                return self.requirements[self.requirement_aliases[name]]
-        raise KeyError("No project with the name %r" % project_name)
-
-    def uninstall(self, auto_confirm=False):
-        for req in self.requirements.values():
-            if req.constraint:
-                continue
-            req.uninstall(auto_confirm=auto_confirm)
-            req.commit_uninstall()
-
-    def prepare_files(self, finder):
-        """
-        Prepare process. Create temp directories, download and/or unpack files.
-        """
-        # make the wheelhouse
-        if self.wheel_download_dir:
-            ensure_dir(self.wheel_download_dir)
-
-        # If any top-level requirement has a hash specified, enter
-        # hash-checking mode, which requires hashes from all.
-        root_reqs = self.unnamed_requirements + self.requirements.values()
-        require_hashes = (self.require_hashes or
-                          any(req.has_hash_options for req in root_reqs))
-        if require_hashes and self.as_egg:
-            raise InstallationError(
-                '--egg is not allowed with --require-hashes mode, since it '
-                'delegates dependency resolution to setuptools and could thus '
-                'result in installation of unhashed packages.')
-
-        # Actually prepare the files, and collect any exceptions. Most hash
-        # exceptions cannot be checked ahead of time, because
-        # req.populate_link() needs to be called before we can make decisions
-        # based on link type.
-        discovered_reqs = []
-        hash_errors = HashErrors()
-        for req in chain(root_reqs, discovered_reqs):
-            try:
-                discovered_reqs.extend(self._prepare_file(
-                    finder,
-                    req,
-                    require_hashes=require_hashes,
-                    ignore_dependencies=self.ignore_dependencies))
-            except HashError as exc:
-                exc.req = req
-                hash_errors.append(exc)
-
-        if hash_errors:
-            raise hash_errors
-
-    def _is_upgrade_allowed(self, req):
-        return self.upgrade and (
-            self.upgrade_strategy == "eager" or (
-                self.upgrade_strategy == "only-if-needed" and req.is_direct
-            )
-        )
-
-    def _check_skip_installed(self, req_to_install, finder):
-        """Check if req_to_install should be skipped.
-
-        This will check if the req is installed, and whether we should upgrade
-        or reinstall it, taking into account all the relevant user options.
-
-        After calling this req_to_install will only have satisfied_by set to
-        None if the req_to_install is to be upgraded/reinstalled etc. Any
-        other value will be a dist recording the current thing installed that
-        satisfies the requirement.
-
-        Note that for vcs urls and the like we can't assess skipping in this
-        routine - we simply identify that we need to pull the thing down,
-        then later on it is pulled down and introspected to assess upgrade/
-        reinstalls etc.
-
-        :return: A text reason for why it was skipped, or None.
-        """
-        # Check whether to upgrade/reinstall this req or not.
-        req_to_install.check_if_exists()
-        if req_to_install.satisfied_by:
-            upgrade_allowed = self._is_upgrade_allowed(req_to_install)
-
-            # Is the best version is installed.
-            best_installed = False
-
-            if upgrade_allowed:
-                # For link based requirements we have to pull the
-                # tree down and inspect to assess the version #, so
-                # its handled way down.
-                if not (self.force_reinstall or req_to_install.link):
-                    try:
-                        finder.find_requirement(
-                            req_to_install, upgrade_allowed)
-                    except BestVersionAlreadyInstalled:
-                        best_installed = True
-                    except DistributionNotFound:
-                        # No distribution found, so we squash the
-                        # error - it will be raised later when we
-                        # re-try later to do the install.
-                        # Why don't we just raise here?
-                        pass
-
-                if not best_installed:
-                    # don't uninstall conflict if user install and
-                    # conflict is not user install
-                    if not (self.use_user_site and not
-                            dist_in_usersite(req_to_install.satisfied_by)):
-                        req_to_install.conflicts_with = \
-                            req_to_install.satisfied_by
-                    req_to_install.satisfied_by = None
-
-            # Figure out a nice message to say why we're skipping this.
-            if best_installed:
-                skip_reason = 'already up-to-date'
-            elif self.upgrade_strategy == "only-if-needed":
-                skip_reason = 'not upgraded as not directly required'
-            else:
-                skip_reason = 'already satisfied'
-
-            return skip_reason
-        else:
-            return None
-
-    def _prepare_file(self,
-                      finder,
-                      req_to_install,
-                      require_hashes=False,
-                      ignore_dependencies=False):
-        """Prepare a single requirements file.
-
-        :return: A list of additional InstallRequirements to also install.
-        """
-        # Tell user what we are doing for this requirement:
-        # obtain (editable), skipping, processing (local url), collecting
-        # (remote url or package name)
-        if req_to_install.constraint or req_to_install.prepared:
-            return []
-
-        req_to_install.prepared = True
-
-        # ###################### #
-        # # print log messages # #
-        # ###################### #
-        if req_to_install.editable:
-            logger.info('Obtaining %s', req_to_install)
-        else:
-            # satisfied_by is only evaluated by calling _check_skip_installed,
-            # so it must be None here.
-            assert req_to_install.satisfied_by is None
-            if not self.ignore_installed:
-                skip_reason = self._check_skip_installed(
-                    req_to_install, finder)
-
-            if req_to_install.satisfied_by:
-                assert skip_reason is not None, (
-                    '_check_skip_installed returned None but '
-                    'req_to_install.satisfied_by is set to %r'
-                    % (req_to_install.satisfied_by,))
-                logger.info(
-                    'Requirement %s: %s', skip_reason,
-                    req_to_install)
-            else:
-                if (req_to_install.link and
-                        req_to_install.link.scheme == 'file'):
-                    path = url_to_path(req_to_install.link.url)
-                    logger.info('Processing %s', display_path(path))
-                else:
-                    logger.info('Collecting %s', req_to_install)
-
-        with indent_log():
-            # ################################ #
-            # # vcs update or unpack archive # #
-            # ################################ #
-            if req_to_install.editable:
-                if require_hashes:
-                    raise InstallationError(
-                        'The editable requirement %s cannot be installed when '
-                        'requiring hashes, because there is no single file to '
-                        'hash.' % req_to_install)
-                req_to_install.ensure_has_source_dir(self.src_dir)
-                req_to_install.update_editable(not self.is_download)
-                abstract_dist = make_abstract_dist(req_to_install)
-                abstract_dist.prep_for_dist()
-                if self.is_download:
-                    req_to_install.archive(self.download_dir)
-                req_to_install.check_if_exists()
-            elif req_to_install.satisfied_by:
-                if require_hashes:
-                    logger.debug(
-                        'Since it is already installed, we are trusting this '
-                        'package without checking its hash. To ensure a '
-                        'completely repeatable environment, install into an '
-                        'empty virtualenv.')
-                abstract_dist = Installed(req_to_install)
-            else:
-                # @@ if filesystem packages are not marked
-                # editable in a req, a non deterministic error
-                # occurs when the script attempts to unpack the
-                # build directory
-                req_to_install.ensure_has_source_dir(self.build_dir)
-                # If a checkout exists, it's unwise to keep going.  version
-                # inconsistencies are logged later, but do not fail the
-                # installation.
-                # FIXME: this won't upgrade when there's an existing
-                # package unpacked in `req_to_install.source_dir`
-                if os.path.exists(
-                        os.path.join(req_to_install.source_dir, 'setup.py')):
-                    raise PreviousBuildDirError(
-                        "pip can't proceed with requirements '%s' due to a"
-                        " pre-existing build directory (%s). This is "
-                        "likely due to a previous installation that failed"
-                        ". pip is being responsible and not assuming it "
-                        "can delete this. Please delete it and try again."
-                        % (req_to_install, req_to_install.source_dir)
-                    )
-                req_to_install.populate_link(
-                    finder,
-                    self._is_upgrade_allowed(req_to_install),
-                    require_hashes
-                )
-                # We can't hit this spot and have populate_link return None.
-                # req_to_install.satisfied_by is None here (because we're
-                # guarded) and upgrade has no impact except when satisfied_by
-                # is not None.
-                # Then inside find_requirement existing_applicable -> False
-                # If no new versions are found, DistributionNotFound is raised,
-                # otherwise a result is guaranteed.
-                assert req_to_install.link
-                link = req_to_install.link
-
-                # Now that we have the real link, we can tell what kind of
-                # requirements we have and raise some more informative errors
-                # than otherwise. (For example, we can raise VcsHashUnsupported
-                # for a VCS URL rather than HashMissing.)
-                if require_hashes:
-                    # We could check these first 2 conditions inside
-                    # unpack_url and save repetition of conditions, but then
-                    # we would report less-useful error messages for
-                    # unhashable requirements, complaining that there's no
-                    # hash provided.
-                    if is_vcs_url(link):
-                        raise VcsHashUnsupported()
-                    elif is_file_url(link) and is_dir_url(link):
-                        raise DirectoryUrlHashUnsupported()
-                    if (not req_to_install.original_link and
-                            not req_to_install.is_pinned):
-                        # Unpinned packages are asking for trouble when a new
-                        # version is uploaded. This isn't a security check, but
-                        # it saves users a surprising hash mismatch in the
-                        # future.
-                        #
-                        # file:/// URLs aren't pinnable, so don't complain
-                        # about them not being pinned.
-                        raise HashUnpinned()
-                hashes = req_to_install.hashes(
-                    trust_internet=not require_hashes)
-                if require_hashes and not hashes:
-                    # Known-good hashes are missing for this requirement, so
-                    # shim it with a facade object that will provoke hash
-                    # computation and then raise a HashMissing exception
-                    # showing the user what the hash should be.
-                    hashes = MissingHashes()
-
-                try:
-                    download_dir = self.download_dir
-                    # We always delete unpacked sdists after pip ran.
-                    autodelete_unpacked = True
-                    if req_to_install.link.is_wheel \
-                            and self.wheel_download_dir:
-                        # when doing 'pip wheel` we download wheels to a
-                        # dedicated dir.
-                        download_dir = self.wheel_download_dir
-                    if req_to_install.link.is_wheel:
-                        if download_dir:
-                            # When downloading, we only unpack wheels to get
-                            # metadata.
-                            autodelete_unpacked = True
-                        else:
-                            # When installing a wheel, we use the unpacked
-                            # wheel.
-                            autodelete_unpacked = False
-                    unpack_url(
-                        req_to_install.link, req_to_install.source_dir,
-                        download_dir, autodelete_unpacked,
-                        session=self.session, hashes=hashes)
-                except requests.HTTPError as exc:
-                    logger.critical(
-                        'Could not install requirement %s because '
-                        'of error %s',
-                        req_to_install,
-                        exc,
-                    )
-                    raise InstallationError(
-                        'Could not install requirement %s because '
-                        'of HTTP error %s for URL %s' %
-                        (req_to_install, exc, req_to_install.link)
-                    )
-                abstract_dist = make_abstract_dist(req_to_install)
-                abstract_dist.prep_for_dist()
-                if self.is_download:
-                    # Make a .zip of the source_dir we already created.
-                    if req_to_install.link.scheme in vcs.all_schemes:
-                        req_to_install.archive(self.download_dir)
-                # req_to_install.req is only avail after unpack for URL
-                # pkgs repeat check_if_exists to uninstall-on-upgrade
-                # (#14)
-                if not self.ignore_installed:
-                    req_to_install.check_if_exists()
-                if req_to_install.satisfied_by:
-                    if self.upgrade or self.ignore_installed:
-                        # don't uninstall conflict if user install and
-                        # conflict is not user install
-                        if not (self.use_user_site and not
-                                dist_in_usersite(
-                                    req_to_install.satisfied_by)):
-                            req_to_install.conflicts_with = \
-                                req_to_install.satisfied_by
-                        req_to_install.satisfied_by = None
-                    else:
-                        logger.info(
-                            'Requirement already satisfied (use '
-                            '--upgrade to upgrade): %s',
-                            req_to_install,
-                        )
-
-            # ###################### #
-            # # parse dependencies # #
-            # ###################### #
-            dist = abstract_dist.dist(finder)
-            try:
-                check_dist_requires_python(dist)
-            except UnsupportedPythonVersion as e:
-                if self.ignore_requires_python:
-                    logger.warning(e.args[0])
-                else:
-                    req_to_install.remove_temporary_source()
-                    raise
-            more_reqs = []
-
-            def add_req(subreq, extras_requested):
-                sub_install_req = InstallRequirement(
-                    str(subreq),
-                    req_to_install,
-                    isolated=self.isolated,
-                    wheel_cache=self._wheel_cache,
-                )
-                more_reqs.extend(self.add_requirement(
-                    sub_install_req, req_to_install.name,
-                    extras_requested=extras_requested))
-
-            # We add req_to_install before its dependencies, so that we
-            # can refer to it when adding dependencies.
-            if not self.has_requirement(req_to_install.name):
-                # 'unnamed' requirements will get added here
-                self.add_requirement(req_to_install, None)
-
-            if not ignore_dependencies:
-                if (req_to_install.extras):
-                    logger.debug(
-                        "Installing extra requirements: %r",
-                        ','.join(req_to_install.extras),
-                    )
-                missing_requested = sorted(
-                    set(req_to_install.extras) - set(dist.extras)
-                )
-                for missing in missing_requested:
-                    logger.warning(
-                        '%s does not provide the extra \'%s\'',
-                        dist, missing
-                    )
-
-                available_requested = sorted(
-                    set(dist.extras) & set(req_to_install.extras)
-                )
-                for subreq in dist.requires(available_requested):
-                    add_req(subreq, extras_requested=available_requested)
-
-            # cleanup tmp src
-            self.reqs_to_cleanup.append(req_to_install)
-
-            if not req_to_install.editable and not req_to_install.satisfied_by:
-                # XXX: --no-install leads this to report 'Successfully
-                # downloaded' for only non-editable reqs, even though we took
-                # action on them.
-                self.successfully_downloaded.append(req_to_install)
-
-        return more_reqs
-
-    def cleanup_files(self):
-        """Clean up files, remove builds."""
-        logger.debug('Cleaning up...')
-        with indent_log():
-            for req in self.reqs_to_cleanup:
-                req.remove_temporary_source()
-
-    def _to_install(self):
-        """Create the installation order.
-
-        The installation order is topological - requirements are installed
-        before the requiring thing. We break cycles at an arbitrary point,
-        and make no other guarantees.
-        """
-        # The current implementation, which we may change at any point
-        # installs the user specified things in the order given, except when
-        # dependencies must come earlier to achieve topological order.
-        order = []
-        ordered_reqs = set()
-
-        def schedule(req):
-            if req.satisfied_by or req in ordered_reqs:
-                return
-            if req.constraint:
-                return
-            ordered_reqs.add(req)
-            for dep in self._dependencies[req]:
-                schedule(dep)
-            order.append(req)
-        for install_req in self.requirements.values():
-            schedule(install_req)
-        return order
-
-    def install(self, install_options, global_options=(), *args, **kwargs):
-        """
-        Install everything in this set (after having downloaded and unpacked
-        the packages)
-        """
-        to_install = self._to_install()
-
-        if to_install:
-            logger.info(
-                'Installing collected packages: %s',
-                ', '.join([req.name for req in to_install]),
-            )
-
-        with indent_log():
-            for requirement in to_install:
-                if requirement.conflicts_with:
-                    logger.info(
-                        'Found existing installation: %s',
-                        requirement.conflicts_with,
-                    )
-                    with indent_log():
-                        requirement.uninstall(auto_confirm=True)
-                try:
-                    requirement.install(
-                        install_options,
-                        global_options,
-                        *args,
-                        **kwargs
-                    )
-                except:
-                    # if install did not succeed, rollback previous uninstall
-                    if (requirement.conflicts_with and not
-                            requirement.install_succeeded):
-                        requirement.rollback_uninstall()
-                    raise
-                else:
-                    if (requirement.conflicts_with and
-                            requirement.install_succeeded):
-                        requirement.commit_uninstall()
-                requirement.remove_temporary_source()
-
-        self.successfully_installed = to_install
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_uninstall.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_uninstall.py
deleted file mode 100644
index 5248430a9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/req/req_uninstall.py
+++ /dev/null
@@ -1,195 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-import tempfile
-
-from pip.compat import uses_pycache, WINDOWS, cache_from_source
-from pip.exceptions import UninstallationError
-from pip.utils import rmtree, ask, is_local, renames, normalize_path
-from pip.utils.logging import indent_log
-
-
-logger = logging.getLogger(__name__)
-
-
-class UninstallPathSet(object):
-    """A set of file paths to be removed in the uninstallation of a
-    requirement."""
-    def __init__(self, dist):
-        self.paths = set()
-        self._refuse = set()
-        self.pth = {}
-        self.dist = dist
-        self.save_dir = None
-        self._moved_paths = []
-
-    def _permitted(self, path):
-        """
-        Return True if the given path is one we are permitted to
-        remove/modify, False otherwise.
-
-        """
-        return is_local(path)
-
-    def add(self, path):
-        head, tail = os.path.split(path)
-
-        # we normalize the head to resolve parent directory symlinks, but not
-        # the tail, since we only want to uninstall symlinks, not their targets
-        path = os.path.join(normalize_path(head), os.path.normcase(tail))
-
-        if not os.path.exists(path):
-            return
-        if self._permitted(path):
-            self.paths.add(path)
-        else:
-            self._refuse.add(path)
-
-        # __pycache__ files can show up after 'installed-files.txt' is created,
-        # due to imports
-        if os.path.splitext(path)[1] == '.py' and uses_pycache:
-            self.add(cache_from_source(path))
-
-    def add_pth(self, pth_file, entry):
-        pth_file = normalize_path(pth_file)
-        if self._permitted(pth_file):
-            if pth_file not in self.pth:
-                self.pth[pth_file] = UninstallPthEntries(pth_file)
-            self.pth[pth_file].add(entry)
-        else:
-            self._refuse.add(pth_file)
-
-    def compact(self, paths):
-        """Compact a path set to contain the minimal number of paths
-        necessary to contain all paths in the set. If /a/path/ and
-        /a/path/to/a/file.txt are both in the set, leave only the
-        shorter path."""
-        short_paths = set()
-        for path in sorted(paths, key=len):
-            if not any([
-                    (path.startswith(shortpath) and
-                     path[len(shortpath.rstrip(os.path.sep))] == os.path.sep)
-                    for shortpath in short_paths]):
-                short_paths.add(path)
-        return short_paths
-
-    def _stash(self, path):
-        return os.path.join(
-            self.save_dir, os.path.splitdrive(path)[1].lstrip(os.path.sep))
-
-    def remove(self, auto_confirm=False):
-        """Remove paths in ``self.paths`` with confirmation (unless
-        ``auto_confirm`` is True)."""
-        if not self.paths:
-            logger.info(
-                "Can't uninstall '%s'. No files were found to uninstall.",
-                self.dist.project_name,
-            )
-            return
-        logger.info(
-            'Uninstalling %s-%s:',
-            self.dist.project_name, self.dist.version
-        )
-
-        with indent_log():
-            paths = sorted(self.compact(self.paths))
-
-            if auto_confirm:
-                response = 'y'
-            else:
-                for path in paths:
-                    logger.info(path)
-                response = ask('Proceed (y/n)? ', ('y', 'n'))
-            if self._refuse:
-                logger.info('Not removing or modifying (outside of prefix):')
-                for path in self.compact(self._refuse):
-                    logger.info(path)
-            if response == 'y':
-                self.save_dir = tempfile.mkdtemp(suffix='-uninstall',
-                                                 prefix='pip-')
-                for path in paths:
-                    new_path = self._stash(path)
-                    logger.debug('Removing file or directory %s', path)
-                    self._moved_paths.append(path)
-                    renames(path, new_path)
-                for pth in self.pth.values():
-                    pth.remove()
-                logger.info(
-                    'Successfully uninstalled %s-%s',
-                    self.dist.project_name, self.dist.version
-                )
-
-    def rollback(self):
-        """Rollback the changes previously made by remove()."""
-        if self.save_dir is None:
-            logger.error(
-                "Can't roll back %s; was not uninstalled",
-                self.dist.project_name,
-            )
-            return False
-        logger.info('Rolling back uninstall of %s', self.dist.project_name)
-        for path in self._moved_paths:
-            tmp_path = self._stash(path)
-            logger.debug('Replacing %s', path)
-            renames(tmp_path, path)
-        for pth in self.pth.values():
-            pth.rollback()
-
-    def commit(self):
-        """Remove temporary save dir: rollback will no longer be possible."""
-        if self.save_dir is not None:
-            rmtree(self.save_dir)
-            self.save_dir = None
-            self._moved_paths = []
-
-
-class UninstallPthEntries(object):
-    def __init__(self, pth_file):
-        if not os.path.isfile(pth_file):
-            raise UninstallationError(
-                "Cannot remove entries from nonexistent file %s" % pth_file
-            )
-        self.file = pth_file
-        self.entries = set()
-        self._saved_lines = None
-
-    def add(self, entry):
-        entry = os.path.normcase(entry)
-        # On Windows, os.path.normcase converts the entry to use
-        # backslashes.  This is correct for entries that describe absolute
-        # paths outside of site-packages, but all the others use forward
-        # slashes.
-        if WINDOWS and not os.path.splitdrive(entry)[0]:
-            entry = entry.replace('\\', '/')
-        self.entries.add(entry)
-
-    def remove(self):
-        logger.debug('Removing pth entries from %s:', self.file)
-        with open(self.file, 'rb') as fh:
-            # windows uses '\r\n' with py3k, but uses '\n' with py2.x
-            lines = fh.readlines()
-            self._saved_lines = lines
-        if any(b'\r\n' in line for line in lines):
-            endline = '\r\n'
-        else:
-            endline = '\n'
-        for entry in self.entries:
-            try:
-                logger.debug('Removing entry: %s', entry)
-                lines.remove((entry + endline).encode("utf-8"))
-            except ValueError:
-                pass
-        with open(self.file, 'wb') as fh:
-            fh.writelines(lines)
-
-    def rollback(self):
-        if self._saved_lines is None:
-            logger.error(
-                'Cannot roll back changes to %s, none were made', self.file
-            )
-            return False
-        logger.debug('Rolling %s back to previous state', self.file)
-        with open(self.file, 'wb') as fh:
-            fh.writelines(self._saved_lines)
-        return True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/status_codes.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/status_codes.py
deleted file mode 100644
index 275360a31..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/status_codes.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from __future__ import absolute_import
-
-SUCCESS = 0
-ERROR = 1
-UNKNOWN_ERROR = 2
-VIRTUALENV_NOT_FOUND = 3
-PREVIOUS_BUILD_DIR_ERROR = 4
-NO_MATCHES_FOUND = 23
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__init__.py
deleted file mode 100644
index 0d25d917a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__init__.py
+++ /dev/null
@@ -1,870 +0,0 @@
-from __future__ import absolute_import
-
-from collections import deque
-import contextlib
-import errno
-import io
-import locale
-# we have a submodule named 'logging' which would shadow this if we used the
-# regular name:
-import logging as std_logging
-import re
-import os
-import posixpath
-import shutil
-import stat
-import subprocess
-import sys
-import tarfile
-import zipfile
-
-from pip.exceptions import InstallationError
-from pip.compat import console_to_str, expanduser, stdlib_pkgs
-from pip.locations import (
-    site_packages, user_site, running_under_virtualenv, virtualenv_no_global,
-    write_delete_marker_file,
-)
-from pip._vendor import pkg_resources
-from pip._vendor.six.moves import input
-from pip._vendor.six import PY2
-from pip._vendor.retrying import retry
-
-if PY2:
-    from io import BytesIO as StringIO
-else:
-    from io import StringIO
-
-__all__ = ['rmtree', 'display_path', 'backup_dir',
-           'ask', 'splitext',
-           'format_size', 'is_installable_dir',
-           'is_svn_page', 'file_contents',
-           'split_leading_dir', 'has_leading_dir',
-           'normalize_path',
-           'renames', 'get_terminal_size', 'get_prog',
-           'unzip_file', 'untar_file', 'unpack_file', 'call_subprocess',
-           'captured_stdout', 'ensure_dir',
-           'ARCHIVE_EXTENSIONS', 'SUPPORTED_EXTENSIONS',
-           'get_installed_version']
-
-
-logger = std_logging.getLogger(__name__)
-
-BZ2_EXTENSIONS = ('.tar.bz2', '.tbz')
-XZ_EXTENSIONS = ('.tar.xz', '.txz', '.tlz', '.tar.lz', '.tar.lzma')
-ZIP_EXTENSIONS = ('.zip', '.whl')
-TAR_EXTENSIONS = ('.tar.gz', '.tgz', '.tar')
-ARCHIVE_EXTENSIONS = (
-    ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS)
-SUPPORTED_EXTENSIONS = ZIP_EXTENSIONS + TAR_EXTENSIONS
-try:
-    import bz2  # noqa
-    SUPPORTED_EXTENSIONS += BZ2_EXTENSIONS
-except ImportError:
-    logger.debug('bz2 module is not available')
-
-try:
-    # Only for Python 3.3+
-    import lzma  # noqa
-    SUPPORTED_EXTENSIONS += XZ_EXTENSIONS
-except ImportError:
-    logger.debug('lzma module is not available')
-
-
-def import_or_raise(pkg_or_module_string, ExceptionType, *args, **kwargs):
-    try:
-        return __import__(pkg_or_module_string)
-    except ImportError:
-        raise ExceptionType(*args, **kwargs)
-
-
-def ensure_dir(path):
-    """os.path.makedirs without EEXIST."""
-    try:
-        os.makedirs(path)
-    except OSError as e:
-        if e.errno != errno.EEXIST:
-            raise
-
-
-def get_prog():
-    try:
-        if os.path.basename(sys.argv[0]) in ('__main__.py', '-c'):
-            return "%s -m pip" % sys.executable
-    except (AttributeError, TypeError, IndexError):
-        pass
-    return 'pip'
-
-
-# Retry every half second for up to 3 seconds
-@retry(stop_max_delay=3000, wait_fixed=500)
-def rmtree(dir, ignore_errors=False):
-    shutil.rmtree(dir, ignore_errors=ignore_errors,
-                  onerror=rmtree_errorhandler)
-
-
-def rmtree_errorhandler(func, path, exc_info):
-    """On Windows, the files in .svn are read-only, so when rmtree() tries to
-    remove them, an exception is thrown.  We catch that here, remove the
-    read-only attribute, and hopefully continue without problems."""
-    # if file type currently read only
-    if os.stat(path).st_mode & stat.S_IREAD:
-        # convert to read/write
-        os.chmod(path, stat.S_IWRITE)
-        # use the original function to repeat the operation
-        func(path)
-        return
-    else:
-        raise
-
-
-def display_path(path):
-    """Gives the display value for a given path, making it relative to cwd
-    if possible."""
-    path = os.path.normcase(os.path.abspath(path))
-    if sys.version_info[0] == 2:
-        path = path.decode(sys.getfilesystemencoding(), 'replace')
-        path = path.encode(sys.getdefaultencoding(), 'replace')
-    if path.startswith(os.getcwd() + os.path.sep):
-        path = '.' + path[len(os.getcwd()):]
-    return path
-
-
-def backup_dir(dir, ext='.bak'):
-    """Figure out the name of a directory to back up the given dir to
-    (adding .bak, .bak2, etc)"""
-    n = 1
-    extension = ext
-    while os.path.exists(dir + extension):
-        n += 1
-        extension = ext + str(n)
-    return dir + extension
-
-
-def ask_path_exists(message, options):
-    for action in os.environ.get('PIP_EXISTS_ACTION', '').split():
-        if action in options:
-            return action
-    return ask(message, options)
-
-
-def ask(message, options):
-    """Ask the message interactively, with the given possible responses"""
-    while 1:
-        if os.environ.get('PIP_NO_INPUT'):
-            raise Exception(
-                'No input was expected ($PIP_NO_INPUT set); question: %s' %
-                message
-            )
-        response = input(message)
-        response = response.strip().lower()
-        if response not in options:
-            print(
-                'Your response (%r) was not one of the expected responses: '
-                '%s' % (response, ', '.join(options))
-            )
-        else:
-            return response
-
-
-def format_size(bytes):
-    if bytes > 1000 * 1000:
-        return '%.1fMB' % (bytes / 1000.0 / 1000)
-    elif bytes > 10 * 1000:
-        return '%ikB' % (bytes / 1000)
-    elif bytes > 1000:
-        return '%.1fkB' % (bytes / 1000.0)
-    else:
-        return '%ibytes' % bytes
-
-
-def is_installable_dir(path):
-    """Return True if `path` is a directory containing a setup.py file."""
-    if not os.path.isdir(path):
-        return False
-    setup_py = os.path.join(path, 'setup.py')
-    if os.path.isfile(setup_py):
-        return True
-    return False
-
-
-def is_svn_page(html):
-    """
-    Returns true if the page appears to be the index page of an svn repository
-    """
-    return (re.search(r'<title>[^<]*Revision \d+:', html) and
-            re.search(r'Powered by (?:<a[^>]*?>)?Subversion', html, re.I))
-
-
-def file_contents(filename):
-    with open(filename, 'rb') as fp:
-        return fp.read().decode('utf-8')
-
-
-def read_chunks(file, size=io.DEFAULT_BUFFER_SIZE):
-    """Yield pieces of data from a file-like object until EOF."""
-    while True:
-        chunk = file.read(size)
-        if not chunk:
-            break
-        yield chunk
-
-
-def split_leading_dir(path):
-    path = path.lstrip('/').lstrip('\\')
-    if '/' in path and (('\\' in path and path.find('/') < path.find('\\')) or
-                        '\\' not in path):
-        return path.split('/', 1)
-    elif '\\' in path:
-        return path.split('\\', 1)
-    else:
-        return path, ''
-
-
-def has_leading_dir(paths):
-    """Returns true if all the paths have the same leading path name
-    (i.e., everything is in one subdirectory in an archive)"""
-    common_prefix = None
-    for path in paths:
-        prefix, rest = split_leading_dir(path)
-        if not prefix:
-            return False
-        elif common_prefix is None:
-            common_prefix = prefix
-        elif prefix != common_prefix:
-            return False
-    return True
-
-
-def normalize_path(path, resolve_symlinks=True):
-    """
-    Convert a path to its canonical, case-normalized, absolute version.
-
-    """
-    path = expanduser(path)
-    if resolve_symlinks:
-        path = os.path.realpath(path)
-    else:
-        path = os.path.abspath(path)
-    return os.path.normcase(path)
-
-
-def splitext(path):
-    """Like os.path.splitext, but take off .tar too"""
-    base, ext = posixpath.splitext(path)
-    if base.lower().endswith('.tar'):
-        ext = base[-4:] + ext
-        base = base[:-4]
-    return base, ext
-
-
-def renames(old, new):
-    """Like os.renames(), but handles renaming across devices."""
-    # Implementation borrowed from os.renames().
-    head, tail = os.path.split(new)
-    if head and tail and not os.path.exists(head):
-        os.makedirs(head)
-
-    shutil.move(old, new)
-
-    head, tail = os.path.split(old)
-    if head and tail:
-        try:
-            os.removedirs(head)
-        except OSError:
-            pass
-
-
-def is_local(path):
-    """
-    Return True if this is a path pip is allowed to modify.
-
-    If we're in a virtualenv, sys.prefix points to the virtualenv's
-    prefix; only sys.prefix is considered local.
-
-    If we're not in a virtualenv, in general we can modify anything.
-    However, if the OS vendor has configured distutils to install
-    somewhere other than sys.prefix (which could be a subdirectory of
-    sys.prefix, e.g. /usr/local), we consider sys.prefix itself nonlocal
-    and the domain of the OS vendor. (In other words, everything _other
-    than_ sys.prefix is considered local.)
-
-    """
-
-    path = normalize_path(path)
-    prefix = normalize_path(sys.prefix)
-
-    if running_under_virtualenv():
-        return path.startswith(normalize_path(sys.prefix))
-    else:
-        from pip.locations import distutils_scheme
-        if path.startswith(prefix):
-            for local_path in distutils_scheme("").values():
-                if path.startswith(normalize_path(local_path)):
-                    return True
-            return False
-        else:
-            return True
-
-
-def dist_is_local(dist):
-    """
-    Return True if given Distribution object is installed somewhere pip
-    is allowed to modify.
-
-    """
-    return is_local(dist_location(dist))
-
-
-def dist_in_usersite(dist):
-    """
-    Return True if given Distribution is installed in user site.
-    """
-    norm_path = normalize_path(dist_location(dist))
-    return norm_path.startswith(normalize_path(user_site))
-
-
-def dist_in_site_packages(dist):
-    """
-    Return True if given Distribution is installed in
-    distutils.sysconfig.get_python_lib().
-    """
-    return normalize_path(
-        dist_location(dist)
-    ).startswith(normalize_path(site_packages))
-
-
-def dist_is_editable(dist):
-    """Is distribution an editable install?"""
-    for path_item in sys.path:
-        egg_link = os.path.join(path_item, dist.project_name + '.egg-link')
-        if os.path.isfile(egg_link):
-            return True
-    return False
-
-
-def get_installed_distributions(local_only=True,
-                                skip=stdlib_pkgs,
-                                include_editables=True,
-                                editables_only=False,
-                                user_only=False):
-    """
-    Return a list of installed Distribution objects.
-
-    If ``local_only`` is True (default), only return installations
-    local to the current virtualenv, if in a virtualenv.
-
-    ``skip`` argument is an iterable of lower-case project names to
-    ignore; defaults to stdlib_pkgs
-
-    If ``editables`` is False, don't report editables.
-
-    If ``editables_only`` is True , only report editables.
-
-    If ``user_only`` is True , only report installations in the user
-    site directory.
-
-    """
-    if local_only:
-        local_test = dist_is_local
-    else:
-        def local_test(d):
-            return True
-
-    if include_editables:
-        def editable_test(d):
-            return True
-    else:
-        def editable_test(d):
-            return not dist_is_editable(d)
-
-    if editables_only:
-        def editables_only_test(d):
-            return dist_is_editable(d)
-    else:
-        def editables_only_test(d):
-            return True
-
-    if user_only:
-        user_test = dist_in_usersite
-    else:
-        def user_test(d):
-            return True
-
-    return [d for d in pkg_resources.working_set
-            if local_test(d) and
-            d.key not in skip and
-            editable_test(d) and
-            editables_only_test(d) and
-            user_test(d)
-            ]
-
-
-def egg_link_path(dist):
-    """
-    Return the path for the .egg-link file if it exists, otherwise, None.
-
-    There's 3 scenarios:
-    1) not in a virtualenv
-       try to find in site.USER_SITE, then site_packages
-    2) in a no-global virtualenv
-       try to find in site_packages
-    3) in a yes-global virtualenv
-       try to find in site_packages, then site.USER_SITE
-       (don't look in global location)
-
-    For #1 and #3, there could be odd cases, where there's an egg-link in 2
-    locations.
-
-    This method will just return the first one found.
-    """
-    sites = []
-    if running_under_virtualenv():
-        if virtualenv_no_global():
-            sites.append(site_packages)
-        else:
-            sites.append(site_packages)
-            if user_site:
-                sites.append(user_site)
-    else:
-        if user_site:
-            sites.append(user_site)
-        sites.append(site_packages)
-
-    for site in sites:
-        egglink = os.path.join(site, dist.project_name) + '.egg-link'
-        if os.path.isfile(egglink):
-            return egglink
-
-
-def dist_location(dist):
-    """
-    Get the site-packages location of this distribution. Generally
-    this is dist.location, except in the case of develop-installed
-    packages, where dist.location is the source code location, and we
-    want to know where the egg-link file is.
-
-    """
-    egg_link = egg_link_path(dist)
-    if egg_link:
-        return egg_link
-    return dist.location
-
-
-def get_terminal_size():
-    """Returns a tuple (x, y) representing the width(x) and the height(x)
-    in characters of the terminal window."""
-    def ioctl_GWINSZ(fd):
-        try:
-            import fcntl
-            import termios
-            import struct
-            cr = struct.unpack(
-                'hh',
-                fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234')
-            )
-        except:
-            return None
-        if cr == (0, 0):
-            return None
-        return cr
-    cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
-    if not cr:
-        try:
-            fd = os.open(os.ctermid(), os.O_RDONLY)
-            cr = ioctl_GWINSZ(fd)
-            os.close(fd)
-        except:
-            pass
-    if not cr:
-        cr = (os.environ.get('LINES', 25), os.environ.get('COLUMNS', 80))
-    return int(cr[1]), int(cr[0])
-
-
-def current_umask():
-    """Get the current umask which involves having to set it temporarily."""
-    mask = os.umask(0)
-    os.umask(mask)
-    return mask
-
-
-def unzip_file(filename, location, flatten=True):
-    """
-    Unzip the file (with path `filename`) to the destination `location`.  All
-    files are written based on system defaults and umask (i.e. permissions are
-    not preserved), except that regular file members with any execute
-    permissions (user, group, or world) have "chmod +x" applied after being
-    written. Note that for windows, any execute changes using os.chmod are
-    no-ops per the python docs.
-    """
-    ensure_dir(location)
-    zipfp = open(filename, 'rb')
-    try:
-        zip = zipfile.ZipFile(zipfp, allowZip64=True)
-        leading = has_leading_dir(zip.namelist()) and flatten
-        for info in zip.infolist():
-            name = info.filename
-            data = zip.read(name)
-            fn = name
-            if leading:
-                fn = split_leading_dir(name)[1]
-            fn = os.path.join(location, fn)
-            dir = os.path.dirname(fn)
-            if fn.endswith('/') or fn.endswith('\\'):
-                # A directory
-                ensure_dir(fn)
-            else:
-                ensure_dir(dir)
-                fp = open(fn, 'wb')
-                try:
-                    fp.write(data)
-                finally:
-                    fp.close()
-                    mode = info.external_attr >> 16
-                    # if mode and regular file and any execute permissions for
-                    # user/group/world?
-                    if mode and stat.S_ISREG(mode) and mode & 0o111:
-                        # make dest file have execute for user/group/world
-                        # (chmod +x) no-op on windows per python docs
-                        os.chmod(fn, (0o777 - current_umask() | 0o111))
-    finally:
-        zipfp.close()
-
-
-def untar_file(filename, location):
-    """
-    Untar the file (with path `filename`) to the destination `location`.
-    All files are written based on system defaults and umask (i.e. permissions
-    are not preserved), except that regular file members with any execute
-    permissions (user, group, or world) have "chmod +x" applied after being
-    written.  Note that for windows, any execute changes using os.chmod are
-    no-ops per the python docs.
-    """
-    ensure_dir(location)
-    if filename.lower().endswith('.gz') or filename.lower().endswith('.tgz'):
-        mode = 'r:gz'
-    elif filename.lower().endswith(BZ2_EXTENSIONS):
-        mode = 'r:bz2'
-    elif filename.lower().endswith(XZ_EXTENSIONS):
-        mode = 'r:xz'
-    elif filename.lower().endswith('.tar'):
-        mode = 'r'
-    else:
-        logger.warning(
-            'Cannot determine compression type for file %s', filename,
-        )
-        mode = 'r:*'
-    tar = tarfile.open(filename, mode)
-    try:
-        # note: python<=2.5 doesn't seem to know about pax headers, filter them
-        leading = has_leading_dir([
-            member.name for member in tar.getmembers()
-            if member.name != 'pax_global_header'
-        ])
-        for member in tar.getmembers():
-            fn = member.name
-            if fn == 'pax_global_header':
-                continue
-            if leading:
-                fn = split_leading_dir(fn)[1]
-            path = os.path.join(location, fn)
-            if member.isdir():
-                ensure_dir(path)
-            elif member.issym():
-                try:
-                    tar._extract_member(member, path)
-                except Exception as exc:
-                    # Some corrupt tar files seem to produce this
-                    # (specifically bad symlinks)
-                    logger.warning(
-                        'In the tar file %s the member %s is invalid: %s',
-                        filename, member.name, exc,
-                    )
-                    continue
-            else:
-                try:
-                    fp = tar.extractfile(member)
-                except (KeyError, AttributeError) as exc:
-                    # Some corrupt tar files seem to produce this
-                    # (specifically bad symlinks)
-                    logger.warning(
-                        'In the tar file %s the member %s is invalid: %s',
-                        filename, member.name, exc,
-                    )
-                    continue
-                ensure_dir(os.path.dirname(path))
-                with open(path, 'wb') as destfp:
-                    shutil.copyfileobj(fp, destfp)
-                fp.close()
-                # Update the timestamp (useful for cython compiled files)
-                tar.utime(member, path)
-                # member have any execute permissions for user/group/world?
-                if member.mode & 0o111:
-                    # make dest file have execute for user/group/world
-                    # no-op on windows per python docs
-                    os.chmod(path, (0o777 - current_umask() | 0o111))
-    finally:
-        tar.close()
-
-
-def unpack_file(filename, location, content_type, link):
-    filename = os.path.realpath(filename)
-    if (content_type == 'application/zip' or
-            filename.lower().endswith(ZIP_EXTENSIONS) or
-            zipfile.is_zipfile(filename)):
-        unzip_file(
-            filename,
-            location,
-            flatten=not filename.endswith('.whl')
-        )
-    elif (content_type == 'application/x-gzip' or
-            tarfile.is_tarfile(filename) or
-            filename.lower().endswith(
-                TAR_EXTENSIONS + BZ2_EXTENSIONS + XZ_EXTENSIONS)):
-        untar_file(filename, location)
-    elif (content_type and content_type.startswith('text/html') and
-            is_svn_page(file_contents(filename))):
-        # We don't really care about this
-        from pip.vcs.subversion import Subversion
-        Subversion('svn+' + link.url).unpack(location)
-    else:
-        # FIXME: handle?
-        # FIXME: magic signatures?
-        logger.critical(
-            'Cannot unpack file %s (downloaded from %s, content-type: %s); '
-            'cannot detect archive format',
-            filename, location, content_type,
-        )
-        raise InstallationError(
-            'Cannot determine archive format of %s' % location
-        )
-
-
-def call_subprocess(cmd, show_stdout=True, cwd=None,
-                    on_returncode='raise',
-                    command_desc=None,
-                    extra_environ=None, spinner=None):
-    # This function's handling of subprocess output is confusing and I
-    # previously broke it terribly, so as penance I will write a long comment
-    # explaining things.
-    #
-    # The obvious thing that affects output is the show_stdout=
-    # kwarg. show_stdout=True means, let the subprocess write directly to our
-    # stdout. Even though it is nominally the default, it is almost never used
-    # inside pip (and should not be used in new code without a very good
-    # reason); as of 2016-02-22 it is only used in a few places inside the VCS
-    # wrapper code. Ideally we should get rid of it entirely, because it
-    # creates a lot of complexity here for a rarely used feature.
-    #
-    # Most places in pip set show_stdout=False. What this means is:
-    # - We connect the child stdout to a pipe, which we read.
-    # - By default, we hide the output but show a spinner -- unless the
-    #   subprocess exits with an error, in which case we show the output.
-    # - If the --verbose option was passed (= loglevel is DEBUG), then we show
-    #   the output unconditionally. (But in this case we don't want to show
-    #   the output a second time if it turns out that there was an error.)
-    #
-    # stderr is always merged with stdout (even if show_stdout=True).
-    if show_stdout:
-        stdout = None
-    else:
-        stdout = subprocess.PIPE
-    if command_desc is None:
-        cmd_parts = []
-        for part in cmd:
-            if ' ' in part or '\n' in part or '"' in part or "'" in part:
-                part = '"%s"' % part.replace('"', '\\"')
-            cmd_parts.append(part)
-        command_desc = ' '.join(cmd_parts)
-    logger.debug("Running command %s", command_desc)
-    env = os.environ.copy()
-    if extra_environ:
-        env.update(extra_environ)
-    try:
-        proc = subprocess.Popen(
-            cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout,
-            cwd=cwd, env=env)
-    except Exception as exc:
-        logger.critical(
-            "Error %s while executing command %s", exc, command_desc,
-        )
-        raise
-    if stdout is not None:
-        all_output = []
-        while True:
-            line = console_to_str(proc.stdout.readline())
-            if not line:
-                break
-            line = line.rstrip()
-            all_output.append(line + '\n')
-            if logger.getEffectiveLevel() <= std_logging.DEBUG:
-                # Show the line immediately
-                logger.debug(line)
-            else:
-                # Update the spinner
-                if spinner is not None:
-                    spinner.spin()
-    proc.wait()
-    if spinner is not None:
-        if proc.returncode:
-            spinner.finish("error")
-        else:
-            spinner.finish("done")
-    if proc.returncode:
-        if on_returncode == 'raise':
-            if (logger.getEffectiveLevel() > std_logging.DEBUG and
-                    not show_stdout):
-                logger.info(
-                    'Complete output from command %s:', command_desc,
-                )
-                logger.info(
-                    ''.join(all_output) +
-                    '\n----------------------------------------'
-                )
-            raise InstallationError(
-                'Command "%s" failed with error code %s in %s'
-                % (command_desc, proc.returncode, cwd))
-        elif on_returncode == 'warn':
-            logger.warning(
-                'Command "%s" had error code %s in %s',
-                command_desc, proc.returncode, cwd,
-            )
-        elif on_returncode == 'ignore':
-            pass
-        else:
-            raise ValueError('Invalid value: on_returncode=%s' %
-                             repr(on_returncode))
-    if not show_stdout:
-        return ''.join(all_output)
-
-
-def read_text_file(filename):
-    """Return the contents of *filename*.
-
-    Try to decode the file contents with utf-8, the preferred system encoding
-    (e.g., cp1252 on some Windows machines), and latin1, in that order.
-    Decoding a byte string with latin1 will never raise an error. In the worst
-    case, the returned string will contain some garbage characters.
-
-    """
-    with open(filename, 'rb') as fp:
-        data = fp.read()
-
-    encodings = ['utf-8', locale.getpreferredencoding(False), 'latin1']
-    for enc in encodings:
-        try:
-            data = data.decode(enc)
-        except UnicodeDecodeError:
-            continue
-        break
-
-    assert type(data) != bytes  # Latin1 should have worked.
-    return data
-
-
-def _make_build_dir(build_dir):
-    os.makedirs(build_dir)
-    write_delete_marker_file(build_dir)
-
-
-class FakeFile(object):
-    """Wrap a list of lines in an object with readline() to make
-    ConfigParser happy."""
-    def __init__(self, lines):
-        self._gen = (l for l in lines)
-
-    def readline(self):
-        try:
-            try:
-                return next(self._gen)
-            except NameError:
-                return self._gen.next()
-        except StopIteration:
-            return ''
-
-    def __iter__(self):
-        return self._gen
-
-
-class StreamWrapper(StringIO):
-
-    @classmethod
-    def from_stream(cls, orig_stream):
-        cls.orig_stream = orig_stream
-        return cls()
-
-    # compileall.compile_dir() needs stdout.encoding to print to stdout
-    @property
-    def encoding(self):
-        return self.orig_stream.encoding
-
-
-@contextlib.contextmanager
-def captured_output(stream_name):
-    """Return a context manager used by captured_stdout/stdin/stderr
-    that temporarily replaces the sys stream *stream_name* with a StringIO.
-
-    Taken from Lib/support/__init__.py in the CPython repo.
-    """
-    orig_stdout = getattr(sys, stream_name)
-    setattr(sys, stream_name, StreamWrapper.from_stream(orig_stdout))
-    try:
-        yield getattr(sys, stream_name)
-    finally:
-        setattr(sys, stream_name, orig_stdout)
-
-
-def captured_stdout():
-    """Capture the output of sys.stdout:
-
-       with captured_stdout() as stdout:
-           print('hello')
-       self.assertEqual(stdout.getvalue(), 'hello\n')
-
-    Taken from Lib/support/__init__.py in the CPython repo.
-    """
-    return captured_output('stdout')
-
-
-class cached_property(object):
-    """A property that is only computed once per instance and then replaces
-       itself with an ordinary attribute. Deleting the attribute resets the
-       property.
-
-       Source: https://github.com/bottlepy/bottle/blob/0.11.5/bottle.py#L175
-    """
-
-    def __init__(self, func):
-        self.__doc__ = getattr(func, '__doc__')
-        self.func = func
-
-    def __get__(self, obj, cls):
-        if obj is None:
-            # We're being accessed from the class itself, not from an object
-            return self
-        value = obj.__dict__[self.func.__name__] = self.func(obj)
-        return value
-
-
-def get_installed_version(dist_name, lookup_dirs=None):
-    """Get the installed version of dist_name avoiding pkg_resources cache"""
-    # Create a requirement that we'll look for inside of setuptools.
-    req = pkg_resources.Requirement.parse(dist_name)
-
-    # We want to avoid having this cached, so we need to construct a new
-    # working set each time.
-    if lookup_dirs is None:
-        working_set = pkg_resources.WorkingSet()
-    else:
-        working_set = pkg_resources.WorkingSet(lookup_dirs)
-
-    # Get the installed distribution from our working set
-    dist = working_set.find(req)
-
-    # Check to see if we got an installed distribution or not, if we did
-    # we want to return it's version.
-    return dist.version if dist else None
-
-
-def consume(iterator):
-    """Consume an iterable at C speed."""
-    deque(iterator, maxlen=0)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index aa79ad65b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/appdirs.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/appdirs.cpython-35.pyc
deleted file mode 100644
index f4b957560..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/appdirs.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/build.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/build.cpython-35.pyc
deleted file mode 100644
index d1ee892c3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/build.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/deprecation.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/deprecation.cpython-35.pyc
deleted file mode 100644
index 60cdc2dcf..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/deprecation.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/encoding.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/encoding.cpython-35.pyc
deleted file mode 100644
index d4cdbbf84..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/encoding.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/filesystem.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/filesystem.cpython-35.pyc
deleted file mode 100644
index 320f385a2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/filesystem.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/glibc.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/glibc.cpython-35.pyc
deleted file mode 100644
index eef23bf30..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/glibc.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/hashes.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/hashes.cpython-35.pyc
deleted file mode 100644
index 8e1b1c7b9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/hashes.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/logging.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/logging.cpython-35.pyc
deleted file mode 100644
index 7e48c14d0..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/logging.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/outdated.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/outdated.cpython-35.pyc
deleted file mode 100644
index 85629d50c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/outdated.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/packaging.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/packaging.cpython-35.pyc
deleted file mode 100644
index e93c3f636..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/packaging.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/setuptools_build.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/setuptools_build.cpython-35.pyc
deleted file mode 100644
index 1a3937a9d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/setuptools_build.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/ui.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/ui.cpython-35.pyc
deleted file mode 100644
index 99fe8a69d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/__pycache__/ui.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/appdirs.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/appdirs.py
deleted file mode 100644
index 9b8280144..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/appdirs.py
+++ /dev/null
@@ -1,248 +0,0 @@
-"""
-This code was taken from https://github.com/ActiveState/appdirs and modified
-to suit our purposes.
-"""
-from __future__ import absolute_import
-
-import os
-import sys
-
-from pip.compat import WINDOWS, expanduser
-from pip._vendor.six import PY2, text_type
-
-
-def user_cache_dir(appname):
-    r"""
-    Return full path to the user-specific cache dir for this application.
-
-        "appname" is the name of application.
-
-    Typical user cache directories are:
-        macOS:      ~/Library/Caches/<AppName>
-        Unix:       ~/.cache/<AppName> (XDG default)
-        Windows:    C:\Users\<username>\AppData\Local\<AppName>\Cache
-
-    On Windows the only suggestion in the MSDN docs is that local settings go
-    in the `CSIDL_LOCAL_APPDATA` directory. This is identical to the
-    non-roaming app data dir (the default returned by `user_data_dir`). Apps
-    typically put cache data somewhere *under* the given dir here. Some
-    examples:
-        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
-        ...\Acme\SuperApp\Cache\1.0
-
-    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
-    """
-    if WINDOWS:
-        # Get the base path
-        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
-
-        # When using Python 2, return paths as bytes on Windows like we do on
-        # other operating systems. See helper function docs for more details.
-        if PY2 and isinstance(path, text_type):
-            path = _win_path_to_bytes(path)
-
-        # Add our app name and Cache directory to it
-        path = os.path.join(path, appname, "Cache")
-    elif sys.platform == "darwin":
-        # Get the base path
-        path = expanduser("~/Library/Caches")
-
-        # Add our app name to it
-        path = os.path.join(path, appname)
-    else:
-        # Get the base path
-        path = os.getenv("XDG_CACHE_HOME", expanduser("~/.cache"))
-
-        # Add our app name to it
-        path = os.path.join(path, appname)
-
-    return path
-
-
-def user_data_dir(appname, roaming=False):
-    """
-    Return full path to the user-specific data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        macOS:                  ~/Library/Application Support/<AppName>
-        Unix:                   ~/.local/share/<AppName>    # or in
-                                $XDG_DATA_HOME, if defined
-        Win XP (not roaming):   C:\Documents and Settings\<username>\ ...
-                                ...Application Data\<AppName>
-        Win XP (roaming):       C:\Documents and Settings\<username>\Local ...
-                                ...Settings\Application Data\<AppName>
-        Win 7  (not roaming):   C:\\Users\<username>\AppData\Local\<AppName>
-        Win 7  (roaming):       C:\\Users\<username>\AppData\Roaming\<AppName>
-
-    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
-    That means, by default "~/.local/share/<AppName>".
-    """
-    if WINDOWS:
-        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
-        path = os.path.join(os.path.normpath(_get_win_folder(const)), appname)
-    elif sys.platform == "darwin":
-        path = os.path.join(
-            expanduser('~/Library/Application Support/'),
-            appname,
-        )
-    else:
-        path = os.path.join(
-            os.getenv('XDG_DATA_HOME', expanduser("~/.local/share")),
-            appname,
-        )
-
-    return path
-
-
-def user_config_dir(appname, roaming=True):
-    """Return full path to the user-specific config dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "roaming" (boolean, default True) can be set False to not use the
-            Windows roaming appdata directory. That means that for users on a
-            Windows network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        macOS:                  same as user_data_dir
-        Unix:                   ~/.config/<AppName>
-        Win *:                  same as user_data_dir
-
-    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by default "~/.config/<AppName>".
-    """
-    if WINDOWS:
-        path = user_data_dir(appname, roaming=roaming)
-    elif sys.platform == "darwin":
-        path = user_data_dir(appname)
-    else:
-        path = os.getenv('XDG_CONFIG_HOME', expanduser("~/.config"))
-        path = os.path.join(path, appname)
-
-    return path
-
-
-# for the discussion regarding site_config_dirs locations
-# see <https://github.com/pypa/pip/issues/1733>
-def site_config_dirs(appname):
-    """Return a list of potential user-shared config dirs for this application.
-
-        "appname" is the name of application.
-
-    Typical user config directories are:
-        macOS:      /Library/Application Support/<AppName>/
-        Unix:       /etc or $XDG_CONFIG_DIRS[i]/<AppName>/ for each value in
-                    $XDG_CONFIG_DIRS
-        Win XP:     C:\Documents and Settings\All Users\Application ...
-                    ...Data\<AppName>\
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory
-                    on Vista.)
-        Win 7:      Hidden, but writeable on Win 7:
-                    C:\ProgramData\<AppName>\
-    """
-    if WINDOWS:
-        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
-        pathlist = [os.path.join(path, appname)]
-    elif sys.platform == 'darwin':
-        pathlist = [os.path.join('/Library/Application Support', appname)]
-    else:
-        # try looking in $XDG_CONFIG_DIRS
-        xdg_config_dirs = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
-        if xdg_config_dirs:
-            pathlist = [
-                os.path.join(expanduser(x), appname)
-                for x in xdg_config_dirs.split(os.pathsep)
-            ]
-        else:
-            pathlist = []
-
-        # always look in /etc directly as well
-        pathlist.append('/etc')
-
-    return pathlist
-
-
-# -- Windows support functions --
-
-def _get_win_folder_from_registry(csidl_name):
-    """
-    This is a fallback technique at best. I'm not sure if using the
-    registry for this guarantees us the correct answer for all CSIDL_*
-    names.
-    """
-    import _winreg
-
-    shell_folder_name = {
-        "CSIDL_APPDATA": "AppData",
-        "CSIDL_COMMON_APPDATA": "Common AppData",
-        "CSIDL_LOCAL_APPDATA": "Local AppData",
-    }[csidl_name]
-
-    key = _winreg.OpenKey(
-        _winreg.HKEY_CURRENT_USER,
-        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-    )
-    directory, _type = _winreg.QueryValueEx(key, shell_folder_name)
-    return directory
-
-
-def _get_win_folder_with_ctypes(csidl_name):
-    csidl_const = {
-        "CSIDL_APPDATA": 26,
-        "CSIDL_COMMON_APPDATA": 35,
-        "CSIDL_LOCAL_APPDATA": 28,
-    }[csidl_name]
-
-    buf = ctypes.create_unicode_buffer(1024)
-    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in buf:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf2 = ctypes.create_unicode_buffer(1024)
-        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
-            buf = buf2
-
-    return buf.value
-
-if WINDOWS:
-    try:
-        import ctypes
-        _get_win_folder = _get_win_folder_with_ctypes
-    except ImportError:
-        _get_win_folder = _get_win_folder_from_registry
-
-
-def _win_path_to_bytes(path):
-    """Encode Windows paths to bytes. Only used on Python 2.
-
-    Motivation is to be consistent with other operating systems where paths
-    are also returned as bytes. This avoids problems mixing bytes and Unicode
-    elsewhere in the codebase. For more details and discussion see
-    <https://github.com/pypa/pip/issues/3463>.
-
-    If encoding using ASCII and MBCS fails, return the original Unicode path.
-    """
-    for encoding in ('ASCII', 'MBCS'):
-        try:
-            return path.encode(encoding)
-        except (UnicodeEncodeError, LookupError):
-            pass
-    return path
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/build.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/build.py
deleted file mode 100644
index fc65cfab3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/build.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from __future__ import absolute_import
-
-import os.path
-import tempfile
-
-from pip.utils import rmtree
-
-
-class BuildDirectory(object):
-
-    def __init__(self, name=None, delete=None):
-        # If we were not given an explicit directory, and we were not given an
-        # explicit delete option, then we'll default to deleting.
-        if name is None and delete is None:
-            delete = True
-
-        if name is None:
-            # We realpath here because some systems have their default tmpdir
-            # symlinked to another directory.  This tends to confuse build
-            # scripts, so we canonicalize the path by traversing potential
-            # symlinks here.
-            name = os.path.realpath(tempfile.mkdtemp(prefix="pip-build-"))
-            # If we were not given an explicit directory, and we were not given
-            # an explicit delete option, then we'll default to deleting.
-            if delete is None:
-                delete = True
-
-        self.name = name
-        self.delete = delete
-
-    def __repr__(self):
-        return "<{} {!r}>".format(self.__class__.__name__, self.name)
-
-    def __enter__(self):
-        return self.name
-
-    def __exit__(self, exc, value, tb):
-        self.cleanup()
-
-    def cleanup(self):
-        if self.delete:
-            rmtree(self.name)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/deprecation.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/deprecation.py
deleted file mode 100644
index c3f799e64..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/deprecation.py
+++ /dev/null
@@ -1,76 +0,0 @@
-"""
-A module that implements tooling to enable easy warnings about deprecations.
-"""
-from __future__ import absolute_import
-
-import logging
-import warnings
-
-
-class PipDeprecationWarning(Warning):
-    pass
-
-
-class Pending(object):
-    pass
-
-
-class RemovedInPip10Warning(PipDeprecationWarning):
-    pass
-
-
-class RemovedInPip11Warning(PipDeprecationWarning, Pending):
-    pass
-
-
-class Python26DeprecationWarning(PipDeprecationWarning):
-    pass
-
-
-# Warnings <-> Logging Integration
-
-
-_warnings_showwarning = None
-
-
-def _showwarning(message, category, filename, lineno, file=None, line=None):
-    if file is not None:
-        if _warnings_showwarning is not None:
-            _warnings_showwarning(
-                message, category, filename, lineno, file, line,
-            )
-    else:
-        if issubclass(category, PipDeprecationWarning):
-            # We use a specially named logger which will handle all of the
-            # deprecation messages for pip.
-            logger = logging.getLogger("pip.deprecations")
-
-            # This is purposely using the % formatter here instead of letting
-            # the logging module handle the interpolation. This is because we
-            # want it to appear as if someone typed this entire message out.
-            log_message = "DEPRECATION: %s" % message
-
-            # PipDeprecationWarnings that are Pending still have at least 2
-            # versions to go until they are removed so they can just be
-            # warnings.  Otherwise, they will be removed in the very next
-            # version of pip. We want these to be more obvious so we use the
-            # ERROR logging level.
-            if issubclass(category, Pending):
-                logger.warning(log_message)
-            else:
-                logger.error(log_message)
-        else:
-            _warnings_showwarning(
-                message, category, filename, lineno, file, line,
-            )
-
-
-def install_warning_logger():
-    # Enable our Deprecation Warnings
-    warnings.simplefilter("default", PipDeprecationWarning, append=True)
-
-    global _warnings_showwarning
-
-    if _warnings_showwarning is None:
-        _warnings_showwarning = warnings.showwarning
-        warnings.showwarning = _showwarning
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/encoding.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/encoding.py
deleted file mode 100644
index 24831686c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/encoding.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import codecs
-import locale
-import re
-
-
-BOMS = [
-    (codecs.BOM_UTF8, 'utf8'),
-    (codecs.BOM_UTF16, 'utf16'),
-    (codecs.BOM_UTF16_BE, 'utf16-be'),
-    (codecs.BOM_UTF16_LE, 'utf16-le'),
-    (codecs.BOM_UTF32, 'utf32'),
-    (codecs.BOM_UTF32_BE, 'utf32-be'),
-    (codecs.BOM_UTF32_LE, 'utf32-le'),
-]
-
-ENCODING_RE = re.compile(b'coding[:=]\s*([-\w.]+)')
-
-
-def auto_decode(data):
-    """Check a bytes string for a BOM to correctly detect the encoding
-
-    Fallback to locale.getpreferredencoding(False) like open() on Python3"""
-    for bom, encoding in BOMS:
-        if data.startswith(bom):
-            return data[len(bom):].decode(encoding)
-    # Lets check the first two lines as in PEP263
-    for line in data.split(b'\n')[:2]:
-        if line[0:1] == b'#' and ENCODING_RE.search(line):
-            encoding = ENCODING_RE.search(line).groups()[0].decode('ascii')
-            return data.decode(encoding)
-    return data.decode(locale.getpreferredencoding(False))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/filesystem.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/filesystem.py
deleted file mode 100644
index 25ad51660..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/filesystem.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import os
-import os.path
-
-from pip.compat import get_path_uid
-
-
-def check_path_owner(path):
-    # If we don't have a way to check the effective uid of this process, then
-    # we'll just assume that we own the directory.
-    if not hasattr(os, "geteuid"):
-        return True
-
-    previous = None
-    while path != previous:
-        if os.path.lexists(path):
-            # Check if path is writable by current user.
-            if os.geteuid() == 0:
-                # Special handling for root user in order to handle properly
-                # cases where users use sudo without -H flag.
-                try:
-                    path_uid = get_path_uid(path)
-                except OSError:
-                    return False
-                return path_uid == 0
-            else:
-                return os.access(path, os.W_OK)
-        else:
-            previous, path = path, os.path.dirname(path)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/glibc.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/glibc.py
deleted file mode 100644
index 7847885c4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/glibc.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from __future__ import absolute_import
-
-import re
-import ctypes
-import platform
-import warnings
-
-
-def glibc_version_string():
-    "Returns glibc version string, or None if not using glibc."
-
-    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
-    # manpage says, "If filename is NULL, then the returned handle is for the
-    # main program". This way we can let the linker do the work to figure out
-    # which libc our process is actually using.
-    process_namespace = ctypes.CDLL(None)
-    try:
-        gnu_get_libc_version = process_namespace.gnu_get_libc_version
-    except AttributeError:
-        # Symbol doesn't exist -> therefore, we are not linked to
-        # glibc.
-        return None
-
-    # Call gnu_get_libc_version, which returns a string like "2.5"
-    gnu_get_libc_version.restype = ctypes.c_char_p
-    version_str = gnu_get_libc_version()
-    # py2 / py3 compatibility:
-    if not isinstance(version_str, str):
-        version_str = version_str.decode("ascii")
-
-    return version_str
-
-
-# Separated out from have_compatible_glibc for easier unit testing
-def check_glibc_version(version_str, required_major, minimum_minor):
-    # Parse string and check against requested version.
-    #
-    # We use a regexp instead of str.split because we want to discard any
-    # random junk that might come after the minor version -- this might happen
-    # in patched/forked versions of glibc (e.g. Linaro's version of glibc
-    # uses version strings like "2.20-2014.11"). See gh-3588.
-    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
-    if not m:
-        warnings.warn("Expected glibc version with 2 components major.minor,"
-                      " got: %s" % version_str, RuntimeWarning)
-        return False
-    return (int(m.group("major")) == required_major and
-            int(m.group("minor")) >= minimum_minor)
-
-
-def have_compatible_glibc(required_major, minimum_minor):
-    version_str = glibc_version_string()
-    if version_str is None:
-        return False
-    return check_glibc_version(version_str, required_major, minimum_minor)
-
-
-# platform.libc_ver regularly returns completely nonsensical glibc
-# versions. E.g. on my computer, platform says:
-#
-#   ~$ python2.7 -c 'import platform; print(platform.libc_ver())'
-#   ('glibc', '2.7')
-#   ~$ python3.5 -c 'import platform; print(platform.libc_ver())'
-#   ('glibc', '2.9')
-#
-# But the truth is:
-#
-#   ~$ ldd --version
-#   ldd (Debian GLIBC 2.22-11) 2.22
-#
-# This is unfortunate, because it means that the linehaul data on libc
-# versions that was generated by pip 8.1.2 and earlier is useless and
-# misleading. Solution: instead of using platform, use our code that actually
-# works.
-def libc_ver():
-    glibc_version = glibc_version_string()
-    if glibc_version is None:
-        # For non-glibc platforms, fall back on platform.libc_ver
-        return platform.libc_ver()
-    else:
-        return ("glibc", glibc_version)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/hashes.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/hashes.py
deleted file mode 100644
index 960297007..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/hashes.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from __future__ import absolute_import
-
-import hashlib
-
-from pip.exceptions import HashMismatch, HashMissing, InstallationError
-from pip.utils import read_chunks
-from pip._vendor.six import iteritems, iterkeys, itervalues
-
-
-# The recommended hash algo of the moment. Change this whenever the state of
-# the art changes; it won't hurt backward compatibility.
-FAVORITE_HASH = 'sha256'
-
-
-# Names of hashlib algorithms allowed by the --hash option and ``pip hash``
-# Currently, those are the ones at least as collision-resistant as sha256.
-STRONG_HASHES = ['sha256', 'sha384', 'sha512']
-
-
-class Hashes(object):
-    """A wrapper that builds multiple hashes at once and checks them against
-    known-good values
-
-    """
-    def __init__(self, hashes=None):
-        """
-        :param hashes: A dict of algorithm names pointing to lists of allowed
-            hex digests
-        """
-        self._allowed = {} if hashes is None else hashes
-
-    def check_against_chunks(self, chunks):
-        """Check good hashes against ones built from iterable of chunks of
-        data.
-
-        Raise HashMismatch if none match.
-
-        """
-        gots = {}
-        for hash_name in iterkeys(self._allowed):
-            try:
-                gots[hash_name] = hashlib.new(hash_name)
-            except (ValueError, TypeError):
-                raise InstallationError('Unknown hash name: %s' % hash_name)
-
-        for chunk in chunks:
-            for hash in itervalues(gots):
-                hash.update(chunk)
-
-        for hash_name, got in iteritems(gots):
-            if got.hexdigest() in self._allowed[hash_name]:
-                return
-        self._raise(gots)
-
-    def _raise(self, gots):
-        raise HashMismatch(self._allowed, gots)
-
-    def check_against_file(self, file):
-        """Check good hashes against a file-like object
-
-        Raise HashMismatch if none match.
-
-        """
-        return self.check_against_chunks(read_chunks(file))
-
-    def check_against_path(self, path):
-        with open(path, 'rb') as file:
-            return self.check_against_file(file)
-
-    def __nonzero__(self):
-        """Return whether I know any known-good hashes."""
-        return bool(self._allowed)
-
-    def __bool__(self):
-        return self.__nonzero__()
-
-
-class MissingHashes(Hashes):
-    """A workalike for Hashes used when we're missing a hash for a requirement
-
-    It computes the actual hash of the requirement and raises a HashMissing
-    exception showing it to the user.
-
-    """
-    def __init__(self):
-        """Don't offer the ``hashes`` kwarg."""
-        # Pass our favorite hash in to generate a "gotten hash". With the
-        # empty list, it will never match, so an error will always raise.
-        super(MissingHashes, self).__init__(hashes={FAVORITE_HASH: []})
-
-    def _raise(self, gots):
-        raise HashMissing(gots[FAVORITE_HASH].hexdigest())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/logging.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/logging.py
deleted file mode 100644
index 1c1053abf..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/logging.py
+++ /dev/null
@@ -1,130 +0,0 @@
-from __future__ import absolute_import
-
-import contextlib
-import logging
-import logging.handlers
-import os
-
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-
-from pip.compat import WINDOWS
-from pip.utils import ensure_dir
-
-try:
-    from pip._vendor import colorama
-# Lots of different errors can come from this, including SystemError and
-# ImportError.
-except Exception:
-    colorama = None
-
-
-_log_state = threading.local()
-_log_state.indentation = 0
-
-
-@contextlib.contextmanager
-def indent_log(num=2):
-    """
-    A context manager which will cause the log output to be indented for any
-    log messages emitted inside it.
-    """
-    _log_state.indentation += num
-    try:
-        yield
-    finally:
-        _log_state.indentation -= num
-
-
-def get_indentation():
-    return getattr(_log_state, 'indentation', 0)
-
-
-class IndentingFormatter(logging.Formatter):
-
-    def format(self, record):
-        """
-        Calls the standard formatter, but will indent all of the log messages
-        by our current indentation level.
-        """
-        formatted = logging.Formatter.format(self, record)
-        formatted = "".join([
-            (" " * get_indentation()) + line
-            for line in formatted.splitlines(True)
-        ])
-        return formatted
-
-
-def _color_wrap(*colors):
-    def wrapped(inp):
-        return "".join(list(colors) + [inp, colorama.Style.RESET_ALL])
-    return wrapped
-
-
-class ColorizedStreamHandler(logging.StreamHandler):
-
-    # Don't build up a list of colors if we don't have colorama
-    if colorama:
-        COLORS = [
-            # This needs to be in order from highest logging level to lowest.
-            (logging.ERROR, _color_wrap(colorama.Fore.RED)),
-            (logging.WARNING, _color_wrap(colorama.Fore.YELLOW)),
-        ]
-    else:
-        COLORS = []
-
-    def __init__(self, stream=None):
-        logging.StreamHandler.__init__(self, stream)
-
-        if WINDOWS and colorama:
-            self.stream = colorama.AnsiToWin32(self.stream)
-
-    def should_color(self):
-        # Don't colorize things if we do not have colorama
-        if not colorama:
-            return False
-
-        real_stream = (
-            self.stream if not isinstance(self.stream, colorama.AnsiToWin32)
-            else self.stream.wrapped
-        )
-
-        # If the stream is a tty we should color it
-        if hasattr(real_stream, "isatty") and real_stream.isatty():
-            return True
-
-        # If we have an ASNI term we should color it
-        if os.environ.get("TERM") == "ANSI":
-            return True
-
-        # If anything else we should not color it
-        return False
-
-    def format(self, record):
-        msg = logging.StreamHandler.format(self, record)
-
-        if self.should_color():
-            for level, color in self.COLORS:
-                if record.levelno >= level:
-                    msg = color(msg)
-                    break
-
-        return msg
-
-
-class BetterRotatingFileHandler(logging.handlers.RotatingFileHandler):
-
-    def _open(self):
-        ensure_dir(os.path.dirname(self.baseFilename))
-        return logging.handlers.RotatingFileHandler._open(self)
-
-
-class MaxLevelFilter(logging.Filter):
-
-    def __init__(self, level):
-        self.level = level
-
-    def filter(self, record):
-        return record.levelno < self.level
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/outdated.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/outdated.py
deleted file mode 100644
index 2164cc3cc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/outdated.py
+++ /dev/null
@@ -1,162 +0,0 @@
-from __future__ import absolute_import
-
-import datetime
-import json
-import logging
-import os.path
-import sys
-
-from pip._vendor import lockfile
-from pip._vendor.packaging import version as packaging_version
-
-from pip.compat import total_seconds, WINDOWS
-from pip.models import PyPI
-from pip.locations import USER_CACHE_DIR, running_under_virtualenv
-from pip.utils import ensure_dir, get_installed_version
-from pip.utils.filesystem import check_path_owner
-
-
-SELFCHECK_DATE_FMT = "%Y-%m-%dT%H:%M:%SZ"
-
-
-logger = logging.getLogger(__name__)
-
-
-class VirtualenvSelfCheckState(object):
-    def __init__(self):
-        self.statefile_path = os.path.join(sys.prefix, "pip-selfcheck.json")
-
-        # Load the existing state
-        try:
-            with open(self.statefile_path) as statefile:
-                self.state = json.load(statefile)
-        except (IOError, ValueError):
-            self.state = {}
-
-    def save(self, pypi_version, current_time):
-        # Attempt to write out our version check file
-        with open(self.statefile_path, "w") as statefile:
-            json.dump(
-                {
-                    "last_check": current_time.strftime(SELFCHECK_DATE_FMT),
-                    "pypi_version": pypi_version,
-                },
-                statefile,
-                sort_keys=True,
-                separators=(",", ":")
-            )
-
-
-class GlobalSelfCheckState(object):
-    def __init__(self):
-        self.statefile_path = os.path.join(USER_CACHE_DIR, "selfcheck.json")
-
-        # Load the existing state
-        try:
-            with open(self.statefile_path) as statefile:
-                self.state = json.load(statefile)[sys.prefix]
-        except (IOError, ValueError, KeyError):
-            self.state = {}
-
-    def save(self, pypi_version, current_time):
-        # Check to make sure that we own the directory
-        if not check_path_owner(os.path.dirname(self.statefile_path)):
-            return
-
-        # Now that we've ensured the directory is owned by this user, we'll go
-        # ahead and make sure that all our directories are created.
-        ensure_dir(os.path.dirname(self.statefile_path))
-
-        # Attempt to write out our version check file
-        with lockfile.LockFile(self.statefile_path):
-            if os.path.exists(self.statefile_path):
-                with open(self.statefile_path) as statefile:
-                    state = json.load(statefile)
-            else:
-                state = {}
-
-            state[sys.prefix] = {
-                "last_check": current_time.strftime(SELFCHECK_DATE_FMT),
-                "pypi_version": pypi_version,
-            }
-
-            with open(self.statefile_path, "w") as statefile:
-                json.dump(state, statefile, sort_keys=True,
-                          separators=(",", ":"))
-
-
-def load_selfcheck_statefile():
-    if running_under_virtualenv():
-        return VirtualenvSelfCheckState()
-    else:
-        return GlobalSelfCheckState()
-
-
-def pip_version_check(session):
-    """Check for an update for pip.
-
-    Limit the frequency of checks to once per week. State is stored either in
-    the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
-    of the pip script path.
-    """
-    installed_version = get_installed_version("pip")
-    if installed_version is None:
-        return
-
-    pip_version = packaging_version.parse(installed_version)
-    pypi_version = None
-
-    try:
-        state = load_selfcheck_statefile()
-
-        current_time = datetime.datetime.utcnow()
-        # Determine if we need to refresh the state
-        if "last_check" in state.state and "pypi_version" in state.state:
-            last_check = datetime.datetime.strptime(
-                state.state["last_check"],
-                SELFCHECK_DATE_FMT
-            )
-            if total_seconds(current_time - last_check) < 7 * 24 * 60 * 60:
-                pypi_version = state.state["pypi_version"]
-
-        # Refresh the version if we need to or just see if we need to warn
-        if pypi_version is None:
-            resp = session.get(
-                PyPI.pip_json_url,
-                headers={"Accept": "application/json"},
-            )
-            resp.raise_for_status()
-            pypi_version = [
-                v for v in sorted(
-                    list(resp.json()["releases"]),
-                    key=packaging_version.parse,
-                )
-                if not packaging_version.parse(v).is_prerelease
-            ][-1]
-
-            # save that we've performed a check
-            state.save(pypi_version, current_time)
-
-        remote_version = packaging_version.parse(pypi_version)
-
-        # Determine if our pypi_version is older
-        if (pip_version < remote_version and
-                pip_version.base_version != remote_version.base_version):
-            # Advise "python -m pip" on Windows to avoid issues
-            # with overwriting pip.exe.
-            if WINDOWS:
-                pip_cmd = "python -m pip"
-            else:
-                pip_cmd = "pip"
-            logger.warning(
-                "You are using pip version %s, however version %s is "
-                "available.\nYou should consider upgrading via the "
-                "'%s install --upgrade pip' command.",
-                pip_version, pypi_version, pip_cmd
-            )
-
-    except Exception:
-        logger.debug(
-            "There was an error checking the latest version of pip",
-            exc_info=True,
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/packaging.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/packaging.py
deleted file mode 100644
index e93b20d15..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/packaging.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from __future__ import absolute_import
-
-from email.parser import FeedParser
-
-import logging
-import sys
-
-from pip._vendor.packaging import specifiers
-from pip._vendor.packaging import version
-from pip._vendor import pkg_resources
-
-from pip import exceptions
-
-logger = logging.getLogger(__name__)
-
-
-def check_requires_python(requires_python):
-    """
-    Check if the python version in use match the `requires_python` specifier.
-
-    Returns `True` if the version of python in use matches the requirement.
-    Returns `False` if the version of python in use does not matches the
-    requirement.
-
-    Raises an InvalidSpecifier if `requires_python` have an invalid format.
-    """
-    if requires_python is None:
-        # The package provides no information
-        return True
-    requires_python_specifier = specifiers.SpecifierSet(requires_python)
-
-    # We only use major.minor.micro
-    python_version = version.parse('.'.join(map(str, sys.version_info[:3])))
-    return python_version in requires_python_specifier
-
-
-def get_metadata(dist):
-    if (isinstance(dist, pkg_resources.DistInfoDistribution) and
-            dist.has_metadata('METADATA')):
-        return dist.get_metadata('METADATA')
-    elif dist.has_metadata('PKG-INFO'):
-        return dist.get_metadata('PKG-INFO')
-
-
-def check_dist_requires_python(dist):
-    metadata = get_metadata(dist)
-    feed_parser = FeedParser()
-    feed_parser.feed(metadata)
-    pkg_info_dict = feed_parser.close()
-    requires_python = pkg_info_dict.get('Requires-Python')
-    try:
-        if not check_requires_python(requires_python):
-            raise exceptions.UnsupportedPythonVersion(
-                "%s requires Python '%s' but the running Python is %s" % (
-                    dist.project_name,
-                    requires_python,
-                    '.'.join(map(str, sys.version_info[:3])),)
-            )
-    except specifiers.InvalidSpecifier as e:
-        logger.warning(
-            "Package %s has an invalid Requires-Python entry %s - %s" % (
-                dist.project_name, requires_python, e))
-        return
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/setuptools_build.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/setuptools_build.py
deleted file mode 100644
index 03973e976..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/setuptools_build.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# Shim to wrap setup.py invocation with setuptools
-SETUPTOOLS_SHIM = (
-    "import setuptools, tokenize;__file__=%r;"
-    "f=getattr(tokenize, 'open', open)(__file__);"
-    "code=f.read().replace('\\r\\n', '\\n');"
-    "f.close();"
-    "exec(compile(code, __file__, 'exec'))"
-)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/ui.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/ui.py
deleted file mode 100644
index bba73e3b1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/utils/ui.py
+++ /dev/null
@@ -1,344 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-
-import itertools
-import sys
-from signal import signal, SIGINT, default_int_handler
-import time
-import contextlib
-import logging
-
-from pip.compat import WINDOWS
-from pip.utils import format_size
-from pip.utils.logging import get_indentation
-from pip._vendor import six
-from pip._vendor.progress.bar import Bar, IncrementalBar
-from pip._vendor.progress.helpers import (WritelnMixin,
-                                          HIDE_CURSOR, SHOW_CURSOR)
-from pip._vendor.progress.spinner import Spinner
-
-try:
-    from pip._vendor import colorama
-# Lots of different errors can come from this, including SystemError and
-# ImportError.
-except Exception:
-    colorama = None
-
-logger = logging.getLogger(__name__)
-
-
-def _select_progress_class(preferred, fallback):
-    encoding = getattr(preferred.file, "encoding", None)
-
-    # If we don't know what encoding this file is in, then we'll just assume
-    # that it doesn't support unicode and use the ASCII bar.
-    if not encoding:
-        return fallback
-
-    # Collect all of the possible characters we want to use with the preferred
-    # bar.
-    characters = [
-        getattr(preferred, "empty_fill", six.text_type()),
-        getattr(preferred, "fill", six.text_type()),
-    ]
-    characters += list(getattr(preferred, "phases", []))
-
-    # Try to decode the characters we're using for the bar using the encoding
-    # of the given file, if this works then we'll assume that we can use the
-    # fancier bar and if not we'll fall back to the plaintext bar.
-    try:
-        six.text_type().join(characters).encode(encoding)
-    except UnicodeEncodeError:
-        return fallback
-    else:
-        return preferred
-
-
-_BaseBar = _select_progress_class(IncrementalBar, Bar)
-
-
-class InterruptibleMixin(object):
-    """
-    Helper to ensure that self.finish() gets called on keyboard interrupt.
-
-    This allows downloads to be interrupted without leaving temporary state
-    (like hidden cursors) behind.
-
-    This class is similar to the progress library's existing SigIntMixin
-    helper, but as of version 1.2, that helper has the following problems:
-
-    1. It calls sys.exit().
-    2. It discards the existing SIGINT handler completely.
-    3. It leaves its own handler in place even after an uninterrupted finish,
-       which will have unexpected delayed effects if the user triggers an
-       unrelated keyboard interrupt some time after a progress-displaying
-       download has already completed, for example.
-    """
-
-    def __init__(self, *args, **kwargs):
-        """
-        Save the original SIGINT handler for later.
-        """
-        super(InterruptibleMixin, self).__init__(*args, **kwargs)
-
-        self.original_handler = signal(SIGINT, self.handle_sigint)
-
-        # If signal() returns None, the previous handler was not installed from
-        # Python, and we cannot restore it. This probably should not happen,
-        # but if it does, we must restore something sensible instead, at least.
-        # The least bad option should be Python's default SIGINT handler, which
-        # just raises KeyboardInterrupt.
-        if self.original_handler is None:
-            self.original_handler = default_int_handler
-
-    def finish(self):
-        """
-        Restore the original SIGINT handler after finishing.
-
-        This should happen regardless of whether the progress display finishes
-        normally, or gets interrupted.
-        """
-        super(InterruptibleMixin, self).finish()
-        signal(SIGINT, self.original_handler)
-
-    def handle_sigint(self, signum, frame):
-        """
-        Call self.finish() before delegating to the original SIGINT handler.
-
-        This handler should only be in place while the progress display is
-        active.
-        """
-        self.finish()
-        self.original_handler(signum, frame)
-
-
-class DownloadProgressMixin(object):
-
-    def __init__(self, *args, **kwargs):
-        super(DownloadProgressMixin, self).__init__(*args, **kwargs)
-        self.message = (" " * (get_indentation() + 2)) + self.message
-
-    @property
-    def downloaded(self):
-        return format_size(self.index)
-
-    @property
-    def download_speed(self):
-        # Avoid zero division errors...
-        if self.avg == 0.0:
-            return "..."
-        return format_size(1 / self.avg) + "/s"
-
-    @property
-    def pretty_eta(self):
-        if self.eta:
-            return "eta %s" % self.eta_td
-        return ""
-
-    def iter(self, it, n=1):
-        for x in it:
-            yield x
-            self.next(n)
-        self.finish()
-
-
-class WindowsMixin(object):
-
-    def __init__(self, *args, **kwargs):
-        # The Windows terminal does not support the hide/show cursor ANSI codes
-        # even with colorama. So we'll ensure that hide_cursor is False on
-        # Windows.
-        # This call neds to go before the super() call, so that hide_cursor
-        # is set in time. The base progress bar class writes the "hide cursor"
-        # code to the terminal in its init, so if we don't set this soon
-        # enough, we get a "hide" with no corresponding "show"...
-        if WINDOWS and self.hide_cursor:
-            self.hide_cursor = False
-
-        super(WindowsMixin, self).__init__(*args, **kwargs)
-
-        # Check if we are running on Windows and we have the colorama module,
-        # if we do then wrap our file with it.
-        if WINDOWS and colorama:
-            self.file = colorama.AnsiToWin32(self.file)
-            # The progress code expects to be able to call self.file.isatty()
-            # but the colorama.AnsiToWin32() object doesn't have that, so we'll
-            # add it.
-            self.file.isatty = lambda: self.file.wrapped.isatty()
-            # The progress code expects to be able to call self.file.flush()
-            # but the colorama.AnsiToWin32() object doesn't have that, so we'll
-            # add it.
-            self.file.flush = lambda: self.file.wrapped.flush()
-
-
-class DownloadProgressBar(WindowsMixin, InterruptibleMixin,
-                          DownloadProgressMixin, _BaseBar):
-
-    file = sys.stdout
-    message = "%(percent)d%%"
-    suffix = "%(downloaded)s %(download_speed)s %(pretty_eta)s"
-
-
-class DownloadProgressSpinner(WindowsMixin, InterruptibleMixin,
-                              DownloadProgressMixin, WritelnMixin, Spinner):
-
-    file = sys.stdout
-    suffix = "%(downloaded)s %(download_speed)s"
-
-    def next_phase(self):
-        if not hasattr(self, "_phaser"):
-            self._phaser = itertools.cycle(self.phases)
-        return next(self._phaser)
-
-    def update(self):
-        message = self.message % self
-        phase = self.next_phase()
-        suffix = self.suffix % self
-        line = ''.join([
-            message,
-            " " if message else "",
-            phase,
-            " " if suffix else "",
-            suffix,
-        ])
-
-        self.writeln(line)
-
-
-################################################################
-# Generic "something is happening" spinners
-#
-# We don't even try using progress.spinner.Spinner here because it's actually
-# simpler to reimplement from scratch than to coerce their code into doing
-# what we need.
-################################################################
-
-@contextlib.contextmanager
-def hidden_cursor(file):
-    # The Windows terminal does not support the hide/show cursor ANSI codes,
-    # even via colorama. So don't even try.
-    if WINDOWS:
-        yield
-    # We don't want to clutter the output with control characters if we're
-    # writing to a file, or if the user is running with --quiet.
-    # See https://github.com/pypa/pip/issues/3418
-    elif not file.isatty() or logger.getEffectiveLevel() > logging.INFO:
-        yield
-    else:
-        file.write(HIDE_CURSOR)
-        try:
-            yield
-        finally:
-            file.write(SHOW_CURSOR)
-
-
-class RateLimiter(object):
-    def __init__(self, min_update_interval_seconds):
-        self._min_update_interval_seconds = min_update_interval_seconds
-        self._last_update = 0
-
-    def ready(self):
-        now = time.time()
-        delta = now - self._last_update
-        return delta >= self._min_update_interval_seconds
-
-    def reset(self):
-        self._last_update = time.time()
-
-
-class InteractiveSpinner(object):
-    def __init__(self, message, file=None, spin_chars="-\\|/",
-                 # Empirically, 8 updates/second looks nice
-                 min_update_interval_seconds=0.125):
-        self._message = message
-        if file is None:
-            file = sys.stdout
-        self._file = file
-        self._rate_limiter = RateLimiter(min_update_interval_seconds)
-        self._finished = False
-
-        self._spin_cycle = itertools.cycle(spin_chars)
-
-        self._file.write(" " * get_indentation() + self._message + " ... ")
-        self._width = 0
-
-    def _write(self, status):
-        assert not self._finished
-        # Erase what we wrote before by backspacing to the beginning, writing
-        # spaces to overwrite the old text, and then backspacing again
-        backup = "\b" * self._width
-        self._file.write(backup + " " * self._width + backup)
-        # Now we have a blank slate to add our status
-        self._file.write(status)
-        self._width = len(status)
-        self._file.flush()
-        self._rate_limiter.reset()
-
-    def spin(self):
-        if self._finished:
-            return
-        if not self._rate_limiter.ready():
-            return
-        self._write(next(self._spin_cycle))
-
-    def finish(self, final_status):
-        if self._finished:
-            return
-        self._write(final_status)
-        self._file.write("\n")
-        self._file.flush()
-        self._finished = True
-
-
-# Used for dumb terminals, non-interactive installs (no tty), etc.
-# We still print updates occasionally (once every 60 seconds by default) to
-# act as a keep-alive for systems like Travis-CI that take lack-of-output as
-# an indication that a task has frozen.
-class NonInteractiveSpinner(object):
-    def __init__(self, message, min_update_interval_seconds=60):
-        self._message = message
-        self._finished = False
-        self._rate_limiter = RateLimiter(min_update_interval_seconds)
-        self._update("started")
-
-    def _update(self, status):
-        assert not self._finished
-        self._rate_limiter.reset()
-        logger.info("%s: %s", self._message, status)
-
-    def spin(self):
-        if self._finished:
-            return
-        if not self._rate_limiter.ready():
-            return
-        self._update("still running...")
-
-    def finish(self, final_status):
-        if self._finished:
-            return
-        self._update("finished with status '%s'" % (final_status,))
-        self._finished = True
-
-
-@contextlib.contextmanager
-def open_spinner(message):
-    # Interactive spinner goes directly to sys.stdout rather than being routed
-    # through the logging system, but it acts like it has level INFO,
-    # i.e. it's only displayed if we're at level INFO or better.
-    # Non-interactive spinner goes through the logging system, so it is always
-    # in sync with logging configuration.
-    if sys.stdout.isatty() and logger.getEffectiveLevel() <= logging.INFO:
-        spinner = InteractiveSpinner(message)
-    else:
-        spinner = NonInteractiveSpinner(message)
-    try:
-        with hidden_cursor(sys.stdout):
-            yield spinner
-    except KeyboardInterrupt:
-        spinner.finish("canceled")
-        raise
-    except Exception:
-        spinner.finish("error")
-        raise
-    else:
-        spinner.finish("done")
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__init__.py
deleted file mode 100644
index 8d3dbb271..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__init__.py
+++ /dev/null
@@ -1,366 +0,0 @@
-"""Handles all VCS (version control) support"""
-from __future__ import absolute_import
-
-import errno
-import logging
-import os
-import shutil
-import sys
-
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-
-from pip.exceptions import BadCommand
-from pip.utils import (display_path, backup_dir, call_subprocess,
-                       rmtree, ask_path_exists)
-
-
-__all__ = ['vcs', 'get_src_requirement']
-
-
-logger = logging.getLogger(__name__)
-
-
-class VcsSupport(object):
-    _registry = {}
-    schemes = ['ssh', 'git', 'hg', 'bzr', 'sftp', 'svn']
-
-    def __init__(self):
-        # Register more schemes with urlparse for various version control
-        # systems
-        urllib_parse.uses_netloc.extend(self.schemes)
-        # Python >= 2.7.4, 3.3 doesn't have uses_fragment
-        if getattr(urllib_parse, 'uses_fragment', None):
-            urllib_parse.uses_fragment.extend(self.schemes)
-        super(VcsSupport, self).__init__()
-
-    def __iter__(self):
-        return self._registry.__iter__()
-
-    @property
-    def backends(self):
-        return list(self._registry.values())
-
-    @property
-    def dirnames(self):
-        return [backend.dirname for backend in self.backends]
-
-    @property
-    def all_schemes(self):
-        schemes = []
-        for backend in self.backends:
-            schemes.extend(backend.schemes)
-        return schemes
-
-    def register(self, cls):
-        if not hasattr(cls, 'name'):
-            logger.warning('Cannot register VCS %s', cls.__name__)
-            return
-        if cls.name not in self._registry:
-            self._registry[cls.name] = cls
-            logger.debug('Registered VCS backend: %s', cls.name)
-
-    def unregister(self, cls=None, name=None):
-        if name in self._registry:
-            del self._registry[name]
-        elif cls in self._registry.values():
-            del self._registry[cls.name]
-        else:
-            logger.warning('Cannot unregister because no class or name given')
-
-    def get_backend_name(self, location):
-        """
-        Return the name of the version control backend if found at given
-        location, e.g. vcs.get_backend_name('/path/to/vcs/checkout')
-        """
-        for vc_type in self._registry.values():
-            if vc_type.controls_location(location):
-                logger.debug('Determine that %s uses VCS: %s',
-                             location, vc_type.name)
-                return vc_type.name
-        return None
-
-    def get_backend(self, name):
-        name = name.lower()
-        if name in self._registry:
-            return self._registry[name]
-
-    def get_backend_from_location(self, location):
-        vc_type = self.get_backend_name(location)
-        if vc_type:
-            return self.get_backend(vc_type)
-        return None
-
-
-vcs = VcsSupport()
-
-
-class VersionControl(object):
-    name = ''
-    dirname = ''
-    # List of supported schemes for this Version Control
-    schemes = ()
-
-    def __init__(self, url=None, *args, **kwargs):
-        self.url = url
-        super(VersionControl, self).__init__(*args, **kwargs)
-
-    def _is_local_repository(self, repo):
-        """
-           posix absolute paths start with os.path.sep,
-           win32 ones start with drive (like c:\\folder)
-        """
-        drive, tail = os.path.splitdrive(repo)
-        return repo.startswith(os.path.sep) or drive
-
-    # See issue #1083 for why this method was introduced:
-    # https://github.com/pypa/pip/issues/1083
-    def translate_egg_surname(self, surname):
-        # For example, Django has branches of the form "stable/1.7.x".
-        return surname.replace('/', '_')
-
-    def export(self, location):
-        """
-        Export the repository at the url to the destination location
-        i.e. only download the files, without vcs informations
-        """
-        raise NotImplementedError
-
-    def get_url_rev(self):
-        """
-        Returns the correct repository URL and revision by parsing the given
-        repository URL
-        """
-        error_message = (
-            "Sorry, '%s' is a malformed VCS url. "
-            "The format is <vcs>+<protocol>://<url>, "
-            "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp"
-        )
-        assert '+' in self.url, error_message % self.url
-        url = self.url.split('+', 1)[1]
-        scheme, netloc, path, query, frag = urllib_parse.urlsplit(url)
-        rev = None
-        if '@' in path:
-            path, rev = path.rsplit('@', 1)
-        url = urllib_parse.urlunsplit((scheme, netloc, path, query, ''))
-        return url, rev
-
-    def get_info(self, location):
-        """
-        Returns (url, revision), where both are strings
-        """
-        assert not location.rstrip('/').endswith(self.dirname), \
-            'Bad directory: %s' % location
-        return self.get_url(location), self.get_revision(location)
-
-    def normalize_url(self, url):
-        """
-        Normalize a URL for comparison by unquoting it and removing any
-        trailing slash.
-        """
-        return urllib_parse.unquote(url).rstrip('/')
-
-    def compare_urls(self, url1, url2):
-        """
-        Compare two repo URLs for identity, ignoring incidental differences.
-        """
-        return (self.normalize_url(url1) == self.normalize_url(url2))
-
-    def obtain(self, dest):
-        """
-        Called when installing or updating an editable package, takes the
-        source path of the checkout.
-        """
-        raise NotImplementedError
-
-    def switch(self, dest, url, rev_options):
-        """
-        Switch the repo at ``dest`` to point to ``URL``.
-        """
-        raise NotImplementedError
-
-    def update(self, dest, rev_options):
-        """
-        Update an already-existing repo to the given ``rev_options``.
-        """
-        raise NotImplementedError
-
-    def check_version(self, dest, rev_options):
-        """
-        Return True if the version is identical to what exists and
-        doesn't need to be updated.
-        """
-        raise NotImplementedError
-
-    def check_destination(self, dest, url, rev_options, rev_display):
-        """
-        Prepare a location to receive a checkout/clone.
-
-        Return True if the location is ready for (and requires) a
-        checkout/clone, False otherwise.
-        """
-        checkout = True
-        prompt = False
-        if os.path.exists(dest):
-            checkout = False
-            if os.path.exists(os.path.join(dest, self.dirname)):
-                existing_url = self.get_url(dest)
-                if self.compare_urls(existing_url, url):
-                    logger.debug(
-                        '%s in %s exists, and has correct URL (%s)',
-                        self.repo_name.title(),
-                        display_path(dest),
-                        url,
-                    )
-                    if not self.check_version(dest, rev_options):
-                        logger.info(
-                            'Updating %s %s%s',
-                            display_path(dest),
-                            self.repo_name,
-                            rev_display,
-                        )
-                        self.update(dest, rev_options)
-                    else:
-                        logger.info(
-                            'Skipping because already up-to-date.')
-                else:
-                    logger.warning(
-                        '%s %s in %s exists with URL %s',
-                        self.name,
-                        self.repo_name,
-                        display_path(dest),
-                        existing_url,
-                    )
-                    prompt = ('(s)witch, (i)gnore, (w)ipe, (b)ackup ',
-                              ('s', 'i', 'w', 'b'))
-            else:
-                logger.warning(
-                    'Directory %s already exists, and is not a %s %s.',
-                    dest,
-                    self.name,
-                    self.repo_name,
-                )
-                prompt = ('(i)gnore, (w)ipe, (b)ackup ', ('i', 'w', 'b'))
-        if prompt:
-            logger.warning(
-                'The plan is to install the %s repository %s',
-                self.name,
-                url,
-            )
-            response = ask_path_exists('What to do?  %s' % prompt[0],
-                                       prompt[1])
-
-            if response == 's':
-                logger.info(
-                    'Switching %s %s to %s%s',
-                    self.repo_name,
-                    display_path(dest),
-                    url,
-                    rev_display,
-                )
-                self.switch(dest, url, rev_options)
-            elif response == 'i':
-                # do nothing
-                pass
-            elif response == 'w':
-                logger.warning('Deleting %s', display_path(dest))
-                rmtree(dest)
-                checkout = True
-            elif response == 'b':
-                dest_dir = backup_dir(dest)
-                logger.warning(
-                    'Backing up %s to %s', display_path(dest), dest_dir,
-                )
-                shutil.move(dest, dest_dir)
-                checkout = True
-            elif response == 'a':
-                sys.exit(-1)
-        return checkout
-
-    def unpack(self, location):
-        """
-        Clean up current location and download the url repository
-        (and vcs infos) into location
-        """
-        if os.path.exists(location):
-            rmtree(location)
-        self.obtain(location)
-
-    def get_src_requirement(self, dist, location):
-        """
-        Return a string representing the requirement needed to
-        redownload the files currently present in location, something
-        like:
-          {repository_url}@{revision}#egg={project_name}-{version_identifier}
-        """
-        raise NotImplementedError
-
-    def get_url(self, location):
-        """
-        Return the url used at location
-        Used in get_info or check_destination
-        """
-        raise NotImplementedError
-
-    def get_revision(self, location):
-        """
-        Return the current revision of the files at location
-        Used in get_info
-        """
-        raise NotImplementedError
-
-    def run_command(self, cmd, show_stdout=True, cwd=None,
-                    on_returncode='raise',
-                    command_desc=None,
-                    extra_environ=None, spinner=None):
-        """
-        Run a VCS subcommand
-        This is simply a wrapper around call_subprocess that adds the VCS
-        command name, and checks that the VCS is available
-        """
-        cmd = [self.name] + cmd
-        try:
-            return call_subprocess(cmd, show_stdout, cwd,
-                                   on_returncode,
-                                   command_desc, extra_environ,
-                                   spinner)
-        except OSError as e:
-            # errno.ENOENT = no such file or directory
-            # In other words, the VCS executable isn't available
-            if e.errno == errno.ENOENT:
-                raise BadCommand('Cannot find command %r' % self.name)
-            else:
-                raise  # re-raise exception if a different error occurred
-
-    @classmethod
-    def controls_location(cls, location):
-        """
-        Check if a location is controlled by the vcs.
-        It is meant to be overridden to implement smarter detection
-        mechanisms for specific vcs.
-        """
-        logger.debug('Checking in %s for %s (%s)...',
-                     location, cls.dirname, cls.name)
-        path = os.path.join(location, cls.dirname)
-        return os.path.exists(path)
-
-
-def get_src_requirement(dist, location):
-    version_control = vcs.get_backend_from_location(location)
-    if version_control:
-        try:
-            return version_control().get_src_requirement(dist,
-                                                         location)
-        except BadCommand:
-            logger.warning(
-                'cannot determine version of editable source in %s '
-                '(%s command not found in path)',
-                location,
-                version_control.name,
-            )
-            return dist.as_requirement()
-    logger.warning(
-        'cannot determine version of editable source in %s (is not SVN '
-        'checkout, Git clone, Mercurial clone or Bazaar branch)',
-        location,
-    )
-    return dist.as_requirement()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a9f22439f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/bazaar.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/bazaar.cpython-35.pyc
deleted file mode 100644
index fdf2b162c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/bazaar.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/git.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/git.cpython-35.pyc
deleted file mode 100644
index fefe28096..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/git.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/mercurial.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/mercurial.cpython-35.pyc
deleted file mode 100644
index 6870bf85d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/mercurial.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/subversion.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/subversion.cpython-35.pyc
deleted file mode 100644
index ecb1b751e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/__pycache__/subversion.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/bazaar.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/bazaar.py
deleted file mode 100644
index 0f095841d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/bazaar.py
+++ /dev/null
@@ -1,116 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-import tempfile
-
-# TODO: Get this into six.moves.urllib.parse
-try:
-    from urllib import parse as urllib_parse
-except ImportError:
-    import urlparse as urllib_parse
-
-from pip.utils import rmtree, display_path
-from pip.vcs import vcs, VersionControl
-from pip.download import path_to_url
-
-
-logger = logging.getLogger(__name__)
-
-
-class Bazaar(VersionControl):
-    name = 'bzr'
-    dirname = '.bzr'
-    repo_name = 'branch'
-    schemes = (
-        'bzr', 'bzr+http', 'bzr+https', 'bzr+ssh', 'bzr+sftp', 'bzr+ftp',
-        'bzr+lp',
-    )
-
-    def __init__(self, url=None, *args, **kwargs):
-        super(Bazaar, self).__init__(url, *args, **kwargs)
-        # Python >= 2.7.4, 3.3 doesn't have uses_fragment or non_hierarchical
-        # Register lp but do not expose as a scheme to support bzr+lp.
-        if getattr(urllib_parse, 'uses_fragment', None):
-            urllib_parse.uses_fragment.extend(['lp'])
-            urllib_parse.non_hierarchical.extend(['lp'])
-
-    def export(self, location):
-        """
-        Export the Bazaar repository at the url to the destination location
-        """
-        temp_dir = tempfile.mkdtemp('-export', 'pip-')
-        self.unpack(temp_dir)
-        if os.path.exists(location):
-            # Remove the location to make sure Bazaar can export it correctly
-            rmtree(location)
-        try:
-            self.run_command(['export', location], cwd=temp_dir,
-                             show_stdout=False)
-        finally:
-            rmtree(temp_dir)
-
-    def switch(self, dest, url, rev_options):
-        self.run_command(['switch', url], cwd=dest)
-
-    def update(self, dest, rev_options):
-        self.run_command(['pull', '-q'] + rev_options, cwd=dest)
-
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        if rev:
-            rev_options = ['-r', rev]
-            rev_display = ' (to revision %s)' % rev
-        else:
-            rev_options = []
-            rev_display = ''
-        if self.check_destination(dest, url, rev_options, rev_display):
-            logger.info(
-                'Checking out %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            self.run_command(['branch', '-q'] + rev_options + [url, dest])
-
-    def get_url_rev(self):
-        # hotfix the URL scheme after removing bzr+ from bzr+ssh:// readd it
-        url, rev = super(Bazaar, self).get_url_rev()
-        if url.startswith('ssh://'):
-            url = 'bzr+' + url
-        return url, rev
-
-    def get_url(self, location):
-        urls = self.run_command(['info'], show_stdout=False, cwd=location)
-        for line in urls.splitlines():
-            line = line.strip()
-            for x in ('checkout of branch: ',
-                      'parent branch: '):
-                if line.startswith(x):
-                    repo = line.split(x)[1]
-                    if self._is_local_repository(repo):
-                        return path_to_url(repo)
-                    return repo
-        return None
-
-    def get_revision(self, location):
-        revision = self.run_command(
-            ['revno'], show_stdout=False, cwd=location)
-        return revision.splitlines()[-1]
-
-    def get_src_requirement(self, dist, location):
-        repo = self.get_url(location)
-        if not repo:
-            return None
-        if not repo.lower().startswith('bzr:'):
-            repo = 'bzr+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        current_rev = self.get_revision(location)
-        return '%s@%s#egg=%s' % (repo, current_rev, egg_project_name)
-
-    def check_version(self, dest, rev_options):
-        """Always assume the versions don't match"""
-        return False
-
-
-vcs.register(Bazaar)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/git.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/git.py
deleted file mode 100644
index 2187dd846..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/git.py
+++ /dev/null
@@ -1,300 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import tempfile
-import os.path
-
-from pip.compat import samefile
-from pip.exceptions import BadCommand
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-from pip._vendor.six.moves.urllib import request as urllib_request
-from pip._vendor.packaging.version import parse as parse_version
-
-from pip.utils import display_path, rmtree
-from pip.vcs import vcs, VersionControl
-
-
-urlsplit = urllib_parse.urlsplit
-urlunsplit = urllib_parse.urlunsplit
-
-
-logger = logging.getLogger(__name__)
-
-
-class Git(VersionControl):
-    name = 'git'
-    dirname = '.git'
-    repo_name = 'clone'
-    schemes = (
-        'git', 'git+http', 'git+https', 'git+ssh', 'git+git', 'git+file',
-    )
-
-    def __init__(self, url=None, *args, **kwargs):
-
-        # Works around an apparent Git bug
-        # (see http://article.gmane.org/gmane.comp.version-control.git/146500)
-        if url:
-            scheme, netloc, path, query, fragment = urlsplit(url)
-            if scheme.endswith('file'):
-                initial_slashes = path[:-len(path.lstrip('/'))]
-                newpath = (
-                    initial_slashes +
-                    urllib_request.url2pathname(path)
-                    .replace('\\', '/').lstrip('/')
-                )
-                url = urlunsplit((scheme, netloc, newpath, query, fragment))
-                after_plus = scheme.find('+') + 1
-                url = scheme[:after_plus] + urlunsplit(
-                    (scheme[after_plus:], netloc, newpath, query, fragment),
-                )
-
-        super(Git, self).__init__(url, *args, **kwargs)
-
-    def get_git_version(self):
-        VERSION_PFX = 'git version '
-        version = self.run_command(['version'], show_stdout=False)
-        if version.startswith(VERSION_PFX):
-            version = version[len(VERSION_PFX):]
-        else:
-            version = ''
-        # get first 3 positions of the git version becasue
-        # on windows it is x.y.z.windows.t, and this parses as
-        # LegacyVersion which always smaller than a Version.
-        version = '.'.join(version.split('.')[:3])
-        return parse_version(version)
-
-    def export(self, location):
-        """Export the Git repository at the url to the destination location"""
-        temp_dir = tempfile.mkdtemp('-export', 'pip-')
-        self.unpack(temp_dir)
-        try:
-            if not location.endswith('/'):
-                location = location + '/'
-            self.run_command(
-                ['checkout-index', '-a', '-f', '--prefix', location],
-                show_stdout=False, cwd=temp_dir)
-        finally:
-            rmtree(temp_dir)
-
-    def check_rev_options(self, rev, dest, rev_options):
-        """Check the revision options before checkout to compensate that tags
-        and branches may need origin/ as a prefix.
-        Returns the SHA1 of the branch or tag if found.
-        """
-        revisions = self.get_short_refs(dest)
-
-        origin_rev = 'origin/%s' % rev
-        if origin_rev in revisions:
-            # remote branch
-            return [revisions[origin_rev]]
-        elif rev in revisions:
-            # a local tag or branch name
-            return [revisions[rev]]
-        else:
-            logger.warning(
-                "Could not find a tag or branch '%s', assuming commit.", rev,
-            )
-            return rev_options
-
-    def check_version(self, dest, rev_options):
-        """
-        Compare the current sha to the ref. ref may be a branch or tag name,
-        but current rev will always point to a sha. This means that a branch
-        or tag will never compare as True. So this ultimately only matches
-        against exact shas.
-        """
-        return self.get_revision(dest).startswith(rev_options[0])
-
-    def switch(self, dest, url, rev_options):
-        self.run_command(['config', 'remote.origin.url', url], cwd=dest)
-        self.run_command(['checkout', '-q'] + rev_options, cwd=dest)
-
-        self.update_submodules(dest)
-
-    def update(self, dest, rev_options):
-        # First fetch changes from the default remote
-        if self.get_git_version() >= parse_version('1.9.0'):
-            # fetch tags in addition to everything else
-            self.run_command(['fetch', '-q', '--tags'], cwd=dest)
-        else:
-            self.run_command(['fetch', '-q'], cwd=dest)
-        # Then reset to wanted revision (maybe even origin/master)
-        if rev_options:
-            rev_options = self.check_rev_options(
-                rev_options[0], dest, rev_options,
-            )
-        self.run_command(['reset', '--hard', '-q'] + rev_options, cwd=dest)
-        #: update submodules
-        self.update_submodules(dest)
-
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        if rev:
-            rev_options = [rev]
-            rev_display = ' (to %s)' % rev
-        else:
-            rev_options = ['origin/master']
-            rev_display = ''
-        if self.check_destination(dest, url, rev_options, rev_display):
-            logger.info(
-                'Cloning %s%s to %s', url, rev_display, display_path(dest),
-            )
-            self.run_command(['clone', '-q', url, dest])
-
-            if rev:
-                rev_options = self.check_rev_options(rev, dest, rev_options)
-                # Only do a checkout if rev_options differs from HEAD
-                if not self.check_version(dest, rev_options):
-                    self.run_command(
-                        ['checkout', '-q'] + rev_options,
-                        cwd=dest,
-                    )
-            #: repo may contain submodules
-            self.update_submodules(dest)
-
-    def get_url(self, location):
-        """Return URL of the first remote encountered."""
-        remotes = self.run_command(
-            ['config', '--get-regexp', 'remote\..*\.url'],
-            show_stdout=False, cwd=location)
-        remotes = remotes.splitlines()
-        found_remote = remotes[0]
-        for remote in remotes:
-            if remote.startswith('remote.origin.url '):
-                found_remote = remote
-                break
-        url = found_remote.split(' ')[1]
-        return url.strip()
-
-    def get_revision(self, location):
-        current_rev = self.run_command(
-            ['rev-parse', 'HEAD'], show_stdout=False, cwd=location)
-        return current_rev.strip()
-
-    def get_full_refs(self, location):
-        """Yields tuples of (commit, ref) for branches and tags"""
-        output = self.run_command(['show-ref'],
-                                  show_stdout=False, cwd=location)
-        for line in output.strip().splitlines():
-            commit, ref = line.split(' ', 1)
-            yield commit.strip(), ref.strip()
-
-    def is_ref_remote(self, ref):
-        return ref.startswith('refs/remotes/')
-
-    def is_ref_branch(self, ref):
-        return ref.startswith('refs/heads/')
-
-    def is_ref_tag(self, ref):
-        return ref.startswith('refs/tags/')
-
-    def is_ref_commit(self, ref):
-        """A ref is a commit sha if it is not anything else"""
-        return not any((
-            self.is_ref_remote(ref),
-            self.is_ref_branch(ref),
-            self.is_ref_tag(ref),
-        ))
-
-    # Should deprecate `get_refs` since it's ambiguous
-    def get_refs(self, location):
-        return self.get_short_refs(location)
-
-    def get_short_refs(self, location):
-        """Return map of named refs (branches or tags) to commit hashes."""
-        rv = {}
-        for commit, ref in self.get_full_refs(location):
-            ref_name = None
-            if self.is_ref_remote(ref):
-                ref_name = ref[len('refs/remotes/'):]
-            elif self.is_ref_branch(ref):
-                ref_name = ref[len('refs/heads/'):]
-            elif self.is_ref_tag(ref):
-                ref_name = ref[len('refs/tags/'):]
-            if ref_name is not None:
-                rv[ref_name] = commit
-        return rv
-
-    def _get_subdirectory(self, location):
-        """Return the relative path of setup.py to the git repo root."""
-        # find the repo root
-        git_dir = self.run_command(['rev-parse', '--git-dir'],
-                                   show_stdout=False, cwd=location).strip()
-        if not os.path.isabs(git_dir):
-            git_dir = os.path.join(location, git_dir)
-        root_dir = os.path.join(git_dir, '..')
-        # find setup.py
-        orig_location = location
-        while not os.path.exists(os.path.join(location, 'setup.py')):
-            last_location = location
-            location = os.path.dirname(location)
-            if location == last_location:
-                # We've traversed up to the root of the filesystem without
-                # finding setup.py
-                logger.warning(
-                    "Could not find setup.py for directory %s (tried all "
-                    "parent directories)",
-                    orig_location,
-                )
-                return None
-        # relative path of setup.py to repo root
-        if samefile(root_dir, location):
-            return None
-        return os.path.relpath(location, root_dir)
-
-    def get_src_requirement(self, dist, location):
-        repo = self.get_url(location)
-        if not repo.lower().startswith('git:'):
-            repo = 'git+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        if not repo:
-            return None
-        current_rev = self.get_revision(location)
-        req = '%s@%s#egg=%s' % (repo, current_rev, egg_project_name)
-        subdirectory = self._get_subdirectory(location)
-        if subdirectory:
-            req += '&subdirectory=' + subdirectory
-        return req
-
-    def get_url_rev(self):
-        """
-        Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.
-        That's required because although they use SSH they sometimes doesn't
-        work with a ssh:// scheme (e.g. Github). But we need a scheme for
-        parsing. Hence we remove it again afterwards and return it as a stub.
-        """
-        if '://' not in self.url:
-            assert 'file:' not in self.url
-            self.url = self.url.replace('git+', 'git+ssh://')
-            url, rev = super(Git, self).get_url_rev()
-            url = url.replace('ssh://', '')
-        else:
-            url, rev = super(Git, self).get_url_rev()
-
-        return url, rev
-
-    def update_submodules(self, location):
-        if not os.path.exists(os.path.join(location, '.gitmodules')):
-            return
-        self.run_command(
-            ['submodule', 'update', '--init', '--recursive', '-q'],
-            cwd=location,
-        )
-
-    @classmethod
-    def controls_location(cls, location):
-        if super(Git, cls).controls_location(location):
-            return True
-        try:
-            r = cls().run_command(['rev-parse'],
-                                  cwd=location,
-                                  show_stdout=False,
-                                  on_returncode='ignore')
-            return not r
-        except BadCommand:
-            logger.debug("could not determine if %s is under git control "
-                         "because git is not available", location)
-            return False
-
-
-vcs.register(Git)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/mercurial.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/mercurial.py
deleted file mode 100644
index 1aa83b914..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/mercurial.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-import tempfile
-
-from pip.utils import display_path, rmtree
-from pip.vcs import vcs, VersionControl
-from pip.download import path_to_url
-from pip._vendor.six.moves import configparser
-
-
-logger = logging.getLogger(__name__)
-
-
-class Mercurial(VersionControl):
-    name = 'hg'
-    dirname = '.hg'
-    repo_name = 'clone'
-    schemes = ('hg', 'hg+http', 'hg+https', 'hg+ssh', 'hg+static-http')
-
-    def export(self, location):
-        """Export the Hg repository at the url to the destination location"""
-        temp_dir = tempfile.mkdtemp('-export', 'pip-')
-        self.unpack(temp_dir)
-        try:
-            self.run_command(
-                ['archive', location], show_stdout=False, cwd=temp_dir)
-        finally:
-            rmtree(temp_dir)
-
-    def switch(self, dest, url, rev_options):
-        repo_config = os.path.join(dest, self.dirname, 'hgrc')
-        config = configparser.SafeConfigParser()
-        try:
-            config.read(repo_config)
-            config.set('paths', 'default', url)
-            with open(repo_config, 'w') as config_file:
-                config.write(config_file)
-        except (OSError, configparser.NoSectionError) as exc:
-            logger.warning(
-                'Could not switch Mercurial repository to %s: %s', url, exc,
-            )
-        else:
-            self.run_command(['update', '-q'] + rev_options, cwd=dest)
-
-    def update(self, dest, rev_options):
-        self.run_command(['pull', '-q'], cwd=dest)
-        self.run_command(['update', '-q'] + rev_options, cwd=dest)
-
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        if rev:
-            rev_options = [rev]
-            rev_display = ' (to revision %s)' % rev
-        else:
-            rev_options = []
-            rev_display = ''
-        if self.check_destination(dest, url, rev_options, rev_display):
-            logger.info(
-                'Cloning hg %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            self.run_command(['clone', '--noupdate', '-q', url, dest])
-            self.run_command(['update', '-q'] + rev_options, cwd=dest)
-
-    def get_url(self, location):
-        url = self.run_command(
-            ['showconfig', 'paths.default'],
-            show_stdout=False, cwd=location).strip()
-        if self._is_local_repository(url):
-            url = path_to_url(url)
-        return url.strip()
-
-    def get_revision(self, location):
-        current_revision = self.run_command(
-            ['parents', '--template={rev}'],
-            show_stdout=False, cwd=location).strip()
-        return current_revision
-
-    def get_revision_hash(self, location):
-        current_rev_hash = self.run_command(
-            ['parents', '--template={node}'],
-            show_stdout=False, cwd=location).strip()
-        return current_rev_hash
-
-    def get_src_requirement(self, dist, location):
-        repo = self.get_url(location)
-        if not repo.lower().startswith('hg:'):
-            repo = 'hg+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        if not repo:
-            return None
-        current_rev_hash = self.get_revision_hash(location)
-        return '%s@%s#egg=%s' % (repo, current_rev_hash, egg_project_name)
-
-    def check_version(self, dest, rev_options):
-        """Always assume the versions don't match"""
-        return False
-
-vcs.register(Mercurial)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/subversion.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/subversion.py
deleted file mode 100644
index 4b2315667..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/vcs/subversion.py
+++ /dev/null
@@ -1,269 +0,0 @@
-from __future__ import absolute_import
-
-import logging
-import os
-import re
-
-from pip._vendor.six.moves.urllib import parse as urllib_parse
-
-from pip.index import Link
-from pip.utils import rmtree, display_path
-from pip.utils.logging import indent_log
-from pip.vcs import vcs, VersionControl
-
-_svn_xml_url_re = re.compile('url="([^"]+)"')
-_svn_rev_re = re.compile('committed-rev="(\d+)"')
-_svn_url_re = re.compile(r'URL: (.+)')
-_svn_revision_re = re.compile(r'Revision: (.+)')
-_svn_info_xml_rev_re = re.compile(r'\s*revision="(\d+)"')
-_svn_info_xml_url_re = re.compile(r'<url>(.*)</url>')
-
-
-logger = logging.getLogger(__name__)
-
-
-class Subversion(VersionControl):
-    name = 'svn'
-    dirname = '.svn'
-    repo_name = 'checkout'
-    schemes = ('svn', 'svn+ssh', 'svn+http', 'svn+https', 'svn+svn')
-
-    def get_info(self, location):
-        """Returns (url, revision), where both are strings"""
-        assert not location.rstrip('/').endswith(self.dirname), \
-            'Bad directory: %s' % location
-        output = self.run_command(
-            ['info', location],
-            show_stdout=False,
-            extra_environ={'LANG': 'C'},
-        )
-        match = _svn_url_re.search(output)
-        if not match:
-            logger.warning(
-                'Cannot determine URL of svn checkout %s',
-                display_path(location),
-            )
-            logger.debug('Output that cannot be parsed: \n%s', output)
-            return None, None
-        url = match.group(1).strip()
-        match = _svn_revision_re.search(output)
-        if not match:
-            logger.warning(
-                'Cannot determine revision of svn checkout %s',
-                display_path(location),
-            )
-            logger.debug('Output that cannot be parsed: \n%s', output)
-            return url, None
-        return url, match.group(1)
-
-    def export(self, location):
-        """Export the svn repository at the url to the destination location"""
-        url, rev = self.get_url_rev()
-        rev_options = get_rev_options(url, rev)
-        url = self.remove_auth_from_url(url)
-        logger.info('Exporting svn repository %s to %s', url, location)
-        with indent_log():
-            if os.path.exists(location):
-                # Subversion doesn't like to check out over an existing
-                # directory --force fixes this, but was only added in svn 1.5
-                rmtree(location)
-            self.run_command(
-                ['export'] + rev_options + [url, location],
-                show_stdout=False)
-
-    def switch(self, dest, url, rev_options):
-        self.run_command(['switch'] + rev_options + [url, dest])
-
-    def update(self, dest, rev_options):
-        self.run_command(['update'] + rev_options + [dest])
-
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        rev_options = get_rev_options(url, rev)
-        url = self.remove_auth_from_url(url)
-        if rev:
-            rev_display = ' (to revision %s)' % rev
-        else:
-            rev_display = ''
-        if self.check_destination(dest, url, rev_options, rev_display):
-            logger.info(
-                'Checking out %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            self.run_command(['checkout', '-q'] + rev_options + [url, dest])
-
-    def get_location(self, dist, dependency_links):
-        for url in dependency_links:
-            egg_fragment = Link(url).egg_fragment
-            if not egg_fragment:
-                continue
-            if '-' in egg_fragment:
-                # FIXME: will this work when a package has - in the name?
-                key = '-'.join(egg_fragment.split('-')[:-1]).lower()
-            else:
-                key = egg_fragment
-            if key == dist.key:
-                return url.split('#', 1)[0]
-        return None
-
-    def get_revision(self, location):
-        """
-        Return the maximum revision for all files under a given location
-        """
-        # Note: taken from setuptools.command.egg_info
-        revision = 0
-
-        for base, dirs, files in os.walk(location):
-            if self.dirname not in dirs:
-                dirs[:] = []
-                continue    # no sense walking uncontrolled subdirs
-            dirs.remove(self.dirname)
-            entries_fn = os.path.join(base, self.dirname, 'entries')
-            if not os.path.exists(entries_fn):
-                # FIXME: should we warn?
-                continue
-
-            dirurl, localrev = self._get_svn_url_rev(base)
-
-            if base == location:
-                base_url = dirurl + '/'   # save the root url
-            elif not dirurl or not dirurl.startswith(base_url):
-                dirs[:] = []
-                continue    # not part of the same svn tree, skip it
-            revision = max(revision, localrev)
-        return revision
-
-    def get_url_rev(self):
-        # hotfix the URL scheme after removing svn+ from svn+ssh:// readd it
-        url, rev = super(Subversion, self).get_url_rev()
-        if url.startswith('ssh://'):
-            url = 'svn+' + url
-        return url, rev
-
-    def get_url(self, location):
-        # In cases where the source is in a subdirectory, not alongside
-        # setup.py we have to look up in the location until we find a real
-        # setup.py
-        orig_location = location
-        while not os.path.exists(os.path.join(location, 'setup.py')):
-            last_location = location
-            location = os.path.dirname(location)
-            if location == last_location:
-                # We've traversed up to the root of the filesystem without
-                # finding setup.py
-                logger.warning(
-                    "Could not find setup.py for directory %s (tried all "
-                    "parent directories)",
-                    orig_location,
-                )
-                return None
-
-        return self._get_svn_url_rev(location)[0]
-
-    def _get_svn_url_rev(self, location):
-        from pip.exceptions import InstallationError
-
-        entries_path = os.path.join(location, self.dirname, 'entries')
-        if os.path.exists(entries_path):
-            with open(entries_path) as f:
-                data = f.read()
-        else:  # subversion >= 1.7 does not have the 'entries' file
-            data = ''
-
-        if (data.startswith('8') or
-                data.startswith('9') or
-                data.startswith('10')):
-            data = list(map(str.splitlines, data.split('\n\x0c\n')))
-            del data[0][0]  # get rid of the '8'
-            url = data[0][3]
-            revs = [int(d[9]) for d in data if len(d) > 9 and d[9]] + [0]
-        elif data.startswith('<?xml'):
-            match = _svn_xml_url_re.search(data)
-            if not match:
-                raise ValueError('Badly formatted data: %r' % data)
-            url = match.group(1)    # get repository URL
-            revs = [int(m.group(1)) for m in _svn_rev_re.finditer(data)] + [0]
-        else:
-            try:
-                # subversion >= 1.7
-                xml = self.run_command(
-                    ['info', '--xml', location],
-                    show_stdout=False,
-                )
-                url = _svn_info_xml_url_re.search(xml).group(1)
-                revs = [
-                    int(m.group(1)) for m in _svn_info_xml_rev_re.finditer(xml)
-                ]
-            except InstallationError:
-                url, revs = None, []
-
-        if revs:
-            rev = max(revs)
-        else:
-            rev = 0
-
-        return url, rev
-
-    def get_src_requirement(self, dist, location):
-        repo = self.get_url(location)
-        if repo is None:
-            return None
-        # FIXME: why not project name?
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        rev = self.get_revision(location)
-        return 'svn+%s@%s#egg=%s' % (repo, rev, egg_project_name)
-
-    def check_version(self, dest, rev_options):
-        """Always assume the versions don't match"""
-        return False
-
-    @staticmethod
-    def remove_auth_from_url(url):
-        # Return a copy of url with 'username:password@' removed.
-        # username/pass params are passed to subversion through flags
-        # and are not recognized in the url.
-
-        # parsed url
-        purl = urllib_parse.urlsplit(url)
-        stripped_netloc = \
-            purl.netloc.split('@')[-1]
-
-        # stripped url
-        url_pieces = (
-            purl.scheme, stripped_netloc, purl.path, purl.query, purl.fragment
-        )
-        surl = urllib_parse.urlunsplit(url_pieces)
-        return surl
-
-
-def get_rev_options(url, rev):
-    if rev:
-        rev_options = ['-r', rev]
-    else:
-        rev_options = []
-
-    r = urllib_parse.urlsplit(url)
-    if hasattr(r, 'username'):
-        # >= Python-2.5
-        username, password = r.username, r.password
-    else:
-        netloc = r[1]
-        if '@' in netloc:
-            auth = netloc.split('@')[0]
-            if ':' in auth:
-                username, password = auth.split(':', 1)
-            else:
-                username, password = auth, None
-        else:
-            username, password = None, None
-
-    if username:
-        rev_options += ['--username', username]
-    if password:
-        rev_options += ['--password', password]
-    return rev_options
-
-
-vcs.register(Subversion)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/wheel.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/wheel.py
deleted file mode 100644
index 9ac9dffed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pip/wheel.py
+++ /dev/null
@@ -1,853 +0,0 @@
-"""
-Support for installing and building the "wheel" binary package format.
-"""
-from __future__ import absolute_import
-
-import compileall
-import csv
-import errno
-import functools
-import hashlib
-import logging
-import os
-import os.path
-import re
-import shutil
-import stat
-import sys
-import tempfile
-import warnings
-
-from base64 import urlsafe_b64encode
-from email.parser import Parser
-
-from pip._vendor.six import StringIO
-
-import pip
-from pip.compat import expanduser
-from pip.download import path_to_url, unpack_url
-from pip.exceptions import (
-    InstallationError, InvalidWheelFilename, UnsupportedWheel)
-from pip.locations import distutils_scheme, PIP_DELETE_MARKER_FILENAME
-from pip import pep425tags
-from pip.utils import (
-    call_subprocess, ensure_dir, captured_stdout, rmtree, read_chunks,
-)
-from pip.utils.ui import open_spinner
-from pip.utils.logging import indent_log
-from pip.utils.setuptools_build import SETUPTOOLS_SHIM
-from pip._vendor.distlib.scripts import ScriptMaker
-from pip._vendor import pkg_resources
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.six.moves import configparser
-
-
-wheel_ext = '.whl'
-
-VERSION_COMPATIBLE = (1, 0)
-
-
-logger = logging.getLogger(__name__)
-
-
-class WheelCache(object):
-    """A cache of wheels for future installs."""
-
-    def __init__(self, cache_dir, format_control):
-        """Create a wheel cache.
-
-        :param cache_dir: The root of the cache.
-        :param format_control: A pip.index.FormatControl object to limit
-            binaries being read from the cache.
-        """
-        self._cache_dir = expanduser(cache_dir) if cache_dir else None
-        self._format_control = format_control
-
-    def cached_wheel(self, link, package_name):
-        return cached_wheel(
-            self._cache_dir, link, self._format_control, package_name)
-
-
-def _cache_for_link(cache_dir, link):
-    """
-    Return a directory to store cached wheels in for link.
-
-    Because there are M wheels for any one sdist, we provide a directory
-    to cache them in, and then consult that directory when looking up
-    cache hits.
-
-    We only insert things into the cache if they have plausible version
-    numbers, so that we don't contaminate the cache with things that were not
-    unique. E.g. ./package might have dozens of installs done for it and build
-    a version of 0.0...and if we built and cached a wheel, we'd end up using
-    the same wheel even if the source has been edited.
-
-    :param cache_dir: The cache_dir being used by pip.
-    :param link: The link of the sdist for which this will cache wheels.
-    """
-
-    # We want to generate an url to use as our cache key, we don't want to just
-    # re-use the URL because it might have other items in the fragment and we
-    # don't care about those.
-    key_parts = [link.url_without_fragment]
-    if link.hash_name is not None and link.hash is not None:
-        key_parts.append("=".join([link.hash_name, link.hash]))
-    key_url = "#".join(key_parts)
-
-    # Encode our key url with sha224, we'll use this because it has similar
-    # security properties to sha256, but with a shorter total output (and thus
-    # less secure). However the differences don't make a lot of difference for
-    # our use case here.
-    hashed = hashlib.sha224(key_url.encode()).hexdigest()
-
-    # We want to nest the directories some to prevent having a ton of top level
-    # directories where we might run out of sub directories on some FS.
-    parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]]
-
-    # Inside of the base location for cached wheels, expand our parts and join
-    # them all together.
-    return os.path.join(cache_dir, "wheels", *parts)
-
-
-def cached_wheel(cache_dir, link, format_control, package_name):
-    if not cache_dir:
-        return link
-    if not link:
-        return link
-    if link.is_wheel:
-        return link
-    if not link.is_artifact:
-        return link
-    if not package_name:
-        return link
-    canonical_name = canonicalize_name(package_name)
-    formats = pip.index.fmt_ctl_formats(format_control, canonical_name)
-    if "binary" not in formats:
-        return link
-    root = _cache_for_link(cache_dir, link)
-    try:
-        wheel_names = os.listdir(root)
-    except OSError as e:
-        if e.errno in (errno.ENOENT, errno.ENOTDIR):
-            return link
-        raise
-    candidates = []
-    for wheel_name in wheel_names:
-        try:
-            wheel = Wheel(wheel_name)
-        except InvalidWheelFilename:
-            continue
-        if not wheel.supported():
-            # Built for a different python/arch/etc
-            continue
-        candidates.append((wheel.support_index_min(), wheel_name))
-    if not candidates:
-        return link
-    candidates.sort()
-    path = os.path.join(root, candidates[0][1])
-    return pip.index.Link(path_to_url(path))
-
-
-def rehash(path, algo='sha256', blocksize=1 << 20):
-    """Return (hash, length) for path using hashlib.new(algo)"""
-    h = hashlib.new(algo)
-    length = 0
-    with open(path, 'rb') as f:
-        for block in read_chunks(f, size=blocksize):
-            length += len(block)
-            h.update(block)
-    digest = 'sha256=' + urlsafe_b64encode(
-        h.digest()
-    ).decode('latin1').rstrip('=')
-    return (digest, length)
-
-
-def open_for_csv(name, mode):
-    if sys.version_info[0] < 3:
-        nl = {}
-        bin = 'b'
-    else:
-        nl = {'newline': ''}
-        bin = ''
-    return open(name, mode + bin, **nl)
-
-
-def fix_script(path):
-    """Replace #!python with #!/path/to/python
-    Return True if file was changed."""
-    # XXX RECORD hashes will need to be updated
-    if os.path.isfile(path):
-        with open(path, 'rb') as script:
-            firstline = script.readline()
-            if not firstline.startswith(b'#!python'):
-                return False
-            exename = sys.executable.encode(sys.getfilesystemencoding())
-            firstline = b'#!' + exename + os.linesep.encode("ascii")
-            rest = script.read()
-        with open(path, 'wb') as script:
-            script.write(firstline)
-            script.write(rest)
-        return True
-
-dist_info_re = re.compile(r"""^(?P<namever>(?P<name>.+?)(-(?P<ver>\d.+?))?)
-                                \.dist-info$""", re.VERBOSE)
-
-
-def root_is_purelib(name, wheeldir):
-    """
-    Return True if the extracted wheel in wheeldir should go into purelib.
-    """
-    name_folded = name.replace("-", "_")
-    for item in os.listdir(wheeldir):
-        match = dist_info_re.match(item)
-        if match and match.group('name') == name_folded:
-            with open(os.path.join(wheeldir, item, 'WHEEL')) as wheel:
-                for line in wheel:
-                    line = line.lower().rstrip()
-                    if line == "root-is-purelib: true":
-                        return True
-    return False
-
-
-def get_entrypoints(filename):
-    if not os.path.exists(filename):
-        return {}, {}
-
-    # This is done because you can pass a string to entry_points wrappers which
-    # means that they may or may not be valid INI files. The attempt here is to
-    # strip leading and trailing whitespace in order to make them valid INI
-    # files.
-    with open(filename) as fp:
-        data = StringIO()
-        for line in fp:
-            data.write(line.strip())
-            data.write("\n")
-        data.seek(0)
-
-    cp = configparser.RawConfigParser()
-    cp.optionxform = lambda option: option
-    cp.readfp(data)
-
-    console = {}
-    gui = {}
-    if cp.has_section('console_scripts'):
-        console = dict(cp.items('console_scripts'))
-    if cp.has_section('gui_scripts'):
-        gui = dict(cp.items('gui_scripts'))
-    return console, gui
-
-
-def move_wheel_files(name, req, wheeldir, user=False, home=None, root=None,
-                     pycompile=True, scheme=None, isolated=False, prefix=None):
-    """Install a wheel"""
-
-    if not scheme:
-        scheme = distutils_scheme(
-            name, user=user, home=home, root=root, isolated=isolated,
-            prefix=prefix,
-        )
-
-    if root_is_purelib(name, wheeldir):
-        lib_dir = scheme['purelib']
-    else:
-        lib_dir = scheme['platlib']
-
-    info_dir = []
-    data_dirs = []
-    source = wheeldir.rstrip(os.path.sep) + os.path.sep
-
-    # Record details of the files moved
-    #   installed = files copied from the wheel to the destination
-    #   changed = files changed while installing (scripts #! line typically)
-    #   generated = files newly generated during the install (script wrappers)
-    installed = {}
-    changed = set()
-    generated = []
-
-    # Compile all of the pyc files that we're going to be installing
-    if pycompile:
-        with captured_stdout() as stdout:
-            with warnings.catch_warnings():
-                warnings.filterwarnings('ignore')
-                compileall.compile_dir(source, force=True, quiet=True)
-        logger.debug(stdout.getvalue())
-
-    def normpath(src, p):
-        return os.path.relpath(src, p).replace(os.path.sep, '/')
-
-    def record_installed(srcfile, destfile, modified=False):
-        """Map archive RECORD paths to installation RECORD paths."""
-        oldpath = normpath(srcfile, wheeldir)
-        newpath = normpath(destfile, lib_dir)
-        installed[oldpath] = newpath
-        if modified:
-            changed.add(destfile)
-
-    def clobber(source, dest, is_base, fixer=None, filter=None):
-        ensure_dir(dest)  # common for the 'include' path
-
-        for dir, subdirs, files in os.walk(source):
-            basedir = dir[len(source):].lstrip(os.path.sep)
-            destdir = os.path.join(dest, basedir)
-            if is_base and basedir.split(os.path.sep, 1)[0].endswith('.data'):
-                continue
-            for s in subdirs:
-                destsubdir = os.path.join(dest, basedir, s)
-                if is_base and basedir == '' and destsubdir.endswith('.data'):
-                    data_dirs.append(s)
-                    continue
-                elif (is_base and
-                        s.endswith('.dist-info') and
-                        canonicalize_name(s).startswith(
-                            canonicalize_name(req.name))):
-                    assert not info_dir, ('Multiple .dist-info directories: ' +
-                                          destsubdir + ', ' +
-                                          ', '.join(info_dir))
-                    info_dir.append(destsubdir)
-            for f in files:
-                # Skip unwanted files
-                if filter and filter(f):
-                    continue
-                srcfile = os.path.join(dir, f)
-                destfile = os.path.join(dest, basedir, f)
-                # directory creation is lazy and after the file filtering above
-                # to ensure we don't install empty dirs; empty dirs can't be
-                # uninstalled.
-                ensure_dir(destdir)
-
-                # We use copyfile (not move, copy, or copy2) to be extra sure
-                # that we are not moving directories over (copyfile fails for
-                # directories) as well as to ensure that we are not copying
-                # over any metadata because we want more control over what
-                # metadata we actually copy over.
-                shutil.copyfile(srcfile, destfile)
-
-                # Copy over the metadata for the file, currently this only
-                # includes the atime and mtime.
-                st = os.stat(srcfile)
-                if hasattr(os, "utime"):
-                    os.utime(destfile, (st.st_atime, st.st_mtime))
-
-                # If our file is executable, then make our destination file
-                # executable.
-                if os.access(srcfile, os.X_OK):
-                    st = os.stat(srcfile)
-                    permissions = (
-                        st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
-                    )
-                    os.chmod(destfile, permissions)
-
-                changed = False
-                if fixer:
-                    changed = fixer(destfile)
-                record_installed(srcfile, destfile, changed)
-
-    clobber(source, lib_dir, True)
-
-    assert info_dir, "%s .dist-info directory not found" % req
-
-    # Get the defined entry points
-    ep_file = os.path.join(info_dir[0], 'entry_points.txt')
-    console, gui = get_entrypoints(ep_file)
-
-    def is_entrypoint_wrapper(name):
-        # EP, EP.exe and EP-script.py are scripts generated for
-        # entry point EP by setuptools
-        if name.lower().endswith('.exe'):
-            matchname = name[:-4]
-        elif name.lower().endswith('-script.py'):
-            matchname = name[:-10]
-        elif name.lower().endswith(".pya"):
-            matchname = name[:-4]
-        else:
-            matchname = name
-        # Ignore setuptools-generated scripts
-        return (matchname in console or matchname in gui)
-
-    for datadir in data_dirs:
-        fixer = None
-        filter = None
-        for subdir in os.listdir(os.path.join(wheeldir, datadir)):
-            fixer = None
-            if subdir == 'scripts':
-                fixer = fix_script
-                filter = is_entrypoint_wrapper
-            source = os.path.join(wheeldir, datadir, subdir)
-            dest = scheme[subdir]
-            clobber(source, dest, False, fixer=fixer, filter=filter)
-
-    maker = ScriptMaker(None, scheme['scripts'])
-
-    # Ensure old scripts are overwritten.
-    # See https://github.com/pypa/pip/issues/1800
-    maker.clobber = True
-
-    # Ensure we don't generate any variants for scripts because this is almost
-    # never what somebody wants.
-    # See https://bitbucket.org/pypa/distlib/issue/35/
-    maker.variants = set(('', ))
-
-    # This is required because otherwise distlib creates scripts that are not
-    # executable.
-    # See https://bitbucket.org/pypa/distlib/issue/32/
-    maker.set_mode = True
-
-    # Simplify the script and fix the fact that the default script swallows
-    # every single stack trace.
-    # See https://bitbucket.org/pypa/distlib/issue/34/
-    # See https://bitbucket.org/pypa/distlib/issue/33/
-    def _get_script_text(entry):
-        if entry.suffix is None:
-            raise InstallationError(
-                "Invalid script entry point: %s for req: %s - A callable "
-                "suffix is required. Cf https://packaging.python.org/en/"
-                "latest/distributing.html#console-scripts for more "
-                "information." % (entry, req)
-            )
-        return maker.script_template % {
-            "module": entry.prefix,
-            "import_name": entry.suffix.split(".")[0],
-            "func": entry.suffix,
-        }
-
-    maker._get_script_text = _get_script_text
-    maker.script_template = """# -*- coding: utf-8 -*-
-import re
-import sys
-
-from %(module)s import %(import_name)s
-
-if __name__ == '__main__':
-    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-    sys.exit(%(func)s())
-"""
-
-    # Special case pip and setuptools to generate versioned wrappers
-    #
-    # The issue is that some projects (specifically, pip and setuptools) use
-    # code in setup.py to create "versioned" entry points - pip2.7 on Python
-    # 2.7, pip3.3 on Python 3.3, etc. But these entry points are baked into
-    # the wheel metadata at build time, and so if the wheel is installed with
-    # a *different* version of Python the entry points will be wrong. The
-    # correct fix for this is to enhance the metadata to be able to describe
-    # such versioned entry points, but that won't happen till Metadata 2.0 is
-    # available.
-    # In the meantime, projects using versioned entry points will either have
-    # incorrect versioned entry points, or they will not be able to distribute
-    # "universal" wheels (i.e., they will need a wheel per Python version).
-    #
-    # Because setuptools and pip are bundled with _ensurepip and virtualenv,
-    # we need to use universal wheels. So, as a stopgap until Metadata 2.0, we
-    # override the versioned entry points in the wheel and generate the
-    # correct ones. This code is purely a short-term measure until Metadata 2.0
-    # is available.
-    #
-    # To add the level of hack in this section of code, in order to support
-    # ensurepip this code will look for an ``ENSUREPIP_OPTIONS`` environment
-    # variable which will control which version scripts get installed.
-    #
-    # ENSUREPIP_OPTIONS=altinstall
-    #   - Only pipX.Y and easy_install-X.Y will be generated and installed
-    # ENSUREPIP_OPTIONS=install
-    #   - pipX.Y, pipX, easy_install-X.Y will be generated and installed. Note
-    #     that this option is technically if ENSUREPIP_OPTIONS is set and is
-    #     not altinstall
-    # DEFAULT
-    #   - The default behavior is to install pip, pipX, pipX.Y, easy_install
-    #     and easy_install-X.Y.
-    pip_script = console.pop('pip', None)
-    if pip_script:
-        if "ENSUREPIP_OPTIONS" not in os.environ:
-            spec = 'pip = ' + pip_script
-            generated.extend(maker.make(spec))
-
-        if os.environ.get("ENSUREPIP_OPTIONS", "") != "altinstall":
-            spec = 'pip%s = %s' % (sys.version[:1], pip_script)
-            generated.extend(maker.make(spec))
-
-        spec = 'pip%s = %s' % (sys.version[:3], pip_script)
-        generated.extend(maker.make(spec))
-        # Delete any other versioned pip entry points
-        pip_ep = [k for k in console if re.match(r'pip(\d(\.\d)?)?$', k)]
-        for k in pip_ep:
-            del console[k]
-    easy_install_script = console.pop('easy_install', None)
-    if easy_install_script:
-        if "ENSUREPIP_OPTIONS" not in os.environ:
-            spec = 'easy_install = ' + easy_install_script
-            generated.extend(maker.make(spec))
-
-        spec = 'easy_install-%s = %s' % (sys.version[:3], easy_install_script)
-        generated.extend(maker.make(spec))
-        # Delete any other versioned easy_install entry points
-        easy_install_ep = [
-            k for k in console if re.match(r'easy_install(-\d\.\d)?$', k)
-        ]
-        for k in easy_install_ep:
-            del console[k]
-
-    # Generate the console and GUI entry points specified in the wheel
-    if len(console) > 0:
-        generated.extend(
-            maker.make_multiple(['%s = %s' % kv for kv in console.items()])
-        )
-    if len(gui) > 0:
-        generated.extend(
-            maker.make_multiple(
-                ['%s = %s' % kv for kv in gui.items()],
-                {'gui': True}
-            )
-        )
-
-    # Record pip as the installer
-    installer = os.path.join(info_dir[0], 'INSTALLER')
-    temp_installer = os.path.join(info_dir[0], 'INSTALLER.pip')
-    with open(temp_installer, 'wb') as installer_file:
-        installer_file.write(b'pip\n')
-    shutil.move(temp_installer, installer)
-    generated.append(installer)
-
-    # Record details of all files installed
-    record = os.path.join(info_dir[0], 'RECORD')
-    temp_record = os.path.join(info_dir[0], 'RECORD.pip')
-    with open_for_csv(record, 'r') as record_in:
-        with open_for_csv(temp_record, 'w+') as record_out:
-            reader = csv.reader(record_in)
-            writer = csv.writer(record_out)
-            for row in reader:
-                row[0] = installed.pop(row[0], row[0])
-                if row[0] in changed:
-                    row[1], row[2] = rehash(row[0])
-                writer.writerow(row)
-            for f in generated:
-                h, l = rehash(f)
-                writer.writerow((normpath(f, lib_dir), h, l))
-            for f in installed:
-                writer.writerow((installed[f], '', ''))
-    shutil.move(temp_record, record)
-
-
-def _unique(fn):
-    @functools.wraps(fn)
-    def unique(*args, **kw):
-        seen = set()
-        for item in fn(*args, **kw):
-            if item not in seen:
-                seen.add(item)
-                yield item
-    return unique
-
-
-# TODO: this goes somewhere besides the wheel module
-@_unique
-def uninstallation_paths(dist):
-    """
-    Yield all the uninstallation paths for dist based on RECORD-without-.pyc
-
-    Yield paths to all the files in RECORD. For each .py file in RECORD, add
-    the .pyc in the same directory.
-
-    UninstallPathSet.add() takes care of the __pycache__ .pyc.
-    """
-    from pip.utils import FakeFile  # circular import
-    r = csv.reader(FakeFile(dist.get_metadata_lines('RECORD')))
-    for row in r:
-        path = os.path.join(dist.location, row[0])
-        yield path
-        if path.endswith('.py'):
-            dn, fn = os.path.split(path)
-            base = fn[:-3]
-            path = os.path.join(dn, base + '.pyc')
-            yield path
-
-
-def wheel_version(source_dir):
-    """
-    Return the Wheel-Version of an extracted wheel, if possible.
-
-    Otherwise, return False if we couldn't parse / extract it.
-    """
-    try:
-        dist = [d for d in pkg_resources.find_on_path(None, source_dir)][0]
-
-        wheel_data = dist.get_metadata('WHEEL')
-        wheel_data = Parser().parsestr(wheel_data)
-
-        version = wheel_data['Wheel-Version'].strip()
-        version = tuple(map(int, version.split('.')))
-        return version
-    except:
-        return False
-
-
-def check_compatibility(version, name):
-    """
-    Raises errors or warns if called with an incompatible Wheel-Version.
-
-    Pip should refuse to install a Wheel-Version that's a major series
-    ahead of what it's compatible with (e.g 2.0 > 1.1); and warn when
-    installing a version only minor version ahead (e.g 1.2 > 1.1).
-
-    version: a 2-tuple representing a Wheel-Version (Major, Minor)
-    name: name of wheel or package to raise exception about
-
-    :raises UnsupportedWheel: when an incompatible Wheel-Version is given
-    """
-    if not version:
-        raise UnsupportedWheel(
-            "%s is in an unsupported or invalid wheel" % name
-        )
-    if version[0] > VERSION_COMPATIBLE[0]:
-        raise UnsupportedWheel(
-            "%s's Wheel-Version (%s) is not compatible with this version "
-            "of pip" % (name, '.'.join(map(str, version)))
-        )
-    elif version > VERSION_COMPATIBLE:
-        logger.warning(
-            'Installing from a newer Wheel-Version (%s)',
-            '.'.join(map(str, version)),
-        )
-
-
-class Wheel(object):
-    """A wheel file"""
-
-    # TODO: maybe move the install code into this class
-
-    wheel_file_re = re.compile(
-        r"""^(?P<namever>(?P<name>.+?)-(?P<ver>\d.*?))
-        ((-(?P<build>\d.*?))?-(?P<pyver>.+?)-(?P<abi>.+?)-(?P<plat>.+?)
-        \.whl|\.dist-info)$""",
-        re.VERBOSE
-    )
-
-    def __init__(self, filename):
-        """
-        :raises InvalidWheelFilename: when the filename is invalid for a wheel
-        """
-        wheel_info = self.wheel_file_re.match(filename)
-        if not wheel_info:
-            raise InvalidWheelFilename(
-                "%s is not a valid wheel filename." % filename
-            )
-        self.filename = filename
-        self.name = wheel_info.group('name').replace('_', '-')
-        # we'll assume "_" means "-" due to wheel naming scheme
-        # (https://github.com/pypa/pip/issues/1150)
-        self.version = wheel_info.group('ver').replace('_', '-')
-        self.pyversions = wheel_info.group('pyver').split('.')
-        self.abis = wheel_info.group('abi').split('.')
-        self.plats = wheel_info.group('plat').split('.')
-
-        # All the tag combinations from this file
-        self.file_tags = set(
-            (x, y, z) for x in self.pyversions
-            for y in self.abis for z in self.plats
-        )
-
-    def support_index_min(self, tags=None):
-        """
-        Return the lowest index that one of the wheel's file_tag combinations
-        achieves in the supported_tags list e.g. if there are 8 supported tags,
-        and one of the file tags is first in the list, then return 0.  Returns
-        None is the wheel is not supported.
-        """
-        if tags is None:  # for mock
-            tags = pep425tags.supported_tags
-        indexes = [tags.index(c) for c in self.file_tags if c in tags]
-        return min(indexes) if indexes else None
-
-    def supported(self, tags=None):
-        """Is this wheel supported on this system?"""
-        if tags is None:  # for mock
-            tags = pep425tags.supported_tags
-        return bool(set(tags).intersection(self.file_tags))
-
-
-class WheelBuilder(object):
-    """Build wheels from a RequirementSet."""
-
-    def __init__(self, requirement_set, finder, build_options=None,
-                 global_options=None):
-        self.requirement_set = requirement_set
-        self.finder = finder
-        self._cache_root = requirement_set._wheel_cache._cache_dir
-        self._wheel_dir = requirement_set.wheel_download_dir
-        self.build_options = build_options or []
-        self.global_options = global_options or []
-
-    def _build_one(self, req, output_dir, python_tag=None):
-        """Build one wheel.
-
-        :return: The filename of the built wheel, or None if the build failed.
-        """
-        tempd = tempfile.mkdtemp('pip-wheel-')
-        try:
-            if self.__build_one(req, tempd, python_tag=python_tag):
-                try:
-                    wheel_name = os.listdir(tempd)[0]
-                    wheel_path = os.path.join(output_dir, wheel_name)
-                    shutil.move(os.path.join(tempd, wheel_name), wheel_path)
-                    logger.info('Stored in directory: %s', output_dir)
-                    return wheel_path
-                except:
-                    pass
-            # Ignore return, we can't do anything else useful.
-            self._clean_one(req)
-            return None
-        finally:
-            rmtree(tempd)
-
-    def _base_setup_args(self, req):
-        return [
-            sys.executable, "-u", '-c',
-            SETUPTOOLS_SHIM % req.setup_py
-        ] + list(self.global_options)
-
-    def __build_one(self, req, tempd, python_tag=None):
-        base_args = self._base_setup_args(req)
-
-        spin_message = 'Running setup.py bdist_wheel for %s' % (req.name,)
-        with open_spinner(spin_message) as spinner:
-            logger.debug('Destination directory: %s', tempd)
-            wheel_args = base_args + ['bdist_wheel', '-d', tempd] \
-                + self.build_options
-
-            if python_tag is not None:
-                wheel_args += ["--python-tag", python_tag]
-
-            try:
-                call_subprocess(wheel_args, cwd=req.setup_py_dir,
-                                show_stdout=False, spinner=spinner)
-                return True
-            except:
-                spinner.finish("error")
-                logger.error('Failed building wheel for %s', req.name)
-                return False
-
-    def _clean_one(self, req):
-        base_args = self._base_setup_args(req)
-
-        logger.info('Running setup.py clean for %s', req.name)
-        clean_args = base_args + ['clean', '--all']
-        try:
-            call_subprocess(clean_args, cwd=req.source_dir, show_stdout=False)
-            return True
-        except:
-            logger.error('Failed cleaning build dir for %s', req.name)
-            return False
-
-    def build(self, autobuilding=False):
-        """Build wheels.
-
-        :param unpack: If True, replace the sdist we built from with the
-            newly built wheel, in preparation for installation.
-        :return: True if all the wheels built correctly.
-        """
-        assert self._wheel_dir or (autobuilding and self._cache_root)
-        # unpack sdists and constructs req set
-        self.requirement_set.prepare_files(self.finder)
-
-        reqset = self.requirement_set.requirements.values()
-
-        buildset = []
-        for req in reqset:
-            if req.constraint:
-                continue
-            if req.is_wheel:
-                if not autobuilding:
-                    logger.info(
-                        'Skipping %s, due to already being wheel.', req.name)
-            elif autobuilding and req.editable:
-                pass
-            elif autobuilding and req.link and not req.link.is_artifact:
-                pass
-            elif autobuilding and not req.source_dir:
-                pass
-            else:
-                if autobuilding:
-                    link = req.link
-                    base, ext = link.splitext()
-                    if pip.index.egg_info_matches(base, None, link) is None:
-                        # Doesn't look like a package - don't autobuild a wheel
-                        # because we'll have no way to lookup the result sanely
-                        continue
-                    if "binary" not in pip.index.fmt_ctl_formats(
-                            self.finder.format_control,
-                            canonicalize_name(req.name)):
-                        logger.info(
-                            "Skipping bdist_wheel for %s, due to binaries "
-                            "being disabled for it.", req.name)
-                        continue
-                buildset.append(req)
-
-        if not buildset:
-            return True
-
-        # Build the wheels.
-        logger.info(
-            'Building wheels for collected packages: %s',
-            ', '.join([req.name for req in buildset]),
-        )
-        with indent_log():
-            build_success, build_failure = [], []
-            for req in buildset:
-                python_tag = None
-                if autobuilding:
-                    python_tag = pep425tags.implementation_tag
-                    output_dir = _cache_for_link(self._cache_root, req.link)
-                    try:
-                        ensure_dir(output_dir)
-                    except OSError as e:
-                        logger.warning("Building wheel for %s failed: %s",
-                                       req.name, e)
-                        build_failure.append(req)
-                        continue
-                else:
-                    output_dir = self._wheel_dir
-                wheel_file = self._build_one(
-                    req, output_dir,
-                    python_tag=python_tag,
-                )
-                if wheel_file:
-                    build_success.append(req)
-                    if autobuilding:
-                        # XXX: This is mildly duplicative with prepare_files,
-                        # but not close enough to pull out to a single common
-                        # method.
-                        # The code below assumes temporary source dirs -
-                        # prevent it doing bad things.
-                        if req.source_dir and not os.path.exists(os.path.join(
-                                req.source_dir, PIP_DELETE_MARKER_FILENAME)):
-                            raise AssertionError(
-                                "bad source dir - missing marker")
-                        # Delete the source we built the wheel from
-                        req.remove_temporary_source()
-                        # set the build directory again - name is known from
-                        # the work prepare_files did.
-                        req.source_dir = req.build_location(
-                            self.requirement_set.build_dir)
-                        # Update the link for this.
-                        req.link = pip.index.Link(
-                            path_to_url(wheel_file))
-                        assert req.link.is_wheel
-                        # extract the wheel into the dir
-                        unpack_url(
-                            req.link, req.source_dir, None, False,
-                            session=self.requirement_set.session)
-                else:
-                    build_failure.append(req)
-
-        # notify success/failure
-        if build_success:
-            logger.info(
-                'Successfully built %s',
-                ' '.join([req.name for req in build_success]),
-            )
-        if build_failure:
-            logger.info(
-                'Failed to build %s',
-                ' '.join([req.name for req in build_failure]),
-            )
-        # Return True if all builds were successful
-        return len(build_failure) == 0
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/DESCRIPTION.rst
deleted file mode 100644
index e1187231a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,3 +0,0 @@
-UNKNOWN
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/METADATA
deleted file mode 100644
index 7a504873a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/METADATA
+++ /dev/null
@@ -1,13 +0,0 @@
-Metadata-Version: 2.0
-Name: pkg_resources
-Version: 0.0.0
-Summary: UNKNOWN
-Home-page: UNKNOWN
-Author: UNKNOWN
-Author-email: UNKNOWN
-License: UNKNOWN
-Platform: UNKNOWN
-
-UNKNOWN
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/RECORD
deleted file mode 100644
index 487bcb20d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/RECORD
+++ /dev/null
@@ -1,36 +0,0 @@
-pkg_resources/__init__.py,sha256=qasrGUKwGQ8dGJP5SOEhLJoWRizj5HinbD2bXfrOH28,103308
-pkg_resources/_vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pkg_resources/_vendor/appdirs.py,sha256=tgGaL0m4Jo2VeuGfoOOifLv7a7oUEJu2n1vRkqoPw-0,22374
-pkg_resources/_vendor/pyparsing.py,sha256=PifeLY3-WhIcBVzLtv0U4T_pwDtPruBhBCkg5vLqa28,229867
-pkg_resources/_vendor/six.py,sha256=A6hdJZVjI3t_geebZ9BzUvwRrIXo0lfwzQlM2LcKyas,30098
-pkg_resources/_vendor/packaging/__about__.py,sha256=zkcCPTN_6TcLW0Nrlg0176-R1QQ_WVPTm8sz1R4-HjM,720
-pkg_resources/_vendor/packaging/__init__.py,sha256=_vNac5TrzwsrzbOFIbF-5cHqc_Y2aPT2D7zrIR06BOo,513
-pkg_resources/_vendor/packaging/_compat.py,sha256=Vi_A0rAQeHbU-a9X0tt1yQm9RqkgQbDSxzRw8WlU9kA,860
-pkg_resources/_vendor/packaging/_structures.py,sha256=RImECJ4c_wTlaTYYwZYLHEiebDMaAJmK1oPARhw1T5o,1416
-pkg_resources/_vendor/packaging/markers.py,sha256=uEcBBtGvzqltgnArqb9c4RrcInXezDLos14zbBHhWJo,8248
-pkg_resources/_vendor/packaging/requirements.py,sha256=SikL2UynbsT0qtY9ltqngndha_sfo0w6XGFhAhoSoaQ,4355
-pkg_resources/_vendor/packaging/specifiers.py,sha256=SAMRerzO3fK2IkFZCaZkuwZaL_EGqHNOz4pni4vhnN0,28025
-pkg_resources/_vendor/packaging/utils.py,sha256=3m6WvPm6NNxE8rkTGmn0r75B_GZSGg7ikafxHsBN1WA,421
-pkg_resources/_vendor/packaging/version.py,sha256=OwGnxYfr2ghNzYx59qWIBkrK3SnB6n-Zfd1XaLpnnM0,11556
-pkg_resources/extern/__init__.py,sha256=JUtlHHvlxHSNuB4pWqNjcx7n6kG-fwXg7qmJ2zNJlIY,2487
-pkg_resources-0.0.0.dist-info/DESCRIPTION.rst,sha256=OCTuuN6LcWulhHS3d5rfjdsQtW22n7HENFRh6jC6ego,10
-pkg_resources-0.0.0.dist-info/METADATA,sha256=FOYDX6cmnDUkWo-yhqWQYtjKIMZR2IW2G1GFZhA6gUQ,177
-pkg_resources-0.0.0.dist-info/RECORD,,
-pkg_resources-0.0.0.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
-pkg_resources-0.0.0.dist-info/metadata.json,sha256=8ZVRFU96pY_wnWouockCkvXw981Y0iDB5nQFFGq8ZiY,221
-pkg_resources-0.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-pkg_resources/_vendor/packaging/__pycache__/specifiers.cpython-35.pyc,,
-pkg_resources/_vendor/__pycache__/pyparsing.cpython-35.pyc,,
-pkg_resources/_vendor/__pycache__/six.cpython-35.pyc,,
-pkg_resources/__pycache__/__init__.cpython-35.pyc,,
-pkg_resources/extern/__pycache__/__init__.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/__init__.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/_compat.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/__about__.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/version.cpython-35.pyc,,
-pkg_resources/_vendor/__pycache__/__init__.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/_structures.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/requirements.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/markers.cpython-35.pyc,,
-pkg_resources/_vendor/packaging/__pycache__/utils.cpython-35.pyc,,
-pkg_resources/_vendor/__pycache__/appdirs.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/WHEEL
deleted file mode 100644
index 8b6dd1b5a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.29.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/metadata.json
deleted file mode 100644
index f7d360ae3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources-0.0.0.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"extensions": {"python.details": {"document_names": {"description": "DESCRIPTION.rst"}}}, "generator": "bdist_wheel (0.29.0)", "metadata_version": "2.0", "name": "pkg_resources", "summary": "UNKNOWN", "version": "0.0.0"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__init__.py
deleted file mode 100644
index 4c9868c76..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__init__.py
+++ /dev/null
@@ -1,3053 +0,0 @@
-# coding: utf-8
-"""
-Package resource API
---------------------
-
-A resource is a logical file contained within a package, or a logical
-subdirectory thereof.  The package resource API expects resource names
-to have their path parts separated with ``/``, *not* whatever the local
-path separator is.  Do not use os.path operations to manipulate resource
-names being passed into the API.
-
-The package resource API is designed to work with normal filesystem packages,
-.egg files, and unpacked .egg files.  It can also work in a limited way with
-.zip files and with custom PEP 302 loaders that support the ``get_data()``
-method.
-"""
-
-from __future__ import absolute_import
-
-import sys
-import os
-import io
-import time
-import re
-import types
-import zipfile
-import zipimport
-import warnings
-import stat
-import functools
-import pkgutil
-import operator
-import platform
-import collections
-import plistlib
-import email.parser
-import tempfile
-import textwrap
-import itertools
-from pkgutil import get_importer
-
-try:
-    import _imp
-except ImportError:
-    # Python 3.2 compatibility
-    import imp as _imp
-
-from pkg_resources.extern import six
-from pkg_resources.extern.six.moves import urllib, map, filter
-
-# capture these to bypass sandboxing
-from os import utime
-try:
-    from os import mkdir, rename, unlink
-    WRITE_SUPPORT = True
-except ImportError:
-    # no write support, probably under GAE
-    WRITE_SUPPORT = False
-
-from os import open as os_open
-from os.path import isdir, split
-
-try:
-    import importlib.machinery as importlib_machinery
-    # access attribute to force import under delayed import mechanisms.
-    importlib_machinery.__name__
-except ImportError:
-    importlib_machinery = None
-
-from pkg_resources.extern import appdirs
-from pkg_resources.extern import packaging
-__import__('pkg_resources.extern.packaging.version')
-__import__('pkg_resources.extern.packaging.specifiers')
-__import__('pkg_resources.extern.packaging.requirements')
-__import__('pkg_resources.extern.packaging.markers')
-
-if (3, 0) < sys.version_info < (3, 3):
-    raise RuntimeError("Python 3.3 or later is required")
-
-# declare some globals that will be defined later to
-# satisfy the linters.
-require = None
-working_set = None
-
-
-class PEP440Warning(RuntimeWarning):
-    """
-    Used when there is an issue with a version or specifier not complying with
-    PEP 440.
-    """
-
-
-class _SetuptoolsVersionMixin(object):
-    def __hash__(self):
-        return super(_SetuptoolsVersionMixin, self).__hash__()
-
-    def __lt__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) < other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__lt__(other)
-
-    def __le__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) <= other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__le__(other)
-
-    def __eq__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) == other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__eq__(other)
-
-    def __ge__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) >= other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__ge__(other)
-
-    def __gt__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) > other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__gt__(other)
-
-    def __ne__(self, other):
-        if isinstance(other, tuple):
-            return tuple(self) != other
-        else:
-            return super(_SetuptoolsVersionMixin, self).__ne__(other)
-
-    def __getitem__(self, key):
-        return tuple(self)[key]
-
-    def __iter__(self):
-        component_re = re.compile(r'(\d+ | [a-z]+ | \.| -)', re.VERBOSE)
-        replace = {
-            'pre': 'c',
-            'preview': 'c',
-            '-': 'final-',
-            'rc': 'c',
-            'dev': '@',
-        }.get
-
-        def _parse_version_parts(s):
-            for part in component_re.split(s):
-                part = replace(part, part)
-                if not part or part == '.':
-                    continue
-                if part[:1] in '0123456789':
-                    # pad for numeric comparison
-                    yield part.zfill(8)
-                else:
-                    yield '*' + part
-
-            # ensure that alpha/beta/candidate are before final
-            yield '*final'
-
-        def old_parse_version(s):
-            parts = []
-            for part in _parse_version_parts(s.lower()):
-                if part.startswith('*'):
-                    # remove '-' before a prerelease tag
-                    if part < '*final':
-                        while parts and parts[-1] == '*final-':
-                            parts.pop()
-                    # remove trailing zeros from each series of numeric parts
-                    while parts and parts[-1] == '00000000':
-                        parts.pop()
-                parts.append(part)
-            return tuple(parts)
-
-        # Warn for use of this function
-        warnings.warn(
-            "You have iterated over the result of "
-            "pkg_resources.parse_version. This is a legacy behavior which is "
-            "inconsistent with the new version class introduced in setuptools "
-            "8.0. In most cases, conversion to a tuple is unnecessary. For "
-            "comparison of versions, sort the Version instances directly. If "
-            "you have another use case requiring the tuple, please file a "
-            "bug with the setuptools project describing that need.",
-            RuntimeWarning,
-            stacklevel=1,
-        )
-
-        for part in old_parse_version(str(self)):
-            yield part
-
-
-class SetuptoolsVersion(_SetuptoolsVersionMixin, packaging.version.Version):
-    pass
-
-
-class SetuptoolsLegacyVersion(_SetuptoolsVersionMixin,
-                              packaging.version.LegacyVersion):
-    pass
-
-
-def parse_version(v):
-    try:
-        return SetuptoolsVersion(v)
-    except packaging.version.InvalidVersion:
-        return SetuptoolsLegacyVersion(v)
-
-
-_state_vars = {}
-
-
-def _declare_state(vartype, **kw):
-    globals().update(kw)
-    _state_vars.update(dict.fromkeys(kw, vartype))
-
-
-def __getstate__():
-    state = {}
-    g = globals()
-    for k, v in _state_vars.items():
-        state[k] = g['_sget_' + v](g[k])
-    return state
-
-
-def __setstate__(state):
-    g = globals()
-    for k, v in state.items():
-        g['_sset_' + _state_vars[k]](k, g[k], v)
-    return state
-
-
-def _sget_dict(val):
-    return val.copy()
-
-
-def _sset_dict(key, ob, state):
-    ob.clear()
-    ob.update(state)
-
-
-def _sget_object(val):
-    return val.__getstate__()
-
-
-def _sset_object(key, ob, state):
-    ob.__setstate__(state)
-
-
-_sget_none = _sset_none = lambda *args: None
-
-
-def get_supported_platform():
-    """Return this platform's maximum compatible version.
-
-    distutils.util.get_platform() normally reports the minimum version
-    of Mac OS X that would be required to *use* extensions produced by
-    distutils.  But what we want when checking compatibility is to know the
-    version of Mac OS X that we are *running*.  To allow usage of packages that
-    explicitly require a newer version of Mac OS X, we must also know the
-    current version of the OS.
-
-    If this condition occurs for any other platform with a version in its
-    platform strings, this function should be extended accordingly.
-    """
-    plat = get_build_platform()
-    m = macosVersionString.match(plat)
-    if m is not None and sys.platform == "darwin":
-        try:
-            plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
-        except ValueError:
-            # not Mac OS X
-            pass
-    return plat
-
-
-__all__ = [
-    # Basic resource access and distribution/entry point discovery
-    'require', 'run_script', 'get_provider', 'get_distribution',
-    'load_entry_point', 'get_entry_map', 'get_entry_info',
-    'iter_entry_points',
-    'resource_string', 'resource_stream', 'resource_filename',
-    'resource_listdir', 'resource_exists', 'resource_isdir',
-
-    # Environmental control
-    'declare_namespace', 'working_set', 'add_activation_listener',
-    'find_distributions', 'set_extraction_path', 'cleanup_resources',
-    'get_default_cache',
-
-    # Primary implementation classes
-    'Environment', 'WorkingSet', 'ResourceManager',
-    'Distribution', 'Requirement', 'EntryPoint',
-
-    # Exceptions
-    'ResolutionError', 'VersionConflict', 'DistributionNotFound',
-    'UnknownExtra', 'ExtractionError',
-
-    # Warnings
-    'PEP440Warning',
-
-    # Parsing functions and string utilities
-    'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
-    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
-    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
-
-    # filesystem utilities
-    'ensure_directory', 'normalize_path',
-
-    # Distribution "precedence" constants
-    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
-
-    # "Provider" interfaces, implementations, and registration/lookup APIs
-    'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
-    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
-    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
-    'register_finder', 'register_namespace_handler', 'register_loader_type',
-    'fixup_namespace_packages', 'get_importer',
-
-    # Deprecated/backward compatibility only
-    'run_main', 'AvailableDistributions',
-]
-
-
-class ResolutionError(Exception):
-    """Abstract base for dependency resolution errors"""
-
-    def __repr__(self):
-        return self.__class__.__name__ + repr(self.args)
-
-
-class VersionConflict(ResolutionError):
-    """
-    An already-installed version conflicts with the requested version.
-
-    Should be initialized with the installed Distribution and the requested
-    Requirement.
-    """
-
-    _template = "{self.dist} is installed but {self.req} is required"
-
-    @property
-    def dist(self):
-        return self.args[0]
-
-    @property
-    def req(self):
-        return self.args[1]
-
-    def report(self):
-        return self._template.format(**locals())
-
-    def with_context(self, required_by):
-        """
-        If required_by is non-empty, return a version of self that is a
-        ContextualVersionConflict.
-        """
-        if not required_by:
-            return self
-        args = self.args + (required_by,)
-        return ContextualVersionConflict(*args)
-
-
-class ContextualVersionConflict(VersionConflict):
-    """
-    A VersionConflict that accepts a third parameter, the set of the
-    requirements that required the installed Distribution.
-    """
-
-    _template = VersionConflict._template + ' by {self.required_by}'
-
-    @property
-    def required_by(self):
-        return self.args[2]
-
-
-class DistributionNotFound(ResolutionError):
-    """A requested distribution was not found"""
-
-    _template = ("The '{self.req}' distribution was not found "
-                 "and is required by {self.requirers_str}")
-
-    @property
-    def req(self):
-        return self.args[0]
-
-    @property
-    def requirers(self):
-        return self.args[1]
-
-    @property
-    def requirers_str(self):
-        if not self.requirers:
-            return 'the application'
-        return ', '.join(self.requirers)
-
-    def report(self):
-        return self._template.format(**locals())
-
-    def __str__(self):
-        return self.report()
-
-
-class UnknownExtra(ResolutionError):
-    """Distribution doesn't have an "extra feature" of the given name"""
-
-
-_provider_factories = {}
-
-PY_MAJOR = sys.version[:3]
-EGG_DIST = 3
-BINARY_DIST = 2
-SOURCE_DIST = 1
-CHECKOUT_DIST = 0
-DEVELOP_DIST = -1
-
-
-def register_loader_type(loader_type, provider_factory):
-    """Register `provider_factory` to make providers for `loader_type`
-
-    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
-    and `provider_factory` is a function that, passed a *module* object,
-    returns an ``IResourceProvider`` for that module.
-    """
-    _provider_factories[loader_type] = provider_factory
-
-
-def get_provider(moduleOrReq):
-    """Return an IResourceProvider for the named module or requirement"""
-    if isinstance(moduleOrReq, Requirement):
-        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
-    try:
-        module = sys.modules[moduleOrReq]
-    except KeyError:
-        __import__(moduleOrReq)
-        module = sys.modules[moduleOrReq]
-    loader = getattr(module, '__loader__', None)
-    return _find_adapter(_provider_factories, loader)(module)
-
-
-def _macosx_vers(_cache=[]):
-    if not _cache:
-        version = platform.mac_ver()[0]
-        # fallback for MacPorts
-        if version == '':
-            plist = '/System/Library/CoreServices/SystemVersion.plist'
-            if os.path.exists(plist):
-                if hasattr(plistlib, 'readPlist'):
-                    plist_content = plistlib.readPlist(plist)
-                    if 'ProductVersion' in plist_content:
-                        version = plist_content['ProductVersion']
-
-        _cache.append(version.split('.'))
-    return _cache[0]
-
-
-def _macosx_arch(machine):
-    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
-
-
-def get_build_platform():
-    """Return this platform's string for platform-specific distributions
-
-    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
-    needs some hacks for Linux and Mac OS X.
-    """
-    try:
-        # Python 2.7 or >=3.2
-        from sysconfig import get_platform
-    except ImportError:
-        from distutils.util import get_platform
-
-    plat = get_platform()
-    if sys.platform == "darwin" and not plat.startswith('macosx-'):
-        try:
-            version = _macosx_vers()
-            machine = os.uname()[4].replace(" ", "_")
-            return "macosx-%d.%d-%s" % (int(version[0]), int(version[1]),
-                _macosx_arch(machine))
-        except ValueError:
-            # if someone is running a non-Mac darwin system, this will fall
-            # through to the default implementation
-            pass
-    return plat
-
-
-macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
-darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
-# XXX backward compat
-get_platform = get_build_platform
-
-
-def compatible_platforms(provided, required):
-    """Can code for the `provided` platform run on the `required` platform?
-
-    Returns true if either platform is ``None``, or the platforms are equal.
-
-    XXX Needs compatibility checks for Linux and other unixy OSes.
-    """
-    if provided is None or required is None or provided == required:
-        # easy case
-        return True
-
-    # Mac OS X special cases
-    reqMac = macosVersionString.match(required)
-    if reqMac:
-        provMac = macosVersionString.match(provided)
-
-        # is this a Mac package?
-        if not provMac:
-            # this is backwards compatibility for packages built before
-            # setuptools 0.6. All packages built after this point will
-            # use the new macosx designation.
-            provDarwin = darwinVersionString.match(provided)
-            if provDarwin:
-                dversion = int(provDarwin.group(1))
-                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
-                if dversion == 7 and macosversion >= "10.3" or \
-                        dversion == 8 and macosversion >= "10.4":
-                    return True
-            # egg isn't macosx or legacy darwin
-            return False
-
-        # are they the same major version and machine type?
-        if provMac.group(1) != reqMac.group(1) or \
-                provMac.group(3) != reqMac.group(3):
-            return False
-
-        # is the required OS major update >= the provided one?
-        if int(provMac.group(2)) > int(reqMac.group(2)):
-            return False
-
-        return True
-
-    # XXX Linux and other platforms' special cases should go here
-    return False
-
-
-def run_script(dist_spec, script_name):
-    """Locate distribution `dist_spec` and run its `script_name` script"""
-    ns = sys._getframe(1).f_globals
-    name = ns['__name__']
-    ns.clear()
-    ns['__name__'] = name
-    require(dist_spec)[0].run_script(script_name, ns)
-
-
-# backward compatibility
-run_main = run_script
-
-
-def get_distribution(dist):
-    """Return a current distribution object for a Requirement or string"""
-    if isinstance(dist, six.string_types):
-        dist = Requirement.parse(dist)
-    if isinstance(dist, Requirement):
-        dist = get_provider(dist)
-    if not isinstance(dist, Distribution):
-        raise TypeError("Expected string, Requirement, or Distribution", dist)
-    return dist
-
-
-def load_entry_point(dist, group, name):
-    """Return `name` entry point of `group` for `dist` or raise ImportError"""
-    return get_distribution(dist).load_entry_point(group, name)
-
-
-def get_entry_map(dist, group=None):
-    """Return the entry point map for `group`, or the full entry map"""
-    return get_distribution(dist).get_entry_map(group)
-
-
-def get_entry_info(dist, group, name):
-    """Return the EntryPoint object for `group`+`name`, or ``None``"""
-    return get_distribution(dist).get_entry_info(group, name)
-
-
-class IMetadataProvider:
-    def has_metadata(name):
-        """Does the package's distribution contain the named metadata?"""
-
-    def get_metadata(name):
-        """The named metadata resource as a string"""
-
-    def get_metadata_lines(name):
-        """Yield named metadata resource as list of non-blank non-comment lines
-
-       Leading and trailing whitespace is stripped from each line, and lines
-       with ``#`` as the first non-blank character are omitted."""
-
-    def metadata_isdir(name):
-        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
-
-    def metadata_listdir(name):
-        """List of metadata names in the directory (like ``os.listdir()``)"""
-
-    def run_script(script_name, namespace):
-        """Execute the named script in the supplied namespace dictionary"""
-
-
-class IResourceProvider(IMetadataProvider):
-    """An object that provides access to package resources"""
-
-    def get_resource_filename(manager, resource_name):
-        """Return a true filesystem path for `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def get_resource_stream(manager, resource_name):
-        """Return a readable file-like object for `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def get_resource_string(manager, resource_name):
-        """Return a string containing the contents of `resource_name`
-
-        `manager` must be an ``IResourceManager``"""
-
-    def has_resource(resource_name):
-        """Does the package contain the named resource?"""
-
-    def resource_isdir(resource_name):
-        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
-
-    def resource_listdir(resource_name):
-        """List of resource names in the directory (like ``os.listdir()``)"""
-
-
-class WorkingSet(object):
-    """A collection of active distributions on sys.path (or a similar list)"""
-
-    def __init__(self, entries=None):
-        """Create working set from list of path entries (default=sys.path)"""
-        self.entries = []
-        self.entry_keys = {}
-        self.by_key = {}
-        self.callbacks = []
-
-        if entries is None:
-            entries = sys.path
-
-        for entry in entries:
-            self.add_entry(entry)
-
-    @classmethod
-    def _build_master(cls):
-        """
-        Prepare the master working set.
-        """
-        ws = cls()
-        try:
-            from __main__ import __requires__
-        except ImportError:
-            # The main program does not list any requirements
-            return ws
-
-        # ensure the requirements are met
-        try:
-            ws.require(__requires__)
-        except VersionConflict:
-            return cls._build_from_requirements(__requires__)
-
-        return ws
-
-    @classmethod
-    def _build_from_requirements(cls, req_spec):
-        """
-        Build a working set from a requirement spec. Rewrites sys.path.
-        """
-        # try it without defaults already on sys.path
-        # by starting with an empty path
-        ws = cls([])
-        reqs = parse_requirements(req_spec)
-        dists = ws.resolve(reqs, Environment())
-        for dist in dists:
-            ws.add(dist)
-
-        # add any missing entries from sys.path
-        for entry in sys.path:
-            if entry not in ws.entries:
-                ws.add_entry(entry)
-
-        # then copy back to sys.path
-        sys.path[:] = ws.entries
-        return ws
-
-    def add_entry(self, entry):
-        """Add a path item to ``.entries``, finding any distributions on it
-
-        ``find_distributions(entry, True)`` is used to find distributions
-        corresponding to the path entry, and they are added.  `entry` is
-        always appended to ``.entries``, even if it is already present.
-        (This is because ``sys.path`` can contain the same value more than
-        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
-        equal ``sys.path``.)
-        """
-        self.entry_keys.setdefault(entry, [])
-        self.entries.append(entry)
-        for dist in find_distributions(entry, True):
-            self.add(dist, entry, False)
-
-    def __contains__(self, dist):
-        """True if `dist` is the active distribution for its project"""
-        return self.by_key.get(dist.key) == dist
-
-    def find(self, req):
-        """Find a distribution matching requirement `req`
-
-        If there is an active distribution for the requested project, this
-        returns it as long as it meets the version requirement specified by
-        `req`.  But, if there is an active distribution for the project and it
-        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
-        If there is no active distribution for the requested project, ``None``
-        is returned.
-        """
-        dist = self.by_key.get(req.key)
-        if dist is not None and dist not in req:
-            # XXX add more info
-            raise VersionConflict(dist, req)
-        return dist
-
-    def iter_entry_points(self, group, name=None):
-        """Yield entry point objects from `group` matching `name`
-
-        If `name` is None, yields all entry points in `group` from all
-        distributions in the working set, otherwise only ones matching
-        both `group` and `name` are yielded (in distribution order).
-        """
-        for dist in self:
-            entries = dist.get_entry_map(group)
-            if name is None:
-                for ep in entries.values():
-                    yield ep
-            elif name in entries:
-                yield entries[name]
-
-    def run_script(self, requires, script_name):
-        """Locate distribution for `requires` and run `script_name` script"""
-        ns = sys._getframe(1).f_globals
-        name = ns['__name__']
-        ns.clear()
-        ns['__name__'] = name
-        self.require(requires)[0].run_script(script_name, ns)
-
-    def __iter__(self):
-        """Yield distributions for non-duplicate projects in the working set
-
-        The yield order is the order in which the items' path entries were
-        added to the working set.
-        """
-        seen = {}
-        for item in self.entries:
-            if item not in self.entry_keys:
-                # workaround a cache issue
-                continue
-
-            for key in self.entry_keys[item]:
-                if key not in seen:
-                    seen[key] = 1
-                    yield self.by_key[key]
-
-    def add(self, dist, entry=None, insert=True, replace=False):
-        """Add `dist` to working set, associated with `entry`
-
-        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
-        On exit from this routine, `entry` is added to the end of the working
-        set's ``.entries`` (if it wasn't already present).
-
-        `dist` is only added to the working set if it's for a project that
-        doesn't already have a distribution in the set, unless `replace=True`.
-        If it's added, any callbacks registered with the ``subscribe()`` method
-        will be called.
-        """
-        if insert:
-            dist.insert_on(self.entries, entry, replace=replace)
-
-        if entry is None:
-            entry = dist.location
-        keys = self.entry_keys.setdefault(entry, [])
-        keys2 = self.entry_keys.setdefault(dist.location, [])
-        if not replace and dist.key in self.by_key:
-            # ignore hidden distros
-            return
-
-        self.by_key[dist.key] = dist
-        if dist.key not in keys:
-            keys.append(dist.key)
-        if dist.key not in keys2:
-            keys2.append(dist.key)
-        self._added_new(dist)
-
-    def resolve(self, requirements, env=None, installer=None,
-            replace_conflicting=False):
-        """List all distributions needed to (recursively) meet `requirements`
-
-        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
-        if supplied, should be an ``Environment`` instance.  If
-        not supplied, it defaults to all distributions available within any
-        entry or distribution in the working set.  `installer`, if supplied,
-        will be invoked with each requirement that cannot be met by an
-        already-installed distribution; it should return a ``Distribution`` or
-        ``None``.
-
-        Unless `replace_conflicting=True`, raises a VersionConflict exception if
-        any requirements are found on the path that have the correct name but
-        the wrong version.  Otherwise, if an `installer` is supplied it will be
-        invoked to obtain the correct version of the requirement and activate
-        it.
-        """
-
-        # set up the stack
-        requirements = list(requirements)[::-1]
-        # set of processed requirements
-        processed = {}
-        # key -> dist
-        best = {}
-        to_activate = []
-
-        req_extras = _ReqExtras()
-
-        # Mapping of requirement to set of distributions that required it;
-        # useful for reporting info about conflicts.
-        required_by = collections.defaultdict(set)
-
-        while requirements:
-            # process dependencies breadth-first
-            req = requirements.pop(0)
-            if req in processed:
-                # Ignore cyclic or redundant dependencies
-                continue
-
-            if not req_extras.markers_pass(req):
-                continue
-
-            dist = best.get(req.key)
-            if dist is None:
-                # Find the best distribution and add it to the map
-                dist = self.by_key.get(req.key)
-                if dist is None or (dist not in req and replace_conflicting):
-                    ws = self
-                    if env is None:
-                        if dist is None:
-                            env = Environment(self.entries)
-                        else:
-                            # Use an empty environment and workingset to avoid
-                            # any further conflicts with the conflicting
-                            # distribution
-                            env = Environment([])
-                            ws = WorkingSet([])
-                    dist = best[req.key] = env.best_match(req, ws, installer)
-                    if dist is None:
-                        requirers = required_by.get(req, None)
-                        raise DistributionNotFound(req, requirers)
-                to_activate.append(dist)
-            if dist not in req:
-                # Oops, the "best" so far conflicts with a dependency
-                dependent_req = required_by[req]
-                raise VersionConflict(dist, req).with_context(dependent_req)
-
-            # push the new requirements onto the stack
-            new_requirements = dist.requires(req.extras)[::-1]
-            requirements.extend(new_requirements)
-
-            # Register the new requirements needed by req
-            for new_requirement in new_requirements:
-                required_by[new_requirement].add(req.project_name)
-                req_extras[new_requirement] = req.extras
-
-            processed[req] = True
-
-        # return list of distros to activate
-        return to_activate
-
-    def find_plugins(self, plugin_env, full_env=None, installer=None,
-            fallback=True):
-        """Find all activatable distributions in `plugin_env`
-
-        Example usage::
-
-            distributions, errors = working_set.find_plugins(
-                Environment(plugin_dirlist)
-            )
-            # add plugins+libs to sys.path
-            map(working_set.add, distributions)
-            # display errors
-            print('Could not load', errors)
-
-        The `plugin_env` should be an ``Environment`` instance that contains
-        only distributions that are in the project's "plugin directory" or
-        directories. The `full_env`, if supplied, should be an ``Environment``
-        contains all currently-available distributions.  If `full_env` is not
-        supplied, one is created automatically from the ``WorkingSet`` this
-        method is called on, which will typically mean that every directory on
-        ``sys.path`` will be scanned for distributions.
-
-        `installer` is a standard installer callback as used by the
-        ``resolve()`` method. The `fallback` flag indicates whether we should
-        attempt to resolve older versions of a plugin if the newest version
-        cannot be resolved.
-
-        This method returns a 2-tuple: (`distributions`, `error_info`), where
-        `distributions` is a list of the distributions found in `plugin_env`
-        that were loadable, along with any other distributions that are needed
-        to resolve their dependencies.  `error_info` is a dictionary mapping
-        unloadable plugin distributions to an exception instance describing the
-        error that occurred. Usually this will be a ``DistributionNotFound`` or
-        ``VersionConflict`` instance.
-        """
-
-        plugin_projects = list(plugin_env)
-        # scan project names in alphabetic order
-        plugin_projects.sort()
-
-        error_info = {}
-        distributions = {}
-
-        if full_env is None:
-            env = Environment(self.entries)
-            env += plugin_env
-        else:
-            env = full_env + plugin_env
-
-        shadow_set = self.__class__([])
-        # put all our entries in shadow_set
-        list(map(shadow_set.add, self))
-
-        for project_name in plugin_projects:
-
-            for dist in plugin_env[project_name]:
-
-                req = [dist.as_requirement()]
-
-                try:
-                    resolvees = shadow_set.resolve(req, env, installer)
-
-                except ResolutionError as v:
-                    # save error info
-                    error_info[dist] = v
-                    if fallback:
-                        # try the next older version of project
-                        continue
-                    else:
-                        # give up on this project, keep going
-                        break
-
-                else:
-                    list(map(shadow_set.add, resolvees))
-                    distributions.update(dict.fromkeys(resolvees))
-
-                    # success, no need to try any more versions of this project
-                    break
-
-        distributions = list(distributions)
-        distributions.sort()
-
-        return distributions, error_info
-
-    def require(self, *requirements):
-        """Ensure that distributions matching `requirements` are activated
-
-        `requirements` must be a string or a (possibly-nested) sequence
-        thereof, specifying the distributions and versions required.  The
-        return value is a sequence of the distributions that needed to be
-        activated to fulfill the requirements; all relevant distributions are
-        included, even if they were already activated in this working set.
-        """
-        needed = self.resolve(parse_requirements(requirements))
-
-        for dist in needed:
-            self.add(dist)
-
-        return needed
-
-    def subscribe(self, callback, existing=True):
-        """Invoke `callback` for all distributions
-
-        If `existing=True` (default),
-        call on all existing ones, as well.
-        """
-        if callback in self.callbacks:
-            return
-        self.callbacks.append(callback)
-        if not existing:
-            return
-        for dist in self:
-            callback(dist)
-
-    def _added_new(self, dist):
-        for callback in self.callbacks:
-            callback(dist)
-
-    def __getstate__(self):
-        return (
-            self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
-            self.callbacks[:]
-        )
-
-    def __setstate__(self, e_k_b_c):
-        entries, keys, by_key, callbacks = e_k_b_c
-        self.entries = entries[:]
-        self.entry_keys = keys.copy()
-        self.by_key = by_key.copy()
-        self.callbacks = callbacks[:]
-
-
-class _ReqExtras(dict):
-    """
-    Map each requirement to the extras that demanded it.
-    """
-
-    def markers_pass(self, req):
-        """
-        Evaluate markers for req against each extra that
-        demanded it.
-
-        Return False if the req has a marker and fails
-        evaluation. Otherwise, return True.
-        """
-        extra_evals = (
-            req.marker.evaluate({'extra': extra})
-            for extra in self.get(req, ()) + (None,)
-        )
-        return not req.marker or any(extra_evals)
-
-
-class Environment(object):
-    """Searchable snapshot of distributions on a search path"""
-
-    def __init__(self, search_path=None, platform=get_supported_platform(),
-            python=PY_MAJOR):
-        """Snapshot distributions available on a search path
-
-        Any distributions found on `search_path` are added to the environment.
-        `search_path` should be a sequence of ``sys.path`` items.  If not
-        supplied, ``sys.path`` is used.
-
-        `platform` is an optional string specifying the name of the platform
-        that platform-specific distributions must be compatible with.  If
-        unspecified, it defaults to the current platform.  `python` is an
-        optional string naming the desired version of Python (e.g. ``'3.3'``);
-        it defaults to the current version.
-
-        You may explicitly set `platform` (and/or `python`) to ``None`` if you
-        wish to map *all* distributions, not just those compatible with the
-        running platform or Python version.
-        """
-        self._distmap = {}
-        self.platform = platform
-        self.python = python
-        self.scan(search_path)
-
-    def can_add(self, dist):
-        """Is distribution `dist` acceptable for this environment?
-
-        The distribution must match the platform and python version
-        requirements specified when this environment was created, or False
-        is returned.
-        """
-        return (self.python is None or dist.py_version is None
-            or dist.py_version == self.python) \
-            and compatible_platforms(dist.platform, self.platform)
-
-    def remove(self, dist):
-        """Remove `dist` from the environment"""
-        self._distmap[dist.key].remove(dist)
-
-    def scan(self, search_path=None):
-        """Scan `search_path` for distributions usable in this environment
-
-        Any distributions found are added to the environment.
-        `search_path` should be a sequence of ``sys.path`` items.  If not
-        supplied, ``sys.path`` is used.  Only distributions conforming to
-        the platform/python version defined at initialization are added.
-        """
-        if search_path is None:
-            search_path = sys.path
-
-        for item in search_path:
-            for dist in find_distributions(item):
-                self.add(dist)
-
-    def __getitem__(self, project_name):
-        """Return a newest-to-oldest list of distributions for `project_name`
-
-        Uses case-insensitive `project_name` comparison, assuming all the
-        project's distributions use their project's name converted to all
-        lowercase as their key.
-
-        """
-        distribution_key = project_name.lower()
-        return self._distmap.get(distribution_key, [])
-
-    def add(self, dist):
-        """Add `dist` if we ``can_add()`` it and it has not already been added
-        """
-        if self.can_add(dist) and dist.has_version():
-            dists = self._distmap.setdefault(dist.key, [])
-            if dist not in dists:
-                dists.append(dist)
-                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
-
-    def best_match(self, req, working_set, installer=None):
-        """Find distribution best matching `req` and usable on `working_set`
-
-        This calls the ``find(req)`` method of the `working_set` to see if a
-        suitable distribution is already active.  (This may raise
-        ``VersionConflict`` if an unsuitable version of the project is already
-        active in the specified `working_set`.)  If a suitable distribution
-        isn't active, this method returns the newest distribution in the
-        environment that meets the ``Requirement`` in `req`.  If no suitable
-        distribution is found, and `installer` is supplied, then the result of
-        calling the environment's ``obtain(req, installer)`` method will be
-        returned.
-        """
-        dist = working_set.find(req)
-        if dist is not None:
-            return dist
-        for dist in self[req.key]:
-            if dist in req:
-                return dist
-        # try to download/install
-        return self.obtain(req, installer)
-
-    def obtain(self, requirement, installer=None):
-        """Obtain a distribution matching `requirement` (e.g. via download)
-
-        Obtain a distro that matches requirement (e.g. via download).  In the
-        base ``Environment`` class, this routine just returns
-        ``installer(requirement)``, unless `installer` is None, in which case
-        None is returned instead.  This method is a hook that allows subclasses
-        to attempt other ways of obtaining a distribution before falling back
-        to the `installer` argument."""
-        if installer is not None:
-            return installer(requirement)
-
-    def __iter__(self):
-        """Yield the unique project names of the available distributions"""
-        for key in self._distmap.keys():
-            if self[key]:
-                yield key
-
-    def __iadd__(self, other):
-        """In-place addition of a distribution or environment"""
-        if isinstance(other, Distribution):
-            self.add(other)
-        elif isinstance(other, Environment):
-            for project in other:
-                for dist in other[project]:
-                    self.add(dist)
-        else:
-            raise TypeError("Can't add %r to environment" % (other,))
-        return self
-
-    def __add__(self, other):
-        """Add an environment or distribution to an environment"""
-        new = self.__class__([], platform=None, python=None)
-        for env in self, other:
-            new += env
-        return new
-
-
-# XXX backward compatibility
-AvailableDistributions = Environment
-
-
-class ExtractionError(RuntimeError):
-    """An error occurred extracting a resource
-
-    The following attributes are available from instances of this exception:
-
-    manager
-        The resource manager that raised this exception
-
-    cache_path
-        The base directory for resource extraction
-
-    original_error
-        The exception instance that caused extraction to fail
-    """
-
-
-class ResourceManager:
-    """Manage resource extraction and packages"""
-    extraction_path = None
-
-    def __init__(self):
-        self.cached_files = {}
-
-    def resource_exists(self, package_or_requirement, resource_name):
-        """Does the named resource exist?"""
-        return get_provider(package_or_requirement).has_resource(resource_name)
-
-    def resource_isdir(self, package_or_requirement, resource_name):
-        """Is the named resource an existing directory?"""
-        return get_provider(package_or_requirement).resource_isdir(
-            resource_name
-        )
-
-    def resource_filename(self, package_or_requirement, resource_name):
-        """Return a true filesystem path for specified resource"""
-        return get_provider(package_or_requirement).get_resource_filename(
-            self, resource_name
-        )
-
-    def resource_stream(self, package_or_requirement, resource_name):
-        """Return a readable file-like object for specified resource"""
-        return get_provider(package_or_requirement).get_resource_stream(
-            self, resource_name
-        )
-
-    def resource_string(self, package_or_requirement, resource_name):
-        """Return specified resource as a string"""
-        return get_provider(package_or_requirement).get_resource_string(
-            self, resource_name
-        )
-
-    def resource_listdir(self, package_or_requirement, resource_name):
-        """List the contents of the named resource directory"""
-        return get_provider(package_or_requirement).resource_listdir(
-            resource_name
-        )
-
-    def extraction_error(self):
-        """Give an error message for problems extracting file(s)"""
-
-        old_exc = sys.exc_info()[1]
-        cache_path = self.extraction_path or get_default_cache()
-
-        tmpl = textwrap.dedent("""
-            Can't extract file(s) to egg cache
-
-            The following error occurred while trying to extract file(s) to the Python egg
-            cache:
-
-              {old_exc}
-
-            The Python egg cache directory is currently set to:
-
-              {cache_path}
-
-            Perhaps your account does not have write access to this directory?  You can
-            change the cache directory by setting the PYTHON_EGG_CACHE environment
-            variable to point to an accessible directory.
-            """).lstrip()
-        err = ExtractionError(tmpl.format(**locals()))
-        err.manager = self
-        err.cache_path = cache_path
-        err.original_error = old_exc
-        raise err
-
-    def get_cache_path(self, archive_name, names=()):
-        """Return absolute location in cache for `archive_name` and `names`
-
-        The parent directory of the resulting path will be created if it does
-        not already exist.  `archive_name` should be the base filename of the
-        enclosing egg (which may not be the name of the enclosing zipfile!),
-        including its ".egg" extension.  `names`, if provided, should be a
-        sequence of path name parts "under" the egg's extraction location.
-
-        This method should only be called by resource providers that need to
-        obtain an extraction location, and only for names they intend to
-        extract, as it tracks the generated names for possible cleanup later.
-        """
-        extract_path = self.extraction_path or get_default_cache()
-        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
-        try:
-            _bypass_ensure_directory(target_path)
-        except:
-            self.extraction_error()
-
-        self._warn_unsafe_extraction_path(extract_path)
-
-        self.cached_files[target_path] = 1
-        return target_path
-
-    @staticmethod
-    def _warn_unsafe_extraction_path(path):
-        """
-        If the default extraction path is overridden and set to an insecure
-        location, such as /tmp, it opens up an opportunity for an attacker to
-        replace an extracted file with an unauthorized payload. Warn the user
-        if a known insecure location is used.
-
-        See Distribute #375 for more details.
-        """
-        if os.name == 'nt' and not path.startswith(os.environ['windir']):
-            # On Windows, permissions are generally restrictive by default
-            #  and temp directories are not writable by other users, so
-            #  bypass the warning.
-            return
-        mode = os.stat(path).st_mode
-        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
-            msg = ("%s is writable by group/others and vulnerable to attack "
-                "when "
-                "used with get_resource_filename. Consider a more secure "
-                "location (set with .set_extraction_path or the "
-                "PYTHON_EGG_CACHE environment variable)." % path)
-            warnings.warn(msg, UserWarning)
-
-    def postprocess(self, tempname, filename):
-        """Perform any platform-specific postprocessing of `tempname`
-
-        This is where Mac header rewrites should be done; other platforms don't
-        have anything special they should do.
-
-        Resource providers should call this method ONLY after successfully
-        extracting a compressed resource.  They must NOT call it on resources
-        that are already in the filesystem.
-
-        `tempname` is the current (temporary) name of the file, and `filename`
-        is the name it will be renamed to by the caller after this routine
-        returns.
-        """
-
-        if os.name == 'posix':
-            # Make the resource executable
-            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
-            os.chmod(tempname, mode)
-
-    def set_extraction_path(self, path):
-        """Set the base path where resources will be extracted to, if needed.
-
-        If you do not call this routine before any extractions take place, the
-        path defaults to the return value of ``get_default_cache()``.  (Which
-        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
-        platform-specific fallbacks.  See that routine's documentation for more
-        details.)
-
-        Resources are extracted to subdirectories of this path based upon
-        information given by the ``IResourceProvider``.  You may set this to a
-        temporary directory, but then you must call ``cleanup_resources()`` to
-        delete the extracted files when done.  There is no guarantee that
-        ``cleanup_resources()`` will be able to remove all extracted files.
-
-        (Note: you may not change the extraction path for a given resource
-        manager once resources have been extracted, unless you first call
-        ``cleanup_resources()``.)
-        """
-        if self.cached_files:
-            raise ValueError(
-                "Can't change extraction path, files already extracted"
-            )
-
-        self.extraction_path = path
-
-    def cleanup_resources(self, force=False):
-        """
-        Delete all extracted resource files and directories, returning a list
-        of the file and directory names that could not be successfully removed.
-        This function does not have any concurrency protection, so it should
-        generally only be called when the extraction path is a temporary
-        directory exclusive to a single process.  This method is not
-        automatically called; you must call it explicitly or register it as an
-        ``atexit`` function if you wish to ensure cleanup of a temporary
-        directory used for extractions.
-        """
-        # XXX
-
-
-def get_default_cache():
-    """
-    Return the ``PYTHON_EGG_CACHE`` environment variable
-    or a platform-relevant user cache dir for an app
-    named "Python-Eggs".
-    """
-    return (
-        os.environ.get('PYTHON_EGG_CACHE')
-        or appdirs.user_cache_dir(appname='Python-Eggs')
-    )
-
-
-def safe_name(name):
-    """Convert an arbitrary string to a standard distribution name
-
-    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
-    """
-    return re.sub('[^A-Za-z0-9.]+', '-', name)
-
-
-def safe_version(version):
-    """
-    Convert an arbitrary string to a standard version string
-    """
-    try:
-        # normalize the version
-        return str(packaging.version.Version(version))
-    except packaging.version.InvalidVersion:
-        version = version.replace(' ', '.')
-        return re.sub('[^A-Za-z0-9.]+', '-', version)
-
-
-def safe_extra(extra):
-    """Convert an arbitrary string to a standard 'extra' name
-
-    Any runs of non-alphanumeric characters are replaced with a single '_',
-    and the result is always lowercased.
-    """
-    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
-
-
-def to_filename(name):
-    """Convert a project or version name to its filename-escaped form
-
-    Any '-' characters are currently replaced with '_'.
-    """
-    return name.replace('-', '_')
-
-
-def invalid_marker(text):
-    """
-    Validate text as a PEP 508 environment marker; return an exception
-    if invalid or False otherwise.
-    """
-    try:
-        evaluate_marker(text)
-    except SyntaxError as e:
-        e.filename = None
-        e.lineno = None
-        return e
-    return False
-
-
-def evaluate_marker(text, extra=None):
-    """
-    Evaluate a PEP 508 environment marker.
-    Return a boolean indicating the marker result in this environment.
-    Raise SyntaxError if marker is invalid.
-
-    This implementation uses the 'pyparsing' module.
-    """
-    try:
-        marker = packaging.markers.Marker(text)
-        return marker.evaluate()
-    except packaging.markers.InvalidMarker as e:
-        raise SyntaxError(e)
-
-
-class NullProvider:
-    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
-
-    egg_name = None
-    egg_info = None
-    loader = None
-
-    def __init__(self, module):
-        self.loader = getattr(module, '__loader__', None)
-        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
-
-    def get_resource_filename(self, manager, resource_name):
-        return self._fn(self.module_path, resource_name)
-
-    def get_resource_stream(self, manager, resource_name):
-        return io.BytesIO(self.get_resource_string(manager, resource_name))
-
-    def get_resource_string(self, manager, resource_name):
-        return self._get(self._fn(self.module_path, resource_name))
-
-    def has_resource(self, resource_name):
-        return self._has(self._fn(self.module_path, resource_name))
-
-    def has_metadata(self, name):
-        return self.egg_info and self._has(self._fn(self.egg_info, name))
-
-    def get_metadata(self, name):
-        if not self.egg_info:
-            return ""
-        value = self._get(self._fn(self.egg_info, name))
-        return value.decode('utf-8') if six.PY3 else value
-
-    def get_metadata_lines(self, name):
-        return yield_lines(self.get_metadata(name))
-
-    def resource_isdir(self, resource_name):
-        return self._isdir(self._fn(self.module_path, resource_name))
-
-    def metadata_isdir(self, name):
-        return self.egg_info and self._isdir(self._fn(self.egg_info, name))
-
-    def resource_listdir(self, resource_name):
-        return self._listdir(self._fn(self.module_path, resource_name))
-
-    def metadata_listdir(self, name):
-        if self.egg_info:
-            return self._listdir(self._fn(self.egg_info, name))
-        return []
-
-    def run_script(self, script_name, namespace):
-        script = 'scripts/' + script_name
-        if not self.has_metadata(script):
-            raise ResolutionError("No script named %r" % script_name)
-        script_text = self.get_metadata(script).replace('\r\n', '\n')
-        script_text = script_text.replace('\r', '\n')
-        script_filename = self._fn(self.egg_info, script)
-        namespace['__file__'] = script_filename
-        if os.path.exists(script_filename):
-            source = open(script_filename).read()
-            code = compile(source, script_filename, 'exec')
-            exec(code, namespace, namespace)
-        else:
-            from linecache import cache
-            cache[script_filename] = (
-                len(script_text), 0, script_text.split('\n'), script_filename
-            )
-            script_code = compile(script_text, script_filename, 'exec')
-            exec(script_code, namespace, namespace)
-
-    def _has(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _isdir(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _listdir(self, path):
-        raise NotImplementedError(
-            "Can't perform this operation for unregistered loader type"
-        )
-
-    def _fn(self, base, resource_name):
-        if resource_name:
-            return os.path.join(base, *resource_name.split('/'))
-        return base
-
-    def _get(self, path):
-        if hasattr(self.loader, 'get_data'):
-            return self.loader.get_data(path)
-        raise NotImplementedError(
-            "Can't perform this operation for loaders without 'get_data()'"
-        )
-
-
-register_loader_type(object, NullProvider)
-
-
-class EggProvider(NullProvider):
-    """Provider based on a virtual filesystem"""
-
-    def __init__(self, module):
-        NullProvider.__init__(self, module)
-        self._setup_prefix()
-
-    def _setup_prefix(self):
-        # we assume here that our metadata may be nested inside a "basket"
-        # of multiple eggs; that's why we use module_path instead of .archive
-        path = self.module_path
-        old = None
-        while path != old:
-            if _is_unpacked_egg(path):
-                self.egg_name = os.path.basename(path)
-                self.egg_info = os.path.join(path, 'EGG-INFO')
-                self.egg_root = path
-                break
-            old = path
-            path, base = os.path.split(path)
-
-
-class DefaultProvider(EggProvider):
-    """Provides access to package resources in the filesystem"""
-
-    def _has(self, path):
-        return os.path.exists(path)
-
-    def _isdir(self, path):
-        return os.path.isdir(path)
-
-    def _listdir(self, path):
-        return os.listdir(path)
-
-    def get_resource_stream(self, manager, resource_name):
-        return open(self._fn(self.module_path, resource_name), 'rb')
-
-    def _get(self, path):
-        with open(path, 'rb') as stream:
-            return stream.read()
-
-    @classmethod
-    def _register(cls):
-        loader_cls = getattr(importlib_machinery, 'SourceFileLoader',
-            type(None))
-        register_loader_type(loader_cls, cls)
-
-
-DefaultProvider._register()
-
-
-class EmptyProvider(NullProvider):
-    """Provider that returns nothing for all requests"""
-
-    _isdir = _has = lambda self, path: False
-    _get = lambda self, path: ''
-    _listdir = lambda self, path: []
-    module_path = None
-
-    def __init__(self):
-        pass
-
-
-empty_provider = EmptyProvider()
-
-
-class ZipManifests(dict):
-    """
-    zip manifest builder
-    """
-
-    @classmethod
-    def build(cls, path):
-        """
-        Build a dictionary similar to the zipimport directory
-        caches, except instead of tuples, store ZipInfo objects.
-
-        Use a platform-specific path separator (os.sep) for the path keys
-        for compatibility with pypy on Windows.
-        """
-        with ContextualZipFile(path) as zfile:
-            items = (
-                (
-                    name.replace('/', os.sep),
-                    zfile.getinfo(name),
-                )
-                for name in zfile.namelist()
-            )
-            return dict(items)
-
-    load = build
-
-
-class MemoizedZipManifests(ZipManifests):
-    """
-    Memoized zipfile manifests.
-    """
-    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
-
-    def load(self, path):
-        """
-        Load a manifest at path or return a suitable manifest already loaded.
-        """
-        path = os.path.normpath(path)
-        mtime = os.stat(path).st_mtime
-
-        if path not in self or self[path].mtime != mtime:
-            manifest = self.build(path)
-            self[path] = self.manifest_mod(manifest, mtime)
-
-        return self[path].manifest
-
-
-class ContextualZipFile(zipfile.ZipFile):
-    """
-    Supplement ZipFile class to support context manager for Python 2.6
-    """
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, value, traceback):
-        self.close()
-
-    def __new__(cls, *args, **kwargs):
-        """
-        Construct a ZipFile or ContextualZipFile as appropriate
-        """
-        if hasattr(zipfile.ZipFile, '__exit__'):
-            return zipfile.ZipFile(*args, **kwargs)
-        return super(ContextualZipFile, cls).__new__(cls)
-
-
-class ZipProvider(EggProvider):
-    """Resource support for zips and eggs"""
-
-    eagers = None
-    _zip_manifests = MemoizedZipManifests()
-
-    def __init__(self, module):
-        EggProvider.__init__(self, module)
-        self.zip_pre = self.loader.archive + os.sep
-
-    def _zipinfo_name(self, fspath):
-        # Convert a virtual filename (full path to file) into a zipfile subpath
-        # usable with the zipimport directory cache for our target archive
-        if fspath.startswith(self.zip_pre):
-            return fspath[len(self.zip_pre):]
-        raise AssertionError(
-            "%s is not a subpath of %s" % (fspath, self.zip_pre)
-        )
-
-    def _parts(self, zip_path):
-        # Convert a zipfile subpath into an egg-relative path part list.
-        # pseudo-fs path
-        fspath = self.zip_pre + zip_path
-        if fspath.startswith(self.egg_root + os.sep):
-            return fspath[len(self.egg_root) + 1:].split(os.sep)
-        raise AssertionError(
-            "%s is not a subpath of %s" % (fspath, self.egg_root)
-        )
-
-    @property
-    def zipinfo(self):
-        return self._zip_manifests.load(self.loader.archive)
-
-    def get_resource_filename(self, manager, resource_name):
-        if not self.egg_name:
-            raise NotImplementedError(
-                "resource_filename() only supported for .egg, not .zip"
-            )
-        # no need to lock for extraction, since we use temp names
-        zip_path = self._resource_to_zip(resource_name)
-        eagers = self._get_eager_resources()
-        if '/'.join(self._parts(zip_path)) in eagers:
-            for name in eagers:
-                self._extract_resource(manager, self._eager_to_zip(name))
-        return self._extract_resource(manager, zip_path)
-
-    @staticmethod
-    def _get_date_and_size(zip_stat):
-        size = zip_stat.file_size
-        # ymdhms+wday, yday, dst
-        date_time = zip_stat.date_time + (0, 0, -1)
-        # 1980 offset already done
-        timestamp = time.mktime(date_time)
-        return timestamp, size
-
-    def _extract_resource(self, manager, zip_path):
-
-        if zip_path in self._index():
-            for name in self._index()[zip_path]:
-                last = self._extract_resource(
-                    manager, os.path.join(zip_path, name)
-                )
-            # return the extracted directory name
-            return os.path.dirname(last)
-
-        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
-
-        if not WRITE_SUPPORT:
-            raise IOError('"os.rename" and "os.unlink" are not supported '
-                          'on this platform')
-        try:
-
-            real_path = manager.get_cache_path(
-                self.egg_name, self._parts(zip_path)
-            )
-
-            if self._is_current(real_path, zip_path):
-                return real_path
-
-            outf, tmpnam = _mkstemp(".$extract", dir=os.path.dirname(real_path))
-            os.write(outf, self.loader.get_data(zip_path))
-            os.close(outf)
-            utime(tmpnam, (timestamp, timestamp))
-            manager.postprocess(tmpnam, real_path)
-
-            try:
-                rename(tmpnam, real_path)
-
-            except os.error:
-                if os.path.isfile(real_path):
-                    if self._is_current(real_path, zip_path):
-                        # the file became current since it was checked above,
-                        #  so proceed.
-                        return real_path
-                    # Windows, del old file and retry
-                    elif os.name == 'nt':
-                        unlink(real_path)
-                        rename(tmpnam, real_path)
-                        return real_path
-                raise
-
-        except os.error:
-            # report a user-friendly error
-            manager.extraction_error()
-
-        return real_path
-
-    def _is_current(self, file_path, zip_path):
-        """
-        Return True if the file_path is current for this zip_path
-        """
-        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
-        if not os.path.isfile(file_path):
-            return False
-        stat = os.stat(file_path)
-        if stat.st_size != size or stat.st_mtime != timestamp:
-            return False
-        # check that the contents match
-        zip_contents = self.loader.get_data(zip_path)
-        with open(file_path, 'rb') as f:
-            file_contents = f.read()
-        return zip_contents == file_contents
-
-    def _get_eager_resources(self):
-        if self.eagers is None:
-            eagers = []
-            for name in ('native_libs.txt', 'eager_resources.txt'):
-                if self.has_metadata(name):
-                    eagers.extend(self.get_metadata_lines(name))
-            self.eagers = eagers
-        return self.eagers
-
-    def _index(self):
-        try:
-            return self._dirindex
-        except AttributeError:
-            ind = {}
-            for path in self.zipinfo:
-                parts = path.split(os.sep)
-                while parts:
-                    parent = os.sep.join(parts[:-1])
-                    if parent in ind:
-                        ind[parent].append(parts[-1])
-                        break
-                    else:
-                        ind[parent] = [parts.pop()]
-            self._dirindex = ind
-            return ind
-
-    def _has(self, fspath):
-        zip_path = self._zipinfo_name(fspath)
-        return zip_path in self.zipinfo or zip_path in self._index()
-
-    def _isdir(self, fspath):
-        return self._zipinfo_name(fspath) in self._index()
-
-    def _listdir(self, fspath):
-        return list(self._index().get(self._zipinfo_name(fspath), ()))
-
-    def _eager_to_zip(self, resource_name):
-        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
-
-    def _resource_to_zip(self, resource_name):
-        return self._zipinfo_name(self._fn(self.module_path, resource_name))
-
-
-register_loader_type(zipimport.zipimporter, ZipProvider)
-
-
-class FileMetadata(EmptyProvider):
-    """Metadata handler for standalone PKG-INFO files
-
-    Usage::
-
-        metadata = FileMetadata("/path/to/PKG-INFO")
-
-    This provider rejects all data and metadata requests except for PKG-INFO,
-    which is treated as existing, and will be the contents of the file at
-    the provided location.
-    """
-
-    def __init__(self, path):
-        self.path = path
-
-    def has_metadata(self, name):
-        return name == 'PKG-INFO' and os.path.isfile(self.path)
-
-    def get_metadata(self, name):
-        if name != 'PKG-INFO':
-            raise KeyError("No metadata except PKG-INFO is available")
-
-        with io.open(self.path, encoding='utf-8', errors="replace") as f:
-            metadata = f.read()
-        self._warn_on_replacement(metadata)
-        return metadata
-
-    def _warn_on_replacement(self, metadata):
-        # Python 2.6 and 3.2 compat for: replacement_char = '�'
-        replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
-        if replacement_char in metadata:
-            tmpl = "{self.path} could not be properly decoded in UTF-8"
-            msg = tmpl.format(**locals())
-            warnings.warn(msg)
-
-    def get_metadata_lines(self, name):
-        return yield_lines(self.get_metadata(name))
-
-
-class PathMetadata(DefaultProvider):
-    """Metadata provider for egg directories
-
-    Usage::
-
-        # Development eggs:
-
-        egg_info = "/path/to/PackageName.egg-info"
-        base_dir = os.path.dirname(egg_info)
-        metadata = PathMetadata(base_dir, egg_info)
-        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
-        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
-
-        # Unpacked egg directories:
-
-        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
-        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
-        dist = Distribution.from_filename(egg_path, metadata=metadata)
-    """
-
-    def __init__(self, path, egg_info):
-        self.module_path = path
-        self.egg_info = egg_info
-
-
-class EggMetadata(ZipProvider):
-    """Metadata provider for .egg files"""
-
-    def __init__(self, importer):
-        """Create a metadata provider from a zipimporter"""
-
-        self.zip_pre = importer.archive + os.sep
-        self.loader = importer
-        if importer.prefix:
-            self.module_path = os.path.join(importer.archive, importer.prefix)
-        else:
-            self.module_path = importer.archive
-        self._setup_prefix()
-
-
-_declare_state('dict', _distribution_finders={})
-
-
-def register_finder(importer_type, distribution_finder):
-    """Register `distribution_finder` to find distributions in sys.path items
-
-    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
-    handler), and `distribution_finder` is a callable that, passed a path
-    item and the importer instance, yields ``Distribution`` instances found on
-    that path item.  See ``pkg_resources.find_on_path`` for an example."""
-    _distribution_finders[importer_type] = distribution_finder
-
-
-def find_distributions(path_item, only=False):
-    """Yield distributions accessible via `path_item`"""
-    importer = get_importer(path_item)
-    finder = _find_adapter(_distribution_finders, importer)
-    return finder(importer, path_item, only)
-
-
-def find_eggs_in_zip(importer, path_item, only=False):
-    """
-    Find eggs in zip files; possibly multiple nested eggs.
-    """
-    if importer.archive.endswith('.whl'):
-        # wheels are not supported with this finder
-        # they don't have PKG-INFO metadata, and won't ever contain eggs
-        return
-    metadata = EggMetadata(importer)
-    if metadata.has_metadata('PKG-INFO'):
-        yield Distribution.from_filename(path_item, metadata=metadata)
-    if only:
-        # don't yield nested distros
-        return
-    for subitem in metadata.resource_listdir('/'):
-        if _is_unpacked_egg(subitem):
-            subpath = os.path.join(path_item, subitem)
-            for dist in find_eggs_in_zip(zipimport.zipimporter(subpath), subpath):
-                yield dist
-
-
-register_finder(zipimport.zipimporter, find_eggs_in_zip)
-
-
-def find_nothing(importer, path_item, only=False):
-    return ()
-
-
-register_finder(object, find_nothing)
-
-
-def _by_version_descending(names):
-    """
-    Given a list of filenames, return them in descending order
-    by version number.
-
-    >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
-    >>> _by_version_descending(names)
-    ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
-    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
-    >>> _by_version_descending(names)
-    ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
-    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
-    >>> _by_version_descending(names)
-    ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
-    """
-    def _by_version(name):
-        """
-        Parse each component of the filename
-        """
-        name, ext = os.path.splitext(name)
-        parts = itertools.chain(name.split('-'), [ext])
-        return [packaging.version.parse(part) for part in parts]
-
-    return sorted(names, key=_by_version, reverse=True)
-
-
-def find_on_path(importer, path_item, only=False):
-    """Yield distributions accessible on a sys.path directory"""
-    path_item = _normalize_cached(path_item)
-
-    if os.path.isdir(path_item) and os.access(path_item, os.R_OK):
-        if _is_unpacked_egg(path_item):
-            yield Distribution.from_filename(
-                path_item, metadata=PathMetadata(
-                    path_item, os.path.join(path_item, 'EGG-INFO')
-                )
-            )
-        else:
-            # scan for .egg and .egg-info in directory
-            path_item_entries = _by_version_descending(os.listdir(path_item))
-            for entry in path_item_entries:
-                lower = entry.lower()
-                if lower.endswith('.egg-info') or lower.endswith('.dist-info'):
-                    fullpath = os.path.join(path_item, entry)
-                    if os.path.isdir(fullpath):
-                        # egg-info directory, allow getting metadata
-                        if len(os.listdir(fullpath)) == 0:
-                            # Empty egg directory, skip.
-                            continue
-                        metadata = PathMetadata(path_item, fullpath)
-                    else:
-                        metadata = FileMetadata(fullpath)
-                    yield Distribution.from_location(
-                        path_item, entry, metadata, precedence=DEVELOP_DIST
-                    )
-                elif not only and _is_unpacked_egg(entry):
-                    dists = find_distributions(os.path.join(path_item, entry))
-                    for dist in dists:
-                        yield dist
-                elif not only and lower.endswith('.egg-link'):
-                    with open(os.path.join(path_item, entry)) as entry_file:
-                        entry_lines = entry_file.readlines()
-                    for line in entry_lines:
-                        if not line.strip():
-                            continue
-                        path = os.path.join(path_item, line.rstrip())
-                        dists = find_distributions(path)
-                        for item in dists:
-                            yield item
-                        break
-
-
-register_finder(pkgutil.ImpImporter, find_on_path)
-
-if hasattr(importlib_machinery, 'FileFinder'):
-    register_finder(importlib_machinery.FileFinder, find_on_path)
-
-_declare_state('dict', _namespace_handlers={})
-_declare_state('dict', _namespace_packages={})
-
-
-def register_namespace_handler(importer_type, namespace_handler):
-    """Register `namespace_handler` to declare namespace packages
-
-    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
-    handler), and `namespace_handler` is a callable like this::
-
-        def namespace_handler(importer, path_entry, moduleName, module):
-            # return a path_entry to use for child packages
-
-    Namespace handlers are only called if the importer object has already
-    agreed that it can handle the relevant path item, and they should only
-    return a subpath if the module __path__ does not already contain an
-    equivalent subpath.  For an example namespace handler, see
-    ``pkg_resources.file_ns_handler``.
-    """
-    _namespace_handlers[importer_type] = namespace_handler
-
-
-def _handle_ns(packageName, path_item):
-    """Ensure that named package includes a subpath of path_item (if needed)"""
-
-    importer = get_importer(path_item)
-    if importer is None:
-        return None
-    loader = importer.find_module(packageName)
-    if loader is None:
-        return None
-    module = sys.modules.get(packageName)
-    if module is None:
-        module = sys.modules[packageName] = types.ModuleType(packageName)
-        module.__path__ = []
-        _set_parent_ns(packageName)
-    elif not hasattr(module, '__path__'):
-        raise TypeError("Not a package:", packageName)
-    handler = _find_adapter(_namespace_handlers, importer)
-    subpath = handler(importer, path_item, packageName, module)
-    if subpath is not None:
-        path = module.__path__
-        path.append(subpath)
-        loader.load_module(packageName)
-        _rebuild_mod_path(path, packageName, module)
-    return subpath
-
-
-def _rebuild_mod_path(orig_path, package_name, module):
-    """
-    Rebuild module.__path__ ensuring that all entries are ordered
-    corresponding to their sys.path order
-    """
-    sys_path = [_normalize_cached(p) for p in sys.path]
-
-    def safe_sys_path_index(entry):
-        """
-        Workaround for #520 and #513.
-        """
-        try:
-            return sys_path.index(entry)
-        except ValueError:
-            return float('inf')
-
-    def position_in_sys_path(path):
-        """
-        Return the ordinal of the path based on its position in sys.path
-        """
-        path_parts = path.split(os.sep)
-        module_parts = package_name.count('.') + 1
-        parts = path_parts[:-module_parts]
-        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
-
-    if not isinstance(orig_path, list):
-        # Is this behavior useful when module.__path__ is not a list?
-        return
-
-    orig_path.sort(key=position_in_sys_path)
-    module.__path__[:] = [_normalize_cached(p) for p in orig_path]
-
-
-def declare_namespace(packageName):
-    """Declare that package 'packageName' is a namespace package"""
-
-    _imp.acquire_lock()
-    try:
-        if packageName in _namespace_packages:
-            return
-
-        path, parent = sys.path, None
-        if '.' in packageName:
-            parent = '.'.join(packageName.split('.')[:-1])
-            declare_namespace(parent)
-            if parent not in _namespace_packages:
-                __import__(parent)
-            try:
-                path = sys.modules[parent].__path__
-            except AttributeError:
-                raise TypeError("Not a package:", parent)
-
-        # Track what packages are namespaces, so when new path items are added,
-        # they can be updated
-        _namespace_packages.setdefault(parent, []).append(packageName)
-        _namespace_packages.setdefault(packageName, [])
-
-        for path_item in path:
-            # Ensure all the parent's path items are reflected in the child,
-            # if they apply
-            _handle_ns(packageName, path_item)
-
-    finally:
-        _imp.release_lock()
-
-
-def fixup_namespace_packages(path_item, parent=None):
-    """Ensure that previously-declared namespace packages include path_item"""
-    _imp.acquire_lock()
-    try:
-        for package in _namespace_packages.get(parent, ()):
-            subpath = _handle_ns(package, path_item)
-            if subpath:
-                fixup_namespace_packages(subpath, package)
-    finally:
-        _imp.release_lock()
-
-
-def file_ns_handler(importer, path_item, packageName, module):
-    """Compute an ns-package subpath for a filesystem or zipfile importer"""
-
-    subpath = os.path.join(path_item, packageName.split('.')[-1])
-    normalized = _normalize_cached(subpath)
-    for item in module.__path__:
-        if _normalize_cached(item) == normalized:
-            break
-    else:
-        # Only return the path if it's not already there
-        return subpath
-
-
-register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
-register_namespace_handler(zipimport.zipimporter, file_ns_handler)
-
-if hasattr(importlib_machinery, 'FileFinder'):
-    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
-
-
-def null_ns_handler(importer, path_item, packageName, module):
-    return None
-
-
-register_namespace_handler(object, null_ns_handler)
-
-
-def normalize_path(filename):
-    """Normalize a file/dir name for comparison purposes"""
-    return os.path.normcase(os.path.realpath(filename))
-
-
-def _normalize_cached(filename, _cache={}):
-    try:
-        return _cache[filename]
-    except KeyError:
-        _cache[filename] = result = normalize_path(filename)
-        return result
-
-
-def _is_unpacked_egg(path):
-    """
-    Determine if given path appears to be an unpacked egg.
-    """
-    return (
-        path.lower().endswith('.egg')
-    )
-
-
-def _set_parent_ns(packageName):
-    parts = packageName.split('.')
-    name = parts.pop()
-    if parts:
-        parent = '.'.join(parts)
-        setattr(sys.modules[parent], name, sys.modules[packageName])
-
-
-def yield_lines(strs):
-    """Yield non-empty/non-comment lines of a string or sequence"""
-    if isinstance(strs, six.string_types):
-        for s in strs.splitlines():
-            s = s.strip()
-            # skip blank lines/comments
-            if s and not s.startswith('#'):
-                yield s
-    else:
-        for ss in strs:
-            for s in yield_lines(ss):
-                yield s
-
-
-MODULE = re.compile(r"\w+(\.\w+)*$").match
-EGG_NAME = re.compile(
-    r"""
-    (?P<name>[^-]+) (
-        -(?P<ver>[^-]+) (
-            -py(?P<pyver>[^-]+) (
-                -(?P<plat>.+)
-            )?
-        )?
-    )?
-    """,
-    re.VERBOSE | re.IGNORECASE,
-).match
-
-
-class EntryPoint(object):
-    """Object representing an advertised importable object"""
-
-    def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
-        if not MODULE(module_name):
-            raise ValueError("Invalid module name", module_name)
-        self.name = name
-        self.module_name = module_name
-        self.attrs = tuple(attrs)
-        self.extras = Requirement.parse(("x[%s]" % ','.join(extras))).extras
-        self.dist = dist
-
-    def __str__(self):
-        s = "%s = %s" % (self.name, self.module_name)
-        if self.attrs:
-            s += ':' + '.'.join(self.attrs)
-        if self.extras:
-            s += ' [%s]' % ','.join(self.extras)
-        return s
-
-    def __repr__(self):
-        return "EntryPoint.parse(%r)" % str(self)
-
-    def load(self, require=True, *args, **kwargs):
-        """
-        Require packages for this EntryPoint, then resolve it.
-        """
-        if not require or args or kwargs:
-            warnings.warn(
-                "Parameters to load are deprecated.  Call .resolve and "
-                ".require separately.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        if require:
-            self.require(*args, **kwargs)
-        return self.resolve()
-
-    def resolve(self):
-        """
-        Resolve the entry point from its module and attrs.
-        """
-        module = __import__(self.module_name, fromlist=['__name__'], level=0)
-        try:
-            return functools.reduce(getattr, self.attrs, module)
-        except AttributeError as exc:
-            raise ImportError(str(exc))
-
-    def require(self, env=None, installer=None):
-        if self.extras and not self.dist:
-            raise UnknownExtra("Can't require() without a distribution", self)
-        reqs = self.dist.requires(self.extras)
-        items = working_set.resolve(reqs, env, installer)
-        list(map(working_set.add, items))
-
-    pattern = re.compile(
-        r'\s*'
-        r'(?P<name>.+?)\s*'
-        r'=\s*'
-        r'(?P<module>[\w.]+)\s*'
-        r'(:\s*(?P<attr>[\w.]+))?\s*'
-        r'(?P<extras>\[.*\])?\s*$'
-    )
-
-    @classmethod
-    def parse(cls, src, dist=None):
-        """Parse a single entry point from string `src`
-
-        Entry point syntax follows the form::
-
-            name = some.module:some.attr [extra1, extra2]
-
-        The entry name and module name are required, but the ``:attrs`` and
-        ``[extras]`` parts are optional
-        """
-        m = cls.pattern.match(src)
-        if not m:
-            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
-            raise ValueError(msg, src)
-        res = m.groupdict()
-        extras = cls._parse_extras(res['extras'])
-        attrs = res['attr'].split('.') if res['attr'] else ()
-        return cls(res['name'], res['module'], attrs, extras, dist)
-
-    @classmethod
-    def _parse_extras(cls, extras_spec):
-        if not extras_spec:
-            return ()
-        req = Requirement.parse('x' + extras_spec)
-        if req.specs:
-            raise ValueError()
-        return req.extras
-
-    @classmethod
-    def parse_group(cls, group, lines, dist=None):
-        """Parse an entry point group"""
-        if not MODULE(group):
-            raise ValueError("Invalid group name", group)
-        this = {}
-        for line in yield_lines(lines):
-            ep = cls.parse(line, dist)
-            if ep.name in this:
-                raise ValueError("Duplicate entry point", group, ep.name)
-            this[ep.name] = ep
-        return this
-
-    @classmethod
-    def parse_map(cls, data, dist=None):
-        """Parse a map of entry point groups"""
-        if isinstance(data, dict):
-            data = data.items()
-        else:
-            data = split_sections(data)
-        maps = {}
-        for group, lines in data:
-            if group is None:
-                if not lines:
-                    continue
-                raise ValueError("Entry points must be listed in groups")
-            group = group.strip()
-            if group in maps:
-                raise ValueError("Duplicate group name", group)
-            maps[group] = cls.parse_group(group, lines, dist)
-        return maps
-
-
-def _remove_md5_fragment(location):
-    if not location:
-        return ''
-    parsed = urllib.parse.urlparse(location)
-    if parsed[-1].startswith('md5='):
-        return urllib.parse.urlunparse(parsed[:-1] + ('',))
-    return location
-
-
-def _version_from_file(lines):
-    """
-    Given an iterable of lines from a Metadata file, return
-    the value of the Version field, if present, or None otherwise.
-    """
-    is_version_line = lambda line: line.lower().startswith('version:')
-    version_lines = filter(is_version_line, lines)
-    line = next(iter(version_lines), '')
-    _, _, value = line.partition(':')
-    return safe_version(value.strip()) or None
-
-
-class Distribution(object):
-    """Wrap an actual or potential sys.path entry w/metadata"""
-    PKG_INFO = 'PKG-INFO'
-
-    def __init__(self, location=None, metadata=None, project_name=None,
-            version=None, py_version=PY_MAJOR, platform=None,
-            precedence=EGG_DIST):
-        self.project_name = safe_name(project_name or 'Unknown')
-        if version is not None:
-            self._version = safe_version(version)
-        self.py_version = py_version
-        self.platform = platform
-        self.location = location
-        self.precedence = precedence
-        self._provider = metadata or empty_provider
-
-    @classmethod
-    def from_location(cls, location, basename, metadata=None, **kw):
-        project_name, version, py_version, platform = [None] * 4
-        basename, ext = os.path.splitext(basename)
-        if ext.lower() in _distributionImpl:
-            cls = _distributionImpl[ext.lower()]
-
-            match = EGG_NAME(basename)
-            if match:
-                project_name, version, py_version, platform = match.group(
-                    'name', 'ver', 'pyver', 'plat'
-                )
-        return cls(
-            location, metadata, project_name=project_name, version=version,
-            py_version=py_version, platform=platform, **kw
-        )._reload_version()
-
-    def _reload_version(self):
-        return self
-
-    @property
-    def hashcmp(self):
-        return (
-            self.parsed_version,
-            self.precedence,
-            self.key,
-            _remove_md5_fragment(self.location),
-            self.py_version or '',
-            self.platform or '',
-        )
-
-    def __hash__(self):
-        return hash(self.hashcmp)
-
-    def __lt__(self, other):
-        return self.hashcmp < other.hashcmp
-
-    def __le__(self, other):
-        return self.hashcmp <= other.hashcmp
-
-    def __gt__(self, other):
-        return self.hashcmp > other.hashcmp
-
-    def __ge__(self, other):
-        return self.hashcmp >= other.hashcmp
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__):
-            # It's not a Distribution, so they are not equal
-            return False
-        return self.hashcmp == other.hashcmp
-
-    def __ne__(self, other):
-        return not self == other
-
-    # These properties have to be lazy so that we don't have to load any
-    # metadata until/unless it's actually needed.  (i.e., some distributions
-    # may not know their name or version without loading PKG-INFO)
-
-    @property
-    def key(self):
-        try:
-            return self._key
-        except AttributeError:
-            self._key = key = self.project_name.lower()
-            return key
-
-    @property
-    def parsed_version(self):
-        if not hasattr(self, "_parsed_version"):
-            self._parsed_version = parse_version(self.version)
-
-        return self._parsed_version
-
-    def _warn_legacy_version(self):
-        LV = packaging.version.LegacyVersion
-        is_legacy = isinstance(self._parsed_version, LV)
-        if not is_legacy:
-            return
-
-        # While an empty version is technically a legacy version and
-        # is not a valid PEP 440 version, it's also unlikely to
-        # actually come from someone and instead it is more likely that
-        # it comes from setuptools attempting to parse a filename and
-        # including it in the list. So for that we'll gate this warning
-        # on if the version is anything at all or not.
-        if not self.version:
-            return
-
-        tmpl = textwrap.dedent("""
-            '{project_name} ({version})' is being parsed as a legacy,
-            non PEP 440,
-            version. You may find odd behavior and sort order.
-            In particular it will be sorted as less than 0.0. It
-            is recommended to migrate to PEP 440 compatible
-            versions.
-            """).strip().replace('\n', ' ')
-
-        warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
-
-    @property
-    def version(self):
-        try:
-            return self._version
-        except AttributeError:
-            version = _version_from_file(self._get_metadata(self.PKG_INFO))
-            if version is None:
-                tmpl = "Missing 'Version:' header and/or %s file"
-                raise ValueError(tmpl % self.PKG_INFO, self)
-            return version
-
-    @property
-    def _dep_map(self):
-        try:
-            return self.__dep_map
-        except AttributeError:
-            dm = self.__dep_map = {None: []}
-            for name in 'requires.txt', 'depends.txt':
-                for extra, reqs in split_sections(self._get_metadata(name)):
-                    if extra:
-                        if ':' in extra:
-                            extra, marker = extra.split(':', 1)
-                            if invalid_marker(marker):
-                                # XXX warn
-                                reqs = []
-                            elif not evaluate_marker(marker):
-                                reqs = []
-                        extra = safe_extra(extra) or None
-                    dm.setdefault(extra, []).extend(parse_requirements(reqs))
-            return dm
-
-    def requires(self, extras=()):
-        """List of Requirements needed for this distro if `extras` are used"""
-        dm = self._dep_map
-        deps = []
-        deps.extend(dm.get(None, ()))
-        for ext in extras:
-            try:
-                deps.extend(dm[safe_extra(ext)])
-            except KeyError:
-                raise UnknownExtra(
-                    "%s has no such extra feature %r" % (self, ext)
-                )
-        return deps
-
-    def _get_metadata(self, name):
-        if self.has_metadata(name):
-            for line in self.get_metadata_lines(name):
-                yield line
-
-    def activate(self, path=None, replace=False):
-        """Ensure distribution is importable on `path` (default=sys.path)"""
-        if path is None:
-            path = sys.path
-        self.insert_on(path, replace=replace)
-        if path is sys.path:
-            fixup_namespace_packages(self.location)
-            for pkg in self._get_metadata('namespace_packages.txt'):
-                if pkg in sys.modules:
-                    declare_namespace(pkg)
-
-    def egg_name(self):
-        """Return what this distribution's standard .egg filename should be"""
-        filename = "%s-%s-py%s" % (
-            to_filename(self.project_name), to_filename(self.version),
-            self.py_version or PY_MAJOR
-        )
-
-        if self.platform:
-            filename += '-' + self.platform
-        return filename
-
-    def __repr__(self):
-        if self.location:
-            return "%s (%s)" % (self, self.location)
-        else:
-            return str(self)
-
-    def __str__(self):
-        try:
-            version = getattr(self, 'version', None)
-        except ValueError:
-            version = None
-        version = version or "[unknown version]"
-        return "%s %s" % (self.project_name, version)
-
-    def __getattr__(self, attr):
-        """Delegate all unrecognized public attributes to .metadata provider"""
-        if attr.startswith('_'):
-            raise AttributeError(attr)
-        return getattr(self._provider, attr)
-
-    @classmethod
-    def from_filename(cls, filename, metadata=None, **kw):
-        return cls.from_location(
-            _normalize_cached(filename), os.path.basename(filename), metadata,
-            **kw
-        )
-
-    def as_requirement(self):
-        """Return a ``Requirement`` that matches this distribution exactly"""
-        if isinstance(self.parsed_version, packaging.version.Version):
-            spec = "%s==%s" % (self.project_name, self.parsed_version)
-        else:
-            spec = "%s===%s" % (self.project_name, self.parsed_version)
-
-        return Requirement.parse(spec)
-
-    def load_entry_point(self, group, name):
-        """Return the `name` entry point of `group` or raise ImportError"""
-        ep = self.get_entry_info(group, name)
-        if ep is None:
-            raise ImportError("Entry point %r not found" % ((group, name),))
-        return ep.load()
-
-    def get_entry_map(self, group=None):
-        """Return the entry point map for `group`, or the full entry map"""
-        try:
-            ep_map = self._ep_map
-        except AttributeError:
-            ep_map = self._ep_map = EntryPoint.parse_map(
-                self._get_metadata('entry_points.txt'), self
-            )
-        if group is not None:
-            return ep_map.get(group, {})
-        return ep_map
-
-    def get_entry_info(self, group, name):
-        """Return the EntryPoint object for `group`+`name`, or ``None``"""
-        return self.get_entry_map(group).get(name)
-
-    def insert_on(self, path, loc=None, replace=False):
-        """Ensure self.location is on path
-
-        If replace=False (default):
-            - If location is already in path anywhere, do nothing.
-            - Else:
-              - If it's an egg and its parent directory is on path,
-                insert just ahead of the parent.
-              - Else: add to the end of path.
-        If replace=True:
-            - If location is already on path anywhere (not eggs)
-              or higher priority than its parent (eggs)
-              do nothing.
-            - Else:
-              - If it's an egg and its parent directory is on path,
-                insert just ahead of the parent,
-                removing any lower-priority entries.
-              - Else: add it to the front of path.
-        """
-
-        loc = loc or self.location
-        if not loc:
-            return
-
-        nloc = _normalize_cached(loc)
-        bdir = os.path.dirname(nloc)
-        npath = [(p and _normalize_cached(p) or p) for p in path]
-
-        for p, item in enumerate(npath):
-            if item == nloc:
-                if replace:
-                    break
-                else:
-                    # don't modify path (even removing duplicates) if found and not replace
-                    return
-            elif item == bdir and self.precedence == EGG_DIST:
-                # if it's an .egg, give it precedence over its directory
-                # UNLESS it's already been added to sys.path and replace=False
-                if (not replace) and nloc in npath[p:]:
-                    return
-                if path is sys.path:
-                    self.check_version_conflict()
-                path.insert(p, loc)
-                npath.insert(p, nloc)
-                break
-        else:
-            if path is sys.path:
-                self.check_version_conflict()
-            if replace:
-                path.insert(0, loc)
-            else:
-                path.append(loc)
-            return
-
-        # p is the spot where we found or inserted loc; now remove duplicates
-        while True:
-            try:
-                np = npath.index(nloc, p + 1)
-            except ValueError:
-                break
-            else:
-                del npath[np], path[np]
-                # ha!
-                p = np
-
-        return
-
-    def check_version_conflict(self):
-        if self.key == 'setuptools':
-            # ignore the inevitable setuptools self-conflicts  :(
-            return
-
-        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
-        loc = normalize_path(self.location)
-        for modname in self._get_metadata('top_level.txt'):
-            if (modname not in sys.modules or modname in nsp
-                    or modname in _namespace_packages):
-                continue
-            if modname in ('pkg_resources', 'setuptools', 'site'):
-                continue
-            fn = getattr(sys.modules[modname], '__file__', None)
-            if fn and (normalize_path(fn).startswith(loc) or
-                       fn.startswith(self.location)):
-                continue
-            issue_warning(
-                "Module %s was already imported from %s, but %s is being added"
-                " to sys.path" % (modname, fn, self.location),
-            )
-
-    def has_version(self):
-        try:
-            self.version
-        except ValueError:
-            issue_warning("Unbuilt egg for " + repr(self))
-            return False
-        return True
-
-    def clone(self, **kw):
-        """Copy this distribution, substituting in any changed keyword args"""
-        names = 'project_name version py_version platform location precedence'
-        for attr in names.split():
-            kw.setdefault(attr, getattr(self, attr, None))
-        kw.setdefault('metadata', self._provider)
-        return self.__class__(**kw)
-
-    @property
-    def extras(self):
-        return [dep for dep in self._dep_map if dep]
-
-
-class EggInfoDistribution(Distribution):
-    def _reload_version(self):
-        """
-        Packages installed by distutils (e.g. numpy or scipy),
-        which uses an old safe_version, and so
-        their version numbers can get mangled when
-        converted to filenames (e.g., 1.11.0.dev0+2329eae to
-        1.11.0.dev0_2329eae). These distributions will not be
-        parsed properly
-        downstream by Distribution and safe_version, so
-        take an extra step and try to get the version number from
-        the metadata file itself instead of the filename.
-        """
-        md_version = _version_from_file(self._get_metadata(self.PKG_INFO))
-        if md_version:
-            self._version = md_version
-        return self
-
-
-class DistInfoDistribution(Distribution):
-    """Wrap an actual or potential sys.path entry w/metadata, .dist-info style"""
-    PKG_INFO = 'METADATA'
-    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
-
-    @property
-    def _parsed_pkg_info(self):
-        """Parse and cache metadata"""
-        try:
-            return self._pkg_info
-        except AttributeError:
-            metadata = self.get_metadata(self.PKG_INFO)
-            self._pkg_info = email.parser.Parser().parsestr(metadata)
-            return self._pkg_info
-
-    @property
-    def _dep_map(self):
-        try:
-            return self.__dep_map
-        except AttributeError:
-            self.__dep_map = self._compute_dependencies()
-            return self.__dep_map
-
-    def _compute_dependencies(self):
-        """Recompute this distribution's dependencies."""
-        dm = self.__dep_map = {None: []}
-
-        reqs = []
-        # Including any condition expressions
-        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
-            reqs.extend(parse_requirements(req))
-
-        def reqs_for_extra(extra):
-            for req in reqs:
-                if not req.marker or req.marker.evaluate({'extra': extra}):
-                    yield req
-
-        common = frozenset(reqs_for_extra(None))
-        dm[None].extend(common)
-
-        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
-            s_extra = safe_extra(extra.strip())
-            dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
-
-        return dm
-
-
-_distributionImpl = {
-    '.egg': Distribution,
-    '.egg-info': EggInfoDistribution,
-    '.dist-info': DistInfoDistribution,
-    }
-
-
-def issue_warning(*args, **kw):
-    level = 1
-    g = globals()
-    try:
-        # find the first stack frame that is *not* code in
-        # the pkg_resources module, to use for the warning
-        while sys._getframe(level).f_globals is g:
-            level += 1
-    except ValueError:
-        pass
-    warnings.warn(stacklevel=level + 1, *args, **kw)
-
-
-class RequirementParseError(ValueError):
-    def __str__(self):
-        return ' '.join(self.args)
-
-
-def parse_requirements(strs):
-    """Yield ``Requirement`` objects for each specification in `strs`
-
-    `strs` must be a string, or a (possibly-nested) iterable thereof.
-    """
-    # create a steppable iterator, so we can handle \-continuations
-    lines = iter(yield_lines(strs))
-
-    for line in lines:
-        # Drop comments -- a hash without a space may be in a URL.
-        if ' #' in line:
-            line = line[:line.find(' #')]
-        # If there is a line continuation, drop it, and append the next line.
-        if line.endswith('\\'):
-            line = line[:-2].strip()
-            line += next(lines)
-        yield Requirement(line)
-
-
-class Requirement(packaging.requirements.Requirement):
-    def __init__(self, requirement_string):
-        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
-        try:
-            super(Requirement, self).__init__(requirement_string)
-        except packaging.requirements.InvalidRequirement as e:
-            raise RequirementParseError(str(e))
-        self.unsafe_name = self.name
-        project_name = safe_name(self.name)
-        self.project_name, self.key = project_name, project_name.lower()
-        self.specs = [
-            (spec.operator, spec.version) for spec in self.specifier]
-        self.extras = tuple(map(safe_extra, self.extras))
-        self.hashCmp = (
-            self.key,
-            self.specifier,
-            frozenset(self.extras),
-            str(self.marker) if self.marker else None,
-        )
-        self.__hash = hash(self.hashCmp)
-
-    def __eq__(self, other):
-        return (
-            isinstance(other, Requirement) and
-            self.hashCmp == other.hashCmp
-        )
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __contains__(self, item):
-        if isinstance(item, Distribution):
-            if item.key != self.key:
-                return False
-
-            item = item.version
-
-        # Allow prereleases always in order to match the previous behavior of
-        # this method. In the future this should be smarter and follow PEP 440
-        # more accurately.
-        return self.specifier.contains(item, prereleases=True)
-
-    def __hash__(self):
-        return self.__hash
-
-    def __repr__(self): return "Requirement.parse(%r)" % str(self)
-
-    @staticmethod
-    def parse(s):
-        req, = parse_requirements(s)
-        return req
-
-
-def _get_mro(cls):
-    """Get an mro for a type or classic class"""
-    if not isinstance(cls, type):
-
-        class cls(cls, object):
-            pass
-
-        return cls.__mro__[1:]
-    return cls.__mro__
-
-
-def _find_adapter(registry, ob):
-    """Return an adapter factory for `ob` from `registry`"""
-    for t in _get_mro(getattr(ob, '__class__', type(ob))):
-        if t in registry:
-            return registry[t]
-
-
-def ensure_directory(path):
-    """Ensure that the parent directory of `path` exists"""
-    dirname = os.path.dirname(path)
-    if not os.path.isdir(dirname):
-        os.makedirs(dirname)
-
-
-def _bypass_ensure_directory(path):
-    """Sandbox-bypassing version of ensure_directory()"""
-    if not WRITE_SUPPORT:
-        raise IOError('"os.mkdir" not supported on this platform.')
-    dirname, filename = split(path)
-    if dirname and filename and not isdir(dirname):
-        _bypass_ensure_directory(dirname)
-        mkdir(dirname, 0o755)
-
-
-def split_sections(s):
-    """Split a string or iterable thereof into (section, content) pairs
-
-    Each ``section`` is a stripped version of the section header ("[section]")
-    and each ``content`` is a list of stripped lines excluding blank lines and
-    comment-only lines.  If there are any such lines before the first section
-    header, they're returned in a first ``section`` of ``None``.
-    """
-    section = None
-    content = []
-    for line in yield_lines(s):
-        if line.startswith("["):
-            if line.endswith("]"):
-                if section or content:
-                    yield section, content
-                section = line[1:-1].strip()
-                content = []
-            else:
-                raise ValueError("Invalid section heading", line)
-        else:
-            content.append(line)
-
-    # wrap up last segment
-    yield section, content
-
-
-def _mkstemp(*args, **kw):
-    old_open = os.open
-    try:
-        # temporarily bypass sandboxing
-        os.open = os_open
-        return tempfile.mkstemp(*args, **kw)
-    finally:
-        # and then put it back
-        os.open = old_open
-
-
-# Silence the PEP440Warning by default, so that end users don't get hit by it
-# randomly just because they use pkg_resources. We want to append the rule
-# because we want earlier uses of filterwarnings to take precedence over this
-# one.
-warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
-
-
-# from jaraco.functools 1.3
-def _call_aside(f, *args, **kwargs):
-    f(*args, **kwargs)
-    return f
-
-
-@_call_aside
-def _initialize(g=globals()):
-    "Set up global resource manager (deliberately not state-saved)"
-    manager = ResourceManager()
-    g['_manager'] = manager
-    g.update(
-        (name, getattr(manager, name))
-        for name in dir(manager)
-        if not name.startswith('_')
-    )
-
-
-@_call_aside
-def _initialize_master_working_set():
-    """
-    Prepare the master working set and make the ``require()``
-    API available.
-
-    This function has explicit effects on the global state
-    of pkg_resources. It is intended to be invoked once at
-    the initialization of this module.
-
-    Invocation by other packages is unsupported and done
-    at their own risk.
-    """
-    working_set = WorkingSet._build_master()
-    _declare_state('object', working_set=working_set)
-
-    require = working_set.require
-    iter_entry_points = working_set.iter_entry_points
-    add_activation_listener = working_set.subscribe
-    run_script = working_set.run_script
-    # backward compatibility
-    run_main = run_script
-    # Activate all distributions already on sys.path with replace=False and
-    # ensure that all distributions added to the working set in the future
-    # (e.g. by calling ``require()``) will get activated as well,
-    # with higher priority (replace=True).
-    tuple(
-        dist.activate(replace=False)
-        for dist in working_set
-    )
-    add_activation_listener(lambda dist: dist.activate(replace=True), existing=False)
-    working_set.entries = []
-    # match order
-    list(map(working_set.add_entry, sys.path))
-    globals().update(locals())
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a2eb59150..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 006436d60..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/appdirs.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/appdirs.cpython-35.pyc
deleted file mode 100644
index 2f8556706..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/appdirs.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/pyparsing.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/pyparsing.cpython-35.pyc
deleted file mode 100644
index d48653383..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/pyparsing.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/six.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/six.cpython-35.pyc
deleted file mode 100644
index b06f7c661..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/__pycache__/six.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/appdirs.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/appdirs.py
deleted file mode 100644
index f4dba0953..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/appdirs.py
+++ /dev/null
@@ -1,552 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2005-2010 ActiveState Software Inc.
-# Copyright (c) 2013 Eddy Petrișor
-
-"""Utilities for determining application-specific dirs.
-
-See <http://github.com/ActiveState/appdirs> for details and usage.
-"""
-# Dev Notes:
-# - MSDN on where to store app data files:
-#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
-# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
-# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-
-__version_info__ = (1, 4, 0)
-__version__ = '.'.join(map(str, __version_info__))
-
-
-import sys
-import os
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    unicode = str
-
-if sys.platform.startswith('java'):
-    import platform
-    os_name = platform.java_ver()[3][0]
-    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
-        system = 'win32'
-    elif os_name.startswith('Mac'): # "Mac OS X", etc.
-        system = 'darwin'
-    else: # "Linux", "SunOS", "FreeBSD", etc.
-        # Setting this to "linux2" is not ideal, but only Windows or Mac
-        # are actually checked for and the rest of the module expects
-        # *sys.platform* style strings.
-        system = 'linux2'
-else:
-    system = sys.platform
-
-
-
-def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        Mac OS X:               ~/Library/Application Support/<AppName>
-        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
-        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
-        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
-        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
-        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
-
-    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
-    That means, by default "~/.local/share/<AppName>".
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
-        path = os.path.normpath(_get_win_folder(const))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Application Support/')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
-    """Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of data dirs should be
-            returned. By default, the first item from XDG_DATA_DIRS is
-            returned, or '/usr/local/share/<AppName>',
-            if XDG_DATA_DIRS is not set
-
-    Typical user data directories are:
-        Mac OS X:   /Library/Application Support/<AppName>
-        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
-        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
-
-    For Unix, this is using the $XDG_DATA_DIRS[0] default.
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('/Library/Application Support')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        # XDG default for $XDG_DATA_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_DATA_DIRS',
-                         os.pathsep.join(['/usr/local/share', '/usr/share']))
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-        return path
-
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific config dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        Mac OS X:               same as user_data_dir
-        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
-        Win *:                  same as user_data_dir
-
-    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by deafult "~/.config/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
-    """Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of config dirs should be
-            returned. By default, the first item from XDG_CONFIG_DIRS is
-            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
-
-    Typical user data directories are:
-        Mac OS X:   same as site_data_dir
-        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
-                    $XDG_CONFIG_DIRS
-        Win *:      same as site_data_dir
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-
-    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system in ["win32", "darwin"]:
-        path = site_data_dir(appname, appauthor)
-        if appname and version:
-            path = os.path.join(path, version)
-    else:
-        # XDG default for $XDG_CONFIG_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-    return path
-
-
-def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific cache dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Cache" to the base app data dir for Windows. See
-            discussion below.
-
-    Typical user cache directories are:
-        Mac OS X:   ~/Library/Caches/<AppName>
-        Unix:       ~/.cache/<AppName> (XDG default)
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
-
-    On Windows the only suggestion in the MSDN docs is that local settings go in
-    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
-    app data dir (the default returned by `user_data_dir` above). Apps typically
-    put cache data somewhere *under* the given dir here. Some examples:
-        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
-        ...\Acme\SuperApp\Cache\1.0
-    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-            if opinion:
-                path = os.path.join(path, "Cache")
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Caches')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific log dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Logs" to the base app data dir for Windows, and "log" to the
-            base cache dir for Unix. See discussion below.
-
-    Typical user cache directories are:
-        Mac OS X:   ~/Library/Logs/<AppName>
-        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
-
-    On Windows the only suggestion in the MSDN docs is that local settings
-    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
-    examples of what some windows apps use for a logs dir.)
-
-    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
-    value for Windows and appends "log" to the user cache dir for Unix.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "darwin":
-        path = os.path.join(
-            os.path.expanduser('~/Library/Logs'),
-            appname)
-    elif system == "win32":
-        path = user_data_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "Logs")
-    else:
-        path = user_cache_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "log")
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-class AppDirs(object):
-    """Convenience wrapper for getting application dirs."""
-    def __init__(self, appname, appauthor=None, version=None, roaming=False,
-                 multipath=False):
-        self.appname = appname
-        self.appauthor = appauthor
-        self.version = version
-        self.roaming = roaming
-        self.multipath = multipath
-
-    @property
-    def user_data_dir(self):
-        return user_data_dir(self.appname, self.appauthor,
-                             version=self.version, roaming=self.roaming)
-
-    @property
-    def site_data_dir(self):
-        return site_data_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_config_dir(self):
-        return user_config_dir(self.appname, self.appauthor,
-                               version=self.version, roaming=self.roaming)
-
-    @property
-    def site_config_dir(self):
-        return site_config_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_cache_dir(self):
-        return user_cache_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_log_dir(self):
-        return user_log_dir(self.appname, self.appauthor,
-                            version=self.version)
-
-
-#---- internal support stuff
-
-def _get_win_folder_from_registry(csidl_name):
-    """This is a fallback technique at best. I'm not sure if using the
-    registry for this guarantees us the correct answer for all CSIDL_*
-    names.
-    """
-    import _winreg
-
-    shell_folder_name = {
-        "CSIDL_APPDATA": "AppData",
-        "CSIDL_COMMON_APPDATA": "Common AppData",
-        "CSIDL_LOCAL_APPDATA": "Local AppData",
-    }[csidl_name]
-
-    key = _winreg.OpenKey(
-        _winreg.HKEY_CURRENT_USER,
-        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-    )
-    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
-    return dir
-
-
-def _get_win_folder_with_pywin32(csidl_name):
-    from win32com.shell import shellcon, shell
-    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
-    # Try to make this a unicode path because SHGetFolderPath does
-    # not return unicode strings when there is unicode data in the
-    # path.
-    try:
-        dir = unicode(dir)
-
-        # Downgrade to short path name if have highbit chars. See
-        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-        has_high_char = False
-        for c in dir:
-            if ord(c) > 255:
-                has_high_char = True
-                break
-        if has_high_char:
-            try:
-                import win32api
-                dir = win32api.GetShortPathName(dir)
-            except ImportError:
-                pass
-    except UnicodeError:
-        pass
-    return dir
-
-
-def _get_win_folder_with_ctypes(csidl_name):
-    import ctypes
-
-    csidl_const = {
-        "CSIDL_APPDATA": 26,
-        "CSIDL_COMMON_APPDATA": 35,
-        "CSIDL_LOCAL_APPDATA": 28,
-    }[csidl_name]
-
-    buf = ctypes.create_unicode_buffer(1024)
-    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in buf:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf2 = ctypes.create_unicode_buffer(1024)
-        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
-            buf = buf2
-
-    return buf.value
-
-def _get_win_folder_with_jna(csidl_name):
-    import array
-    from com.sun import jna
-    from com.sun.jna.platform import win32
-
-    buf_size = win32.WinDef.MAX_PATH * 2
-    buf = array.zeros('c', buf_size)
-    shell = win32.Shell32.INSTANCE
-    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
-    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in dir:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf = array.zeros('c', buf_size)
-        kernel = win32.Kernel32.INSTANCE
-        if kernal.GetShortPathName(dir, buf, buf_size):
-            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    return dir
-
-if system == "win32":
-    try:
-        import win32com.shell
-        _get_win_folder = _get_win_folder_with_pywin32
-    except ImportError:
-        try:
-            from ctypes import windll
-            _get_win_folder = _get_win_folder_with_ctypes
-        except ImportError:
-            try:
-                import com.sun.jna
-                _get_win_folder = _get_win_folder_with_jna
-            except ImportError:
-                _get_win_folder = _get_win_folder_from_registry
-
-
-#---- self test code
-
-if __name__ == "__main__":
-    appname = "MyApp"
-    appauthor = "MyCompany"
-
-    props = ("user_data_dir", "site_data_dir",
-             "user_config_dir", "site_config_dir",
-             "user_cache_dir", "user_log_dir")
-
-    print("-- app dirs (with optional 'version')")
-    dirs = AppDirs(appname, appauthor, version="1.0")
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'version')")
-    dirs = AppDirs(appname, appauthor)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'appauthor')")
-    dirs = AppDirs(appname)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (with disabled 'appauthor')")
-    dirs = AppDirs(appname, appauthor=False)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__about__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__about__.py
deleted file mode 100644
index 95d330ef8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__about__.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-__all__ = [
-    "__title__", "__summary__", "__uri__", "__version__", "__author__",
-    "__email__", "__license__", "__copyright__",
-]
-
-__title__ = "packaging"
-__summary__ = "Core utilities for Python packages"
-__uri__ = "https://github.com/pypa/packaging"
-
-__version__ = "16.8"
-
-__author__ = "Donald Stufft and individual contributors"
-__email__ = "donald@stufft.io"
-
-__license__ = "BSD or Apache License, Version 2.0"
-__copyright__ = "Copyright 2014-2016 %s" % __author__
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__init__.py
deleted file mode 100644
index 5ee622020..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-from .__about__ import (
-    __author__, __copyright__, __email__, __license__, __summary__, __title__,
-    __uri__, __version__
-)
-
-__all__ = [
-    "__title__", "__summary__", "__uri__", "__version__", "__author__",
-    "__email__", "__license__", "__copyright__",
-]
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__about__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__about__.cpython-35.pyc
deleted file mode 100644
index 7a40a7a96..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__about__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 4d8911a19..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index fcc0751ac..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_structures.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_structures.cpython-35.pyc
deleted file mode 100644
index 4a2380ecc..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/_structures.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/markers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/markers.cpython-35.pyc
deleted file mode 100644
index a1dfed5c7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/markers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/requirements.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/requirements.cpython-35.pyc
deleted file mode 100644
index 07341bad7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/requirements.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/specifiers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/specifiers.cpython-35.pyc
deleted file mode 100644
index 82c9267a5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/specifiers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/utils.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/utils.cpython-35.pyc
deleted file mode 100644
index ec61045ce..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/utils.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/version.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/version.cpython-35.pyc
deleted file mode 100644
index 0573098a6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/__pycache__/version.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_compat.py
deleted file mode 100644
index 210bb80b7..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_compat.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import sys
-
-
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-
-# flake8: noqa
-
-if PY3:
-    string_types = str,
-else:
-    string_types = basestring,
-
-
-def with_metaclass(meta, *bases):
-    """
-    Create a base class with a metaclass.
-    """
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_structures.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_structures.py
deleted file mode 100644
index ccc27861c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/_structures.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-
-class Infinity(object):
-
-    def __repr__(self):
-        return "Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return False
-
-    def __le__(self, other):
-        return False
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return True
-
-    def __ge__(self, other):
-        return True
-
-    def __neg__(self):
-        return NegativeInfinity
-
-Infinity = Infinity()
-
-
-class NegativeInfinity(object):
-
-    def __repr__(self):
-        return "-Infinity"
-
-    def __hash__(self):
-        return hash(repr(self))
-
-    def __lt__(self, other):
-        return True
-
-    def __le__(self, other):
-        return True
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
-        return False
-
-    def __ge__(self, other):
-        return False
-
-    def __neg__(self):
-        return Infinity
-
-NegativeInfinity = NegativeInfinity()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/markers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/markers.py
deleted file mode 100644
index 892e578ed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/markers.py
+++ /dev/null
@@ -1,301 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import operator
-import os
-import platform
-import sys
-
-from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
-from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
-from pkg_resources.extern.pyparsing import Literal as L  # noqa
-
-from ._compat import string_types
-from .specifiers import Specifier, InvalidSpecifier
-
-
-__all__ = [
-    "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName",
-    "Marker", "default_environment",
-]
-
-
-class InvalidMarker(ValueError):
-    """
-    An invalid marker was found, users should refer to PEP 508.
-    """
-
-
-class UndefinedComparison(ValueError):
-    """
-    An invalid operation was attempted on a value that doesn't support it.
-    """
-
-
-class UndefinedEnvironmentName(ValueError):
-    """
-    A name was attempted to be used that does not exist inside of the
-    environment.
-    """
-
-
-class Node(object):
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return str(self.value)
-
-    def __repr__(self):
-        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
-
-    def serialize(self):
-        raise NotImplementedError
-
-
-class Variable(Node):
-
-    def serialize(self):
-        return str(self)
-
-
-class Value(Node):
-
-    def serialize(self):
-        return '"{0}"'.format(self)
-
-
-class Op(Node):
-
-    def serialize(self):
-        return str(self)
-
-
-VARIABLE = (
-    L("implementation_version") |
-    L("platform_python_implementation") |
-    L("implementation_name") |
-    L("python_full_version") |
-    L("platform_release") |
-    L("platform_version") |
-    L("platform_machine") |
-    L("platform_system") |
-    L("python_version") |
-    L("sys_platform") |
-    L("os_name") |
-    L("os.name") |  # PEP-345
-    L("sys.platform") |  # PEP-345
-    L("platform.version") |  # PEP-345
-    L("platform.machine") |  # PEP-345
-    L("platform.python_implementation") |  # PEP-345
-    L("python_implementation") |  # undocumented setuptools legacy
-    L("extra")
-)
-ALIASES = {
-    'os.name': 'os_name',
-    'sys.platform': 'sys_platform',
-    'platform.version': 'platform_version',
-    'platform.machine': 'platform_machine',
-    'platform.python_implementation': 'platform_python_implementation',
-    'python_implementation': 'platform_python_implementation'
-}
-VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
-
-VERSION_CMP = (
-    L("===") |
-    L("==") |
-    L(">=") |
-    L("<=") |
-    L("!=") |
-    L("~=") |
-    L(">") |
-    L("<")
-)
-
-MARKER_OP = VERSION_CMP | L("not in") | L("in")
-MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
-
-MARKER_VALUE = QuotedString("'") | QuotedString('"')
-MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
-
-BOOLOP = L("and") | L("or")
-
-MARKER_VAR = VARIABLE | MARKER_VALUE
-
-MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
-MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
-
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-
-MARKER_EXPR = Forward()
-MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
-MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
-
-MARKER = stringStart + MARKER_EXPR + stringEnd
-
-
-def _coerce_parse_result(results):
-    if isinstance(results, ParseResults):
-        return [_coerce_parse_result(i) for i in results]
-    else:
-        return results
-
-
-def _format_marker(marker, first=True):
-    assert isinstance(marker, (list, tuple, string_types))
-
-    # Sometimes we have a structure like [[...]] which is a single item list
-    # where the single item is itself it's own list. In that case we want skip
-    # the rest of this function so that we don't get extraneous () on the
-    # outside.
-    if (isinstance(marker, list) and len(marker) == 1 and
-            isinstance(marker[0], (list, tuple))):
-        return _format_marker(marker[0])
-
-    if isinstance(marker, list):
-        inner = (_format_marker(m, first=False) for m in marker)
-        if first:
-            return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
-        return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
-
-
-_operators = {
-    "in": lambda lhs, rhs: lhs in rhs,
-    "not in": lambda lhs, rhs: lhs not in rhs,
-    "<": operator.lt,
-    "<=": operator.le,
-    "==": operator.eq,
-    "!=": operator.ne,
-    ">=": operator.ge,
-    ">": operator.gt,
-}
-
-
-def _eval_op(lhs, op, rhs):
-    try:
-        spec = Specifier("".join([op.serialize(), rhs]))
-    except InvalidSpecifier:
-        pass
-    else:
-        return spec.contains(lhs)
-
-    oper = _operators.get(op.serialize())
-    if oper is None:
-        raise UndefinedComparison(
-            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
-        )
-
-    return oper(lhs, rhs)
-
-
-_undefined = object()
-
-
-def _get_env(environment, name):
-    value = environment.get(name, _undefined)
-
-    if value is _undefined:
-        raise UndefinedEnvironmentName(
-            "{0!r} does not exist in evaluation environment.".format(name)
-        )
-
-    return value
-
-
-def _evaluate_markers(markers, environment):
-    groups = [[]]
-
-    for marker in markers:
-        assert isinstance(marker, (list, tuple, string_types))
-
-        if isinstance(marker, list):
-            groups[-1].append(_evaluate_markers(marker, environment))
-        elif isinstance(marker, tuple):
-            lhs, op, rhs = marker
-
-            if isinstance(lhs, Variable):
-                lhs_value = _get_env(environment, lhs.value)
-                rhs_value = rhs.value
-            else:
-                lhs_value = lhs.value
-                rhs_value = _get_env(environment, rhs.value)
-
-            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-        else:
-            assert marker in ["and", "or"]
-            if marker == "or":
-                groups.append([])
-
-    return any(all(item) for item in groups)
-
-
-def format_full_version(info):
-    version = '{0.major}.{0.minor}.{0.micro}'.format(info)
-    kind = info.releaselevel
-    if kind != 'final':
-        version += kind[0] + str(info.serial)
-    return version
-
-
-def default_environment():
-    if hasattr(sys, 'implementation'):
-        iver = format_full_version(sys.implementation.version)
-        implementation_name = sys.implementation.name
-    else:
-        iver = '0'
-        implementation_name = ''
-
-    return {
-        "implementation_name": implementation_name,
-        "implementation_version": iver,
-        "os_name": os.name,
-        "platform_machine": platform.machine(),
-        "platform_release": platform.release(),
-        "platform_system": platform.system(),
-        "platform_version": platform.version(),
-        "python_full_version": platform.python_version(),
-        "platform_python_implementation": platform.python_implementation(),
-        "python_version": platform.python_version()[:3],
-        "sys_platform": sys.platform,
-    }
-
-
-class Marker(object):
-
-    def __init__(self, marker):
-        try:
-            self._markers = _coerce_parse_result(MARKER.parseString(marker))
-        except ParseException as e:
-            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
-                marker, marker[e.loc:e.loc + 8])
-            raise InvalidMarker(err_str)
-
-    def __str__(self):
-        return _format_marker(self._markers)
-
-    def __repr__(self):
-        return "<Marker({0!r})>".format(str(self))
-
-    def evaluate(self, environment=None):
-        """Evaluate a marker.
-
-        Return the boolean from evaluating the given marker against the
-        environment. environment is an optional argument to override all or
-        part of the determined environment.
-
-        The environment is determined from the current Python process.
-        """
-        current_environment = default_environment()
-        if environment is not None:
-            current_environment.update(environment)
-
-        return _evaluate_markers(self._markers, current_environment)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/requirements.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/requirements.py
deleted file mode 100644
index 0c8c4a385..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/requirements.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import string
-import re
-
-from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
-from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
-from pkg_resources.extern.pyparsing import Literal as L  # noqa
-from pkg_resources.extern.six.moves.urllib import parse as urlparse
-
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
-URI = Regex(r'[^ ]+')("url")
-URL = (AT + URI)
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
-VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE),
-                       joinString=",", adjacent=False)("_raw_spec")
-_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
-_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '')
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
-    lambda s, l, t: Marker(s[t._original_start:t._original_end])
-)
-MARKER_SEPERATOR = SEMICOLON
-MARKER = MARKER_SEPERATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
-NAMED_REQUIREMENT = \
-    NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
-
-
-class Requirement(object):
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
-    def __init__(self, requirement_string):
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
-            raise InvalidRequirement(
-                "Invalid requirement, parse error at \"{0!r}\"".format(
-                    requirement_string[e.loc:e.loc + 8]))
-
-        self.name = req.name
-        if req.url:
-            parsed_url = urlparse.urlparse(req.url)
-            if not (parsed_url.scheme and parsed_url.netloc) or (
-                    not parsed_url.scheme and not parsed_url.netloc):
-                raise InvalidRequirement("Invalid URL given")
-            self.url = req.url
-        else:
-            self.url = None
-        self.extras = set(req.extras.asList() if req.extras else [])
-        self.specifier = SpecifierSet(req.specifier)
-        self.marker = req.marker if req.marker else None
-
-    def __str__(self):
-        parts = [self.name]
-
-        if self.extras:
-            parts.append("[{0}]".format(",".join(sorted(self.extras))))
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
-            parts.append("@ {0}".format(self.url))
-
-        if self.marker:
-            parts.append("; {0}".format(self.marker))
-
-        return "".join(parts)
-
-    def __repr__(self):
-        return "<Requirement({0!r})>".format(str(self))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/specifiers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/specifiers.py
deleted file mode 100644
index 7f5a76cfd..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/specifiers.py
+++ /dev/null
@@ -1,774 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import abc
-import functools
-import itertools
-import re
-
-from ._compat import string_types, with_metaclass
-from .version import Version, LegacyVersion, parse
-
-
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
-class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
-
-    @abc.abstractmethod
-    def __str__(self):
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
-    def __hash__(self):
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
-    def __eq__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractmethod
-    def __ne__(self, other):
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are not equal.
-        """
-
-    @abc.abstractproperty
-    def prereleases(self):
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
-    def prereleases(self, value):
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
-    def contains(self, item, prereleases=None):
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
-    def filter(self, iterable, prereleases=None):
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
-    _operators = {}
-
-    def __init__(self, spec="", prereleases=None):
-        match = self._regex.search(spec)
-        if not match:
-            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
-
-        self._spec = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
-        )
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<{0}({1!r}{2})>".format(
-            self.__class__.__name__,
-            str(self),
-            pre,
-        )
-
-    def __str__(self):
-        return "{0}{1}".format(*self._spec)
-
-    def __hash__(self):
-        return hash(self._spec)
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec == other._spec
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            try:
-                other = self.__class__(other)
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec != other._spec
-
-    def _get_operator(self, op):
-        return getattr(self, "_compare_{0}".format(self._operators[op]))
-
-    def _coerce_version(self, version):
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
-    def operator(self):
-        return self._spec[0]
-
-    @property
-    def version(self):
-        return self._spec[1]
-
-    @property
-    def prereleases(self):
-        return self._prereleases
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
-        item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
-        if item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
-        return self._get_operator(self.operator)(item, self.version)
-
-    def filter(self, iterable, prereleases=None):
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
-                # prereleases, then we'll store it for later incase nothing
-                # else matches this specifier.
-                if (parsed_version.is_prerelease and not
-                        (prereleases or self.prereleases)):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
-                # accepting prereleases from the begining.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
-    _regex_str = (
-        r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-    )
-
-    _regex = re.compile(
-        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
-    def _coerce_version(self, version):
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
-    def _compare_equal(self, prospective, spec):
-        return prospective == self._coerce_version(spec)
-
-    def _compare_not_equal(self, prospective, spec):
-        return prospective != self._coerce_version(spec)
-
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= self._coerce_version(spec)
-
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= self._coerce_version(spec)
-
-    def _compare_less_than(self, prospective, spec):
-        return prospective < self._coerce_version(spec)
-
-    def _compare_greater_than(self, prospective, spec):
-        return prospective > self._coerce_version(spec)
-
-
-def _require_version_compare(fn):
-    @functools.wraps(fn)
-    def wrapped(self, prospective, spec):
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
-    _regex_str = (
-        r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-    )
-
-    _regex = re.compile(
-        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
-    def _compare_compatible(self, prospective, spec):
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
-        # ignore post and dev releases and we want to treat the pre-release as
-        # it's own separate segment.
-        prefix = ".".join(
-            list(
-                itertools.takewhile(
-                    lambda x: (not x.startswith("post") and not
-                               x.startswith("dev")),
-                    _version_split(spec),
-                )
-            )[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
-        return (self._get_operator(">=")(prospective, spec) and
-                self._get_operator("==")(prospective, prefix))
-
-    @_require_version_compare
-    def _compare_equal(self, prospective, spec):
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
-            spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
-            prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
-            prospective = prospective[:len(spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
-            spec, prospective = _pad_version(spec, prospective)
-        else:
-            # Convert our spec string into a Version
-            spec = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
-            if not spec.local:
-                prospective = Version(prospective.public)
-
-        return prospective == spec
-
-    @_require_version_compare
-    def _compare_not_equal(self, prospective, spec):
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
-    def _compare_less_than_equal(self, prospective, spec):
-        return prospective <= Version(spec)
-
-    @_require_version_compare
-    def _compare_greater_than_equal(self, prospective, spec):
-        return prospective >= Version(spec)
-
-    @_require_version_compare
-    def _compare_less_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
-    def _compare_greater_than(self, prospective, spec):
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
-        spec = Version(spec)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is techincally greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
-    def _compare_arbitrary(self, prospective, spec):
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
-    def prereleases(self):
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
-def _version_split(version):
-    result = []
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
-def _pad_version(left, right):
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
-    left_split.append(left[len(left_split[0]):])
-    right_split.append(right[len(right_split[0]):])
-
-    # Insert our padding
-    left_split.insert(
-        1,
-        ["0"] * max(0, len(right_split[0]) - len(left_split[0])),
-    )
-    right_split.insert(
-        1,
-        ["0"] * max(0, len(left_split[0]) - len(right_split[0])),
-    )
-
-    return (
-        list(itertools.chain(*left_split)),
-        list(itertools.chain(*right_split)),
-    )
-
-
-class SpecifierSet(BaseSpecifier):
-
-    def __init__(self, specifiers="", prereleases=None):
-        # Split on , to break each indidivual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
-        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
-        parsed = set()
-        for specifier in specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
-    def __repr__(self):
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
-
-    def __str__(self):
-        return ",".join(sorted(str(s) for s in self._specs))
-
-    def __hash__(self):
-        return hash(self._specs)
-
-    def __and__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
-    def __eq__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
-    def __ne__(self, other):
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif isinstance(other, _IndividualSpecifier):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs != other._specs
-
-    def __len__(self):
-        return len(self._specs)
-
-    def __iter__(self):
-        return iter(self._specs)
-
-    @property
-    def prereleases(self):
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
-    def prereleases(self, value):
-        self._prereleases = value
-
-    def __contains__(self, item):
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
-        return all(
-            s.contains(item, prereleases=prereleases)
-            for s in self._specs
-        )
-
-    def filter(self, iterable, prereleases=None):
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
-            filtered = []
-            found_prereleases = []
-
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/utils.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/utils.py
deleted file mode 100644
index 942387cef..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/utils.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import re
-
-
-_canonicalize_regex = re.compile(r"[-_.]+")
-
-
-def canonicalize_name(name):
-    # This is taken from PEP 503.
-    return _canonicalize_regex.sub("-", name).lower()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/version.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/version.py
deleted file mode 100644
index 83b5ee8c5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/packaging/version.py
+++ /dev/null
@@ -1,393 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import collections
-import itertools
-import re
-
-from ._structures import Infinity
-
-
-__all__ = [
-    "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"
-]
-
-
-_Version = collections.namedtuple(
-    "_Version",
-    ["epoch", "release", "dev", "pre", "post", "local"],
-)
-
-
-def parse(version):
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
-class _BaseVersion(object):
-
-    def __hash__(self):
-        return hash(self._key)
-
-    def __lt__(self, other):
-        return self._compare(other, lambda s, o: s < o)
-
-    def __le__(self, other):
-        return self._compare(other, lambda s, o: s <= o)
-
-    def __eq__(self, other):
-        return self._compare(other, lambda s, o: s == o)
-
-    def __ge__(self, other):
-        return self._compare(other, lambda s, o: s >= o)
-
-    def __gt__(self, other):
-        return self._compare(other, lambda s, o: s > o)
-
-    def __ne__(self, other):
-        return self._compare(other, lambda s, o: s != o)
-
-    def _compare(self, other, method):
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
-        return method(self._key, other._key)
-
-
-class LegacyVersion(_BaseVersion):
-
-    def __init__(self, version):
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
-    def __str__(self):
-        return self._version
-
-    def __repr__(self):
-        return "<LegacyVersion({0})>".format(repr(str(self)))
-
-    @property
-    def public(self):
-        return self._version
-
-    @property
-    def base_version(self):
-        return self._version
-
-    @property
-    def local(self):
-        return None
-
-    @property
-    def is_prerelease(self):
-        return False
-
-    @property
-    def is_postrelease(self):
-        return False
-
-
-_legacy_version_component_re = re.compile(
-    r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE,
-)
-
-_legacy_version_replacement_map = {
-    "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@",
-}
-
-
-def _parse_version_parts(s):
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
-def _legacy_cmpkey(version):
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
-    parts = []
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-    parts = tuple(parts)
-
-    return epoch, parts
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
-    _regex = re.compile(
-        r"^\s*" + VERSION_PATTERN + r"\s*$",
-        re.VERBOSE | re.IGNORECASE,
-    )
-
-    def __init__(self, version):
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion("Invalid version: '{0}'".format(version))
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
-            pre=_parse_letter_version(
-                match.group("pre_l"),
-                match.group("pre_n"),
-            ),
-            post=_parse_letter_version(
-                match.group("post_l"),
-                match.group("post_n1") or match.group("post_n2"),
-            ),
-            dev=_parse_letter_version(
-                match.group("dev_l"),
-                match.group("dev_n"),
-            ),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
-    def __repr__(self):
-        return "<Version({0})>".format(repr(str(self)))
-
-    def __str__(self):
-        parts = []
-
-        # Epoch
-        if self._version.epoch != 0:
-            parts.append("{0}!".format(self._version.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self._version.release))
-
-        # Pre-release
-        if self._version.pre is not None:
-            parts.append("".join(str(x) for x in self._version.pre))
-
-        # Post-release
-        if self._version.post is not None:
-            parts.append(".post{0}".format(self._version.post[1]))
-
-        # Development release
-        if self._version.dev is not None:
-            parts.append(".dev{0}".format(self._version.dev[1]))
-
-        # Local version segment
-        if self._version.local is not None:
-            parts.append(
-                "+{0}".format(".".join(str(x) for x in self._version.local))
-            )
-
-        return "".join(parts)
-
-    @property
-    def public(self):
-        return str(self).split("+", 1)[0]
-
-    @property
-    def base_version(self):
-        parts = []
-
-        # Epoch
-        if self._version.epoch != 0:
-            parts.append("{0}!".format(self._version.epoch))
-
-        # Release segment
-        parts.append(".".join(str(x) for x in self._version.release))
-
-        return "".join(parts)
-
-    @property
-    def local(self):
-        version_string = str(self)
-        if "+" in version_string:
-            return version_string.split("+", 1)[1]
-
-    @property
-    def is_prerelease(self):
-        return bool(self._version.dev or self._version.pre)
-
-    @property
-    def is_postrelease(self):
-        return bool(self._version.post)
-
-
-def _parse_letter_version(letter, number):
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
-
-_local_version_seperators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local):
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
-            for part in _local_version_seperators.split(local)
-        )
-
-
-def _cmpkey(epoch, release, pre, post, dev, local):
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
-    release = tuple(
-        reversed(list(
-            itertools.dropwhile(
-                lambda x: x == 0,
-                reversed(release),
-            )
-        ))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
-        pre = -Infinity
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
-        pre = Infinity
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
-        post = -Infinity
-
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
-        dev = Infinity
-
-    if local is None:
-        # Versions without a local segment should sort before those with one.
-        local = -Infinity
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
-        local = tuple(
-            (i, "") if isinstance(i, int) else (-Infinity, i)
-            for i in local
-        )
-
-    return epoch, release, pre, post, dev, local
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/pyparsing.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/pyparsing.py
deleted file mode 100644
index a21224359..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/pyparsing.py
+++ /dev/null
@@ -1,5696 +0,0 @@
-# module pyparsing.py
-#
-# Copyright (c) 2003-2016  Paul T. McGuire
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-__doc__ = \
-"""
-pyparsing module - Classes and methods to define and execute parsing grammars
-
-The pyparsing module is an alternative approach to creating and executing simple grammars,
-vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
-don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
-provides a library of classes that you use to construct the grammar directly in Python.
-
-Here is a program to parse "Hello, World!" (or any greeting of the form 
-C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 
-(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to
-L{Literal} expressions)::
-
-    from pyparsing import Word, alphas
-
-    # define grammar of a greeting
-    greet = Word(alphas) + "," + Word(alphas) + "!"
-
-    hello = "Hello, World!"
-    print (hello, "->", greet.parseString(hello))
-
-The program outputs the following::
-
-    Hello, World! -> ['Hello', ',', 'World', '!']
-
-The Python representation of the grammar is quite readable, owing to the self-explanatory
-class names, and the use of '+', '|' and '^' operators.
-
-The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an
-object with named attributes.
-
-The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
- - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
- - quoted strings
- - embedded comments
-"""
-
-__version__ = "2.1.10"
-__versionTime__ = "07 Oct 2016 01:31 UTC"
-__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
-
-import string
-from weakref import ref as wkref
-import copy
-import sys
-import warnings
-import re
-import sre_constants
-import collections
-import pprint
-import traceback
-import types
-from datetime import datetime
-
-try:
-    from _thread import RLock
-except ImportError:
-    from threading import RLock
-
-try:
-    from collections import OrderedDict as _OrderedDict
-except ImportError:
-    try:
-        from ordereddict import OrderedDict as _OrderedDict
-    except ImportError:
-        _OrderedDict = None
-
-#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
-
-__all__ = [
-'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
-'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
-'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
-'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
-'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
-'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
-'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
-'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
-'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
-'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
-'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
-'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
-'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
-'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
-'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
-'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
-'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
-'CloseMatch', 'tokenMap', 'pyparsing_common',
-]
-
-system_version = tuple(sys.version_info)[:3]
-PY_3 = system_version[0] == 3
-if PY_3:
-    _MAX_INT = sys.maxsize
-    basestring = str
-    unichr = chr
-    _ustr = str
-
-    # build list of single arg builtins, that can be used as parse actions
-    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
-
-else:
-    _MAX_INT = sys.maxint
-    range = xrange
-
-    def _ustr(obj):
-        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
-           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
-           then < returns the unicode object | encodes it with the default encoding | ... >.
-        """
-        if isinstance(obj,unicode):
-            return obj
-
-        try:
-            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
-            # it won't break any existing code.
-            return str(obj)
-
-        except UnicodeEncodeError:
-            # Else encode it
-            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
-            xmlcharref = Regex('&#\d+;')
-            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
-            return xmlcharref.transformString(ret)
-
-    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
-    singleArgBuiltins = []
-    import __builtin__
-    for fname in "sum len sorted reversed list tuple set any all min max".split():
-        try:
-            singleArgBuiltins.append(getattr(__builtin__,fname))
-        except AttributeError:
-            continue
-            
-_generatorType = type((y for y in range(1)))
- 
-def _xml_escape(data):
-    """Escape &, <, >, ", ', etc. in a string of data."""
-
-    # ampersand must be replaced first
-    from_symbols = '&><"\''
-    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
-    for from_,to_ in zip(from_symbols, to_symbols):
-        data = data.replace(from_, to_)
-    return data
-
-class _Constants(object):
-    pass
-
-alphas     = string.ascii_uppercase + string.ascii_lowercase
-nums       = "0123456789"
-hexnums    = nums + "ABCDEFabcdef"
-alphanums  = alphas + nums
-_bslash    = chr(92)
-printables = "".join(c for c in string.printable if c not in string.whitespace)
-
-class ParseBaseException(Exception):
-    """base exception class for all parsing runtime exceptions"""
-    # Performance tuning: we construct a *lot* of these, so keep this
-    # constructor as small and fast as possible
-    def __init__( self, pstr, loc=0, msg=None, elem=None ):
-        self.loc = loc
-        if msg is None:
-            self.msg = pstr
-            self.pstr = ""
-        else:
-            self.msg = msg
-            self.pstr = pstr
-        self.parserElement = elem
-        self.args = (pstr, loc, msg)
-
-    @classmethod
-    def _from_exception(cls, pe):
-        """
-        internal factory method to simplify creating one type of ParseException 
-        from another - avoids having __init__ signature conflicts among subclasses
-        """
-        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
-
-    def __getattr__( self, aname ):
-        """supported attributes by name are:
-            - lineno - returns the line number of the exception text
-            - col - returns the column number of the exception text
-            - line - returns the line containing the exception text
-        """
-        if( aname == "lineno" ):
-            return lineno( self.loc, self.pstr )
-        elif( aname in ("col", "column") ):
-            return col( self.loc, self.pstr )
-        elif( aname == "line" ):
-            return line( self.loc, self.pstr )
-        else:
-            raise AttributeError(aname)
-
-    def __str__( self ):
-        return "%s (at char %d), (line:%d, col:%d)" % \
-                ( self.msg, self.loc, self.lineno, self.column )
-    def __repr__( self ):
-        return _ustr(self)
-    def markInputline( self, markerString = ">!<" ):
-        """Extracts the exception line from the input string, and marks
-           the location of the exception with a special symbol.
-        """
-        line_str = self.line
-        line_column = self.column - 1
-        if markerString:
-            line_str = "".join((line_str[:line_column],
-                                markerString, line_str[line_column:]))
-        return line_str.strip()
-    def __dir__(self):
-        return "lineno col line".split() + dir(type(self))
-
-class ParseException(ParseBaseException):
-    """
-    Exception thrown when parse expressions don't match class;
-    supported attributes by name are:
-     - lineno - returns the line number of the exception text
-     - col - returns the column number of the exception text
-     - line - returns the line containing the exception text
-        
-    Example::
-        try:
-            Word(nums).setName("integer").parseString("ABC")
-        except ParseException as pe:
-            print(pe)
-            print("column: {}".format(pe.col))
-            
-    prints::
-       Expected integer (at char 0), (line:1, col:1)
-        column: 1
-    """
-    pass
-
-class ParseFatalException(ParseBaseException):
-    """user-throwable exception thrown when inconsistent parse content
-       is found; stops all parsing immediately"""
-    pass
-
-class ParseSyntaxException(ParseFatalException):
-    """just like L{ParseFatalException}, but thrown internally when an
-       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 
-       immediately because an unbacktrackable syntax error has been found"""
-    pass
-
-#~ class ReparseException(ParseBaseException):
-    #~ """Experimental class - parse actions can raise this exception to cause
-       #~ pyparsing to reparse the input string:
-        #~ - with a modified input string, and/or
-        #~ - with a modified start location
-       #~ Set the values of the ReparseException in the constructor, and raise the
-       #~ exception in a parse action to cause pyparsing to use the new string/location.
-       #~ Setting the values as None causes no change to be made.
-       #~ """
-    #~ def __init_( self, newstring, restartLoc ):
-        #~ self.newParseText = newstring
-        #~ self.reparseLoc = restartLoc
-
-class RecursiveGrammarException(Exception):
-    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
-    def __init__( self, parseElementList ):
-        self.parseElementTrace = parseElementList
-
-    def __str__( self ):
-        return "RecursiveGrammarException: %s" % self.parseElementTrace
-
-class _ParseResultsWithOffset(object):
-    def __init__(self,p1,p2):
-        self.tup = (p1,p2)
-    def __getitem__(self,i):
-        return self.tup[i]
-    def __repr__(self):
-        return repr(self.tup[0])
-    def setOffset(self,i):
-        self.tup = (self.tup[0],i)
-
-class ParseResults(object):
-    """
-    Structured parse results, to provide multiple means of access to the parsed data:
-       - as a list (C{len(results)})
-       - by list index (C{results[0], results[1]}, etc.)
-       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})
-
-    Example::
-        integer = Word(nums)
-        date_str = (integer.setResultsName("year") + '/' 
-                        + integer.setResultsName("month") + '/' 
-                        + integer.setResultsName("day"))
-        # equivalent form:
-        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-
-        # parseString returns a ParseResults object
-        result = date_str.parseString("1999/12/31")
-
-        def test(s, fn=repr):
-            print("%s -> %s" % (s, fn(eval(s))))
-        test("list(result)")
-        test("result[0]")
-        test("result['month']")
-        test("result.day")
-        test("'month' in result")
-        test("'minutes' in result")
-        test("result.dump()", str)
-    prints::
-        list(result) -> ['1999', '/', '12', '/', '31']
-        result[0] -> '1999'
-        result['month'] -> '12'
-        result.day -> '31'
-        'month' in result -> True
-        'minutes' in result -> False
-        result.dump() -> ['1999', '/', '12', '/', '31']
-        - day: 31
-        - month: 12
-        - year: 1999
-    """
-    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
-        if isinstance(toklist, cls):
-            return toklist
-        retobj = object.__new__(cls)
-        retobj.__doinit = True
-        return retobj
-
-    # Performance tuning: we construct a *lot* of these, so keep this
-    # constructor as small and fast as possible
-    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
-        if self.__doinit:
-            self.__doinit = False
-            self.__name = None
-            self.__parent = None
-            self.__accumNames = {}
-            self.__asList = asList
-            self.__modal = modal
-            if toklist is None:
-                toklist = []
-            if isinstance(toklist, list):
-                self.__toklist = toklist[:]
-            elif isinstance(toklist, _generatorType):
-                self.__toklist = list(toklist)
-            else:
-                self.__toklist = [toklist]
-            self.__tokdict = dict()
-
-        if name is not None and name:
-            if not modal:
-                self.__accumNames[name] = 0
-            if isinstance(name,int):
-                name = _ustr(name) # will always return a str, but use _ustr for consistency
-            self.__name = name
-            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
-                if isinstance(toklist,basestring):
-                    toklist = [ toklist ]
-                if asList:
-                    if isinstance(toklist,ParseResults):
-                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
-                    else:
-                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
-                    self[name].__name = name
-                else:
-                    try:
-                        self[name] = toklist[0]
-                    except (KeyError,TypeError,IndexError):
-                        self[name] = toklist
-
-    def __getitem__( self, i ):
-        if isinstance( i, (int,slice) ):
-            return self.__toklist[i]
-        else:
-            if i not in self.__accumNames:
-                return self.__tokdict[i][-1][0]
-            else:
-                return ParseResults([ v[0] for v in self.__tokdict[i] ])
-
-    def __setitem__( self, k, v, isinstance=isinstance ):
-        if isinstance(v,_ParseResultsWithOffset):
-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
-            sub = v[0]
-        elif isinstance(k,(int,slice)):
-            self.__toklist[k] = v
-            sub = v
-        else:
-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
-            sub = v
-        if isinstance(sub,ParseResults):
-            sub.__parent = wkref(self)
-
-    def __delitem__( self, i ):
-        if isinstance(i,(int,slice)):
-            mylen = len( self.__toklist )
-            del self.__toklist[i]
-
-            # convert int to slice
-            if isinstance(i, int):
-                if i < 0:
-                    i += mylen
-                i = slice(i, i+1)
-            # get removed indices
-            removed = list(range(*i.indices(mylen)))
-            removed.reverse()
-            # fixup indices in token dictionary
-            for name,occurrences in self.__tokdict.items():
-                for j in removed:
-                    for k, (value, position) in enumerate(occurrences):
-                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
-        else:
-            del self.__tokdict[i]
-
-    def __contains__( self, k ):
-        return k in self.__tokdict
-
-    def __len__( self ): return len( self.__toklist )
-    def __bool__(self): return ( not not self.__toklist )
-    __nonzero__ = __bool__
-    def __iter__( self ): return iter( self.__toklist )
-    def __reversed__( self ): return iter( self.__toklist[::-1] )
-    def _iterkeys( self ):
-        if hasattr(self.__tokdict, "iterkeys"):
-            return self.__tokdict.iterkeys()
-        else:
-            return iter(self.__tokdict)
-
-    def _itervalues( self ):
-        return (self[k] for k in self._iterkeys())
-            
-    def _iteritems( self ):
-        return ((k, self[k]) for k in self._iterkeys())
-
-    if PY_3:
-        keys = _iterkeys       
-        """Returns an iterator of all named result keys (Python 3.x only)."""
-
-        values = _itervalues
-        """Returns an iterator of all named result values (Python 3.x only)."""
-
-        items = _iteritems
-        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""
-
-    else:
-        iterkeys = _iterkeys
-        """Returns an iterator of all named result keys (Python 2.x only)."""
-
-        itervalues = _itervalues
-        """Returns an iterator of all named result values (Python 2.x only)."""
-
-        iteritems = _iteritems
-        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""
-
-        def keys( self ):
-            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
-            return list(self.iterkeys())
-
-        def values( self ):
-            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
-            return list(self.itervalues())
-                
-        def items( self ):
-            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
-            return list(self.iteritems())
-
-    def haskeys( self ):
-        """Since keys() returns an iterator, this method is helpful in bypassing
-           code that looks for the existence of any defined results names."""
-        return bool(self.__tokdict)
-        
-    def pop( self, *args, **kwargs):
-        """
-        Removes and returns item at specified index (default=C{last}).
-        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
-        argument or an integer argument, it will use C{list} semantics
-        and pop tokens from the list of parsed tokens. If passed a 
-        non-integer argument (most likely a string), it will use C{dict}
-        semantics and pop the corresponding value from any defined 
-        results names. A second default return value argument is 
-        supported, just as in C{dict.pop()}.
-
-        Example::
-            def remove_first(tokens):
-                tokens.pop(0)
-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
-            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
-
-            label = Word(alphas)
-            patt = label("LABEL") + OneOrMore(Word(nums))
-            print(patt.parseString("AAB 123 321").dump())
-
-            # Use pop() in a parse action to remove named result (note that corresponding value is not
-            # removed from list form of results)
-            def remove_LABEL(tokens):
-                tokens.pop("LABEL")
-                return tokens
-            patt.addParseAction(remove_LABEL)
-            print(patt.parseString("AAB 123 321").dump())
-        prints::
-            ['AAB', '123', '321']
-            - LABEL: AAB
-
-            ['AAB', '123', '321']
-        """
-        if not args:
-            args = [-1]
-        for k,v in kwargs.items():
-            if k == 'default':
-                args = (args[0], v)
-            else:
-                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
-        if (isinstance(args[0], int) or 
-                        len(args) == 1 or 
-                        args[0] in self):
-            index = args[0]
-            ret = self[index]
-            del self[index]
-            return ret
-        else:
-            defaultvalue = args[1]
-            return defaultvalue
-
-    def get(self, key, defaultValue=None):
-        """
-        Returns named result matching the given key, or if there is no
-        such name, then returns the given C{defaultValue} or C{None} if no
-        C{defaultValue} is specified.
-
-        Similar to C{dict.get()}.
-        
-        Example::
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
-
-            result = date_str.parseString("1999/12/31")
-            print(result.get("year")) # -> '1999'
-            print(result.get("hour", "not specified")) # -> 'not specified'
-            print(result.get("hour")) # -> None
-        """
-        if key in self:
-            return self[key]
-        else:
-            return defaultValue
-
-    def insert( self, index, insStr ):
-        """
-        Inserts new element at location index in the list of parsed tokens.
-        
-        Similar to C{list.insert()}.
-
-        Example::
-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
-
-            # use a parse action to insert the parse location in the front of the parsed results
-            def insert_locn(locn, tokens):
-                tokens.insert(0, locn)
-            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
-        """
-        self.__toklist.insert(index, insStr)
-        # fixup indices in token dictionary
-        for name,occurrences in self.__tokdict.items():
-            for k, (value, position) in enumerate(occurrences):
-                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
-
-    def append( self, item ):
-        """
-        Add single element to end of ParseResults list of elements.
-
-        Example::
-            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
-            
-            # use a parse action to compute the sum of the parsed integers, and add it to the end
-            def append_sum(tokens):
-                tokens.append(sum(map(int, tokens)))
-            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
-        """
-        self.__toklist.append(item)
-
-    def extend( self, itemseq ):
-        """
-        Add sequence of elements to end of ParseResults list of elements.
-
-        Example::
-            patt = OneOrMore(Word(alphas))
-            
-            # use a parse action to append the reverse of the matched strings, to make a palindrome
-            def make_palindrome(tokens):
-                tokens.extend(reversed([t[::-1] for t in tokens]))
-                return ''.join(tokens)
-            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
-        """
-        if isinstance(itemseq, ParseResults):
-            self += itemseq
-        else:
-            self.__toklist.extend(itemseq)
-
-    def clear( self ):
-        """
-        Clear all elements and results names.
-        """
-        del self.__toklist[:]
-        self.__tokdict.clear()
-
-    def __getattr__( self, name ):
-        try:
-            return self[name]
-        except KeyError:
-            return ""
-            
-        if name in self.__tokdict:
-            if name not in self.__accumNames:
-                return self.__tokdict[name][-1][0]
-            else:
-                return ParseResults([ v[0] for v in self.__tokdict[name] ])
-        else:
-            return ""
-
-    def __add__( self, other ):
-        ret = self.copy()
-        ret += other
-        return ret
-
-    def __iadd__( self, other ):
-        if other.__tokdict:
-            offset = len(self.__toklist)
-            addoffset = lambda a: offset if a<0 else a+offset
-            otheritems = other.__tokdict.items()
-            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
-                                for (k,vlist) in otheritems for v in vlist]
-            for k,v in otherdictitems:
-                self[k] = v
-                if isinstance(v[0],ParseResults):
-                    v[0].__parent = wkref(self)
-            
-        self.__toklist += other.__toklist
-        self.__accumNames.update( other.__accumNames )
-        return self
-
-    def __radd__(self, other):
-        if isinstance(other,int) and other == 0:
-            # useful for merging many ParseResults using sum() builtin
-            return self.copy()
-        else:
-            # this may raise a TypeError - so be it
-            return other + self
-        
-    def __repr__( self ):
-        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
-
-    def __str__( self ):
-        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
-
-    def _asStringList( self, sep='' ):
-        out = []
-        for item in self.__toklist:
-            if out and sep:
-                out.append(sep)
-            if isinstance( item, ParseResults ):
-                out += item._asStringList()
-            else:
-                out.append( _ustr(item) )
-        return out
-
-    def asList( self ):
-        """
-        Returns the parse results as a nested list of matching tokens, all converted to strings.
-
-        Example::
-            patt = OneOrMore(Word(alphas))
-            result = patt.parseString("sldkj lsdkj sldkj")
-            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
-            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
-            
-            # Use asList() to create an actual list
-            result_list = result.asList()
-            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
-        """
-        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]
-
-    def asDict( self ):
-        """
-        Returns the named parse results as a nested dictionary.
-
-        Example::
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-            
-            result = date_str.parseString('12/31/1999')
-            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
-            
-            result_dict = result.asDict()
-            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
-
-            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
-            import json
-            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
-            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
-        """
-        if PY_3:
-            item_fn = self.items
-        else:
-            item_fn = self.iteritems
-            
-        def toItem(obj):
-            if isinstance(obj, ParseResults):
-                if obj.haskeys():
-                    return obj.asDict()
-                else:
-                    return [toItem(v) for v in obj]
-            else:
-                return obj
-                
-        return dict((k,toItem(v)) for k,v in item_fn())
-
-    def copy( self ):
-        """
-        Returns a new copy of a C{ParseResults} object.
-        """
-        ret = ParseResults( self.__toklist )
-        ret.__tokdict = self.__tokdict.copy()
-        ret.__parent = self.__parent
-        ret.__accumNames.update( self.__accumNames )
-        ret.__name = self.__name
-        return ret
-
-    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
-        """
-        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
-        """
-        nl = "\n"
-        out = []
-        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
-                                                            for v in vlist)
-        nextLevelIndent = indent + "  "
-
-        # collapse out indents if formatting is not desired
-        if not formatted:
-            indent = ""
-            nextLevelIndent = ""
-            nl = ""
-
-        selfTag = None
-        if doctag is not None:
-            selfTag = doctag
-        else:
-            if self.__name:
-                selfTag = self.__name
-
-        if not selfTag:
-            if namedItemsOnly:
-                return ""
-            else:
-                selfTag = "ITEM"
-
-        out += [ nl, indent, "<", selfTag, ">" ]
-
-        for i,res in enumerate(self.__toklist):
-            if isinstance(res,ParseResults):
-                if i in namedItems:
-                    out += [ res.asXML(namedItems[i],
-                                        namedItemsOnly and doctag is None,
-                                        nextLevelIndent,
-                                        formatted)]
-                else:
-                    out += [ res.asXML(None,
-                                        namedItemsOnly and doctag is None,
-                                        nextLevelIndent,
-                                        formatted)]
-            else:
-                # individual token, see if there is a name for it
-                resTag = None
-                if i in namedItems:
-                    resTag = namedItems[i]
-                if not resTag:
-                    if namedItemsOnly:
-                        continue
-                    else:
-                        resTag = "ITEM"
-                xmlBodyText = _xml_escape(_ustr(res))
-                out += [ nl, nextLevelIndent, "<", resTag, ">",
-                                                xmlBodyText,
-                                                "</", resTag, ">" ]
-
-        out += [ nl, indent, "</", selfTag, ">" ]
-        return "".join(out)
-
-    def __lookup(self,sub):
-        for k,vlist in self.__tokdict.items():
-            for v,loc in vlist:
-                if sub is v:
-                    return k
-        return None
-
-    def getName(self):
-        """
-        Returns the results name for this token expression. Useful when several 
-        different expressions might match at a particular location.
-
-        Example::
-            integer = Word(nums)
-            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
-            house_number_expr = Suppress('#') + Word(nums, alphanums)
-            user_data = (Group(house_number_expr)("house_number") 
-                        | Group(ssn_expr)("ssn")
-                        | Group(integer)("age"))
-            user_info = OneOrMore(user_data)
-            
-            result = user_info.parseString("22 111-22-3333 #221B")
-            for item in result:
-                print(item.getName(), ':', item[0])
-        prints::
-            age : 22
-            ssn : 111-22-3333
-            house_number : 221B
-        """
-        if self.__name:
-            return self.__name
-        elif self.__parent:
-            par = self.__parent()
-            if par:
-                return par.__lookup(self)
-            else:
-                return None
-        elif (len(self) == 1 and
-               len(self.__tokdict) == 1 and
-               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
-            return next(iter(self.__tokdict.keys()))
-        else:
-            return None
-
-    def dump(self, indent='', depth=0, full=True):
-        """
-        Diagnostic method for listing out the contents of a C{ParseResults}.
-        Accepts an optional C{indent} argument so that this string can be embedded
-        in a nested display of other data.
-
-        Example::
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-            
-            result = date_str.parseString('12/31/1999')
-            print(result.dump())
-        prints::
-            ['12', '/', '31', '/', '1999']
-            - day: 1999
-            - month: 31
-            - year: 12
-        """
-        out = []
-        NL = '\n'
-        out.append( indent+_ustr(self.asList()) )
-        if full:
-            if self.haskeys():
-                items = sorted((str(k), v) for k,v in self.items())
-                for k,v in items:
-                    if out:
-                        out.append(NL)
-                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
-                    if isinstance(v,ParseResults):
-                        if v:
-                            out.append( v.dump(indent,depth+1) )
-                        else:
-                            out.append(_ustr(v))
-                    else:
-                        out.append(repr(v))
-            elif any(isinstance(vv,ParseResults) for vv in self):
-                v = self
-                for i,vv in enumerate(v):
-                    if isinstance(vv,ParseResults):
-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
-                    else:
-                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
-            
-        return "".join(out)
-
-    def pprint(self, *args, **kwargs):
-        """
-        Pretty-printer for parsed results as a list, using the C{pprint} module.
-        Accepts additional positional or keyword args as defined for the 
-        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})
-
-        Example::
-            ident = Word(alphas, alphanums)
-            num = Word(nums)
-            func = Forward()
-            term = ident | num | Group('(' + func + ')')
-            func <<= ident + Group(Optional(delimitedList(term)))
-            result = func.parseString("fna a,b,(fnb c,d,200),100")
-            result.pprint(width=40)
-        prints::
-            ['fna',
-             ['a',
-              'b',
-              ['(', 'fnb', ['c', 'd', '200'], ')'],
-              '100']]
-        """
-        pprint.pprint(self.asList(), *args, **kwargs)
-
-    # add support for pickle protocol
-    def __getstate__(self):
-        return ( self.__toklist,
-                 ( self.__tokdict.copy(),
-                   self.__parent is not None and self.__parent() or None,
-                   self.__accumNames,
-                   self.__name ) )
-
-    def __setstate__(self,state):
-        self.__toklist = state[0]
-        (self.__tokdict,
-         par,
-         inAccumNames,
-         self.__name) = state[1]
-        self.__accumNames = {}
-        self.__accumNames.update(inAccumNames)
-        if par is not None:
-            self.__parent = wkref(par)
-        else:
-            self.__parent = None
-
-    def __getnewargs__(self):
-        return self.__toklist, self.__name, self.__asList, self.__modal
-
-    def __dir__(self):
-        return (dir(type(self)) + list(self.keys()))
-
-collections.MutableMapping.register(ParseResults)
-
-def col (loc,strg):
-    """Returns current column within a string, counting newlines as line separators.
-   The first column is number 1.
-
-   Note: the default parsing behavior is to expand tabs in the input string
-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
-   consistent view of the parsed string, the parse location, and line and column
-   positions within the parsed string.
-   """
-    s = strg
-    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)
-
-def lineno(loc,strg):
-    """Returns current line number within a string, counting newlines as line separators.
-   The first line is number 1.
-
-   Note: the default parsing behavior is to expand tabs in the input string
-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
-   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
-   consistent view of the parsed string, the parse location, and line and column
-   positions within the parsed string.
-   """
-    return strg.count("\n",0,loc) + 1
-
-def line( loc, strg ):
-    """Returns the line of text containing loc within a string, counting newlines as line separators.
-       """
-    lastCR = strg.rfind("\n", 0, loc)
-    nextCR = strg.find("\n", loc)
-    if nextCR >= 0:
-        return strg[lastCR+1:nextCR]
-    else:
-        return strg[lastCR+1:]
-
-def _defaultStartDebugAction( instring, loc, expr ):
-    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))
-
-def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
-    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
-
-def _defaultExceptionDebugAction( instring, loc, expr, exc ):
-    print ("Exception raised:" + _ustr(exc))
-
-def nullDebugAction(*args):
-    """'Do-nothing' debug action, to suppress debugging output during parsing."""
-    pass
-
-# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
-#~ 'decorator to trim function calls to match the arity of the target'
-#~ def _trim_arity(func, maxargs=3):
-    #~ if func in singleArgBuiltins:
-        #~ return lambda s,l,t: func(t)
-    #~ limit = 0
-    #~ foundArity = False
-    #~ def wrapper(*args):
-        #~ nonlocal limit,foundArity
-        #~ while 1:
-            #~ try:
-                #~ ret = func(*args[limit:])
-                #~ foundArity = True
-                #~ return ret
-            #~ except TypeError:
-                #~ if limit == maxargs or foundArity:
-                    #~ raise
-                #~ limit += 1
-                #~ continue
-    #~ return wrapper
-
-# this version is Python 2.x-3.x cross-compatible
-'decorator to trim function calls to match the arity of the target'
-def _trim_arity(func, maxargs=2):
-    if func in singleArgBuiltins:
-        return lambda s,l,t: func(t)
-    limit = [0]
-    foundArity = [False]
-    
-    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
-    if system_version[:2] >= (3,5):
-        def extract_stack(limit=0):
-            # special handling for Python 3.5.0 - extra deep call stack by 1
-            offset = -3 if system_version == (3,5,0) else -2
-            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
-            return [(frame_summary.filename, frame_summary.lineno)]
-        def extract_tb(tb, limit=0):
-            frames = traceback.extract_tb(tb, limit=limit)
-            frame_summary = frames[-1]
-            return [(frame_summary.filename, frame_summary.lineno)]
-    else:
-        extract_stack = traceback.extract_stack
-        extract_tb = traceback.extract_tb
-    
-    # synthesize what would be returned by traceback.extract_stack at the call to 
-    # user's parse action 'func', so that we don't incur call penalty at parse time
-    
-    LINE_DIFF = 6
-    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
-    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
-    this_line = extract_stack(limit=2)[-1]
-    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)
-
-    def wrapper(*args):
-        while 1:
-            try:
-                ret = func(*args[limit[0]:])
-                foundArity[0] = True
-                return ret
-            except TypeError:
-                # re-raise TypeErrors if they did not come from our arity testing
-                if foundArity[0]:
-                    raise
-                else:
-                    try:
-                        tb = sys.exc_info()[-1]
-                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
-                            raise
-                    finally:
-                        del tb
-
-                if limit[0] <= maxargs:
-                    limit[0] += 1
-                    continue
-                raise
-
-    # copy func name to wrapper for sensible debug output
-    func_name = "<parse action>"
-    try:
-        func_name = getattr(func, '__name__', 
-                            getattr(func, '__class__').__name__)
-    except Exception:
-        func_name = str(func)
-    wrapper.__name__ = func_name
-
-    return wrapper
-
-class ParserElement(object):
-    """Abstract base level parser element class."""
-    DEFAULT_WHITE_CHARS = " \n\t\r"
-    verbose_stacktrace = False
-
-    @staticmethod
-    def setDefaultWhitespaceChars( chars ):
-        r"""
-        Overrides the default whitespace chars
-
-        Example::
-            # default whitespace chars are space, <TAB> and newline
-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
-            
-            # change to just treat newline as significant
-            ParserElement.setDefaultWhitespaceChars(" \t")
-            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
-        """
-        ParserElement.DEFAULT_WHITE_CHARS = chars
-
-    @staticmethod
-    def inlineLiteralsUsing(cls):
-        """
-        Set class to be used for inclusion of string literals into a parser.
-        
-        Example::
-            # default literal class used is Literal
-            integer = Word(nums)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
-
-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
-
-
-            # change to Suppress
-            ParserElement.inlineLiteralsUsing(Suppress)
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
-
-            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
-        """
-        ParserElement._literalStringClass = cls
-
-    def __init__( self, savelist=False ):
-        self.parseAction = list()
-        self.failAction = None
-        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
-        self.strRepr = None
-        self.resultsName = None
-        self.saveAsList = savelist
-        self.skipWhitespace = True
-        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
-        self.copyDefaultWhiteChars = True
-        self.mayReturnEmpty = False # used when checking for left-recursion
-        self.keepTabs = False
-        self.ignoreExprs = list()
-        self.debug = False
-        self.streamlined = False
-        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
-        self.errmsg = ""
-        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
-        self.debugActions = ( None, None, None ) #custom debug actions
-        self.re = None
-        self.callPreparse = True # used to avoid redundant calls to preParse
-        self.callDuringTry = False
-
-    def copy( self ):
-        """
-        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
-        for the same parsing pattern, using copies of the original parse element.
-        
-        Example::
-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
-            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
-            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
-            
-            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
-        prints::
-            [5120, 100, 655360, 268435456]
-        Equivalent form of C{expr.copy()} is just C{expr()}::
-            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
-        """
-        cpy = copy.copy( self )
-        cpy.parseAction = self.parseAction[:]
-        cpy.ignoreExprs = self.ignoreExprs[:]
-        if self.copyDefaultWhiteChars:
-            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
-        return cpy
-
-    def setName( self, name ):
-        """
-        Define name for this expression, makes debugging and exception messages clearer.
-        
-        Example::
-            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
-            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
-        """
-        self.name = name
-        self.errmsg = "Expected " + self.name
-        if hasattr(self,"exception"):
-            self.exception.msg = self.errmsg
-        return self
-
-    def setResultsName( self, name, listAllMatches=False ):
-        """
-        Define name for referencing matching tokens as a nested attribute
-        of the returned parse results.
-        NOTE: this returns a *copy* of the original C{ParserElement} object;
-        this is so that the client can define a basic element, such as an
-        integer, and reference it in multiple places with different names.
-
-        You can also set results names using the abbreviated syntax,
-        C{expr("name")} in place of C{expr.setResultsName("name")} - 
-        see L{I{__call__}<__call__>}.
-
-        Example::
-            date_str = (integer.setResultsName("year") + '/' 
-                        + integer.setResultsName("month") + '/' 
-                        + integer.setResultsName("day"))
-
-            # equivalent form:
-            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
-        """
-        newself = self.copy()
-        if name.endswith("*"):
-            name = name[:-1]
-            listAllMatches=True
-        newself.resultsName = name
-        newself.modalResults = not listAllMatches
-        return newself
-
-    def setBreak(self,breakFlag = True):
-        """Method to invoke the Python pdb debugger when this element is
-           about to be parsed. Set C{breakFlag} to True to enable, False to
-           disable.
-        """
-        if breakFlag:
-            _parseMethod = self._parse
-            def breaker(instring, loc, doActions=True, callPreParse=True):
-                import pdb
-                pdb.set_trace()
-                return _parseMethod( instring, loc, doActions, callPreParse )
-            breaker._originalParseMethod = _parseMethod
-            self._parse = breaker
-        else:
-            if hasattr(self._parse,"_originalParseMethod"):
-                self._parse = self._parse._originalParseMethod
-        return self
-
-    def setParseAction( self, *fns, **kwargs ):
-        """
-        Define action to perform when successfully matching parse element definition.
-        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
-        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
-         - s   = the original string being parsed (see note below)
-         - loc = the location of the matching substring
-         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
-        If the functions in fns modify the tokens, they can return them as the return
-        value from fn, and the modified list of tokens will replace the original.
-        Otherwise, fn does not need to return any value.
-
-        Optional keyword arguments:
-         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing
-
-        Note: the default parsing behavior is to expand tabs in the input string
-        before starting the parsing process.  See L{I{parseString}<parseString>} for more information
-        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
-        consistent view of the parsed string, the parse location, and line and column
-        positions within the parsed string.
-        
-        Example::
-            integer = Word(nums)
-            date_str = integer + '/' + integer + '/' + integer
-
-            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
-
-            # use parse action to convert to ints at parse time
-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
-            date_str = integer + '/' + integer + '/' + integer
-
-            # note that integer fields are now ints, not strings
-            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
-        """
-        self.parseAction = list(map(_trim_arity, list(fns)))
-        self.callDuringTry = kwargs.get("callDuringTry", False)
-        return self
-
-    def addParseAction( self, *fns, **kwargs ):
-        """
-        Add parse action to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.
-        
-        See examples in L{I{copy}<copy>}.
-        """
-        self.parseAction += list(map(_trim_arity, list(fns)))
-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
-        return self
-
-    def addCondition(self, *fns, **kwargs):
-        """Add a boolean predicate function to expression's list of parse actions. See 
-        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 
-        functions passed to C{addCondition} need to return boolean success/fail of the condition.
-
-        Optional keyword arguments:
-         - message = define a custom message to be used in the raised exception
-         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
-         
-        Example::
-            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
-            year_int = integer.copy()
-            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
-            date_str = year_int + '/' + integer + '/' + integer
-
-            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
-        """
-        msg = kwargs.get("message", "failed user-defined condition")
-        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
-        for fn in fns:
-            def pa(s,l,t):
-                if not bool(_trim_arity(fn)(s,l,t)):
-                    raise exc_type(s,l,msg)
-            self.parseAction.append(pa)
-        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
-        return self
-
-    def setFailAction( self, fn ):
-        """Define action to perform if parsing fails at this expression.
-           Fail acton fn is a callable function that takes the arguments
-           C{fn(s,loc,expr,err)} where:
-            - s = string being parsed
-            - loc = location where expression match was attempted and failed
-            - expr = the parse expression that failed
-            - err = the exception thrown
-           The function returns no value.  It may throw C{L{ParseFatalException}}
-           if it is desired to stop parsing immediately."""
-        self.failAction = fn
-        return self
-
-    def _skipIgnorables( self, instring, loc ):
-        exprsFound = True
-        while exprsFound:
-            exprsFound = False
-            for e in self.ignoreExprs:
-                try:
-                    while 1:
-                        loc,dummy = e._parse( instring, loc )
-                        exprsFound = True
-                except ParseException:
-                    pass
-        return loc
-
-    def preParse( self, instring, loc ):
-        if self.ignoreExprs:
-            loc = self._skipIgnorables( instring, loc )
-
-        if self.skipWhitespace:
-            wt = self.whiteChars
-            instrlen = len(instring)
-            while loc < instrlen and instring[loc] in wt:
-                loc += 1
-
-        return loc
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        return loc, []
-
-    def postParse( self, instring, loc, tokenlist ):
-        return tokenlist
-
-    #~ @profile
-    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
-        debugging = ( self.debug ) #and doActions )
-
-        if debugging or self.failAction:
-            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
-            if (self.debugActions[0] ):
-                self.debugActions[0]( instring, loc, self )
-            if callPreParse and self.callPreparse:
-                preloc = self.preParse( instring, loc )
-            else:
-                preloc = loc
-            tokensStart = preloc
-            try:
-                try:
-                    loc,tokens = self.parseImpl( instring, preloc, doActions )
-                except IndexError:
-                    raise ParseException( instring, len(instring), self.errmsg, self )
-            except ParseBaseException as err:
-                #~ print ("Exception raised:", err)
-                if self.debugActions[2]:
-                    self.debugActions[2]( instring, tokensStart, self, err )
-                if self.failAction:
-                    self.failAction( instring, tokensStart, self, err )
-                raise
-        else:
-            if callPreParse and self.callPreparse:
-                preloc = self.preParse( instring, loc )
-            else:
-                preloc = loc
-            tokensStart = preloc
-            if self.mayIndexError or loc >= len(instring):
-                try:
-                    loc,tokens = self.parseImpl( instring, preloc, doActions )
-                except IndexError:
-                    raise ParseException( instring, len(instring), self.errmsg, self )
-            else:
-                loc,tokens = self.parseImpl( instring, preloc, doActions )
-
-        tokens = self.postParse( instring, loc, tokens )
-
-        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
-        if self.parseAction and (doActions or self.callDuringTry):
-            if debugging:
-                try:
-                    for fn in self.parseAction:
-                        tokens = fn( instring, tokensStart, retTokens )
-                        if tokens is not None:
-                            retTokens = ParseResults( tokens,
-                                                      self.resultsName,
-                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
-                                                      modal=self.modalResults )
-                except ParseBaseException as err:
-                    #~ print "Exception raised in user parse action:", err
-                    if (self.debugActions[2] ):
-                        self.debugActions[2]( instring, tokensStart, self, err )
-                    raise
-            else:
-                for fn in self.parseAction:
-                    tokens = fn( instring, tokensStart, retTokens )
-                    if tokens is not None:
-                        retTokens = ParseResults( tokens,
-                                                  self.resultsName,
-                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
-                                                  modal=self.modalResults )
-
-        if debugging:
-            #~ print ("Matched",self,"->",retTokens.asList())
-            if (self.debugActions[1] ):
-                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
-
-        return loc, retTokens
-
-    def tryParse( self, instring, loc ):
-        try:
-            return self._parse( instring, loc, doActions=False )[0]
-        except ParseFatalException:
-            raise ParseException( instring, loc, self.errmsg, self)
-    
-    def canParseNext(self, instring, loc):
-        try:
-            self.tryParse(instring, loc)
-        except (ParseException, IndexError):
-            return False
-        else:
-            return True
-
-    class _UnboundedCache(object):
-        def __init__(self):
-            cache = {}
-            self.not_in_cache = not_in_cache = object()
-
-            def get(self, key):
-                return cache.get(key, not_in_cache)
-
-            def set(self, key, value):
-                cache[key] = value
-
-            def clear(self):
-                cache.clear()
-
-            self.get = types.MethodType(get, self)
-            self.set = types.MethodType(set, self)
-            self.clear = types.MethodType(clear, self)
-
-    if _OrderedDict is not None:
-        class _FifoCache(object):
-            def __init__(self, size):
-                self.not_in_cache = not_in_cache = object()
-
-                cache = _OrderedDict()
-
-                def get(self, key):
-                    return cache.get(key, not_in_cache)
-
-                def set(self, key, value):
-                    cache[key] = value
-                    if len(cache) > size:
-                        cache.popitem(False)
-
-                def clear(self):
-                    cache.clear()
-
-                self.get = types.MethodType(get, self)
-                self.set = types.MethodType(set, self)
-                self.clear = types.MethodType(clear, self)
-
-    else:
-        class _FifoCache(object):
-            def __init__(self, size):
-                self.not_in_cache = not_in_cache = object()
-
-                cache = {}
-                key_fifo = collections.deque([], size)
-
-                def get(self, key):
-                    return cache.get(key, not_in_cache)
-
-                def set(self, key, value):
-                    cache[key] = value
-                    if len(cache) > size:
-                        cache.pop(key_fifo.popleft(), None)
-                    key_fifo.append(key)
-
-                def clear(self):
-                    cache.clear()
-                    key_fifo.clear()
-
-                self.get = types.MethodType(get, self)
-                self.set = types.MethodType(set, self)
-                self.clear = types.MethodType(clear, self)
-
-    # argument cache for optimizing repeated calls when backtracking through recursive expressions
-    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
-    packrat_cache_lock = RLock()
-    packrat_cache_stats = [0, 0]
-
-    # this method gets repeatedly called during backtracking with the same arguments -
-    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
-    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
-        HIT, MISS = 0, 1
-        lookup = (self, instring, loc, callPreParse, doActions)
-        with ParserElement.packrat_cache_lock:
-            cache = ParserElement.packrat_cache
-            value = cache.get(lookup)
-            if value is cache.not_in_cache:
-                ParserElement.packrat_cache_stats[MISS] += 1
-                try:
-                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
-                except ParseBaseException as pe:
-                    # cache a copy of the exception, without the traceback
-                    cache.set(lookup, pe.__class__(*pe.args))
-                    raise
-                else:
-                    cache.set(lookup, (value[0], value[1].copy()))
-                    return value
-            else:
-                ParserElement.packrat_cache_stats[HIT] += 1
-                if isinstance(value, Exception):
-                    raise value
-                return (value[0], value[1].copy())
-
-    _parse = _parseNoCache
-
-    @staticmethod
-    def resetCache():
-        ParserElement.packrat_cache.clear()
-        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)
-
-    _packratEnabled = False
-    @staticmethod
-    def enablePackrat(cache_size_limit=128):
-        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
-           Repeated parse attempts at the same string location (which happens
-           often in many complex grammars) can immediately return a cached value,
-           instead of re-executing parsing/validating code.  Memoizing is done of
-           both valid results and parsing exceptions.
-           
-           Parameters:
-            - cache_size_limit - (default=C{128}) - if an integer value is provided
-              will limit the size of the packrat cache; if None is passed, then
-              the cache size will be unbounded; if 0 is passed, the cache will
-              be effectively disabled.
-            
-           This speedup may break existing programs that use parse actions that
-           have side-effects.  For this reason, packrat parsing is disabled when
-           you first import pyparsing.  To activate the packrat feature, your
-           program must call the class method C{ParserElement.enablePackrat()}.  If
-           your program uses C{psyco} to "compile as you go", you must call
-           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
-           Python will crash.  For best results, call C{enablePackrat()} immediately
-           after importing pyparsing.
-           
-           Example::
-               import pyparsing
-               pyparsing.ParserElement.enablePackrat()
-        """
-        if not ParserElement._packratEnabled:
-            ParserElement._packratEnabled = True
-            if cache_size_limit is None:
-                ParserElement.packrat_cache = ParserElement._UnboundedCache()
-            else:
-                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
-            ParserElement._parse = ParserElement._parseCache
-
-    def parseString( self, instring, parseAll=False ):
-        """
-        Execute the parse expression with the given string.
-        This is the main interface to the client code, once the complete
-        expression has been built.
-
-        If you want the grammar to require that the entire input string be
-        successfully parsed, then set C{parseAll} to True (equivalent to ending
-        the grammar with C{L{StringEnd()}}).
-
-        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
-        in order to report proper column numbers in parse actions.
-        If the input string contains tabs and
-        the grammar uses parse actions that use the C{loc} argument to index into the
-        string being parsed, you can ensure you have a consistent view of the input
-        string by:
-         - calling C{parseWithTabs} on your grammar before calling C{parseString}
-           (see L{I{parseWithTabs}<parseWithTabs>})
-         - define your parse action using the full C{(s,loc,toks)} signature, and
-           reference the input string using the parse action's C{s} argument
-         - explictly expand the tabs in your input string before calling
-           C{parseString}
-        
-        Example::
-            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
-            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
-        """
-        ParserElement.resetCache()
-        if not self.streamlined:
-            self.streamline()
-            #~ self.saveAsList = True
-        for e in self.ignoreExprs:
-            e.streamline()
-        if not self.keepTabs:
-            instring = instring.expandtabs()
-        try:
-            loc, tokens = self._parse( instring, 0 )
-            if parseAll:
-                loc = self.preParse( instring, loc )
-                se = Empty() + StringEnd()
-                se._parse( instring, loc )
-        except ParseBaseException as exc:
-            if ParserElement.verbose_stacktrace:
-                raise
-            else:
-                # catch and re-raise exception from here, clears out pyparsing internal stack trace
-                raise exc
-        else:
-            return tokens
-
-    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
-        """
-        Scan the input string for expression matches.  Each match will return the
-        matching tokens, start location, and end location.  May be called with optional
-        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
-        C{overlap} is specified, then overlapping matches will be reported.
-
-        Note that the start and end locations are reported relative to the string
-        being parsed.  See L{I{parseString}<parseString>} for more information on parsing
-        strings with embedded tabs.
-
-        Example::
-            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
-            print(source)
-            for tokens,start,end in Word(alphas).scanString(source):
-                print(' '*start + '^'*(end-start))
-                print(' '*start + tokens[0])
-        
-        prints::
-        
-            sldjf123lsdjjkf345sldkjf879lkjsfd987
-            ^^^^^
-            sldjf
-                    ^^^^^^^
-                    lsdjjkf
-                              ^^^^^^
-                              sldkjf
-                                       ^^^^^^
-                                       lkjsfd
-        """
-        if not self.streamlined:
-            self.streamline()
-        for e in self.ignoreExprs:
-            e.streamline()
-
-        if not self.keepTabs:
-            instring = _ustr(instring).expandtabs()
-        instrlen = len(instring)
-        loc = 0
-        preparseFn = self.preParse
-        parseFn = self._parse
-        ParserElement.resetCache()
-        matches = 0
-        try:
-            while loc <= instrlen and matches < maxMatches:
-                try:
-                    preloc = preparseFn( instring, loc )
-                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
-                except ParseException:
-                    loc = preloc+1
-                else:
-                    if nextLoc > loc:
-                        matches += 1
-                        yield tokens, preloc, nextLoc
-                        if overlap:
-                            nextloc = preparseFn( instring, loc )
-                            if nextloc > loc:
-                                loc = nextLoc
-                            else:
-                                loc += 1
-                        else:
-                            loc = nextLoc
-                    else:
-                        loc = preloc+1
-        except ParseBaseException as exc:
-            if ParserElement.verbose_stacktrace:
-                raise
-            else:
-                # catch and re-raise exception from here, clears out pyparsing internal stack trace
-                raise exc
-
-    def transformString( self, instring ):
-        """
-        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
-        be returned from a parse action.  To use C{transformString}, define a grammar and
-        attach a parse action to it that modifies the returned token list.
-        Invoking C{transformString()} on a target string will then scan for matches,
-        and replace the matched text patterns according to the logic in the parse
-        action.  C{transformString()} returns the resulting transformed string.
-        
-        Example::
-            wd = Word(alphas)
-            wd.setParseAction(lambda toks: toks[0].title())
-            
-            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
-        Prints::
-            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
-        """
-        out = []
-        lastE = 0
-        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
-        # keep string locs straight between transformString and scanString
-        self.keepTabs = True
-        try:
-            for t,s,e in self.scanString( instring ):
-                out.append( instring[lastE:s] )
-                if t:
-                    if isinstance(t,ParseResults):
-                        out += t.asList()
-                    elif isinstance(t,list):
-                        out += t
-                    else:
-                        out.append(t)
-                lastE = e
-            out.append(instring[lastE:])
-            out = [o for o in out if o]
-            return "".join(map(_ustr,_flatten(out)))
-        except ParseBaseException as exc:
-            if ParserElement.verbose_stacktrace:
-                raise
-            else:
-                # catch and re-raise exception from here, clears out pyparsing internal stack trace
-                raise exc
-
-    def searchString( self, instring, maxMatches=_MAX_INT ):
-        """
-        Another extension to C{L{scanString}}, simplifying the access to the tokens found
-        to match the given parse expression.  May be called with optional
-        C{maxMatches} argument, to clip searching after 'n' matches are found.
-        
-        Example::
-            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
-            cap_word = Word(alphas.upper(), alphas.lower())
-            
-            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
-        prints::
-            ['More', 'Iron', 'Lead', 'Gold', 'I']
-        """
-        try:
-            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
-        except ParseBaseException as exc:
-            if ParserElement.verbose_stacktrace:
-                raise
-            else:
-                # catch and re-raise exception from here, clears out pyparsing internal stack trace
-                raise exc
-
-    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
-        """
-        Generator method to split a string using the given expression as a separator.
-        May be called with optional C{maxsplit} argument, to limit the number of splits;
-        and the optional C{includeSeparators} argument (default=C{False}), if the separating
-        matching text should be included in the split results.
-        
-        Example::        
-            punc = oneOf(list(".,;:/-!?"))
-            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
-        prints::
-            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
-        """
-        splits = 0
-        last = 0
-        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
-            yield instring[last:s]
-            if includeSeparators:
-                yield t[0]
-            last = e
-        yield instring[last:]
-
-    def __add__(self, other ):
-        """
-        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
-        converts them to L{Literal}s by default.
-        
-        Example::
-            greet = Word(alphas) + "," + Word(alphas) + "!"
-            hello = "Hello, World!"
-            print (hello, "->", greet.parseString(hello))
-        Prints::
-            Hello, World! -> ['Hello', ',', 'World', '!']
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return And( [ self, other ] )
-
-    def __radd__(self, other ):
-        """
-        Implementation of + operator when left operand is not a C{L{ParserElement}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other + self
-
-    def __sub__(self, other):
-        """
-        Implementation of - operator, returns C{L{And}} with error stop
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return And( [ self, And._ErrorStop(), other ] )
-
-    def __rsub__(self, other ):
-        """
-        Implementation of - operator when left operand is not a C{L{ParserElement}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other - self
-
-    def __mul__(self,other):
-        """
-        Implementation of * operator, allows use of C{expr * 3} in place of
-        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
-        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
-        may also include C{None} as in:
-         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
-              to C{expr*n + L{ZeroOrMore}(expr)}
-              (read as "at least n instances of C{expr}")
-         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
-              (read as "0 to n instances of C{expr}")
-         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
-         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
-
-        Note that C{expr*(None,n)} does not raise an exception if
-        more than n exprs exist in the input stream; that is,
-        C{expr*(None,n)} does not enforce a maximum number of expr
-        occurrences.  If this behavior is desired, then write
-        C{expr*(None,n) + ~expr}
-        """
-        if isinstance(other,int):
-            minElements, optElements = other,0
-        elif isinstance(other,tuple):
-            other = (other + (None, None))[:2]
-            if other[0] is None:
-                other = (0, other[1])
-            if isinstance(other[0],int) and other[1] is None:
-                if other[0] == 0:
-                    return ZeroOrMore(self)
-                if other[0] == 1:
-                    return OneOrMore(self)
-                else:
-                    return self*other[0] + ZeroOrMore(self)
-            elif isinstance(other[0],int) and isinstance(other[1],int):
-                minElements, optElements = other
-                optElements -= minElements
-            else:
-                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
-        else:
-            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
-
-        if minElements < 0:
-            raise ValueError("cannot multiply ParserElement by negative value")
-        if optElements < 0:
-            raise ValueError("second tuple value must be greater or equal to first tuple value")
-        if minElements == optElements == 0:
-            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
-
-        if (optElements):
-            def makeOptionalList(n):
-                if n>1:
-                    return Optional(self + makeOptionalList(n-1))
-                else:
-                    return Optional(self)
-            if minElements:
-                if minElements == 1:
-                    ret = self + makeOptionalList(optElements)
-                else:
-                    ret = And([self]*minElements) + makeOptionalList(optElements)
-            else:
-                ret = makeOptionalList(optElements)
-        else:
-            if minElements == 1:
-                ret = self
-            else:
-                ret = And([self]*minElements)
-        return ret
-
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __or__(self, other ):
-        """
-        Implementation of | operator - returns C{L{MatchFirst}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return MatchFirst( [ self, other ] )
-
-    def __ror__(self, other ):
-        """
-        Implementation of | operator when left operand is not a C{L{ParserElement}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other | self
-
-    def __xor__(self, other ):
-        """
-        Implementation of ^ operator - returns C{L{Or}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return Or( [ self, other ] )
-
-    def __rxor__(self, other ):
-        """
-        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other ^ self
-
-    def __and__(self, other ):
-        """
-        Implementation of & operator - returns C{L{Each}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return Each( [ self, other ] )
-
-    def __rand__(self, other ):
-        """
-        Implementation of & operator when left operand is not a C{L{ParserElement}}
-        """
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other & self
-
-    def __invert__( self ):
-        """
-        Implementation of ~ operator - returns C{L{NotAny}}
-        """
-        return NotAny( self )
-
-    def __call__(self, name=None):
-        """
-        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
-        
-        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
-        passed as C{True}.
-           
-        If C{name} is omitted, same as calling C{L{copy}}.
-
-        Example::
-            # these are equivalent
-            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
-            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
-        """
-        if name is not None:
-            return self.setResultsName(name)
-        else:
-            return self.copy()
-
-    def suppress( self ):
-        """
-        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
-        cluttering up returned output.
-        """
-        return Suppress( self )
-
-    def leaveWhitespace( self ):
-        """
-        Disables the skipping of whitespace before matching the characters in the
-        C{ParserElement}'s defined pattern.  This is normally only used internally by
-        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
-        """
-        self.skipWhitespace = False
-        return self
-
-    def setWhitespaceChars( self, chars ):
-        """
-        Overrides the default whitespace chars
-        """
-        self.skipWhitespace = True
-        self.whiteChars = chars
-        self.copyDefaultWhiteChars = False
-        return self
-
-    def parseWithTabs( self ):
-        """
-        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.
-        Must be called before C{parseString} when the input grammar contains elements that
-        match C{<TAB>} characters.
-        """
-        self.keepTabs = True
-        return self
-
-    def ignore( self, other ):
-        """
-        Define expression to be ignored (e.g., comments) while doing pattern
-        matching; may be called repeatedly, to define multiple comment or other
-        ignorable patterns.
-        
-        Example::
-            patt = OneOrMore(Word(alphas))
-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
-            
-            patt.ignore(cStyleComment)
-            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
-        """
-        if isinstance(other, basestring):
-            other = Suppress(other)
-
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                self.ignoreExprs.append(other)
-        else:
-            self.ignoreExprs.append( Suppress( other.copy() ) )
-        return self
-
-    def setDebugActions( self, startAction, successAction, exceptionAction ):
-        """
-        Enable display of debugging messages while doing pattern matching.
-        """
-        self.debugActions = (startAction or _defaultStartDebugAction,
-                             successAction or _defaultSuccessDebugAction,
-                             exceptionAction or _defaultExceptionDebugAction)
-        self.debug = True
-        return self
-
-    def setDebug( self, flag=True ):
-        """
-        Enable display of debugging messages while doing pattern matching.
-        Set C{flag} to True to enable, False to disable.
-
-        Example::
-            wd = Word(alphas).setName("alphaword")
-            integer = Word(nums).setName("numword")
-            term = wd | integer
-            
-            # turn on debugging for wd
-            wd.setDebug()
-
-            OneOrMore(term).parseString("abc 123 xyz 890")
-        
-        prints::
-            Match alphaword at loc 0(1,1)
-            Matched alphaword -> ['abc']
-            Match alphaword at loc 3(1,4)
-            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
-            Match alphaword at loc 7(1,8)
-            Matched alphaword -> ['xyz']
-            Match alphaword at loc 11(1,12)
-            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
-            Match alphaword at loc 15(1,16)
-            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
-
-        The output shown is that produced by the default debug actions - custom debug actions can be
-        specified using L{setDebugActions}. Prior to attempting
-        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}
-        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
-        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
-        which makes debugging and exception messages easier to understand - for instance, the default
-        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
-        """
-        if flag:
-            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
-        else:
-            self.debug = False
-        return self
-
-    def __str__( self ):
-        return self.name
-
-    def __repr__( self ):
-        return _ustr(self)
-
-    def streamline( self ):
-        self.streamlined = True
-        self.strRepr = None
-        return self
-
-    def checkRecursion( self, parseElementList ):
-        pass
-
-    def validate( self, validateTrace=[] ):
-        """
-        Check defined expressions for valid structure, check for infinite recursive definitions.
-        """
-        self.checkRecursion( [] )
-
-    def parseFile( self, file_or_filename, parseAll=False ):
-        """
-        Execute the parse expression on the given file or filename.
-        If a filename is specified (instead of a file object),
-        the entire file is opened, read, and closed before parsing.
-        """
-        try:
-            file_contents = file_or_filename.read()
-        except AttributeError:
-            with open(file_or_filename, "r") as f:
-                file_contents = f.read()
-        try:
-            return self.parseString(file_contents, parseAll)
-        except ParseBaseException as exc:
-            if ParserElement.verbose_stacktrace:
-                raise
-            else:
-                # catch and re-raise exception from here, clears out pyparsing internal stack trace
-                raise exc
-
-    def __eq__(self,other):
-        if isinstance(other, ParserElement):
-            return self is other or vars(self) == vars(other)
-        elif isinstance(other, basestring):
-            return self.matches(other)
-        else:
-            return super(ParserElement,self)==other
-
-    def __ne__(self,other):
-        return not (self == other)
-
-    def __hash__(self):
-        return hash(id(self))
-
-    def __req__(self,other):
-        return self == other
-
-    def __rne__(self,other):
-        return not (self == other)
-
-    def matches(self, testString, parseAll=True):
-        """
-        Method for quick testing of a parser against a test string. Good for simple 
-        inline microtests of sub expressions while building up larger parser.
-           
-        Parameters:
-         - testString - to test against this expression for a match
-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
-            
-        Example::
-            expr = Word(nums)
-            assert expr.matches("100")
-        """
-        try:
-            self.parseString(_ustr(testString), parseAll=parseAll)
-            return True
-        except ParseBaseException:
-            return False
-                
-    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
-        """
-        Execute the parse expression on a series of test strings, showing each
-        test, the parsed results or where the parse failed. Quick and easy way to
-        run a parse expression against a list of sample strings.
-           
-        Parameters:
-         - tests - a list of separate test strings, or a multiline string of test strings
-         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
-         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
-              string; pass None to disable comment filtering
-         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
-              if False, only dump nested list
-         - printResults - (default=C{True}) prints test output to stdout
-         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing
-
-        Returns: a (success, results) tuple, where success indicates that all tests succeeded
-        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
-        test's output
-        
-        Example::
-            number_expr = pyparsing_common.number.copy()
-
-            result = number_expr.runTests('''
-                # unsigned integer
-                100
-                # negative integer
-                -100
-                # float with scientific notation
-                6.02e23
-                # integer with scientific notation
-                1e-12
-                ''')
-            print("Success" if result[0] else "Failed!")
-
-            result = number_expr.runTests('''
-                # stray character
-                100Z
-                # missing leading digit before '.'
-                -.100
-                # too many '.'
-                3.14.159
-                ''', failureTests=True)
-            print("Success" if result[0] else "Failed!")
-        prints::
-            # unsigned integer
-            100
-            [100]
-
-            # negative integer
-            -100
-            [-100]
-
-            # float with scientific notation
-            6.02e23
-            [6.02e+23]
-
-            # integer with scientific notation
-            1e-12
-            [1e-12]
-
-            Success
-            
-            # stray character
-            100Z
-               ^
-            FAIL: Expected end of text (at char 3), (line:1, col:4)
-
-            # missing leading digit before '.'
-            -.100
-            ^
-            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
-
-            # too many '.'
-            3.14.159
-                ^
-            FAIL: Expected end of text (at char 4), (line:1, col:5)
-
-            Success
-
-        Each test string must be on a single line. If you want to test a string that spans multiple
-        lines, create a test like this::
-
-            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
-        
-        (Note that this is a raw string literal, you must include the leading 'r'.)
-        """
-        if isinstance(tests, basestring):
-            tests = list(map(str.strip, tests.rstrip().splitlines()))
-        if isinstance(comment, basestring):
-            comment = Literal(comment)
-        allResults = []
-        comments = []
-        success = True
-        for t in tests:
-            if comment is not None and comment.matches(t, False) or comments and not t:
-                comments.append(t)
-                continue
-            if not t:
-                continue
-            out = ['\n'.join(comments), t]
-            comments = []
-            try:
-                t = t.replace(r'\n','\n')
-                result = self.parseString(t, parseAll=parseAll)
-                out.append(result.dump(full=fullDump))
-                success = success and not failureTests
-            except ParseBaseException as pe:
-                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
-                if '\n' in t:
-                    out.append(line(pe.loc, t))
-                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
-                else:
-                    out.append(' '*pe.loc + '^' + fatal)
-                out.append("FAIL: " + str(pe))
-                success = success and failureTests
-                result = pe
-            except Exception as exc:
-                out.append("FAIL-EXCEPTION: " + str(exc))
-                success = success and failureTests
-                result = exc
-
-            if printResults:
-                if fullDump:
-                    out.append('')
-                print('\n'.join(out))
-
-            allResults.append((t, result))
-        
-        return success, allResults
-
-        
-class Token(ParserElement):
-    """
-    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
-    """
-    def __init__( self ):
-        super(Token,self).__init__( savelist=False )
-
-
-class Empty(Token):
-    """
-    An empty token, will always match.
-    """
-    def __init__( self ):
-        super(Empty,self).__init__()
-        self.name = "Empty"
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-
-
-class NoMatch(Token):
-    """
-    A token that will never match.
-    """
-    def __init__( self ):
-        super(NoMatch,self).__init__()
-        self.name = "NoMatch"
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-        self.errmsg = "Unmatchable token"
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        raise ParseException(instring, loc, self.errmsg, self)
-
-
-class Literal(Token):
-    """
-    Token to exactly match a specified string.
-    
-    Example::
-        Literal('blah').parseString('blah')  # -> ['blah']
-        Literal('blah').parseString('blahfooblah')  # -> ['blah']
-        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
-    
-    For case-insensitive matching, use L{CaselessLiteral}.
-    
-    For keyword matching (force word break before and after the matched string),
-    use L{Keyword} or L{CaselessKeyword}.
-    """
-    def __init__( self, matchString ):
-        super(Literal,self).__init__()
-        self.match = matchString
-        self.matchLen = len(matchString)
-        try:
-            self.firstMatchChar = matchString[0]
-        except IndexError:
-            warnings.warn("null string passed to Literal; use Empty() instead",
-                            SyntaxWarning, stacklevel=2)
-            self.__class__ = Empty
-        self.name = '"%s"' % _ustr(self.match)
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = False
-        self.mayIndexError = False
-
-    # Performance tuning: this routine gets called a *lot*
-    # if this is a single character match string  and the first character matches,
-    # short-circuit as quickly as possible, and avoid calling startswith
-    #~ @profile
-    def parseImpl( self, instring, loc, doActions=True ):
-        if (instring[loc] == self.firstMatchChar and
-            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
-            return loc+self.matchLen, self.match
-        raise ParseException(instring, loc, self.errmsg, self)
-_L = Literal
-ParserElement._literalStringClass = Literal
-
-class Keyword(Token):
-    """
-    Token to exactly match a specified string as a keyword, that is, it must be
-    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
-     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
-     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
-    Accepts two optional constructor arguments in addition to the keyword string:
-     - C{identChars} is a string of characters that would be valid identifier characters,
-          defaulting to all alphanumerics + "_" and "$"
-     - C{caseless} allows case-insensitive matching, default is C{False}.
-       
-    Example::
-        Keyword("start").parseString("start")  # -> ['start']
-        Keyword("start").parseString("starting")  # -> Exception
-
-    For case-insensitive matching, use L{CaselessKeyword}.
-    """
-    DEFAULT_KEYWORD_CHARS = alphanums+"_$"
-
-    def __init__( self, matchString, identChars=None, caseless=False ):
-        super(Keyword,self).__init__()
-        if identChars is None:
-            identChars = Keyword.DEFAULT_KEYWORD_CHARS
-        self.match = matchString
-        self.matchLen = len(matchString)
-        try:
-            self.firstMatchChar = matchString[0]
-        except IndexError:
-            warnings.warn("null string passed to Keyword; use Empty() instead",
-                            SyntaxWarning, stacklevel=2)
-        self.name = '"%s"' % self.match
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = False
-        self.mayIndexError = False
-        self.caseless = caseless
-        if caseless:
-            self.caselessmatch = matchString.upper()
-            identChars = identChars.upper()
-        self.identChars = set(identChars)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.caseless:
-            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
-                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
-                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
-                return loc+self.matchLen, self.match
-        else:
-            if (instring[loc] == self.firstMatchChar and
-                (self.matchLen==1 or instring.startswith(self.match,loc)) and
-                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
-                (loc == 0 or instring[loc-1] not in self.identChars) ):
-                return loc+self.matchLen, self.match
-        raise ParseException(instring, loc, self.errmsg, self)
-
-    def copy(self):
-        c = super(Keyword,self).copy()
-        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
-        return c
-
-    @staticmethod
-    def setDefaultKeywordChars( chars ):
-        """Overrides the default Keyword chars
-        """
-        Keyword.DEFAULT_KEYWORD_CHARS = chars
-
-class CaselessLiteral(Literal):
-    """
-    Token to match a specified string, ignoring case of letters.
-    Note: the matched results will always be in the case of the given
-    match string, NOT the case of the input text.
-
-    Example::
-        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
-        
-    (Contrast with example for L{CaselessKeyword}.)
-    """
-    def __init__( self, matchString ):
-        super(CaselessLiteral,self).__init__( matchString.upper() )
-        # Preserve the defining literal.
-        self.returnString = matchString
-        self.name = "'%s'" % self.returnString
-        self.errmsg = "Expected " + self.name
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if instring[ loc:loc+self.matchLen ].upper() == self.match:
-            return loc+self.matchLen, self.returnString
-        raise ParseException(instring, loc, self.errmsg, self)
-
-class CaselessKeyword(Keyword):
-    """
-    Caseless version of L{Keyword}.
-
-    Example::
-        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
-        
-    (Contrast with example for L{CaselessLiteral}.)
-    """
-    def __init__( self, matchString, identChars=None ):
-        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
-             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
-            return loc+self.matchLen, self.match
-        raise ParseException(instring, loc, self.errmsg, self)
-
-class CloseMatch(Token):
-    """
-    A variation on L{Literal} which matches "close" matches, that is, 
-    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
-     - C{match_string} - string to be matched
-     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
-    
-    The results from a successful parse will contain the matched text from the input string and the following named results:
-     - C{mismatches} - a list of the positions within the match_string where mismatches were found
-     - C{original} - the original match_string used to compare against the input string
-    
-    If C{mismatches} is an empty list, then the match was an exact match.
-    
-    Example::
-        patt = CloseMatch("ATCATCGAATGGA")
-        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
-        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
-
-        # exact match
-        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
-
-        # close match allowing up to 2 mismatches
-        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
-        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
-    """
-    def __init__(self, match_string, maxMismatches=1):
-        super(CloseMatch,self).__init__()
-        self.name = match_string
-        self.match_string = match_string
-        self.maxMismatches = maxMismatches
-        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
-        self.mayIndexError = False
-        self.mayReturnEmpty = False
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        start = loc
-        instrlen = len(instring)
-        maxloc = start + len(self.match_string)
-
-        if maxloc <= instrlen:
-            match_string = self.match_string
-            match_stringloc = 0
-            mismatches = []
-            maxMismatches = self.maxMismatches
-
-            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
-                src,mat = s_m
-                if src != mat:
-                    mismatches.append(match_stringloc)
-                    if len(mismatches) > maxMismatches:
-                        break
-            else:
-                loc = match_stringloc + 1
-                results = ParseResults([instring[start:loc]])
-                results['original'] = self.match_string
-                results['mismatches'] = mismatches
-                return loc, results
-
-        raise ParseException(instring, loc, self.errmsg, self)
-
-
-class Word(Token):
-    """
-    Token for matching words composed of allowed character sets.
-    Defined with string containing all allowed initial characters,
-    an optional string containing allowed body characters (if omitted,
-    defaults to the initial character set), and an optional minimum,
-    maximum, and/or exact length.  The default value for C{min} is 1 (a
-    minimum value < 1 is not valid); the default values for C{max} and C{exact}
-    are 0, meaning no maximum or exact length restriction. An optional
-    C{excludeChars} parameter can list characters that might be found in 
-    the input C{bodyChars} string; useful to define a word of all printables
-    except for one or two characters, for instance.
-    
-    L{srange} is useful for defining custom character set strings for defining 
-    C{Word} expressions, using range notation from regular expression character sets.
-    
-    A common mistake is to use C{Word} to match a specific literal string, as in 
-    C{Word("Address")}. Remember that C{Word} uses the string argument to define
-    I{sets} of matchable characters. This expression would match "Add", "AAA",
-    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
-    To match an exact literal string, use L{Literal} or L{Keyword}.
-
-    pyparsing includes helper strings for building Words:
-     - L{alphas}
-     - L{nums}
-     - L{alphanums}
-     - L{hexnums}
-     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
-     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
-     - L{printables} (any non-whitespace character)
-
-    Example::
-        # a word composed of digits
-        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
-        
-        # a word with a leading capital, and zero or more lowercase
-        capital_word = Word(alphas.upper(), alphas.lower())
-
-        # hostnames are alphanumeric, with leading alpha, and '-'
-        hostname = Word(alphas, alphanums+'-')
-        
-        # roman numeral (not a strict parser, accepts invalid mix of characters)
-        roman = Word("IVXLCDM")
-        
-        # any string of non-whitespace characters, except for ','
-        csv_value = Word(printables, excludeChars=",")
-    """
-    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
-        super(Word,self).__init__()
-        if excludeChars:
-            initChars = ''.join(c for c in initChars if c not in excludeChars)
-            if bodyChars:
-                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
-        self.initCharsOrig = initChars
-        self.initChars = set(initChars)
-        if bodyChars :
-            self.bodyCharsOrig = bodyChars
-            self.bodyChars = set(bodyChars)
-        else:
-            self.bodyCharsOrig = initChars
-            self.bodyChars = set(initChars)
-
-        self.maxSpecified = max > 0
-
-        if min < 1:
-            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        self.mayIndexError = False
-        self.asKeyword = asKeyword
-
-        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
-            if self.bodyCharsOrig == self.initCharsOrig:
-                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
-            elif len(self.initCharsOrig) == 1:
-                self.reString = "%s[%s]*" % \
-                                      (re.escape(self.initCharsOrig),
-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
-            else:
-                self.reString = "[%s][%s]*" % \
-                                      (_escapeRegexRangeChars(self.initCharsOrig),
-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
-            if self.asKeyword:
-                self.reString = r"\b"+self.reString+r"\b"
-            try:
-                self.re = re.compile( self.reString )
-            except Exception:
-                self.re = None
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.re:
-            result = self.re.match(instring,loc)
-            if not result:
-                raise ParseException(instring, loc, self.errmsg, self)
-
-            loc = result.end()
-            return loc, result.group()
-
-        if not(instring[ loc ] in self.initChars):
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        start = loc
-        loc += 1
-        instrlen = len(instring)
-        bodychars = self.bodyChars
-        maxloc = start + self.maxLen
-        maxloc = min( maxloc, instrlen )
-        while loc < maxloc and instring[loc] in bodychars:
-            loc += 1
-
-        throwException = False
-        if loc - start < self.minLen:
-            throwException = True
-        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
-            throwException = True
-        if self.asKeyword:
-            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
-                throwException = True
-
-        if throwException:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        return loc, instring[start:loc]
-
-    def __str__( self ):
-        try:
-            return super(Word,self).__str__()
-        except Exception:
-            pass
-
-
-        if self.strRepr is None:
-
-            def charsAsStr(s):
-                if len(s)>4:
-                    return s[:4]+"..."
-                else:
-                    return s
-
-            if ( self.initCharsOrig != self.bodyCharsOrig ):
-                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
-            else:
-                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
-
-        return self.strRepr
-
-
-class Regex(Token):
-    """
-    Token for matching strings that match a given regular expression.
-    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
-    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 
-    named parse results.
-
-    Example::
-        realnum = Regex(r"[+-]?\d+\.\d*")
-        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
-        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
-        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
-    """
-    compiledREtype = type(re.compile("[A-Z]"))
-    def __init__( self, pattern, flags=0):
-        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
-        super(Regex,self).__init__()
-
-        if isinstance(pattern, basestring):
-            if not pattern:
-                warnings.warn("null string passed to Regex; use Empty() instead",
-                        SyntaxWarning, stacklevel=2)
-
-            self.pattern = pattern
-            self.flags = flags
-
-            try:
-                self.re = re.compile(self.pattern, self.flags)
-                self.reString = self.pattern
-            except sre_constants.error:
-                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
-                    SyntaxWarning, stacklevel=2)
-                raise
-
-        elif isinstance(pattern, Regex.compiledREtype):
-            self.re = pattern
-            self.pattern = \
-            self.reString = str(pattern)
-            self.flags = flags
-            
-        else:
-            raise ValueError("Regex may only be constructed with a string or a compiled RE object")
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        self.mayIndexError = False
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        result = self.re.match(instring,loc)
-        if not result:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        loc = result.end()
-        d = result.groupdict()
-        ret = ParseResults(result.group())
-        if d:
-            for k in d:
-                ret[k] = d[k]
-        return loc,ret
-
-    def __str__( self ):
-        try:
-            return super(Regex,self).__str__()
-        except Exception:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "Re:(%s)" % repr(self.pattern)
-
-        return self.strRepr
-
-
-class QuotedString(Token):
-    r"""
-    Token for matching strings that are delimited by quoting characters.
-    
-    Defined with the following parameters:
-        - quoteChar - string of one or more characters defining the quote delimiting string
-        - escChar - character to escape quotes, typically backslash (default=C{None})
-        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
-        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
-        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
-        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
-        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})
-
-    Example::
-        qs = QuotedString('"')
-        print(qs.searchString('lsjdf "This is the quote" sldjf'))
-        complex_qs = QuotedString('{{', endQuoteChar='}}')
-        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
-        sql_qs = QuotedString('"', escQuote='""')
-        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
-    prints::
-        [['This is the quote']]
-        [['This is the "quote"']]
-        [['This is the quote with "embedded" quotes']]
-    """
-    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
-        super(QuotedString,self).__init__()
-
-        # remove white space from quote chars - wont work anyway
-        quoteChar = quoteChar.strip()
-        if not quoteChar:
-            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
-            raise SyntaxError()
-
-        if endQuoteChar is None:
-            endQuoteChar = quoteChar
-        else:
-            endQuoteChar = endQuoteChar.strip()
-            if not endQuoteChar:
-                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
-                raise SyntaxError()
-
-        self.quoteChar = quoteChar
-        self.quoteCharLen = len(quoteChar)
-        self.firstQuoteChar = quoteChar[0]
-        self.endQuoteChar = endQuoteChar
-        self.endQuoteCharLen = len(endQuoteChar)
-        self.escChar = escChar
-        self.escQuote = escQuote
-        self.unquoteResults = unquoteResults
-        self.convertWhitespaceEscapes = convertWhitespaceEscapes
-
-        if multiline:
-            self.flags = re.MULTILINE | re.DOTALL
-            self.pattern = r'%s(?:[^%s%s]' % \
-                ( re.escape(self.quoteChar),
-                  _escapeRegexRangeChars(self.endQuoteChar[0]),
-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
-        else:
-            self.flags = 0
-            self.pattern = r'%s(?:[^%s\n\r%s]' % \
-                ( re.escape(self.quoteChar),
-                  _escapeRegexRangeChars(self.endQuoteChar[0]),
-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
-        if len(self.endQuoteChar) > 1:
-            self.pattern += (
-                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
-                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
-                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
-                )
-        if escQuote:
-            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
-        if escChar:
-            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
-            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
-        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
-
-        try:
-            self.re = re.compile(self.pattern, self.flags)
-            self.reString = self.pattern
-        except sre_constants.error:
-            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
-                SyntaxWarning, stacklevel=2)
-            raise
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        self.mayIndexError = False
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
-        if not result:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        loc = result.end()
-        ret = result.group()
-
-        if self.unquoteResults:
-
-            # strip off quotes
-            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
-
-            if isinstance(ret,basestring):
-                # replace escaped whitespace
-                if '\\' in ret and self.convertWhitespaceEscapes:
-                    ws_map = {
-                        r'\t' : '\t',
-                        r'\n' : '\n',
-                        r'\f' : '\f',
-                        r'\r' : '\r',
-                    }
-                    for wslit,wschar in ws_map.items():
-                        ret = ret.replace(wslit, wschar)
-
-                # replace escaped characters
-                if self.escChar:
-                    ret = re.sub(self.escCharReplacePattern,"\g<1>",ret)
-
-                # replace escaped quotes
-                if self.escQuote:
-                    ret = ret.replace(self.escQuote, self.endQuoteChar)
-
-        return loc, ret
-
-    def __str__( self ):
-        try:
-            return super(QuotedString,self).__str__()
-        except Exception:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
-
-        return self.strRepr
-
-
-class CharsNotIn(Token):
-    """
-    Token for matching words composed of characters I{not} in a given set (will
-    include whitespace in matched characters if not listed in the provided exclusion set - see example).
-    Defined with string containing all disallowed characters, and an optional
-    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
-    minimum value < 1 is not valid); the default values for C{max} and C{exact}
-    are 0, meaning no maximum or exact length restriction.
-
-    Example::
-        # define a comma-separated-value as anything that is not a ','
-        csv_value = CharsNotIn(',')
-        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
-    prints::
-        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
-    """
-    def __init__( self, notChars, min=1, max=0, exact=0 ):
-        super(CharsNotIn,self).__init__()
-        self.skipWhitespace = False
-        self.notChars = notChars
-
-        if min < 1:
-            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = ( self.minLen == 0 )
-        self.mayIndexError = False
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if instring[loc] in self.notChars:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        start = loc
-        loc += 1
-        notchars = self.notChars
-        maxlen = min( start+self.maxLen, len(instring) )
-        while loc < maxlen and \
-              (instring[loc] not in notchars):
-            loc += 1
-
-        if loc - start < self.minLen:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        return loc, instring[start:loc]
-
-    def __str__( self ):
-        try:
-            return super(CharsNotIn, self).__str__()
-        except Exception:
-            pass
-
-        if self.strRepr is None:
-            if len(self.notChars) > 4:
-                self.strRepr = "!W:(%s...)" % self.notChars[:4]
-            else:
-                self.strRepr = "!W:(%s)" % self.notChars
-
-        return self.strRepr
-
-class White(Token):
-    """
-    Special matching class for matching whitespace.  Normally, whitespace is ignored
-    by pyparsing grammars.  This class is included when some whitespace structures
-    are significant.  Define with a string containing the whitespace characters to be
-    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
-    as defined for the C{L{Word}} class.
-    """
-    whiteStrs = {
-        " " : "<SPC>",
-        "\t": "<TAB>",
-        "\n": "<LF>",
-        "\r": "<CR>",
-        "\f": "<FF>",
-        }
-    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
-        super(White,self).__init__()
-        self.matchWhite = ws
-        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
-        #~ self.leaveWhitespace()
-        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
-        self.mayReturnEmpty = True
-        self.errmsg = "Expected " + self.name
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if not(instring[ loc ] in self.matchWhite):
-            raise ParseException(instring, loc, self.errmsg, self)
-        start = loc
-        loc += 1
-        maxloc = start + self.maxLen
-        maxloc = min( maxloc, len(instring) )
-        while loc < maxloc and instring[loc] in self.matchWhite:
-            loc += 1
-
-        if loc - start < self.minLen:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        return loc, instring[start:loc]
-
-
-class _PositionToken(Token):
-    def __init__( self ):
-        super(_PositionToken,self).__init__()
-        self.name=self.__class__.__name__
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-
-class GoToColumn(_PositionToken):
-    """
-    Token to advance to a specific column of input text; useful for tabular report scraping.
-    """
-    def __init__( self, colno ):
-        super(GoToColumn,self).__init__()
-        self.col = colno
-
-    def preParse( self, instring, loc ):
-        if col(loc,instring) != self.col:
-            instrlen = len(instring)
-            if self.ignoreExprs:
-                loc = self._skipIgnorables( instring, loc )
-            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
-                loc += 1
-        return loc
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        thiscol = col( loc, instring )
-        if thiscol > self.col:
-            raise ParseException( instring, loc, "Text not in expected column", self )
-        newloc = loc + self.col - thiscol
-        ret = instring[ loc: newloc ]
-        return newloc, ret
-
-
-class LineStart(_PositionToken):
-    """
-    Matches if current position is at the beginning of a line within the parse string
-    
-    Example::
-    
-        test = '''\
-        AAA this line
-        AAA and this line
-          AAA but not this one
-        B AAA and definitely not this one
-        '''
-
-        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
-            print(t)
-    
-    Prints::
-        ['AAA', ' this line']
-        ['AAA', ' and this line']    
-
-    """
-    def __init__( self ):
-        super(LineStart,self).__init__()
-        self.errmsg = "Expected start of line"
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if col(loc, instring) == 1:
-            return loc, []
-        raise ParseException(instring, loc, self.errmsg, self)
-
-class LineEnd(_PositionToken):
-    """
-    Matches if current position is at the end of a line within the parse string
-    """
-    def __init__( self ):
-        super(LineEnd,self).__init__()
-        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
-        self.errmsg = "Expected end of line"
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc<len(instring):
-            if instring[loc] == "\n":
-                return loc+1, "\n"
-            else:
-                raise ParseException(instring, loc, self.errmsg, self)
-        elif loc == len(instring):
-            return loc+1, []
-        else:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-class StringStart(_PositionToken):
-    """
-    Matches if current position is at the beginning of the parse string
-    """
-    def __init__( self ):
-        super(StringStart,self).__init__()
-        self.errmsg = "Expected start of text"
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc != 0:
-            # see if entire string up to here is just whitespace and ignoreables
-            if loc != self.preParse( instring, 0 ):
-                raise ParseException(instring, loc, self.errmsg, self)
-        return loc, []
-
-class StringEnd(_PositionToken):
-    """
-    Matches if current position is at the end of the parse string
-    """
-    def __init__( self ):
-        super(StringEnd,self).__init__()
-        self.errmsg = "Expected end of text"
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc < len(instring):
-            raise ParseException(instring, loc, self.errmsg, self)
-        elif loc == len(instring):
-            return loc+1, []
-        elif loc > len(instring):
-            return loc, []
-        else:
-            raise ParseException(instring, loc, self.errmsg, self)
-
-class WordStart(_PositionToken):
-    """
-    Matches if the current position is at the beginning of a Word, and
-    is not preceded by any character in a given set of C{wordChars}
-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
-    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
-    the string being parsed, or at the beginning of a line.
-    """
-    def __init__(self, wordChars = printables):
-        super(WordStart,self).__init__()
-        self.wordChars = set(wordChars)
-        self.errmsg = "Not at the start of a word"
-
-    def parseImpl(self, instring, loc, doActions=True ):
-        if loc != 0:
-            if (instring[loc-1] in self.wordChars or
-                instring[loc] not in self.wordChars):
-                raise ParseException(instring, loc, self.errmsg, self)
-        return loc, []
-
-class WordEnd(_PositionToken):
-    """
-    Matches if the current position is at the end of a Word, and
-    is not followed by any character in a given set of C{wordChars}
-    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
-    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
-    the string being parsed, or at the end of a line.
-    """
-    def __init__(self, wordChars = printables):
-        super(WordEnd,self).__init__()
-        self.wordChars = set(wordChars)
-        self.skipWhitespace = False
-        self.errmsg = "Not at the end of a word"
-
-    def parseImpl(self, instring, loc, doActions=True ):
-        instrlen = len(instring)
-        if instrlen>0 and loc<instrlen:
-            if (instring[loc] in self.wordChars or
-                instring[loc-1] not in self.wordChars):
-                raise ParseException(instring, loc, self.errmsg, self)
-        return loc, []
-
-
-class ParseExpression(ParserElement):
-    """
-    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.
-    """
-    def __init__( self, exprs, savelist = False ):
-        super(ParseExpression,self).__init__(savelist)
-        if isinstance( exprs, _generatorType ):
-            exprs = list(exprs)
-
-        if isinstance( exprs, basestring ):
-            self.exprs = [ ParserElement._literalStringClass( exprs ) ]
-        elif isinstance( exprs, collections.Iterable ):
-            exprs = list(exprs)
-            # if sequence of strings provided, wrap with Literal
-            if all(isinstance(expr, basestring) for expr in exprs):
-                exprs = map(ParserElement._literalStringClass, exprs)
-            self.exprs = list(exprs)
-        else:
-            try:
-                self.exprs = list( exprs )
-            except TypeError:
-                self.exprs = [ exprs ]
-        self.callPreparse = False
-
-    def __getitem__( self, i ):
-        return self.exprs[i]
-
-    def append( self, other ):
-        self.exprs.append( other )
-        self.strRepr = None
-        return self
-
-    def leaveWhitespace( self ):
-        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on
-           all contained expressions."""
-        self.skipWhitespace = False
-        self.exprs = [ e.copy() for e in self.exprs ]
-        for e in self.exprs:
-            e.leaveWhitespace()
-        return self
-
-    def ignore( self, other ):
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                super( ParseExpression, self).ignore( other )
-                for e in self.exprs:
-                    e.ignore( self.ignoreExprs[-1] )
-        else:
-            super( ParseExpression, self).ignore( other )
-            for e in self.exprs:
-                e.ignore( self.ignoreExprs[-1] )
-        return self
-
-    def __str__( self ):
-        try:
-            return super(ParseExpression,self).__str__()
-        except Exception:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )
-        return self.strRepr
-
-    def streamline( self ):
-        super(ParseExpression,self).streamline()
-
-        for e in self.exprs:
-            e.streamline()
-
-        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )
-        # but only if there are no parse actions or resultsNames on the nested And's
-        # (likewise for Or's and MatchFirst's)
-        if ( len(self.exprs) == 2 ):
-            other = self.exprs[0]
-            if ( isinstance( other, self.__class__ ) and
-                  not(other.parseAction) and
-                  other.resultsName is None and
-                  not other.debug ):
-                self.exprs = other.exprs[:] + [ self.exprs[1] ]
-                self.strRepr = None
-                self.mayReturnEmpty |= other.mayReturnEmpty
-                self.mayIndexError  |= other.mayIndexError
-
-            other = self.exprs[-1]
-            if ( isinstance( other, self.__class__ ) and
-                  not(other.parseAction) and
-                  other.resultsName is None and
-                  not other.debug ):
-                self.exprs = self.exprs[:-1] + other.exprs[:]
-                self.strRepr = None
-                self.mayReturnEmpty |= other.mayReturnEmpty
-                self.mayIndexError  |= other.mayIndexError
-
-        self.errmsg = "Expected " + _ustr(self)
-        
-        return self
-
-    def setResultsName( self, name, listAllMatches=False ):
-        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)
-        return ret
-
-    def validate( self, validateTrace=[] ):
-        tmp = validateTrace[:]+[self]
-        for e in self.exprs:
-            e.validate(tmp)
-        self.checkRecursion( [] )
-        
-    def copy(self):
-        ret = super(ParseExpression,self).copy()
-        ret.exprs = [e.copy() for e in self.exprs]
-        return ret
-
-class And(ParseExpression):
-    """
-    Requires all given C{ParseExpression}s to be found in the given order.
-    Expressions may be separated by whitespace.
-    May be constructed using the C{'+'} operator.
-    May also be constructed using the C{'-'} operator, which will suppress backtracking.
-
-    Example::
-        integer = Word(nums)
-        name_expr = OneOrMore(Word(alphas))
-
-        expr = And([integer("id"),name_expr("name"),integer("age")])
-        # more easily written as:
-        expr = integer("id") + name_expr("name") + integer("age")
-    """
-
-    class _ErrorStop(Empty):
-        def __init__(self, *args, **kwargs):
-            super(And._ErrorStop,self).__init__(*args, **kwargs)
-            self.name = '-'
-            self.leaveWhitespace()
-
-    def __init__( self, exprs, savelist = True ):
-        super(And,self).__init__(exprs, savelist)
-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
-        self.setWhitespaceChars( self.exprs[0].whiteChars )
-        self.skipWhitespace = self.exprs[0].skipWhitespace
-        self.callPreparse = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        # pass False as last arg to _parse for first element, since we already
-        # pre-parsed the string as part of our And pre-parsing
-        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )
-        errorStop = False
-        for e in self.exprs[1:]:
-            if isinstance(e, And._ErrorStop):
-                errorStop = True
-                continue
-            if errorStop:
-                try:
-                    loc, exprtokens = e._parse( instring, loc, doActions )
-                except ParseSyntaxException:
-                    raise
-                except ParseBaseException as pe:
-                    pe.__traceback__ = None
-                    raise ParseSyntaxException._from_exception(pe)
-                except IndexError:
-                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)
-            else:
-                loc, exprtokens = e._parse( instring, loc, doActions )
-            if exprtokens or exprtokens.haskeys():
-                resultlist += exprtokens
-        return loc, resultlist
-
-    def __iadd__(self, other ):
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        return self.append( other ) #And( [ self, other ] )
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-            if not e.mayReturnEmpty:
-                break
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
-
-        return self.strRepr
-
-
-class Or(ParseExpression):
-    """
-    Requires that at least one C{ParseExpression} is found.
-    If two expressions match, the expression that matches the longest string will be used.
-    May be constructed using the C{'^'} operator.
-
-    Example::
-        # construct Or using '^' operator
-        
-        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
-        print(number.searchString("123 3.1416 789"))
-    prints::
-        [['123'], ['3.1416'], ['789']]
-    """
-    def __init__( self, exprs, savelist = False ):
-        super(Or,self).__init__(exprs, savelist)
-        if self.exprs:
-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
-        else:
-            self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        maxExcLoc = -1
-        maxException = None
-        matches = []
-        for e in self.exprs:
-            try:
-                loc2 = e.tryParse( instring, loc )
-            except ParseException as err:
-                err.__traceback__ = None
-                if err.loc > maxExcLoc:
-                    maxException = err
-                    maxExcLoc = err.loc
-            except IndexError:
-                if len(instring) > maxExcLoc:
-                    maxException = ParseException(instring,len(instring),e.errmsg,self)
-                    maxExcLoc = len(instring)
-            else:
-                # save match among all matches, to retry longest to shortest
-                matches.append((loc2, e))
-
-        if matches:
-            matches.sort(key=lambda x: -x[0])
-            for _,e in matches:
-                try:
-                    return e._parse( instring, loc, doActions )
-                except ParseException as err:
-                    err.__traceback__ = None
-                    if err.loc > maxExcLoc:
-                        maxException = err
-                        maxExcLoc = err.loc
-
-        if maxException is not None:
-            maxException.msg = self.errmsg
-            raise maxException
-        else:
-            raise ParseException(instring, loc, "no defined alternatives to match", self)
-
-
-    def __ixor__(self, other ):
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        return self.append( other ) #Or( [ self, other ] )
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class MatchFirst(ParseExpression):
-    """
-    Requires that at least one C{ParseExpression} is found.
-    If two expressions match, the first one listed is the one that will match.
-    May be constructed using the C{'|'} operator.
-
-    Example::
-        # construct MatchFirst using '|' operator
-        
-        # watch the order of expressions to match
-        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
-        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
-
-        # put more selective expression first
-        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
-        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
-    """
-    def __init__( self, exprs, savelist = False ):
-        super(MatchFirst,self).__init__(exprs, savelist)
-        if self.exprs:
-            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
-        else:
-            self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        maxExcLoc = -1
-        maxException = None
-        for e in self.exprs:
-            try:
-                ret = e._parse( instring, loc, doActions )
-                return ret
-            except ParseException as err:
-                if err.loc > maxExcLoc:
-                    maxException = err
-                    maxExcLoc = err.loc
-            except IndexError:
-                if len(instring) > maxExcLoc:
-                    maxException = ParseException(instring,len(instring),e.errmsg,self)
-                    maxExcLoc = len(instring)
-
-        # only got here if no expression matched, raise exception for match that made it the furthest
-        else:
-            if maxException is not None:
-                maxException.msg = self.errmsg
-                raise maxException
-            else:
-                raise ParseException(instring, loc, "no defined alternatives to match", self)
-
-    def __ior__(self, other ):
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass( other )
-        return self.append( other ) #MatchFirst( [ self, other ] )
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class Each(ParseExpression):
-    """
-    Requires all given C{ParseExpression}s to be found, but in any order.
-    Expressions may be separated by whitespace.
-    May be constructed using the C{'&'} operator.
-
-    Example::
-        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
-        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
-        integer = Word(nums)
-        shape_attr = "shape:" + shape_type("shape")
-        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
-        color_attr = "color:" + color("color")
-        size_attr = "size:" + integer("size")
-
-        # use Each (using operator '&') to accept attributes in any order 
-        # (shape and posn are required, color and size are optional)
-        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
-
-        shape_spec.runTests('''
-            shape: SQUARE color: BLACK posn: 100, 120
-            shape: CIRCLE size: 50 color: BLUE posn: 50,80
-            color:GREEN size:20 shape:TRIANGLE posn:20,40
-            '''
-            )
-    prints::
-        shape: SQUARE color: BLACK posn: 100, 120
-        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
-        - color: BLACK
-        - posn: ['100', ',', '120']
-          - x: 100
-          - y: 120
-        - shape: SQUARE
-
-
-        shape: CIRCLE size: 50 color: BLUE posn: 50,80
-        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
-        - color: BLUE
-        - posn: ['50', ',', '80']
-          - x: 50
-          - y: 80
-        - shape: CIRCLE
-        - size: 50
-
-
-        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
-        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
-        - color: GREEN
-        - posn: ['20', ',', '40']
-          - x: 20
-          - y: 40
-        - shape: TRIANGLE
-        - size: 20
-    """
-    def __init__( self, exprs, savelist = True ):
-        super(Each,self).__init__(exprs, savelist)
-        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
-        self.skipWhitespace = True
-        self.initExprGroups = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.initExprGroups:
-            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
-            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
-            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
-            self.optionals = opt1 + opt2
-            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
-            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
-            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
-            self.required += self.multirequired
-            self.initExprGroups = False
-        tmpLoc = loc
-        tmpReqd = self.required[:]
-        tmpOpt  = self.optionals[:]
-        matchOrder = []
-
-        keepMatching = True
-        while keepMatching:
-            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
-            failed = []
-            for e in tmpExprs:
-                try:
-                    tmpLoc = e.tryParse( instring, tmpLoc )
-                except ParseException:
-                    failed.append(e)
-                else:
-                    matchOrder.append(self.opt1map.get(id(e),e))
-                    if e in tmpReqd:
-                        tmpReqd.remove(e)
-                    elif e in tmpOpt:
-                        tmpOpt.remove(e)
-            if len(failed) == len(tmpExprs):
-                keepMatching = False
-
-        if tmpReqd:
-            missing = ", ".join(_ustr(e) for e in tmpReqd)
-            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
-
-        # add any unmatched Optionals, in case they have default values defined
-        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
-
-        resultlist = []
-        for e in matchOrder:
-            loc,results = e._parse(instring,loc,doActions)
-            resultlist.append(results)
-
-        finalResults = sum(resultlist, ParseResults([]))
-        return loc, finalResults
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class ParseElementEnhance(ParserElement):
-    """
-    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
-    """
-    def __init__( self, expr, savelist=False ):
-        super(ParseElementEnhance,self).__init__(savelist)
-        if isinstance( expr, basestring ):
-            if issubclass(ParserElement._literalStringClass, Token):
-                expr = ParserElement._literalStringClass(expr)
-            else:
-                expr = ParserElement._literalStringClass(Literal(expr))
-        self.expr = expr
-        self.strRepr = None
-        if expr is not None:
-            self.mayIndexError = expr.mayIndexError
-            self.mayReturnEmpty = expr.mayReturnEmpty
-            self.setWhitespaceChars( expr.whiteChars )
-            self.skipWhitespace = expr.skipWhitespace
-            self.saveAsList = expr.saveAsList
-            self.callPreparse = expr.callPreparse
-            self.ignoreExprs.extend(expr.ignoreExprs)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.expr is not None:
-            return self.expr._parse( instring, loc, doActions, callPreParse=False )
-        else:
-            raise ParseException("",loc,self.errmsg,self)
-
-    def leaveWhitespace( self ):
-        self.skipWhitespace = False
-        self.expr = self.expr.copy()
-        if self.expr is not None:
-            self.expr.leaveWhitespace()
-        return self
-
-    def ignore( self, other ):
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                super( ParseElementEnhance, self).ignore( other )
-                if self.expr is not None:
-                    self.expr.ignore( self.ignoreExprs[-1] )
-        else:
-            super( ParseElementEnhance, self).ignore( other )
-            if self.expr is not None:
-                self.expr.ignore( self.ignoreExprs[-1] )
-        return self
-
-    def streamline( self ):
-        super(ParseElementEnhance,self).streamline()
-        if self.expr is not None:
-            self.expr.streamline()
-        return self
-
-    def checkRecursion( self, parseElementList ):
-        if self in parseElementList:
-            raise RecursiveGrammarException( parseElementList+[self] )
-        subRecCheckList = parseElementList[:] + [ self ]
-        if self.expr is not None:
-            self.expr.checkRecursion( subRecCheckList )
-
-    def validate( self, validateTrace=[] ):
-        tmp = validateTrace[:]+[self]
-        if self.expr is not None:
-            self.expr.validate(tmp)
-        self.checkRecursion( [] )
-
-    def __str__( self ):
-        try:
-            return super(ParseElementEnhance,self).__str__()
-        except Exception:
-            pass
-
-        if self.strRepr is None and self.expr is not None:
-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
-        return self.strRepr
-
-
-class FollowedBy(ParseElementEnhance):
-    """
-    Lookahead matching of the given parse expression.  C{FollowedBy}
-    does I{not} advance the parsing position within the input string, it only
-    verifies that the specified parse expression matches at the current
-    position.  C{FollowedBy} always returns a null token list.
-
-    Example::
-        # use FollowedBy to match a label only if it is followed by a ':'
-        data_word = Word(alphas)
-        label = data_word + FollowedBy(':')
-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
-        
-        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
-    prints::
-        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
-    """
-    def __init__( self, expr ):
-        super(FollowedBy,self).__init__(expr)
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        self.expr.tryParse( instring, loc )
-        return loc, []
-
-
-class NotAny(ParseElementEnhance):
-    """
-    Lookahead to disallow matching with the given parse expression.  C{NotAny}
-    does I{not} advance the parsing position within the input string, it only
-    verifies that the specified parse expression does I{not} match at the current
-    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
-    always returns a null token list.  May be constructed using the '~' operator.
-
-    Example::
-        
-    """
-    def __init__( self, expr ):
-        super(NotAny,self).__init__(expr)
-        #~ self.leaveWhitespace()
-        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
-        self.mayReturnEmpty = True
-        self.errmsg = "Found unwanted token, "+_ustr(self.expr)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.expr.canParseNext(instring, loc):
-            raise ParseException(instring, loc, self.errmsg, self)
-        return loc, []
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "~{" + _ustr(self.expr) + "}"
-
-        return self.strRepr
-
-class _MultipleMatch(ParseElementEnhance):
-    def __init__( self, expr, stopOn=None):
-        super(_MultipleMatch, self).__init__(expr)
-        self.saveAsList = True
-        ender = stopOn
-        if isinstance(ender, basestring):
-            ender = ParserElement._literalStringClass(ender)
-        self.not_ender = ~ender if ender is not None else None
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        self_expr_parse = self.expr._parse
-        self_skip_ignorables = self._skipIgnorables
-        check_ender = self.not_ender is not None
-        if check_ender:
-            try_not_ender = self.not_ender.tryParse
-        
-        # must be at least one (but first see if we are the stopOn sentinel;
-        # if so, fail)
-        if check_ender:
-            try_not_ender(instring, loc)
-        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
-        try:
-            hasIgnoreExprs = (not not self.ignoreExprs)
-            while 1:
-                if check_ender:
-                    try_not_ender(instring, loc)
-                if hasIgnoreExprs:
-                    preloc = self_skip_ignorables( instring, loc )
-                else:
-                    preloc = loc
-                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
-                if tmptokens or tmptokens.haskeys():
-                    tokens += tmptokens
-        except (ParseException,IndexError):
-            pass
-
-        return loc, tokens
-        
-class OneOrMore(_MultipleMatch):
-    """
-    Repetition of one or more of the given expression.
-    
-    Parameters:
-     - expr - expression that must match one or more times
-     - stopOn - (default=C{None}) - expression for a terminating sentinel
-          (only required if the sentinel would ordinarily match the repetition 
-          expression)          
-
-    Example::
-        data_word = Word(alphas)
-        label = data_word + FollowedBy(':')
-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
-
-        text = "shape: SQUARE posn: upper left color: BLACK"
-        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
-
-        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
-        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
-        
-        # could also be written as
-        (attr_expr * (1,)).parseString(text).pprint()
-    """
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + _ustr(self.expr) + "}..."
-
-        return self.strRepr
-
-class ZeroOrMore(_MultipleMatch):
-    """
-    Optional repetition of zero or more of the given expression.
-    
-    Parameters:
-     - expr - expression that must match zero or more times
-     - stopOn - (default=C{None}) - expression for a terminating sentinel
-          (only required if the sentinel would ordinarily match the repetition 
-          expression)          
-
-    Example: similar to L{OneOrMore}
-    """
-    def __init__( self, expr, stopOn=None):
-        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
-        self.mayReturnEmpty = True
-        
-    def parseImpl( self, instring, loc, doActions=True ):
-        try:
-            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
-        except (ParseException,IndexError):
-            return loc, []
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "[" + _ustr(self.expr) + "]..."
-
-        return self.strRepr
-
-class _NullToken(object):
-    def __bool__(self):
-        return False
-    __nonzero__ = __bool__
-    def __str__(self):
-        return ""
-
-_optionalNotMatched = _NullToken()
-class Optional(ParseElementEnhance):
-    """
-    Optional matching of the given expression.
-
-    Parameters:
-     - expr - expression that must match zero or more times
-     - default (optional) - value to be returned if the optional expression is not found.
-
-    Example::
-        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
-        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
-        zip.runTests('''
-            # traditional ZIP code
-            12345
-            
-            # ZIP+4 form
-            12101-0001
-            
-            # invalid ZIP
-            98765-
-            ''')
-    prints::
-        # traditional ZIP code
-        12345
-        ['12345']
-
-        # ZIP+4 form
-        12101-0001
-        ['12101-0001']
-
-        # invalid ZIP
-        98765-
-             ^
-        FAIL: Expected end of text (at char 5), (line:1, col:6)
-    """
-    def __init__( self, expr, default=_optionalNotMatched ):
-        super(Optional,self).__init__( expr, savelist=False )
-        self.saveAsList = self.expr.saveAsList
-        self.defaultValue = default
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        try:
-            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
-        except (ParseException,IndexError):
-            if self.defaultValue is not _optionalNotMatched:
-                if self.expr.resultsName:
-                    tokens = ParseResults([ self.defaultValue ])
-                    tokens[self.expr.resultsName] = self.defaultValue
-                else:
-                    tokens = [ self.defaultValue ]
-            else:
-                tokens = []
-        return loc, tokens
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "[" + _ustr(self.expr) + "]"
-
-        return self.strRepr
-
-class SkipTo(ParseElementEnhance):
-    """
-    Token for skipping over all undefined text until the matched expression is found.
-
-    Parameters:
-     - expr - target expression marking the end of the data to be skipped
-     - include - (default=C{False}) if True, the target expression is also parsed 
-          (the skipped text and target expression are returned as a 2-element list).
-     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
-          comments) that might contain false matches to the target expression
-     - failOn - (default=C{None}) define expressions that are not allowed to be 
-          included in the skipped test; if found before the target expression is found, 
-          the SkipTo is not a match
-
-    Example::
-        report = '''
-            Outstanding Issues Report - 1 Jan 2000
-
-               # | Severity | Description                               |  Days Open
-            -----+----------+-------------------------------------------+-----------
-             101 | Critical | Intermittent system crash                 |          6
-              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
-              79 | Minor    | System slow when running too many reports |         47
-            '''
-        integer = Word(nums)
-        SEP = Suppress('|')
-        # use SkipTo to simply match everything up until the next SEP
-        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
-        # - parse action will call token.strip() for each matched token, i.e., the description body
-        string_data = SkipTo(SEP, ignore=quotedString)
-        string_data.setParseAction(tokenMap(str.strip))
-        ticket_expr = (integer("issue_num") + SEP 
-                      + string_data("sev") + SEP 
-                      + string_data("desc") + SEP 
-                      + integer("days_open"))
-        
-        for tkt in ticket_expr.searchString(report):
-            print tkt.dump()
-    prints::
-        ['101', 'Critical', 'Intermittent system crash', '6']
-        - days_open: 6
-        - desc: Intermittent system crash
-        - issue_num: 101
-        - sev: Critical
-        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
-        - days_open: 14
-        - desc: Spelling error on Login ('log|n')
-        - issue_num: 94
-        - sev: Cosmetic
-        ['79', 'Minor', 'System slow when running too many reports', '47']
-        - days_open: 47
-        - desc: System slow when running too many reports
-        - issue_num: 79
-        - sev: Minor
-    """
-    def __init__( self, other, include=False, ignore=None, failOn=None ):
-        super( SkipTo, self ).__init__( other )
-        self.ignoreExpr = ignore
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-        self.includeMatch = include
-        self.asList = False
-        if isinstance(failOn, basestring):
-            self.failOn = ParserElement._literalStringClass(failOn)
-        else:
-            self.failOn = failOn
-        self.errmsg = "No match found for "+_ustr(self.expr)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        startloc = loc
-        instrlen = len(instring)
-        expr = self.expr
-        expr_parse = self.expr._parse
-        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
-        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
-        
-        tmploc = loc
-        while tmploc <= instrlen:
-            if self_failOn_canParseNext is not None:
-                # break if failOn expression matches
-                if self_failOn_canParseNext(instring, tmploc):
-                    break
-                    
-            if self_ignoreExpr_tryParse is not None:
-                # advance past ignore expressions
-                while 1:
-                    try:
-                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
-                    except ParseBaseException:
-                        break
-            
-            try:
-                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
-            except (ParseException, IndexError):
-                # no match, advance loc in string
-                tmploc += 1
-            else:
-                # matched skipto expr, done
-                break
-
-        else:
-            # ran off the end of the input string without matching skipto expr, fail
-            raise ParseException(instring, loc, self.errmsg, self)
-
-        # build up return values
-        loc = tmploc
-        skiptext = instring[startloc:loc]
-        skipresult = ParseResults(skiptext)
-        
-        if self.includeMatch:
-            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
-            skipresult += mat
-
-        return loc, skipresult
-
-class Forward(ParseElementEnhance):
-    """
-    Forward declaration of an expression to be defined later -
-    used for recursive grammars, such as algebraic infix notation.
-    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
-
-    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
-    Specifically, '|' has a lower precedence than '<<', so that::
-        fwdExpr << a | b | c
-    will actually be evaluated as::
-        (fwdExpr << a) | b | c
-    thereby leaving b and c out as parseable alternatives.  It is recommended that you
-    explicitly group the values inserted into the C{Forward}::
-        fwdExpr << (a | b | c)
-    Converting to use the '<<=' operator instead will avoid this problem.
-
-    See L{ParseResults.pprint} for an example of a recursive parser created using
-    C{Forward}.
-    """
-    def __init__( self, other=None ):
-        super(Forward,self).__init__( other, savelist=False )
-
-    def __lshift__( self, other ):
-        if isinstance( other, basestring ):
-            other = ParserElement._literalStringClass(other)
-        self.expr = other
-        self.strRepr = None
-        self.mayIndexError = self.expr.mayIndexError
-        self.mayReturnEmpty = self.expr.mayReturnEmpty
-        self.setWhitespaceChars( self.expr.whiteChars )
-        self.skipWhitespace = self.expr.skipWhitespace
-        self.saveAsList = self.expr.saveAsList
-        self.ignoreExprs.extend(self.expr.ignoreExprs)
-        return self
-        
-    def __ilshift__(self, other):
-        return self << other
-    
-    def leaveWhitespace( self ):
-        self.skipWhitespace = False
-        return self
-
-    def streamline( self ):
-        if not self.streamlined:
-            self.streamlined = True
-            if self.expr is not None:
-                self.expr.streamline()
-        return self
-
-    def validate( self, validateTrace=[] ):
-        if self not in validateTrace:
-            tmp = validateTrace[:]+[self]
-            if self.expr is not None:
-                self.expr.validate(tmp)
-        self.checkRecursion([])
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-        return self.__class__.__name__ + ": ..."
-
-        # stubbed out for now - creates awful memory and perf issues
-        self._revertClass = self.__class__
-        self.__class__ = _ForwardNoRecurse
-        try:
-            if self.expr is not None:
-                retString = _ustr(self.expr)
-            else:
-                retString = "None"
-        finally:
-            self.__class__ = self._revertClass
-        return self.__class__.__name__ + ": " + retString
-
-    def copy(self):
-        if self.expr is not None:
-            return super(Forward,self).copy()
-        else:
-            ret = Forward()
-            ret <<= self
-            return ret
-
-class _ForwardNoRecurse(Forward):
-    def __str__( self ):
-        return "..."
-
-class TokenConverter(ParseElementEnhance):
-    """
-    Abstract subclass of C{ParseExpression}, for converting parsed results.
-    """
-    def __init__( self, expr, savelist=False ):
-        super(TokenConverter,self).__init__( expr )#, savelist )
-        self.saveAsList = False
-
-class Combine(TokenConverter):
-    """
-    Converter to concatenate all matching tokens to a single string.
-    By default, the matching patterns must also be contiguous in the input string;
-    this can be disabled by specifying C{'adjacent=False'} in the constructor.
-
-    Example::
-        real = Word(nums) + '.' + Word(nums)
-        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
-        # will also erroneously match the following
-        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
-
-        real = Combine(Word(nums) + '.' + Word(nums))
-        print(real.parseString('3.1416')) # -> ['3.1416']
-        # no match when there are internal spaces
-        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
-    """
-    def __init__( self, expr, joinString="", adjacent=True ):
-        super(Combine,self).__init__( expr )
-        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
-        if adjacent:
-            self.leaveWhitespace()
-        self.adjacent = adjacent
-        self.skipWhitespace = True
-        self.joinString = joinString
-        self.callPreparse = True
-
-    def ignore( self, other ):
-        if self.adjacent:
-            ParserElement.ignore(self, other)
-        else:
-            super( Combine, self).ignore( other )
-        return self
-
-    def postParse( self, instring, loc, tokenlist ):
-        retToks = tokenlist.copy()
-        del retToks[:]
-        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
-
-        if self.resultsName and retToks.haskeys():
-            return [ retToks ]
-        else:
-            return retToks
-
-class Group(TokenConverter):
-    """
-    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.
-
-    Example::
-        ident = Word(alphas)
-        num = Word(nums)
-        term = ident | num
-        func = ident + Optional(delimitedList(term))
-        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']
-
-        func = ident + Group(Optional(delimitedList(term)))
-        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
-    """
-    def __init__( self, expr ):
-        super(Group,self).__init__( expr )
-        self.saveAsList = True
-
-    def postParse( self, instring, loc, tokenlist ):
-        return [ tokenlist ]
-
-class Dict(TokenConverter):
-    """
-    Converter to return a repetitive expression as a list, but also as a dictionary.
-    Each element can also be referenced using the first token in the expression as its key.
-    Useful for tabular report scraping when the first column can be used as a item key.
-
-    Example::
-        data_word = Word(alphas)
-        label = data_word + FollowedBy(':')
-        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
-
-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
-        
-        # print attributes as plain groups
-        print(OneOrMore(attr_expr).parseString(text).dump())
-        
-        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
-        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
-        print(result.dump())
-        
-        # access named fields as dict entries, or output as dict
-        print(result['shape'])        
-        print(result.asDict())
-    prints::
-        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
-
-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
-        - color: light blue
-        - posn: upper left
-        - shape: SQUARE
-        - texture: burlap
-        SQUARE
-        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
-    See more examples at L{ParseResults} of accessing fields by results name.
-    """
-    def __init__( self, expr ):
-        super(Dict,self).__init__( expr )
-        self.saveAsList = True
-
-    def postParse( self, instring, loc, tokenlist ):
-        for i,tok in enumerate(tokenlist):
-            if len(tok) == 0:
-                continue
-            ikey = tok[0]
-            if isinstance(ikey,int):
-                ikey = _ustr(tok[0]).strip()
-            if len(tok)==1:
-                tokenlist[ikey] = _ParseResultsWithOffset("",i)
-            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
-                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
-            else:
-                dictvalue = tok.copy() #ParseResults(i)
-                del dictvalue[0]
-                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
-                else:
-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
-
-        if self.resultsName:
-            return [ tokenlist ]
-        else:
-            return tokenlist
-
-
-class Suppress(TokenConverter):
-    """
-    Converter for ignoring the results of a parsed expression.
-
-    Example::
-        source = "a, b, c,d"
-        wd = Word(alphas)
-        wd_list1 = wd + ZeroOrMore(',' + wd)
-        print(wd_list1.parseString(source))
-
-        # often, delimiters that are useful during parsing are just in the
-        # way afterward - use Suppress to keep them out of the parsed output
-        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
-        print(wd_list2.parseString(source))
-    prints::
-        ['a', ',', 'b', ',', 'c', ',', 'd']
-        ['a', 'b', 'c', 'd']
-    (See also L{delimitedList}.)
-    """
-    def postParse( self, instring, loc, tokenlist ):
-        return []
-
-    def suppress( self ):
-        return self
-
-
-class OnlyOnce(object):
-    """
-    Wrapper for parse actions, to ensure they are only called once.
-    """
-    def __init__(self, methodCall):
-        self.callable = _trim_arity(methodCall)
-        self.called = False
-    def __call__(self,s,l,t):
-        if not self.called:
-            results = self.callable(s,l,t)
-            self.called = True
-            return results
-        raise ParseException(s,l,"")
-    def reset(self):
-        self.called = False
-
-def traceParseAction(f):
-    """
-    Decorator for debugging parse actions. 
-    
-    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
-    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.
-
-    Example::
-        wd = Word(alphas)
-
-        @traceParseAction
-        def remove_duplicate_chars(tokens):
-            return ''.join(sorted(set(''.join(tokens)))
-
-        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
-        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
-    prints::
-        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
-        <<leaving remove_duplicate_chars (ret: 'dfjkls')
-        ['dfjkls']
-    """
-    f = _trim_arity(f)
-    def z(*paArgs):
-        thisFunc = f.__name__
-        s,l,t = paArgs[-3:]
-        if len(paArgs)>3:
-            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
-        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
-        try:
-            ret = f(*paArgs)
-        except Exception as exc:
-            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
-            raise
-        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )
-        return ret
-    try:
-        z.__name__ = f.__name__
-    except AttributeError:
-        pass
-    return z
-
-#
-# global helpers
-#
-def delimitedList( expr, delim=",", combine=False ):
-    """
-    Helper to define a delimited list of expressions - the delimiter defaults to ','.
-    By default, the list elements and delimiters can have intervening whitespace, and
-    comments, but this can be overridden by passing C{combine=True} in the constructor.
-    If C{combine} is set to C{True}, the matching tokens are returned as a single token
-    string, with the delimiters included; otherwise, the matching tokens are returned
-    as a list of tokens, with the delimiters suppressed.
-
-    Example::
-        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
-        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
-    """
-    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
-    if combine:
-        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
-    else:
-        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)
-
-def countedArray( expr, intExpr=None ):
-    """
-    Helper to define a counted list of expressions.
-    This helper defines a pattern of the form::
-        integer expr expr expr...
-    where the leading integer tells how many expr expressions follow.
-    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
-    
-    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.
-
-    Example::
-        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']
-
-        # in this parser, the leading integer value is given in binary,
-        # '10' indicating that 2 values are in the array
-        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
-        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
-    """
-    arrayExpr = Forward()
-    def countFieldParseAction(s,l,t):
-        n = t[0]
-        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
-        return []
-    if intExpr is None:
-        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
-    else:
-        intExpr = intExpr.copy()
-    intExpr.setName("arrayLen")
-    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
-    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')
-
-def _flatten(L):
-    ret = []
-    for i in L:
-        if isinstance(i,list):
-            ret.extend(_flatten(i))
-        else:
-            ret.append(i)
-    return ret
-
-def matchPreviousLiteral(expr):
-    """
-    Helper to define an expression that is indirectly defined from
-    the tokens matched in a previous expression, that is, it looks
-    for a 'repeat' of a previous expression.  For example::
-        first = Word(nums)
-        second = matchPreviousLiteral(first)
-        matchExpr = first + ":" + second
-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
-    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
-    If this is not desired, use C{matchPreviousExpr}.
-    Do I{not} use with packrat parsing enabled.
-    """
-    rep = Forward()
-    def copyTokenToRepeater(s,l,t):
-        if t:
-            if len(t) == 1:
-                rep << t[0]
-            else:
-                # flatten t tokens
-                tflat = _flatten(t.asList())
-                rep << And(Literal(tt) for tt in tflat)
-        else:
-            rep << Empty()
-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
-    rep.setName('(prev) ' + _ustr(expr))
-    return rep
-
-def matchPreviousExpr(expr):
-    """
-    Helper to define an expression that is indirectly defined from
-    the tokens matched in a previous expression, that is, it looks
-    for a 'repeat' of a previous expression.  For example::
-        first = Word(nums)
-        second = matchPreviousExpr(first)
-        matchExpr = first + ":" + second
-    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
-    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
-    the expressions are evaluated first, and then compared, so
-    C{"1"} is compared with C{"10"}.
-    Do I{not} use with packrat parsing enabled.
-    """
-    rep = Forward()
-    e2 = expr.copy()
-    rep <<= e2
-    def copyTokenToRepeater(s,l,t):
-        matchTokens = _flatten(t.asList())
-        def mustMatchTheseTokens(s,l,t):
-            theseTokens = _flatten(t.asList())
-            if  theseTokens != matchTokens:
-                raise ParseException("",0,"")
-        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
-    rep.setName('(prev) ' + _ustr(expr))
-    return rep
-
-def _escapeRegexRangeChars(s):
-    #~  escape these chars: ^-]
-    for c in r"\^-]":
-        s = s.replace(c,_bslash+c)
-    s = s.replace("\n",r"\n")
-    s = s.replace("\t",r"\t")
-    return _ustr(s)
-
-def oneOf( strs, caseless=False, useRegex=True ):
-    """
-    Helper to quickly define a set of alternative Literals, and makes sure to do
-    longest-first testing when there is a conflict, regardless of the input order,
-    but returns a C{L{MatchFirst}} for best performance.
-
-    Parameters:
-     - strs - a string of space-delimited literals, or a collection of string literals
-     - caseless - (default=C{False}) - treat all literals as caseless
-     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
-          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
-          if creating a C{Regex} raises an exception)
-
-    Example::
-        comp_oper = oneOf("< = > <= >= !=")
-        var = Word(alphas)
-        number = Word(nums)
-        term = var | number
-        comparison_expr = term + comp_oper + term
-        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
-    prints::
-        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
-    """
-    if caseless:
-        isequal = ( lambda a,b: a.upper() == b.upper() )
-        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
-        parseElementClass = CaselessLiteral
-    else:
-        isequal = ( lambda a,b: a == b )
-        masks = ( lambda a,b: b.startswith(a) )
-        parseElementClass = Literal
-
-    symbols = []
-    if isinstance(strs,basestring):
-        symbols = strs.split()
-    elif isinstance(strs, collections.Iterable):
-        symbols = list(strs)
-    else:
-        warnings.warn("Invalid argument to oneOf, expected string or iterable",
-                SyntaxWarning, stacklevel=2)
-    if not symbols:
-        return NoMatch()
-
-    i = 0
-    while i < len(symbols)-1:
-        cur = symbols[i]
-        for j,other in enumerate(symbols[i+1:]):
-            if ( isequal(other, cur) ):
-                del symbols[i+j+1]
-                break
-            elif ( masks(cur, other) ):
-                del symbols[i+j+1]
-                symbols.insert(i,other)
-                cur = other
-                break
-        else:
-            i += 1
-
-    if not caseless and useRegex:
-        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
-        try:
-            if len(symbols)==len("".join(symbols)):
-                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
-            else:
-                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
-        except Exception:
-            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
-                    SyntaxWarning, stacklevel=2)
-
-
-    # last resort, just use MatchFirst
-    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))
-
-def dictOf( key, value ):
-    """
-    Helper to easily and clearly define a dictionary by specifying the respective patterns
-    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
-    in the proper order.  The key pattern can include delimiting markers or punctuation,
-    as long as they are suppressed, thereby leaving the significant key text.  The value
-    pattern can include named results, so that the C{Dict} results can include named token
-    fields.
-
-    Example::
-        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
-        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
-        print(OneOrMore(attr_expr).parseString(text).dump())
-        
-        attr_label = label
-        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
-
-        # similar to Dict, but simpler call format
-        result = dictOf(attr_label, attr_value).parseString(text)
-        print(result.dump())
-        print(result['shape'])
-        print(result.shape)  # object attribute access works too
-        print(result.asDict())
-    prints::
-        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
-        - color: light blue
-        - posn: upper left
-        - shape: SQUARE
-        - texture: burlap
-        SQUARE
-        SQUARE
-        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
-    """
-    return Dict( ZeroOrMore( Group ( key + value ) ) )
-
-def originalTextFor(expr, asString=True):
-    """
-    Helper to return the original, untokenized text for a given expression.  Useful to
-    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
-    revert separate tokens with intervening whitespace back to the original matching
-    input text. By default, returns astring containing the original parsed text.  
-       
-    If the optional C{asString} argument is passed as C{False}, then the return value is a 
-    C{L{ParseResults}} containing any results names that were originally matched, and a 
-    single token containing the original matched text from the input string.  So if 
-    the expression passed to C{L{originalTextFor}} contains expressions with defined
-    results names, you must set C{asString} to C{False} if you want to preserve those
-    results name values.
-
-    Example::
-        src = "this is test <b> bold <i>text</i> </b> normal text "
-        for tag in ("b","i"):
-            opener,closer = makeHTMLTags(tag)
-            patt = originalTextFor(opener + SkipTo(closer) + closer)
-            print(patt.searchString(src)[0])
-    prints::
-        ['<b> bold <i>text</i> </b>']
-        ['<i>text</i>']
-    """
-    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
-    endlocMarker = locMarker.copy()
-    endlocMarker.callPreparse = False
-    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
-    if asString:
-        extractText = lambda s,l,t: s[t._original_start:t._original_end]
-    else:
-        def extractText(s,l,t):
-            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
-    matchExpr.setParseAction(extractText)
-    matchExpr.ignoreExprs = expr.ignoreExprs
-    return matchExpr
-
-def ungroup(expr): 
-    """
-    Helper to undo pyparsing's default grouping of And expressions, even
-    if all but one are non-empty.
-    """
-    return TokenConverter(expr).setParseAction(lambda t:t[0])
-
-def locatedExpr(expr):
-    """
-    Helper to decorate a returned token with its starting and ending locations in the input string.
-    This helper adds the following results names:
-     - locn_start = location where matched expression begins
-     - locn_end = location where matched expression ends
-     - value = the actual parsed results
-
-    Be careful if the input text contains C{<TAB>} characters, you may want to call
-    C{L{ParserElement.parseWithTabs}}
-
-    Example::
-        wd = Word(alphas)
-        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
-            print(match)
-    prints::
-        [[0, 'ljsdf', 5]]
-        [[8, 'lksdjjf', 15]]
-        [[18, 'lkkjj', 23]]
-    """
-    locator = Empty().setParseAction(lambda s,l,t: l)
-    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
-
-
-# convenience constants for positional expressions
-empty       = Empty().setName("empty")
-lineStart   = LineStart().setName("lineStart")
-lineEnd     = LineEnd().setName("lineEnd")
-stringStart = StringStart().setName("stringStart")
-stringEnd   = StringEnd().setName("stringEnd")
-
-_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
-_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
-_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(printables, excludeChars=r'\]', exact=1) | Regex(r"\w", re.UNICODE)
-_charRange = Group(_singleChar + Suppress("-") + _singleChar)
-_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
-
-def srange(s):
-    r"""
-    Helper to easily define string ranges for use in Word construction.  Borrows
-    syntax from regexp '[]' string range definitions::
-        srange("[0-9]")   -> "0123456789"
-        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
-        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
-    The input string must be enclosed in []'s, and the returned string is the expanded
-    character set joined into a single string.
-    The values enclosed in the []'s may be:
-     - a single character
-     - an escaped character with a leading backslash (such as C{\-} or C{\]})
-     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
-         (C{\0x##} is also supported for backwards compatibility) 
-     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
-     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
-     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
-    """
-    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
-    try:
-        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
-    except Exception:
-        return ""
-
-def matchOnlyAtCol(n):
-    """
-    Helper method for defining parse actions that require matching at a specific
-    column in the input text.
-    """
-    def verifyCol(strg,locn,toks):
-        if col(locn,strg) != n:
-            raise ParseException(strg,locn,"matched token not at column %d" % n)
-    return verifyCol
-
-def replaceWith(replStr):
-    """
-    Helper method for common parse actions that simply return a literal value.  Especially
-    useful when used with C{L{transformString<ParserElement.transformString>}()}.
-
-    Example::
-        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
-        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
-        term = na | num
-        
-        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
-    """
-    return lambda s,l,t: [replStr]
-
-def removeQuotes(s,l,t):
-    """
-    Helper parse action for removing quotation marks from parsed quoted strings.
-
-    Example::
-        # by default, quotation marks are included in parsed results
-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
-
-        # use removeQuotes to strip quotation marks from parsed results
-        quotedString.setParseAction(removeQuotes)
-        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
-    """
-    return t[0][1:-1]
-
-def tokenMap(func, *args):
-    """
-    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
-    args are passed, they are forwarded to the given function as additional arguments after
-    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
-    parsed data to an integer using base 16.
-
-    Example (compare the last to example in L{ParserElement.transformString}::
-        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
-        hex_ints.runTests('''
-            00 11 22 aa FF 0a 0d 1a
-            ''')
-        
-        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
-        OneOrMore(upperword).runTests('''
-            my kingdom for a horse
-            ''')
-
-        wd = Word(alphas).setParseAction(tokenMap(str.title))
-        OneOrMore(wd).setParseAction(' '.join).runTests('''
-            now is the winter of our discontent made glorious summer by this sun of york
-            ''')
-    prints::
-        00 11 22 aa FF 0a 0d 1a
-        [0, 17, 34, 170, 255, 10, 13, 26]
-
-        my kingdom for a horse
-        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
-
-        now is the winter of our discontent made glorious summer by this sun of york
-        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
-    """
-    def pa(s,l,t):
-        return [func(tokn, *args) for tokn in t]
-
-    try:
-        func_name = getattr(func, '__name__', 
-                            getattr(func, '__class__').__name__)
-    except Exception:
-        func_name = str(func)
-    pa.__name__ = func_name
-
-    return pa
-
-upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
-"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""
-
-downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
-"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
-    
-def _makeTags(tagStr, xml):
-    """Internal helper to construct opening and closing tag expressions, given a tag name"""
-    if isinstance(tagStr,basestring):
-        resname = tagStr
-        tagStr = Keyword(tagStr, caseless=not xml)
-    else:
-        resname = tagStr.name
-
-    tagAttrName = Word(alphas,alphanums+"_-:")
-    if (xml):
-        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
-        openTag = Suppress("<") + tagStr("tag") + \
-                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
-    else:
-        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
-        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
-        openTag = Suppress("<") + tagStr("tag") + \
-                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
-                Optional( Suppress("=") + tagAttrValue ) ))) + \
-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
-    closeTag = Combine(_L("</") + tagStr + ">")
-
-    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
-    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)
-    openTag.tag = resname
-    closeTag.tag = resname
-    return openTag, closeTag
-
-def makeHTMLTags(tagStr):
-    """
-    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
-    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.
-
-    Example::
-        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
-        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
-        a,a_end = makeHTMLTags("A")
-        link_expr = a + SkipTo(a_end)("link_text") + a_end
-        
-        for link in link_expr.searchString(text):
-            # attributes in the <A> tag (like "href" shown here) are also accessible as named results
-            print(link.link_text, '->', link.href)
-    prints::
-        pyparsing -> http://pyparsing.wikispaces.com
-    """
-    return _makeTags( tagStr, False )
-
-def makeXMLTags(tagStr):
-    """
-    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
-    tags only in the given upper/lower case.
-
-    Example: similar to L{makeHTMLTags}
-    """
-    return _makeTags( tagStr, True )
-
-def withAttribute(*args,**attrDict):
-    """
-    Helper to create a validating parse action to be used with start tags created
-    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
-    with a required attribute value, to avoid false matches on common tags such as
-    C{<TD>} or C{<DIV>}.
-
-    Call C{withAttribute} with a series of attribute names and values. Specify the list
-    of filter attributes names and values as:
-     - keyword arguments, as in C{(align="right")}, or
-     - as an explicit dict with C{**} operator, when an attribute name is also a Python
-          reserved word, as in C{**{"class":"Customer", "align":"right"}}
-     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
-    For attribute names with a namespace prefix, you must use the second form.  Attribute
-    names are matched insensitive to upper/lower case.
-       
-    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
-
-    To verify that the attribute exists, but without specifying a value, pass
-    C{withAttribute.ANY_VALUE} as the value.
-
-    Example::
-        html = '''
-            <div>
-            Some text
-            <div type="grid">1 4 0 1 0</div>
-            <div type="graph">1,3 2,3 1,1</div>
-            <div>this has no type</div>
-            </div>
-                
-        '''
-        div,div_end = makeHTMLTags("div")
-
-        # only match div tag having a type attribute with value "grid"
-        div_grid = div().setParseAction(withAttribute(type="grid"))
-        grid_expr = div_grid + SkipTo(div | div_end)("body")
-        for grid_header in grid_expr.searchString(html):
-            print(grid_header.body)
-        
-        # construct a match with any div tag having a type attribute, regardless of the value
-        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
-        div_expr = div_any_type + SkipTo(div | div_end)("body")
-        for div_header in div_expr.searchString(html):
-            print(div_header.body)
-    prints::
-        1 4 0 1 0
-
-        1 4 0 1 0
-        1,3 2,3 1,1
-    """
-    if args:
-        attrs = args[:]
-    else:
-        attrs = attrDict.items()
-    attrs = [(k,v) for k,v in attrs]
-    def pa(s,l,tokens):
-        for attrName,attrValue in attrs:
-            if attrName not in tokens:
-                raise ParseException(s,l,"no matching attribute " + attrName)
-            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
-                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
-                                            (attrName, tokens[attrName], attrValue))
-    return pa
-withAttribute.ANY_VALUE = object()
-
-def withClass(classname, namespace=''):
-    """
-    Simplified version of C{L{withAttribute}} when matching on a div class - made
-    difficult because C{class} is a reserved word in Python.
-
-    Example::
-        html = '''
-            <div>
-            Some text
-            <div class="grid">1 4 0 1 0</div>
-            <div class="graph">1,3 2,3 1,1</div>
-            <div>this &lt;div&gt; has no class</div>
-            </div>
-                
-        '''
-        div,div_end = makeHTMLTags("div")
-        div_grid = div().setParseAction(withClass("grid"))
-        
-        grid_expr = div_grid + SkipTo(div | div_end)("body")
-        for grid_header in grid_expr.searchString(html):
-            print(grid_header.body)
-        
-        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
-        div_expr = div_any_type + SkipTo(div | div_end)("body")
-        for div_header in div_expr.searchString(html):
-            print(div_header.body)
-    prints::
-        1 4 0 1 0
-
-        1 4 0 1 0
-        1,3 2,3 1,1
-    """
-    classattr = "%s:class" % namespace if namespace else "class"
-    return withAttribute(**{classattr : classname})        
-
-opAssoc = _Constants()
-opAssoc.LEFT = object()
-opAssoc.RIGHT = object()
-
-def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
-    """
-    Helper method for constructing grammars of expressions made up of
-    operators working in a precedence hierarchy.  Operators may be unary or
-    binary, left- or right-associative.  Parse actions can also be attached
-    to operator expressions. The generated parser will also recognize the use 
-    of parentheses to override operator precedences (see example below).
-    
-    Note: if you define a deep operator list, you may see performance issues
-    when using infixNotation. See L{ParserElement.enablePackrat} for a
-    mechanism to potentially improve your parser performance.
-
-    Parameters:
-     - baseExpr - expression representing the most basic element for the nested
-     - opList - list of tuples, one for each operator precedence level in the
-      expression grammar; each tuple is of the form
-      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
-       - opExpr is the pyparsing expression for the operator;
-          may also be a string, which will be converted to a Literal;
-          if numTerms is 3, opExpr is a tuple of two expressions, for the
-          two operators separating the 3 terms
-       - numTerms is the number of terms for this operator (must
-          be 1, 2, or 3)
-       - rightLeftAssoc is the indicator whether the operator is
-          right or left associative, using the pyparsing-defined
-          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
-       - parseAction is the parse action to be associated with
-          expressions matching this operator expression (the
-          parse action tuple member may be omitted)
-     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
-     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})
-
-    Example::
-        # simple example of four-function arithmetic with ints and variable names
-        integer = pyparsing_common.signed_integer
-        varname = pyparsing_common.identifier 
-        
-        arith_expr = infixNotation(integer | varname,
-            [
-            ('-', 1, opAssoc.RIGHT),
-            (oneOf('* /'), 2, opAssoc.LEFT),
-            (oneOf('+ -'), 2, opAssoc.LEFT),
-            ])
-        
-        arith_expr.runTests('''
-            5+3*6
-            (5+3)*6
-            -2--11
-            ''', fullDump=False)
-    prints::
-        5+3*6
-        [[5, '+', [3, '*', 6]]]
-
-        (5+3)*6
-        [[[5, '+', 3], '*', 6]]
-
-        -2--11
-        [[['-', 2], '-', ['-', 11]]]
-    """
-    ret = Forward()
-    lastExpr = baseExpr | ( lpar + ret + rpar )
-    for i,operDef in enumerate(opList):
-        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
-        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
-        if arity == 3:
-            if opExpr is None or len(opExpr) != 2:
-                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
-            opExpr1, opExpr2 = opExpr
-        thisExpr = Forward().setName(termName)
-        if rightLeftAssoc == opAssoc.LEFT:
-            if arity == 1:
-                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
-            elif arity == 2:
-                if opExpr is not None:
-                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
-                else:
-                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
-            elif arity == 3:
-                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
-                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
-            else:
-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
-        elif rightLeftAssoc == opAssoc.RIGHT:
-            if arity == 1:
-                # try to avoid LR with this extra test
-                if not isinstance(opExpr, Optional):
-                    opExpr = Optional(opExpr)
-                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
-            elif arity == 2:
-                if opExpr is not None:
-                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
-                else:
-                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
-            elif arity == 3:
-                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
-                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
-            else:
-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
-        else:
-            raise ValueError("operator must indicate right or left associativity")
-        if pa:
-            matchExpr.setParseAction( pa )
-        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
-        lastExpr = thisExpr
-    ret <<= lastExpr
-    return ret
-
-operatorPrecedence = infixNotation
-"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""
-
-dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
-sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
-quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
-                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
-unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")
-
-def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
-    """
-    Helper method for defining nested lists enclosed in opening and closing
-    delimiters ("(" and ")" are the default).
-
-    Parameters:
-     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
-     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
-     - content - expression for items within the nested lists (default=C{None})
-     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})
-
-    If an expression is not provided for the content argument, the nested
-    expression will capture all whitespace-delimited content between delimiters
-    as a list of separate values.
-
-    Use the C{ignoreExpr} argument to define expressions that may contain
-    opening or closing characters that should not be treated as opening
-    or closing characters for nesting, such as quotedString or a comment
-    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
-    The default is L{quotedString}, but if no expressions are to be ignored,
-    then pass C{None} for this argument.
-
-    Example::
-        data_type = oneOf("void int short long char float double")
-        decl_data_type = Combine(data_type + Optional(Word('*')))
-        ident = Word(alphas+'_', alphanums+'_')
-        number = pyparsing_common.number
-        arg = Group(decl_data_type + ident)
-        LPAR,RPAR = map(Suppress, "()")
-
-        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
-
-        c_function = (decl_data_type("type") 
-                      + ident("name")
-                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
-                      + code_body("body"))
-        c_function.ignore(cStyleComment)
-        
-        source_code = '''
-            int is_odd(int x) { 
-                return (x%2); 
-            }
-                
-            int dec_to_hex(char hchar) { 
-                if (hchar >= '0' && hchar <= '9') { 
-                    return (ord(hchar)-ord('0')); 
-                } else { 
-                    return (10+ord(hchar)-ord('A'));
-                } 
-            }
-        '''
-        for func in c_function.searchString(source_code):
-            print("%(name)s (%(type)s) args: %(args)s" % func)
-
-    prints::
-        is_odd (int) args: [['int', 'x']]
-        dec_to_hex (int) args: [['char', 'hchar']]
-    """
-    if opener == closer:
-        raise ValueError("opening and closing strings cannot be the same")
-    if content is None:
-        if isinstance(opener,basestring) and isinstance(closer,basestring):
-            if len(opener) == 1 and len(closer)==1:
-                if ignoreExpr is not None:
-                    content = (Combine(OneOrMore(~ignoreExpr +
-                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-                else:
-                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
-                                ).setParseAction(lambda t:t[0].strip()))
-            else:
-                if ignoreExpr is not None:
-                    content = (Combine(OneOrMore(~ignoreExpr + 
-                                    ~Literal(opener) + ~Literal(closer) +
-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-                else:
-                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-        else:
-            raise ValueError("opening and closing arguments must be strings if no content expression is given")
-    ret = Forward()
-    if ignoreExpr is not None:
-        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
-    else:
-        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
-    ret.setName('nested %s%s expression' % (opener,closer))
-    return ret
-
-def indentedBlock(blockStatementExpr, indentStack, indent=True):
-    """
-    Helper method for defining space-delimited indentation blocks, such as
-    those used to define block statements in Python source code.
-
-    Parameters:
-     - blockStatementExpr - expression defining syntax of statement that
-            is repeated within the indented block
-     - indentStack - list created by caller to manage indentation stack
-            (multiple statementWithIndentedBlock expressions within a single grammar
-            should share a common indentStack)
-     - indent - boolean indicating whether block must be indented beyond the
-            the current level; set to False for block of left-most statements
-            (default=C{True})
-
-    A valid block must contain at least one C{blockStatement}.
-
-    Example::
-        data = '''
-        def A(z):
-          A1
-          B = 100
-          G = A2
-          A2
-          A3
-        B
-        def BB(a,b,c):
-          BB1
-          def BBA():
-            bba1
-            bba2
-            bba3
-        C
-        D
-        def spam(x,y):
-             def eggs(z):
-                 pass
-        '''
-
-
-        indentStack = [1]
-        stmt = Forward()
-
-        identifier = Word(alphas, alphanums)
-        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
-        func_body = indentedBlock(stmt, indentStack)
-        funcDef = Group( funcDecl + func_body )
-
-        rvalue = Forward()
-        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
-        rvalue << (funcCall | identifier | Word(nums))
-        assignment = Group(identifier + "=" + rvalue)
-        stmt << ( funcDef | assignment | identifier )
-
-        module_body = OneOrMore(stmt)
-
-        parseTree = module_body.parseString(data)
-        parseTree.pprint()
-    prints::
-        [['def',
-          'A',
-          ['(', 'z', ')'],
-          ':',
-          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
-         'B',
-         ['def',
-          'BB',
-          ['(', 'a', 'b', 'c', ')'],
-          ':',
-          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
-         'C',
-         'D',
-         ['def',
-          'spam',
-          ['(', 'x', 'y', ')'],
-          ':',
-          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
-    """
-    def checkPeerIndent(s,l,t):
-        if l >= len(s): return
-        curCol = col(l,s)
-        if curCol != indentStack[-1]:
-            if curCol > indentStack[-1]:
-                raise ParseFatalException(s,l,"illegal nesting")
-            raise ParseException(s,l,"not a peer entry")
-
-    def checkSubIndent(s,l,t):
-        curCol = col(l,s)
-        if curCol > indentStack[-1]:
-            indentStack.append( curCol )
-        else:
-            raise ParseException(s,l,"not a subentry")
-
-    def checkUnindent(s,l,t):
-        if l >= len(s): return
-        curCol = col(l,s)
-        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
-            raise ParseException(s,l,"not an unindent")
-        indentStack.pop()
-
-    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
-    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
-    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
-    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
-    if indent:
-        smExpr = Group( Optional(NL) +
-            #~ FollowedBy(blockStatementExpr) +
-            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
-    else:
-        smExpr = Group( Optional(NL) +
-            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
-    blockStatementExpr.ignore(_bslash + LineEnd())
-    return smExpr.setName('indented block')
-
-alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
-punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
-
-anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
-_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
-commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
-def replaceHTMLEntity(t):
-    """Helper parser action to replace common HTML entities with their special characters"""
-    return _htmlEntityMap.get(t.entity)
-
-# it's easy to get these comment structures wrong - they're very common, so may as well make them available
-cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
-"Comment of the form C{/* ... */}"
-
-htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")
-"Comment of the form C{<!-- ... -->}"
-
-restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
-dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
-"Comment of the form C{// ... (to end of line)}"
-
-cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
-"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"
-
-javaStyleComment = cppStyleComment
-"Same as C{L{cppStyleComment}}"
-
-pythonStyleComment = Regex(r"#.*").setName("Python style comment")
-"Comment of the form C{# ... (to end of line)}"
-
-_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
-                                  Optional( Word(" \t") +
-                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
-commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
-"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
-   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""
-
-# some other useful expressions - using lower-case class name since we are really using this as a namespace
-class pyparsing_common:
-    """
-    Here are some common low-level expressions that may be useful in jump-starting parser development:
-     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})
-     - common L{programming identifiers<identifier>}
-     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})
-     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}
-     - L{UUID<uuid>}
-     - L{comma-separated list<comma_separated_list>}
-    Parse actions:
-     - C{L{convertToInteger}}
-     - C{L{convertToFloat}}
-     - C{L{convertToDate}}
-     - C{L{convertToDatetime}}
-     - C{L{stripHTMLTags}}
-     - C{L{upcaseTokens}}
-     - C{L{downcaseTokens}}
-
-    Example::
-        pyparsing_common.number.runTests('''
-            # any int or real number, returned as the appropriate type
-            100
-            -100
-            +100
-            3.14159
-            6.02e23
-            1e-12
-            ''')
-
-        pyparsing_common.fnumber.runTests('''
-            # any int or real number, returned as float
-            100
-            -100
-            +100
-            3.14159
-            6.02e23
-            1e-12
-            ''')
-
-        pyparsing_common.hex_integer.runTests('''
-            # hex numbers
-            100
-            FF
-            ''')
-
-        pyparsing_common.fraction.runTests('''
-            # fractions
-            1/2
-            -3/4
-            ''')
-
-        pyparsing_common.mixed_integer.runTests('''
-            # mixed fractions
-            1
-            1/2
-            -3/4
-            1-3/4
-            ''')
-
-        import uuid
-        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
-        pyparsing_common.uuid.runTests('''
-            # uuid
-            12345678-1234-5678-1234-567812345678
-            ''')
-    prints::
-        # any int or real number, returned as the appropriate type
-        100
-        [100]
-
-        -100
-        [-100]
-
-        +100
-        [100]
-
-        3.14159
-        [3.14159]
-
-        6.02e23
-        [6.02e+23]
-
-        1e-12
-        [1e-12]
-
-        # any int or real number, returned as float
-        100
-        [100.0]
-
-        -100
-        [-100.0]
-
-        +100
-        [100.0]
-
-        3.14159
-        [3.14159]
-
-        6.02e23
-        [6.02e+23]
-
-        1e-12
-        [1e-12]
-
-        # hex numbers
-        100
-        [256]
-
-        FF
-        [255]
-
-        # fractions
-        1/2
-        [0.5]
-
-        -3/4
-        [-0.75]
-
-        # mixed fractions
-        1
-        [1]
-
-        1/2
-        [0.5]
-
-        -3/4
-        [-0.75]
-
-        1-3/4
-        [1.75]
-
-        # uuid
-        12345678-1234-5678-1234-567812345678
-        [UUID('12345678-1234-5678-1234-567812345678')]
-    """
-
-    convertToInteger = tokenMap(int)
-    """
-    Parse action for converting parsed integers to Python int
-    """
-
-    convertToFloat = tokenMap(float)
-    """
-    Parse action for converting parsed numbers to Python float
-    """
-
-    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
-    """expression that parses an unsigned integer, returns an int"""
-
-    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
-    """expression that parses a hexadecimal integer, returns an int"""
-
-    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
-    """expression that parses an integer with optional leading sign, returns an int"""
-
-    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
-    """fractional expression of an integer divided by an integer, returns a float"""
-    fraction.addParseAction(lambda t: t[0]/t[-1])
-
-    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
-    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
-    mixed_integer.addParseAction(sum)
-
-    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
-    """expression that parses a floating point number and returns a float"""
-
-    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
-    """expression that parses a floating point number with optional scientific notation and returns a float"""
-
-    # streamlining this expression makes the docs nicer-looking
-    number = (sci_real | real | signed_integer).streamline()
-    """any numeric expression, returns the corresponding Python type"""
-
-    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
-    """any int or real number, returned as float"""
-    
-    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
-    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
-    
-    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
-    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"
-
-    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
-    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
-    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
-    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
-    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
-    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
-    "IPv6 address (long, short, or mixed form)"
-    
-    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
-    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
-
-    @staticmethod
-    def convertToDate(fmt="%Y-%m-%d"):
-        """
-        Helper to create a parse action for converting parsed date string to Python datetime.date
-
-        Params -
-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})
-
-        Example::
-            date_expr = pyparsing_common.iso8601_date.copy()
-            date_expr.setParseAction(pyparsing_common.convertToDate())
-            print(date_expr.parseString("1999-12-31"))
-        prints::
-            [datetime.date(1999, 12, 31)]
-        """
-        def cvt_fn(s,l,t):
-            try:
-                return datetime.strptime(t[0], fmt).date()
-            except ValueError as ve:
-                raise ParseException(s, l, str(ve))
-        return cvt_fn
-
-    @staticmethod
-    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
-        """
-        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime
-
-        Params -
-         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})
-
-        Example::
-            dt_expr = pyparsing_common.iso8601_datetime.copy()
-            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
-            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
-        prints::
-            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
-        """
-        def cvt_fn(s,l,t):
-            try:
-                return datetime.strptime(t[0], fmt)
-            except ValueError as ve:
-                raise ParseException(s, l, str(ve))
-        return cvt_fn
-
-    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")
-    "ISO8601 date (C{yyyy-mm-dd})"
-
-    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
-    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"
-
-    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
-    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"
-
-    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
-    @staticmethod
-    def stripHTMLTags(s, l, tokens):
-        """
-        Parse action to remove HTML tags from web page HTML source
-
-        Example::
-            # strip HTML links from normal text 
-            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
-            td,td_end = makeHTMLTags("TD")
-            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
-            
-            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
-        """
-        return pyparsing_common._html_stripper.transformString(tokens[0])
-
-    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
-                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
-    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
-    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
-
-    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
-    """Parse action to convert tokens to upper case."""
-
-    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
-    """Parse action to convert tokens to lower case."""
-
-
-if __name__ == "__main__":
-
-    selectToken    = CaselessLiteral("select")
-    fromToken      = CaselessLiteral("from")
-
-    ident          = Word(alphas, alphanums + "_$")
-
-    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
-    columnNameList = Group(delimitedList(columnName)).setName("columns")
-    columnSpec     = ('*' | columnNameList)
-
-    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
-    tableNameList  = Group(delimitedList(tableName)).setName("tables")
-    
-    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")
-
-    # demo runTests method, including embedded comments in test string
-    simpleSQL.runTests("""
-        # '*' as column list and dotted table name
-        select * from SYS.XYZZY
-
-        # caseless match on "SELECT", and casts back to "select"
-        SELECT * from XYZZY, ABC
-
-        # list of column names, and mixed case SELECT keyword
-        Select AA,BB,CC from Sys.dual
-
-        # multiple tables
-        Select A, B, C from Sys.dual, Table2
-
-        # invalid SELECT keyword - should fail
-        Xelect A, B, C from Sys.dual
-
-        # incomplete command - should fail
-        Select
-
-        # invalid column name - should fail
-        Select ^^^ frox Sys.dual
-
-        """)
-
-    pyparsing_common.number.runTests("""
-        100
-        -100
-        +100
-        3.14159
-        6.02e23
-        1e-12
-        """)
-
-    # any int or real number, returned as float
-    pyparsing_common.fnumber.runTests("""
-        100
-        -100
-        +100
-        3.14159
-        6.02e23
-        1e-12
-        """)
-
-    pyparsing_common.hex_integer.runTests("""
-        100
-        FF
-        """)
-
-    import uuid
-    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
-    pyparsing_common.uuid.runTests("""
-        12345678-1234-5678-1234-567812345678
-        """)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/six.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/six.py
deleted file mode 100644
index 190c0239c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/_vendor/six.py
+++ /dev/null
@@ -1,868 +0,0 @@
-"""Utilities for writing code that runs on Python 2 and 3"""
-
-# Copyright (c) 2010-2015 Benjamin Peterson
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-from __future__ import absolute_import
-
-import functools
-import itertools
-import operator
-import sys
-import types
-
-__author__ = "Benjamin Peterson <benjamin@python.org>"
-__version__ = "1.10.0"
-
-
-# Useful for very coarse version differentiation.
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-PY34 = sys.version_info[0:2] >= (3, 4)
-
-if PY3:
-    string_types = str,
-    integer_types = int,
-    class_types = type,
-    text_type = str
-    binary_type = bytes
-
-    MAXSIZE = sys.maxsize
-else:
-    string_types = basestring,
-    integer_types = (int, long)
-    class_types = (type, types.ClassType)
-    text_type = unicode
-    binary_type = str
-
-    if sys.platform.startswith("java"):
-        # Jython always uses 32 bits.
-        MAXSIZE = int((1 << 31) - 1)
-    else:
-        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
-        class X(object):
-
-            def __len__(self):
-                return 1 << 31
-        try:
-            len(X())
-        except OverflowError:
-            # 32-bit
-            MAXSIZE = int((1 << 31) - 1)
-        else:
-            # 64-bit
-            MAXSIZE = int((1 << 63) - 1)
-        del X
-
-
-def _add_doc(func, doc):
-    """Add documentation to a function."""
-    func.__doc__ = doc
-
-
-def _import_module(name):
-    """Import module, returning the module after the last dot."""
-    __import__(name)
-    return sys.modules[name]
-
-
-class _LazyDescr(object):
-
-    def __init__(self, name):
-        self.name = name
-
-    def __get__(self, obj, tp):
-        result = self._resolve()
-        setattr(obj, self.name, result)  # Invokes __set__.
-        try:
-            # This is a bit ugly, but it avoids running this again by
-            # removing this descriptor.
-            delattr(obj.__class__, self.name)
-        except AttributeError:
-            pass
-        return result
-
-
-class MovedModule(_LazyDescr):
-
-    def __init__(self, name, old, new=None):
-        super(MovedModule, self).__init__(name)
-        if PY3:
-            if new is None:
-                new = name
-            self.mod = new
-        else:
-            self.mod = old
-
-    def _resolve(self):
-        return _import_module(self.mod)
-
-    def __getattr__(self, attr):
-        _module = self._resolve()
-        value = getattr(_module, attr)
-        setattr(self, attr, value)
-        return value
-
-
-class _LazyModule(types.ModuleType):
-
-    def __init__(self, name):
-        super(_LazyModule, self).__init__(name)
-        self.__doc__ = self.__class__.__doc__
-
-    def __dir__(self):
-        attrs = ["__doc__", "__name__"]
-        attrs += [attr.name for attr in self._moved_attributes]
-        return attrs
-
-    # Subclasses should override this
-    _moved_attributes = []
-
-
-class MovedAttribute(_LazyDescr):
-
-    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
-        super(MovedAttribute, self).__init__(name)
-        if PY3:
-            if new_mod is None:
-                new_mod = name
-            self.mod = new_mod
-            if new_attr is None:
-                if old_attr is None:
-                    new_attr = name
-                else:
-                    new_attr = old_attr
-            self.attr = new_attr
-        else:
-            self.mod = old_mod
-            if old_attr is None:
-                old_attr = name
-            self.attr = old_attr
-
-    def _resolve(self):
-        module = _import_module(self.mod)
-        return getattr(module, self.attr)
-
-
-class _SixMetaPathImporter(object):
-
-    """
-    A meta path importer to import six.moves and its submodules.
-
-    This class implements a PEP302 finder and loader. It should be compatible
-    with Python 2.5 and all existing versions of Python3
-    """
-
-    def __init__(self, six_module_name):
-        self.name = six_module_name
-        self.known_modules = {}
-
-    def _add_module(self, mod, *fullnames):
-        for fullname in fullnames:
-            self.known_modules[self.name + "." + fullname] = mod
-
-    def _get_module(self, fullname):
-        return self.known_modules[self.name + "." + fullname]
-
-    def find_module(self, fullname, path=None):
-        if fullname in self.known_modules:
-            return self
-        return None
-
-    def __get_module(self, fullname):
-        try:
-            return self.known_modules[fullname]
-        except KeyError:
-            raise ImportError("This loader does not know module " + fullname)
-
-    def load_module(self, fullname):
-        try:
-            # in case of a reload
-            return sys.modules[fullname]
-        except KeyError:
-            pass
-        mod = self.__get_module(fullname)
-        if isinstance(mod, MovedModule):
-            mod = mod._resolve()
-        else:
-            mod.__loader__ = self
-        sys.modules[fullname] = mod
-        return mod
-
-    def is_package(self, fullname):
-        """
-        Return true, if the named module is a package.
-
-        We need this method to get correct spec objects with
-        Python 3.4 (see PEP451)
-        """
-        return hasattr(self.__get_module(fullname), "__path__")
-
-    def get_code(self, fullname):
-        """Return None
-
-        Required, if is_package is implemented"""
-        self.__get_module(fullname)  # eventually raises ImportError
-        return None
-    get_source = get_code  # same as get_code
-
-_importer = _SixMetaPathImporter(__name__)
-
-
-class _MovedItems(_LazyModule):
-
-    """Lazy loading of moved objects"""
-    __path__ = []  # mark as package
-
-
-_moved_attributes = [
-    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
-    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
-    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
-    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
-    MovedAttribute("intern", "__builtin__", "sys"),
-    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
-    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
-    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
-    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
-    MovedAttribute("reduce", "__builtin__", "functools"),
-    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
-    MovedAttribute("StringIO", "StringIO", "io"),
-    MovedAttribute("UserDict", "UserDict", "collections"),
-    MovedAttribute("UserList", "UserList", "collections"),
-    MovedAttribute("UserString", "UserString", "collections"),
-    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
-    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
-    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
-    MovedModule("builtins", "__builtin__"),
-    MovedModule("configparser", "ConfigParser"),
-    MovedModule("copyreg", "copy_reg"),
-    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
-    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
-    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
-    MovedModule("http_cookies", "Cookie", "http.cookies"),
-    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
-    MovedModule("html_parser", "HTMLParser", "html.parser"),
-    MovedModule("http_client", "httplib", "http.client"),
-    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
-    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
-    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
-    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
-    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
-    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
-    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
-    MovedModule("cPickle", "cPickle", "pickle"),
-    MovedModule("queue", "Queue"),
-    MovedModule("reprlib", "repr"),
-    MovedModule("socketserver", "SocketServer"),
-    MovedModule("_thread", "thread", "_thread"),
-    MovedModule("tkinter", "Tkinter"),
-    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
-    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
-    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
-    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
-    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
-    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
-    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
-    MovedModule("tkinter_colorchooser", "tkColorChooser",
-                "tkinter.colorchooser"),
-    MovedModule("tkinter_commondialog", "tkCommonDialog",
-                "tkinter.commondialog"),
-    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
-    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
-    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
-    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
-                "tkinter.simpledialog"),
-    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
-    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
-    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
-    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
-    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
-    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
-]
-# Add windows specific modules.
-if sys.platform == "win32":
-    _moved_attributes += [
-        MovedModule("winreg", "_winreg"),
-    ]
-
-for attr in _moved_attributes:
-    setattr(_MovedItems, attr.name, attr)
-    if isinstance(attr, MovedModule):
-        _importer._add_module(attr, "moves." + attr.name)
-del attr
-
-_MovedItems._moved_attributes = _moved_attributes
-
-moves = _MovedItems(__name__ + ".moves")
-_importer._add_module(moves, "moves")
-
-
-class Module_six_moves_urllib_parse(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_parse"""
-
-
-_urllib_parse_moved_attributes = [
-    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
-    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
-    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
-    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
-    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
-    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
-    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
-    MovedAttribute("quote", "urllib", "urllib.parse"),
-    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("unquote", "urllib", "urllib.parse"),
-    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
-    MovedAttribute("urlencode", "urllib", "urllib.parse"),
-    MovedAttribute("splitquery", "urllib", "urllib.parse"),
-    MovedAttribute("splittag", "urllib", "urllib.parse"),
-    MovedAttribute("splituser", "urllib", "urllib.parse"),
-    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
-    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
-]
-for attr in _urllib_parse_moved_attributes:
-    setattr(Module_six_moves_urllib_parse, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
-                      "moves.urllib_parse", "moves.urllib.parse")
-
-
-class Module_six_moves_urllib_error(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_error"""
-
-
-_urllib_error_moved_attributes = [
-    MovedAttribute("URLError", "urllib2", "urllib.error"),
-    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
-    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
-]
-for attr in _urllib_error_moved_attributes:
-    setattr(Module_six_moves_urllib_error, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
-                      "moves.urllib_error", "moves.urllib.error")
-
-
-class Module_six_moves_urllib_request(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_request"""
-
-
-_urllib_request_moved_attributes = [
-    MovedAttribute("urlopen", "urllib2", "urllib.request"),
-    MovedAttribute("install_opener", "urllib2", "urllib.request"),
-    MovedAttribute("build_opener", "urllib2", "urllib.request"),
-    MovedAttribute("pathname2url", "urllib", "urllib.request"),
-    MovedAttribute("url2pathname", "urllib", "urllib.request"),
-    MovedAttribute("getproxies", "urllib", "urllib.request"),
-    MovedAttribute("Request", "urllib2", "urllib.request"),
-    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
-    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
-    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
-    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
-    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
-    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
-    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
-    MovedAttribute("URLopener", "urllib", "urllib.request"),
-    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
-    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
-]
-for attr in _urllib_request_moved_attributes:
-    setattr(Module_six_moves_urllib_request, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
-                      "moves.urllib_request", "moves.urllib.request")
-
-
-class Module_six_moves_urllib_response(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_response"""
-
-
-_urllib_response_moved_attributes = [
-    MovedAttribute("addbase", "urllib", "urllib.response"),
-    MovedAttribute("addclosehook", "urllib", "urllib.response"),
-    MovedAttribute("addinfo", "urllib", "urllib.response"),
-    MovedAttribute("addinfourl", "urllib", "urllib.response"),
-]
-for attr in _urllib_response_moved_attributes:
-    setattr(Module_six_moves_urllib_response, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
-                      "moves.urllib_response", "moves.urllib.response")
-
-
-class Module_six_moves_urllib_robotparser(_LazyModule):
-
-    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
-
-
-_urllib_robotparser_moved_attributes = [
-    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
-]
-for attr in _urllib_robotparser_moved_attributes:
-    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
-del attr
-
-Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
-
-_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
-                      "moves.urllib_robotparser", "moves.urllib.robotparser")
-
-
-class Module_six_moves_urllib(types.ModuleType):
-
-    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
-    __path__ = []  # mark as package
-    parse = _importer._get_module("moves.urllib_parse")
-    error = _importer._get_module("moves.urllib_error")
-    request = _importer._get_module("moves.urllib_request")
-    response = _importer._get_module("moves.urllib_response")
-    robotparser = _importer._get_module("moves.urllib_robotparser")
-
-    def __dir__(self):
-        return ['parse', 'error', 'request', 'response', 'robotparser']
-
-_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
-                      "moves.urllib")
-
-
-def add_move(move):
-    """Add an item to six.moves."""
-    setattr(_MovedItems, move.name, move)
-
-
-def remove_move(name):
-    """Remove item from six.moves."""
-    try:
-        delattr(_MovedItems, name)
-    except AttributeError:
-        try:
-            del moves.__dict__[name]
-        except KeyError:
-            raise AttributeError("no such move, %r" % (name,))
-
-
-if PY3:
-    _meth_func = "__func__"
-    _meth_self = "__self__"
-
-    _func_closure = "__closure__"
-    _func_code = "__code__"
-    _func_defaults = "__defaults__"
-    _func_globals = "__globals__"
-else:
-    _meth_func = "im_func"
-    _meth_self = "im_self"
-
-    _func_closure = "func_closure"
-    _func_code = "func_code"
-    _func_defaults = "func_defaults"
-    _func_globals = "func_globals"
-
-
-try:
-    advance_iterator = next
-except NameError:
-    def advance_iterator(it):
-        return it.next()
-next = advance_iterator
-
-
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-if PY3:
-    def get_unbound_function(unbound):
-        return unbound
-
-    create_bound_method = types.MethodType
-
-    def create_unbound_method(func, cls):
-        return func
-
-    Iterator = object
-else:
-    def get_unbound_function(unbound):
-        return unbound.im_func
-
-    def create_bound_method(func, obj):
-        return types.MethodType(func, obj, obj.__class__)
-
-    def create_unbound_method(func, cls):
-        return types.MethodType(func, None, cls)
-
-    class Iterator(object):
-
-        def next(self):
-            return type(self).__next__(self)
-
-    callable = callable
-_add_doc(get_unbound_function,
-         """Get the function out of a possibly unbound function""")
-
-
-get_method_function = operator.attrgetter(_meth_func)
-get_method_self = operator.attrgetter(_meth_self)
-get_function_closure = operator.attrgetter(_func_closure)
-get_function_code = operator.attrgetter(_func_code)
-get_function_defaults = operator.attrgetter(_func_defaults)
-get_function_globals = operator.attrgetter(_func_globals)
-
-
-if PY3:
-    def iterkeys(d, **kw):
-        return iter(d.keys(**kw))
-
-    def itervalues(d, **kw):
-        return iter(d.values(**kw))
-
-    def iteritems(d, **kw):
-        return iter(d.items(**kw))
-
-    def iterlists(d, **kw):
-        return iter(d.lists(**kw))
-
-    viewkeys = operator.methodcaller("keys")
-
-    viewvalues = operator.methodcaller("values")
-
-    viewitems = operator.methodcaller("items")
-else:
-    def iterkeys(d, **kw):
-        return d.iterkeys(**kw)
-
-    def itervalues(d, **kw):
-        return d.itervalues(**kw)
-
-    def iteritems(d, **kw):
-        return d.iteritems(**kw)
-
-    def iterlists(d, **kw):
-        return d.iterlists(**kw)
-
-    viewkeys = operator.methodcaller("viewkeys")
-
-    viewvalues = operator.methodcaller("viewvalues")
-
-    viewitems = operator.methodcaller("viewitems")
-
-_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
-_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
-_add_doc(iteritems,
-         "Return an iterator over the (key, value) pairs of a dictionary.")
-_add_doc(iterlists,
-         "Return an iterator over the (key, [values]) pairs of a dictionary.")
-
-
-if PY3:
-    def b(s):
-        return s.encode("latin-1")
-
-    def u(s):
-        return s
-    unichr = chr
-    import struct
-    int2byte = struct.Struct(">B").pack
-    del struct
-    byte2int = operator.itemgetter(0)
-    indexbytes = operator.getitem
-    iterbytes = iter
-    import io
-    StringIO = io.StringIO
-    BytesIO = io.BytesIO
-    _assertCountEqual = "assertCountEqual"
-    if sys.version_info[1] <= 1:
-        _assertRaisesRegex = "assertRaisesRegexp"
-        _assertRegex = "assertRegexpMatches"
-    else:
-        _assertRaisesRegex = "assertRaisesRegex"
-        _assertRegex = "assertRegex"
-else:
-    def b(s):
-        return s
-    # Workaround for standalone backslash
-
-    def u(s):
-        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
-    unichr = unichr
-    int2byte = chr
-
-    def byte2int(bs):
-        return ord(bs[0])
-
-    def indexbytes(buf, i):
-        return ord(buf[i])
-    iterbytes = functools.partial(itertools.imap, ord)
-    import StringIO
-    StringIO = BytesIO = StringIO.StringIO
-    _assertCountEqual = "assertItemsEqual"
-    _assertRaisesRegex = "assertRaisesRegexp"
-    _assertRegex = "assertRegexpMatches"
-_add_doc(b, """Byte literal""")
-_add_doc(u, """Text literal""")
-
-
-def assertCountEqual(self, *args, **kwargs):
-    return getattr(self, _assertCountEqual)(*args, **kwargs)
-
-
-def assertRaisesRegex(self, *args, **kwargs):
-    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
-
-
-def assertRegex(self, *args, **kwargs):
-    return getattr(self, _assertRegex)(*args, **kwargs)
-
-
-if PY3:
-    exec_ = getattr(moves.builtins, "exec")
-
-    def reraise(tp, value, tb=None):
-        if value is None:
-            value = tp()
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-else:
-    def exec_(_code_, _globs_=None, _locs_=None):
-        """Execute code in a namespace."""
-        if _globs_ is None:
-            frame = sys._getframe(1)
-            _globs_ = frame.f_globals
-            if _locs_ is None:
-                _locs_ = frame.f_locals
-            del frame
-        elif _locs_ is None:
-            _locs_ = _globs_
-        exec("""exec _code_ in _globs_, _locs_""")
-
-    exec_("""def reraise(tp, value, tb=None):
-    raise tp, value, tb
-""")
-
-
-if sys.version_info[:2] == (3, 2):
-    exec_("""def raise_from(value, from_value):
-    if from_value is None:
-        raise value
-    raise value from from_value
-""")
-elif sys.version_info[:2] > (3, 2):
-    exec_("""def raise_from(value, from_value):
-    raise value from from_value
-""")
-else:
-    def raise_from(value, from_value):
-        raise value
-
-
-print_ = getattr(moves.builtins, "print", None)
-if print_ is None:
-    def print_(*args, **kwargs):
-        """The new-style print function for Python 2.4 and 2.5."""
-        fp = kwargs.pop("file", sys.stdout)
-        if fp is None:
-            return
-
-        def write(data):
-            if not isinstance(data, basestring):
-                data = str(data)
-            # If the file has an encoding, encode unicode with it.
-            if (isinstance(fp, file) and
-                    isinstance(data, unicode) and
-                    fp.encoding is not None):
-                errors = getattr(fp, "errors", None)
-                if errors is None:
-                    errors = "strict"
-                data = data.encode(fp.encoding, errors)
-            fp.write(data)
-        want_unicode = False
-        sep = kwargs.pop("sep", None)
-        if sep is not None:
-            if isinstance(sep, unicode):
-                want_unicode = True
-            elif not isinstance(sep, str):
-                raise TypeError("sep must be None or a string")
-        end = kwargs.pop("end", None)
-        if end is not None:
-            if isinstance(end, unicode):
-                want_unicode = True
-            elif not isinstance(end, str):
-                raise TypeError("end must be None or a string")
-        if kwargs:
-            raise TypeError("invalid keyword arguments to print()")
-        if not want_unicode:
-            for arg in args:
-                if isinstance(arg, unicode):
-                    want_unicode = True
-                    break
-        if want_unicode:
-            newline = unicode("\n")
-            space = unicode(" ")
-        else:
-            newline = "\n"
-            space = " "
-        if sep is None:
-            sep = space
-        if end is None:
-            end = newline
-        for i, arg in enumerate(args):
-            if i:
-                write(sep)
-            write(arg)
-        write(end)
-if sys.version_info[:2] < (3, 3):
-    _print = print_
-
-    def print_(*args, **kwargs):
-        fp = kwargs.get("file", sys.stdout)
-        flush = kwargs.pop("flush", False)
-        _print(*args, **kwargs)
-        if flush and fp is not None:
-            fp.flush()
-
-_add_doc(reraise, """Reraise an exception.""")
-
-if sys.version_info[0:2] < (3, 4):
-    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
-              updated=functools.WRAPPER_UPDATES):
-        def wrapper(f):
-            f = functools.wraps(wrapped, assigned, updated)(f)
-            f.__wrapped__ = wrapped
-            return f
-        return wrapper
-else:
-    wraps = functools.wraps
-
-
-def with_metaclass(meta, *bases):
-    """Create a base class with a metaclass."""
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
-    class metaclass(meta):
-
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-    return type.__new__(metaclass, 'temporary_class', (), {})
-
-
-def add_metaclass(metaclass):
-    """Class decorator for creating a class with a metaclass."""
-    def wrapper(cls):
-        orig_vars = cls.__dict__.copy()
-        slots = orig_vars.get('__slots__')
-        if slots is not None:
-            if isinstance(slots, str):
-                slots = [slots]
-            for slots_var in slots:
-                orig_vars.pop(slots_var)
-        orig_vars.pop('__dict__', None)
-        orig_vars.pop('__weakref__', None)
-        return metaclass(cls.__name__, cls.__bases__, orig_vars)
-    return wrapper
-
-
-def python_2_unicode_compatible(klass):
-    """
-    A decorator that defines __unicode__ and __str__ methods under Python 2.
-    Under Python 3 it does nothing.
-
-    To support Python 2 and 3 with a single code base, define a __str__ method
-    returning text and apply this decorator to the class.
-    """
-    if PY2:
-        if '__str__' not in klass.__dict__:
-            raise ValueError("@python_2_unicode_compatible cannot be applied "
-                             "to %s because it doesn't define __str__()." %
-                             klass.__name__)
-        klass.__unicode__ = klass.__str__
-        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
-    return klass
-
-
-# Complete the moves implementation.
-# This code is at the end of this module to speed up module loading.
-# Turn this module into a package.
-__path__ = []  # required for PEP 302 and PEP 451
-__package__ = __name__  # see PEP 366 @ReservedAssignment
-if globals().get("__spec__") is not None:
-    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
-# Remove other six meta path importers, since they cause problems. This can
-# happen if six is removed from sys.modules and then reloaded. (Setuptools does
-# this for some reason.)
-if sys.meta_path:
-    for i, importer in enumerate(sys.meta_path):
-        # Here's some real nastiness: Another "instance" of the six module might
-        # be floating around. Therefore, we can't use isinstance() to check for
-        # the six meta path importer, since the other six instance will have
-        # inserted an importer with different class.
-        if (type(importer).__name__ == "_SixMetaPathImporter" and
-                importer.name == __name__):
-            del sys.meta_path[i]
-            break
-    del i, importer
-# Finally, add the importer to the meta path import hook.
-sys.meta_path.append(_importer)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__init__.py
deleted file mode 100644
index b4156fec2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__init__.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import sys
-
-
-class VendorImporter:
-    """
-    A PEP 302 meta path importer for finding optionally-vendored
-    or otherwise naturally-installed packages from root_name.
-    """
-
-    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
-        self.root_name = root_name
-        self.vendored_names = set(vendored_names)
-        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
-
-    @property
-    def search_path(self):
-        """
-        Search first the vendor package then as a natural package.
-        """
-        yield self.vendor_pkg + '.'
-        yield ''
-
-    def find_module(self, fullname, path=None):
-        """
-        Return self when fullname starts with root_name and the
-        target module is one vendored through this importer.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        if root:
-            return
-        if not any(map(target.startswith, self.vendored_names)):
-            return
-        return self
-
-    def load_module(self, fullname):
-        """
-        Iterate over the search path to locate and load fullname.
-        """
-        root, base, target = fullname.partition(self.root_name + '.')
-        for prefix in self.search_path:
-            try:
-                extant = prefix + target
-                __import__(extant)
-                mod = sys.modules[extant]
-                sys.modules[fullname] = mod
-                # mysterious hack:
-                # Remove the reference to the extant package/module
-                # on later Python versions to cause relative imports
-                # in the vendor package to resolve the same modules
-                # as those going through this importer.
-                if sys.version_info > (3, 3):
-                    del sys.modules[extant]
-                return mod
-            except ImportError:
-                pass
-        else:
-            raise ImportError(
-                "The '{target}' package is required; "
-                "normally this is bundled with this package so if you get "
-                "this warning, consult the packager of your "
-                "distribution.".format(**locals())
-            )
-
-    def install(self):
-        """
-        Install this importer into sys.meta_path if not already present.
-        """
-        if self not in sys.meta_path:
-            sys.meta_path.append(self)
-
-
-names = 'packaging', 'pyparsing', 'six', 'appdirs'
-VendorImporter(__name__, names).install()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 2c5f33292..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/pkg_resources/extern/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/DESCRIPTION.rst b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/DESCRIPTION.rst
deleted file mode 100644
index 692d325fb..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/DESCRIPTION.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-.. image:: https://readthedocs.org/projects/setuptools/badge/?version=latest
-    :target: https://setuptools.readthedocs.io
-
-See the `Installation Instructions
-<https://packaging.python.org/installing/>`_ in the Python Packaging
-User's Guide for instructions on installing, upgrading, and uninstalling
-Setuptools.
-
-The project is `maintained at GitHub <https://github.com/pypa/setuptools>`_.
-
-Questions and comments should be directed to the `distutils-sig
-mailing list <http://mail.python.org/pipermail/distutils-sig/>`_.
-Bug reports and especially tested patches may be
-submitted directly to the `bug tracker
-<https://github.com/pypa/setuptools/issues>`_.
-
-
-Code of Conduct
----------------
-
-Everyone interacting in the setuptools project's codebases, issue trackers,
-chat rooms, and mailing lists is expected to follow the
-`PyPA Code of Conduct <https://www.pypa.io/en/latest/code-of-conduct/>`_.
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/INSTALLER b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/METADATA b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/METADATA
deleted file mode 100644
index f710ac8ed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/METADATA
+++ /dev/null
@@ -1,51 +0,0 @@
-Metadata-Version: 2.0
-Name: setuptools
-Version: 33.1.1
-Summary: Easily download, build, install, upgrade, and uninstall Python packages
-Home-page: https://github.com/pypa/setuptools
-Author: Python Packaging Authority
-Author-email: distutils-sig@python.org
-License: UNKNOWN
-Keywords: CPAN PyPI distutils eggs package management
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Archiving :: Packaging
-Classifier: Topic :: System :: Systems Administration
-Classifier: Topic :: Utilities
-Requires-Python: >=2.6,!=3.0.*,!=3.1.*,!=3.2.*
-
-.. image:: https://readthedocs.org/projects/setuptools/badge/?version=latest
-    :target: https://setuptools.readthedocs.io
-
-See the `Installation Instructions
-<https://packaging.python.org/installing/>`_ in the Python Packaging
-User's Guide for instructions on installing, upgrading, and uninstalling
-Setuptools.
-
-The project is `maintained at GitHub <https://github.com/pypa/setuptools>`_.
-
-Questions and comments should be directed to the `distutils-sig
-mailing list <http://mail.python.org/pipermail/distutils-sig/>`_.
-Bug reports and especially tested patches may be
-submitted directly to the `bug tracker
-<https://github.com/pypa/setuptools/issues>`_.
-
-
-Code of Conduct
----------------
-
-Everyone interacting in the setuptools project's codebases, issue trackers,
-chat rooms, and mailing lists is expected to follow the
-`PyPA Code of Conduct <https://www.pypa.io/en/latest/code-of-conduct/>`_.
-
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/RECORD b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/RECORD
deleted file mode 100644
index 6b9fe23a8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/RECORD
+++ /dev/null
@@ -1,119 +0,0 @@
-easy_install.py,sha256=MDC9vt5AxDsXX5qcKlBz2TnW6Tpuv_AobnfhCJ9X3PM,126
-setuptools/__init__.py,sha256=MsRcLyrl8E49pBeFZ-PSwST-I2adqjvkfCC1h9gl0TQ,5037
-setuptools/archive_util.py,sha256=Z58-gbZQ0j92UJy7X7uZevwI28JTVEXd__AjKy4aw78,6613
-setuptools/cli-32.exe,sha256=dfEuovMNnA2HLa3jRfMPVi5tk4R7alCbpTvuxtCyw0Y,65536
-setuptools/cli-64.exe,sha256=KLABu5pyrnokJCv6skjXZ6GsXeyYHGcqOUT3oHI3Xpo,74752
-setuptools/cli.exe,sha256=dfEuovMNnA2HLa3jRfMPVi5tk4R7alCbpTvuxtCyw0Y,65536
-setuptools/config.py,sha256=OsvOeCvH4U3XQMWSGGizzJ80TCdPzTLb02d4IqMHbAo,16413
-setuptools/depends.py,sha256=hC8QIDcM3VDpRXvRVA6OfL9AaQfxvhxHcN_w6sAyNq8,5837
-setuptools/dist.py,sha256=zWG4YreNxYH77jEqs6aR2UpLrIXQiUUVq1dKSqsVWfE,37548
-setuptools/extension.py,sha256=uc6nHI-MxwmNCNPbUiBnybSyqhpJqjbhvOQ-emdvt_E,1729
-setuptools/glob.py,sha256=Y-fpv8wdHZzv9DPCaGACpMSBWJ6amq_1e0R_i8_el4w,5207
-setuptools/gui-32.exe,sha256=XBr0bHMA6Hpz2s9s9Bzjl-PwXfa9nH4ie0rFn4V2kWA,65536
-setuptools/gui-64.exe,sha256=aYKMhX1IJLn4ULHgWX0sE0yREUt6B3TEHf_jOw6yNyE,75264
-setuptools/gui.exe,sha256=XBr0bHMA6Hpz2s9s9Bzjl-PwXfa9nH4ie0rFn4V2kWA,65536
-setuptools/launch.py,sha256=sd7ejwhBocCDx_wG9rIs0OaZ8HtmmFU8ZC6IR_S0Lvg,787
-setuptools/lib2to3_ex.py,sha256=t5e12hbR2pi9V4ezWDTB4JM-AISUnGOkmcnYHek3xjg,2013
-setuptools/monkey.py,sha256=4tyvck6n4gm7TPTHYnK19WBQnHtWD0-_Ibv8KDMkB0I,5441
-setuptools/msvc.py,sha256=6cKqwOxTH8pJNMrNyRLBGB6Efz2rxTTdQQJABUW-6WU,37091
-setuptools/namespaces.py,sha256=66TyxK0mtwh2Ftny356GBvXOPbOocUalrHL-kgG4Hi0,3215
-setuptools/package_index.py,sha256=0PVRMrPGAbvxjiZS1atH8kmgq-NcpuLucNoWuhWgUmE,39964
-setuptools/py26compat.py,sha256=VRGHC7z2gliR4_uICJsQNodUcNUzybpus3BrJkWbnK4,679
-setuptools/py27compat.py,sha256=m-hBhbvvdUAZY0LPHv4HS5sPGEPzDaagFLJBzJDwrao,583
-setuptools/py31compat.py,sha256=qGRk3tefux8HbhNzhM0laR3mD8vhAZtffZgzLkBMXJs,1645
-setuptools/py33compat.py,sha256=W8_JFZr8WQbJT_7-JFWjc_6lHGtoMK-4pCrHIwk5JN0,998
-setuptools/py36compat.py,sha256=VUDWxmu5rt4QHlGTRtAFu6W5jvfL6WBjeDAzeoBy0OM,2891
-setuptools/sandbox.py,sha256=qvFtWjnLM4rtEubgfmnjYzI5Fsi0LUZDi6aXJbzQMpo,14356
-setuptools/script (dev).tmpl,sha256=f7MR17dTkzaqkCMSVseyOCMVrPVSMdmTQsaB8cZzfuI,201
-setuptools/script.tmpl,sha256=WGTt5piezO27c-Dbx6l5Q4T3Ff20A5z7872hv3aAhYY,138
-setuptools/site-patch.py,sha256=BVt6yIrDMXJoflA5J6DJIcsJUfW_XEeVhOzelTTFDP4,2307
-setuptools/ssl_support.py,sha256=Axo1QtiAtsvuENZq_BvhW5PeWw2nrX39-4qoSiVpB6w,8220
-setuptools/unicode_utils.py,sha256=NOiZ_5hD72A6w-4wVj8awHFM3n51Kmw1Ic_vx15XFqw,996
-setuptools/version.py,sha256=og_cuZQb0QI6ukKZFfZWPlr1HgJBPPn2vO2m_bI9ZTE,144
-setuptools/windows_support.py,sha256=5GrfqSP2-dLGJoZTq2g6dCKkyQxxa2n5IQiXlJCoYEE,714
-setuptools/command/__init__.py,sha256=FCLDWoQEGsNexQviqbeJ4MEYGYpYVbbwc7i-9gjzBkM,563
-setuptools/command/alias.py,sha256=KjpE0sz_SDIHv3fpZcIQK-sCkJz-SrC6Gmug6b9Nkc8,2426
-setuptools/command/bdist_egg.py,sha256=XDamu6-cfyYrqd67YGQ5gWo-0c8kuWqkPy1vYpfsAxw,17178
-setuptools/command/bdist_rpm.py,sha256=B7l0TnzCGb-0nLlm6rS00jWLkojASwVmdhW2w5Qz_Ak,1508
-setuptools/command/bdist_wininst.py,sha256=_6dz3lpB1tY200LxKPLM7qgwTCceOMgaWFF-jW2-pm0,637
-setuptools/command/build_ext.py,sha256=dO89j-IC0dAjSty1sSZxvi0LSdkPGR_ZPXFuAAFDZj4,13049
-setuptools/command/build_py.py,sha256=yWyYaaS9F3o9JbIczn064A5g1C5_UiKRDxGaTqYbtLE,9596
-setuptools/command/develop.py,sha256=k7ycyx9vEQf4q2RL_vftssWxIKu6YmOMYSNghjUGFIE,7522
-setuptools/command/easy_install.py,sha256=KkKoP6oFUjDHxiY3PiXXB214bNnilpuU_cVxQYU8hek,88319
-setuptools/command/egg_info.py,sha256=xl9fJDJ_7AJXzJeIcVHGKmpEjF3bbYhia9C-NHUSQ9U,24750
-setuptools/command/install.py,sha256=a0EZpL_A866KEdhicTGbuyD_TYl1sykfzdrri-zazT4,4683
-setuptools/command/install_egg_info.py,sha256=4zq_Ad3jE-EffParuyDEnvxU6efB-Xhrzdr8aB6Ln_8,3195
-setuptools/command/install_lib.py,sha256=n2iLR8f1MlYeGHtV2oFxDpUiL-wyLaQgwSAFX-YIEv4,5012
-setuptools/command/install_scripts.py,sha256=UD0rEZ6861mTYhIdzcsqKnUl8PozocXWl9VBQ1VTWnc,2439
-setuptools/command/launcher manifest.xml,sha256=xlLbjWrB01tKC0-hlVkOKkiSPbzMml2eOPtJ_ucCnbE,628
-setuptools/command/py36compat.py,sha256=SzjZcOxF7zdFUT47Zv2n7AM3H8koDys_0OpS-n9gIfc,4986
-setuptools/command/register.py,sha256=bHlMm1qmBbSdahTOT8w6UhA-EgeQIz7p6cD-qOauaiI,270
-setuptools/command/rotate.py,sha256=co5C1EkI7P0GGT6Tqz-T2SIj2LBJTZXYELpmao6d4KQ,2164
-setuptools/command/saveopts.py,sha256=za7QCBcQimKKriWcoCcbhxPjUz30gSB74zuTL47xpP4,658
-setuptools/command/sdist.py,sha256=jIvjqSzUpsRU6Ysr--EQsh_s6wULhI5V4pe0QEFin1Q,6844
-setuptools/command/setopt.py,sha256=NTWDyx-gjDF-txf4dO577s7LOzHVoKR0Mq33rFxaRr8,5085
-setuptools/command/test.py,sha256=-Qt5wsE_BxHhqInN7LAoOZNwUkUHG6fBa0jinMv_Xqk,8857
-setuptools/command/upload.py,sha256=6LbdC9NWFe19tb8u-6L3Hriei-nVgtqfO7tn0Si7yLo,1077
-setuptools/command/upload_docs.py,sha256=0Ft5uo7Unnk4lJdZtIm6Nzq7hlyux-9zIYcXC8k_Czs,7275
-setuptools/extern/__init__.py,sha256=ZtCLYQ8JTtOtm7SYoxekZw-UzY3TR50SRIUaeqr2ROk,131
-setuptools-33.1.1.dist-info/DESCRIPTION.rst,sha256=fWVE3Nl6cnjokuGh4p-r7Z1JTwYjsFFbwyGjF4h0hqs,901
-setuptools-33.1.1.dist-info/METADATA,sha256=JbFUl-xb-VLvxYOIhPXvkJ7BdM7d5ZzA312b9Hxk1AE,2002
-setuptools-33.1.1.dist-info/RECORD,,
-setuptools-33.1.1.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
-setuptools-33.1.1.dist-info/dependency_links.txt,sha256=HlkCFkoK5TbZ5EMLbLKYhLcY_E31kBWD8TqW2EgmatQ,239
-setuptools-33.1.1.dist-info/entry_points.txt,sha256=siaWCyzsbU9caWHkUUlimTc8e0nLtjlsS6onJYZ0_mk,2829
-setuptools-33.1.1.dist-info/metadata.json,sha256=okzad5aSySpxh3MoCgb7X1ZkOPH9DB4kSL1I_aM2Foo,4345
-setuptools-33.1.1.dist-info/top_level.txt,sha256=2HUXVVwA4Pff1xgTFr3GsTXXKaPaO6vlG6oNJ_4u4Tg,38
-setuptools-33.1.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-../../../bin/easy_install,sha256=dJHoYCM2BHH_8V9VLesNb3Y2K1Nbef7pdIEl_PHKBUs,271
-../../../bin/easy_install-3.5,sha256=dJHoYCM2BHH_8V9VLesNb3Y2K1Nbef7pdIEl_PHKBUs,271
-setuptools-33.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-setuptools/command/__pycache__/egg_info.cpython-35.pyc,,
-setuptools/__pycache__/msvc.cpython-35.pyc,,
-setuptools/command/__pycache__/upload.cpython-35.pyc,,
-setuptools/__pycache__/site-patch.cpython-35.pyc,,
-setuptools/command/__pycache__/test.cpython-35.pyc,,
-setuptools/__pycache__/ssl_support.cpython-35.pyc,,
-setuptools/command/__pycache__/bdist_egg.cpython-35.pyc,,
-setuptools/__pycache__/sandbox.cpython-35.pyc,,
-setuptools/command/__pycache__/register.cpython-35.pyc,,
-setuptools/__pycache__/glob.cpython-35.pyc,,
-setuptools/command/__pycache__/alias.cpython-35.pyc,,
-setuptools/command/__pycache__/install.cpython-35.pyc,,
-setuptools/__pycache__/depends.cpython-35.pyc,,
-setuptools/command/__pycache__/sdist.cpython-35.pyc,,
-setuptools/command/__pycache__/upload_docs.cpython-35.pyc,,
-setuptools/__pycache__/version.cpython-35.pyc,,
-setuptools/__pycache__/windows_support.cpython-35.pyc,,
-setuptools/__pycache__/py26compat.cpython-35.pyc,,
-setuptools/extern/__pycache__/__init__.cpython-35.pyc,,
-setuptools/command/__pycache__/setopt.cpython-35.pyc,,
-setuptools/__pycache__/py36compat.cpython-35.pyc,,
-setuptools/command/__pycache__/easy_install.cpython-35.pyc,,
-setuptools/command/__pycache__/bdist_rpm.cpython-35.pyc,,
-setuptools/__pycache__/dist.cpython-35.pyc,,
-setuptools/command/__pycache__/saveopts.cpython-35.pyc,,
-setuptools/__pycache__/config.cpython-35.pyc,,
-setuptools/command/__pycache__/install_egg_info.cpython-35.pyc,,
-setuptools/__pycache__/launch.cpython-35.pyc,,
-setuptools/__pycache__/unicode_utils.cpython-35.pyc,,
-setuptools/command/__pycache__/__init__.cpython-35.pyc,,
-setuptools/__pycache__/monkey.cpython-35.pyc,,
-setuptools/__pycache__/extension.cpython-35.pyc,,
-setuptools/command/__pycache__/build_ext.cpython-35.pyc,,
-setuptools/command/__pycache__/develop.cpython-35.pyc,,
-setuptools/__pycache__/py33compat.cpython-35.pyc,,
-setuptools/__pycache__/namespaces.cpython-35.pyc,,
-setuptools/command/__pycache__/rotate.cpython-35.pyc,,
-setuptools/__pycache__/lib2to3_ex.cpython-35.pyc,,
-setuptools/command/__pycache__/install_lib.cpython-35.pyc,,
-setuptools/__pycache__/py31compat.cpython-35.pyc,,
-setuptools/__pycache__/py27compat.cpython-35.pyc,,
-setuptools/__pycache__/__init__.cpython-35.pyc,,
-setuptools/command/__pycache__/install_scripts.cpython-35.pyc,,
-setuptools/command/__pycache__/bdist_wininst.cpython-35.pyc,,
-setuptools/command/__pycache__/build_py.cpython-35.pyc,,
-setuptools/__pycache__/package_index.cpython-35.pyc,,
-setuptools/__pycache__/archive_util.cpython-35.pyc,,
-__pycache__/easy_install.cpython-35.pyc,,
-setuptools/command/__pycache__/py36compat.cpython-35.pyc,,
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/WHEEL b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/WHEEL
deleted file mode 100644
index 8b6dd1b5a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.29.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/dependency_links.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/dependency_links.txt
deleted file mode 100644
index e87d02103..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/dependency_links.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-https://files.pythonhosted.org/packages/source/c/certifi/certifi-2016.9.26.tar.gz#md5=baa81e951a29958563689d868ef1064d
-https://files.pythonhosted.org/packages/source/w/wincertstore/wincertstore-0.2.zip#md5=ae728f2f007185648d0c7a8679b361e2
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/entry_points.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/entry_points.txt
deleted file mode 100644
index 41df37635..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/entry_points.txt
+++ /dev/null
@@ -1,62 +0,0 @@
-[console_scripts]
-easy_install = setuptools.command.easy_install:main
-
-[distutils.commands]
-alias = setuptools.command.alias:alias
-bdist_egg = setuptools.command.bdist_egg:bdist_egg
-bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
-bdist_wininst = setuptools.command.bdist_wininst:bdist_wininst
-build_ext = setuptools.command.build_ext:build_ext
-build_py = setuptools.command.build_py:build_py
-develop = setuptools.command.develop:develop
-easy_install = setuptools.command.easy_install:easy_install
-egg_info = setuptools.command.egg_info:egg_info
-install = setuptools.command.install:install
-install_egg_info = setuptools.command.install_egg_info:install_egg_info
-install_lib = setuptools.command.install_lib:install_lib
-install_scripts = setuptools.command.install_scripts:install_scripts
-register = setuptools.command.register:register
-rotate = setuptools.command.rotate:rotate
-saveopts = setuptools.command.saveopts:saveopts
-sdist = setuptools.command.sdist:sdist
-setopt = setuptools.command.setopt:setopt
-test = setuptools.command.test:test
-upload = setuptools.command.upload:upload
-upload_docs = setuptools.command.upload_docs:upload_docs
-
-[distutils.setup_keywords]
-convert_2to3_doctests = setuptools.dist:assert_string_list
-dependency_links = setuptools.dist:assert_string_list
-eager_resources = setuptools.dist:assert_string_list
-entry_points = setuptools.dist:check_entry_points
-exclude_package_data = setuptools.dist:check_package_data
-extras_require = setuptools.dist:check_extras
-include_package_data = setuptools.dist:assert_bool
-install_requires = setuptools.dist:check_requirements
-namespace_packages = setuptools.dist:check_nsp
-package_data = setuptools.dist:check_package_data
-packages = setuptools.dist:check_packages
-python_requires = setuptools.dist:check_specifier
-setup_requires = setuptools.dist:check_requirements
-test_loader = setuptools.dist:check_importable
-test_runner = setuptools.dist:check_importable
-test_suite = setuptools.dist:check_test_suite
-tests_require = setuptools.dist:check_requirements
-use_2to3 = setuptools.dist:assert_bool
-use_2to3_exclude_fixers = setuptools.dist:assert_string_list
-use_2to3_fixers = setuptools.dist:assert_string_list
-zip_safe = setuptools.dist:assert_bool
-
-[egg_info.writers]
-PKG-INFO = setuptools.command.egg_info:write_pkg_info
-dependency_links.txt = setuptools.command.egg_info:overwrite_arg
-depends.txt = setuptools.command.egg_info:warn_depends_obsolete
-eager_resources.txt = setuptools.command.egg_info:overwrite_arg
-entry_points.txt = setuptools.command.egg_info:write_entries
-namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
-requires.txt = setuptools.command.egg_info:write_requirements
-top_level.txt = setuptools.command.egg_info:write_toplevel_names
-
-[setuptools.installation]
-eggsecutable = setuptools.command.easy_install:bootstrap
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/metadata.json b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/metadata.json
deleted file mode 100644
index b61def618..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/metadata.json
+++ /dev/null
@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: System :: Archiving :: Packaging", "Topic :: System :: Systems Administration", "Topic :: Utilities"], "extensions": {"python.commands": {"wrap_console": {"easy_install": "setuptools.command.easy_install:main"}}, "python.details": {"contacts": [{"email": "distutils-sig@python.org", "name": "Python Packaging Authority", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/pypa/setuptools"}}, "python.exports": {"console_scripts": {"easy_install": "setuptools.command.easy_install:main"}, "distutils.commands": {"alias": "setuptools.command.alias:alias", "bdist_egg": "setuptools.command.bdist_egg:bdist_egg", "bdist_rpm": "setuptools.command.bdist_rpm:bdist_rpm", "bdist_wininst": "setuptools.command.bdist_wininst:bdist_wininst", "build_ext": "setuptools.command.build_ext:build_ext", "build_py": "setuptools.command.build_py:build_py", "develop": "setuptools.command.develop:develop", "easy_install": "setuptools.command.easy_install:easy_install", "egg_info": "setuptools.command.egg_info:egg_info", "install": "setuptools.command.install:install", "install_egg_info": "setuptools.command.install_egg_info:install_egg_info", "install_lib": "setuptools.command.install_lib:install_lib", "install_scripts": "setuptools.command.install_scripts:install_scripts", "register": "setuptools.command.register:register", "rotate": "setuptools.command.rotate:rotate", "saveopts": "setuptools.command.saveopts:saveopts", "sdist": "setuptools.command.sdist:sdist", "setopt": "setuptools.command.setopt:setopt", "test": "setuptools.command.test:test", "upload": "setuptools.command.upload:upload", "upload_docs": "setuptools.command.upload_docs:upload_docs"}, "distutils.setup_keywords": {"convert_2to3_doctests": "setuptools.dist:assert_string_list", "dependency_links": "setuptools.dist:assert_string_list", "eager_resources": "setuptools.dist:assert_string_list", "entry_points": "setuptools.dist:check_entry_points", "exclude_package_data": "setuptools.dist:check_package_data", "extras_require": "setuptools.dist:check_extras", "include_package_data": "setuptools.dist:assert_bool", "install_requires": "setuptools.dist:check_requirements", "namespace_packages": "setuptools.dist:check_nsp", "package_data": "setuptools.dist:check_package_data", "packages": "setuptools.dist:check_packages", "python_requires": "setuptools.dist:check_specifier", "setup_requires": "setuptools.dist:check_requirements", "test_loader": "setuptools.dist:check_importable", "test_runner": "setuptools.dist:check_importable", "test_suite": "setuptools.dist:check_test_suite", "tests_require": "setuptools.dist:check_requirements", "use_2to3": "setuptools.dist:assert_bool", "use_2to3_exclude_fixers": "setuptools.dist:assert_string_list", "use_2to3_fixers": "setuptools.dist:assert_string_list", "zip_safe": "setuptools.dist:assert_bool"}, "egg_info.writers": {"PKG-INFO": "setuptools.command.egg_info:write_pkg_info", "dependency_links.txt": "setuptools.command.egg_info:overwrite_arg", "depends.txt": "setuptools.command.egg_info:warn_depends_obsolete", "eager_resources.txt": "setuptools.command.egg_info:overwrite_arg", "entry_points.txt": "setuptools.command.egg_info:write_entries", "namespace_packages.txt": "setuptools.command.egg_info:overwrite_arg", "requires.txt": "setuptools.command.egg_info:write_requirements", "top_level.txt": "setuptools.command.egg_info:write_toplevel_names"}, "setuptools.installation": {"eggsecutable": "setuptools.command.easy_install:bootstrap"}}}, "generator": "bdist_wheel (0.29.0)", "keywords": ["CPAN", "PyPI", "distutils", "eggs", "package", "management"], "metadata_version": "2.0", "name": "setuptools", "requires_python": ">=2.6,!=3.0.*,!=3.1.*,!=3.2.*", "summary": "Easily download, build, install, upgrade, and uninstall Python packages", "version": "33.1.1"}
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/top_level.txt b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/top_level.txt
deleted file mode 100644
index 4577c6a79..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/top_level.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-easy_install
-pkg_resources
-setuptools
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/zip-safe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/zip-safe
deleted file mode 100644
index 8b1378917..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools-33.1.1.dist-info/zip-safe
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__init__.py
deleted file mode 100644
index 04f767408..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__init__.py
+++ /dev/null
@@ -1,160 +0,0 @@
-"""Extensions to the 'distutils' for large or complex distributions"""
-
-import os
-import functools
-import distutils.core
-import distutils.filelist
-from distutils.util import convert_path
-from fnmatch import fnmatchcase
-
-from setuptools.extern.six.moves import filter, map
-
-import setuptools.version
-from setuptools.extension import Extension
-from setuptools.dist import Distribution, Feature
-from setuptools.depends import Require
-from . import monkey
-
-__all__ = [
-    'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require',
-    'find_packages',
-]
-
-__version__ = setuptools.version.__version__
-
-bootstrap_install_from = None
-
-# If we run 2to3 on .py files, should we also convert docstrings?
-# Default: yes; assume that we can detect doctests reliably
-run_2to3_on_doctests = True
-# Standard package names for fixer packages
-lib2to3_fixer_packages = ['lib2to3.fixes']
-
-
-class PackageFinder(object):
-    """
-    Generate a list of all Python packages found within a directory
-    """
-
-    @classmethod
-    def find(cls, where='.', exclude=(), include=('*',)):
-        """Return a list all Python packages found within directory 'where'
-
-        'where' is the root directory which will be searched for packages.  It
-        should be supplied as a "cross-platform" (i.e. URL-style) path; it will
-        be converted to the appropriate local path syntax.
-
-        'exclude' is a sequence of package names to exclude; '*' can be used
-        as a wildcard in the names, such that 'foo.*' will exclude all
-        subpackages of 'foo' (but not 'foo' itself).
-
-        'include' is a sequence of package names to include.  If it's
-        specified, only the named packages will be included.  If it's not
-        specified, all found packages will be included.  'include' can contain
-        shell style wildcard patterns just like 'exclude'.
-        """
-
-        return list(cls._find_packages_iter(
-            convert_path(where),
-            cls._build_filter('ez_setup', '*__pycache__', *exclude),
-            cls._build_filter(*include)))
-
-    @classmethod
-    def _find_packages_iter(cls, where, exclude, include):
-        """
-        All the packages found in 'where' that pass the 'include' filter, but
-        not the 'exclude' filter.
-        """
-        for root, dirs, files in os.walk(where, followlinks=True):
-            # Copy dirs to iterate over it, then empty dirs.
-            all_dirs = dirs[:]
-            dirs[:] = []
-
-            for dir in all_dirs:
-                full_path = os.path.join(root, dir)
-                rel_path = os.path.relpath(full_path, where)
-                package = rel_path.replace(os.path.sep, '.')
-
-                # Skip directory trees that are not valid packages
-                if ('.' in dir or not cls._looks_like_package(full_path)):
-                    continue
-
-                # Should this package be included?
-                if include(package) and not exclude(package):
-                    yield package
-
-                # Keep searching subdirectories, as there may be more packages
-                # down there, even if the parent was excluded.
-                dirs.append(dir)
-
-    @staticmethod
-    def _looks_like_package(path):
-        """Does a directory look like a package?"""
-        return os.path.isfile(os.path.join(path, '__init__.py'))
-
-    @staticmethod
-    def _build_filter(*patterns):
-        """
-        Given a list of patterns, return a callable that will be true only if
-        the input matches at least one of the patterns.
-        """
-        return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
-
-
-class PEP420PackageFinder(PackageFinder):
-    @staticmethod
-    def _looks_like_package(path):
-        return True
-
-
-find_packages = PackageFinder.find
-
-setup = distutils.core.setup
-
-_Command = monkey.get_unpatched(distutils.core.Command)
-
-
-class Command(_Command):
-    __doc__ = _Command.__doc__
-
-    command_consumes_arguments = False
-
-    def __init__(self, dist, **kw):
-        """
-        Construct the command for dist, updating
-        vars(self) with any keyword parameters.
-        """
-        _Command.__init__(self, dist)
-        vars(self).update(kw)
-
-    def reinitialize_command(self, command, reinit_subcommands=0, **kw):
-        cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
-        vars(cmd).update(kw)
-        return cmd
-
-
-def _find_all_simple(path):
-    """
-    Find all files under 'path'
-    """
-    results = (
-        os.path.join(base, file)
-        for base, dirs, files in os.walk(path, followlinks=True)
-        for file in files
-    )
-    return filter(os.path.isfile, results)
-
-
-def findall(dir=os.curdir):
-    """
-    Find all files under 'dir' and return the list of full filenames.
-    Unless dir is '.', return full filenames with dir prepended.
-    """
-    files = _find_all_simple(dir)
-    if dir == os.curdir:
-        make_rel = functools.partial(os.path.relpath, start=dir)
-        files = map(make_rel, files)
-    return list(files)
-
-
-monkey.patch_all()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 67b99b0a9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/archive_util.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/archive_util.cpython-35.pyc
deleted file mode 100644
index b02b25fba..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/archive_util.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/config.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/config.cpython-35.pyc
deleted file mode 100644
index 31e46a013..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/config.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/depends.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/depends.cpython-35.pyc
deleted file mode 100644
index c28d263dd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/depends.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/dist.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/dist.cpython-35.pyc
deleted file mode 100644
index 7d7d6352b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/dist.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/extension.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/extension.cpython-35.pyc
deleted file mode 100644
index 98c0d7286..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/extension.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/glob.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/glob.cpython-35.pyc
deleted file mode 100644
index 2f9792d45..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/glob.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/launch.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/launch.cpython-35.pyc
deleted file mode 100644
index 58235ea75..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/launch.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/lib2to3_ex.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/lib2to3_ex.cpython-35.pyc
deleted file mode 100644
index 23da4b858..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/lib2to3_ex.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/monkey.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/monkey.cpython-35.pyc
deleted file mode 100644
index 5ebf69499..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/monkey.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/msvc.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/msvc.cpython-35.pyc
deleted file mode 100644
index 2868ee691..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/msvc.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/namespaces.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/namespaces.cpython-35.pyc
deleted file mode 100644
index 03cb1d283..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/namespaces.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/package_index.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/package_index.cpython-35.pyc
deleted file mode 100644
index 8d9815c0e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/package_index.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py26compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py26compat.cpython-35.pyc
deleted file mode 100644
index 464ca9a65..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py26compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py27compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py27compat.cpython-35.pyc
deleted file mode 100644
index 4227220ad..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py27compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py31compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py31compat.cpython-35.pyc
deleted file mode 100644
index de29720e2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py31compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py33compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py33compat.cpython-35.pyc
deleted file mode 100644
index 01c058b51..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py33compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py36compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py36compat.cpython-35.pyc
deleted file mode 100644
index e7a00dba5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/py36compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/sandbox.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/sandbox.cpython-35.pyc
deleted file mode 100644
index 23dab99af..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/sandbox.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/site-patch.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/site-patch.cpython-35.pyc
deleted file mode 100644
index 83b098065..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/site-patch.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/ssl_support.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/ssl_support.cpython-35.pyc
deleted file mode 100644
index 762b55cc4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/ssl_support.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/unicode_utils.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/unicode_utils.cpython-35.pyc
deleted file mode 100644
index cf07844b9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/unicode_utils.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/version.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/version.cpython-35.pyc
deleted file mode 100644
index 651222e17..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/version.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/windows_support.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/windows_support.cpython-35.pyc
deleted file mode 100644
index f9ac42858..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/__pycache__/windows_support.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/archive_util.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/archive_util.py
deleted file mode 100644
index cc82b3da3..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/archive_util.py
+++ /dev/null
@@ -1,173 +0,0 @@
-"""Utilities for extracting common archive formats"""
-
-import zipfile
-import tarfile
-import os
-import shutil
-import posixpath
-import contextlib
-from distutils.errors import DistutilsError
-
-from pkg_resources import ensure_directory, ContextualZipFile
-
-__all__ = [
-    "unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
-    "UnrecognizedFormat", "extraction_drivers", "unpack_directory",
-]
-
-
-class UnrecognizedFormat(DistutilsError):
-    """Couldn't recognize the archive type"""
-
-
-def default_filter(src, dst):
-    """The default progress/filter callback; returns True for all files"""
-    return dst
-
-
-def unpack_archive(filename, extract_dir, progress_filter=default_filter,
-        drivers=None):
-    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
-
-    `progress_filter` is a function taking two arguments: a source path
-    internal to the archive ('/'-separated), and a filesystem path where it
-    will be extracted.  The callback must return the desired extract path
-    (which may be the same as the one passed in), or else ``None`` to skip
-    that file or directory.  The callback can thus be used to report on the
-    progress of the extraction, as well as to filter the items extracted or
-    alter their extraction paths.
-
-    `drivers`, if supplied, must be a non-empty sequence of functions with the
-    same signature as this function (minus the `drivers` argument), that raise
-    ``UnrecognizedFormat`` if they do not support extracting the designated
-    archive type.  The `drivers` are tried in sequence until one is found that
-    does not raise an error, or until all are exhausted (in which case
-    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
-    drivers, the module's ``extraction_drivers`` constant will be used, which
-    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
-    order.
-    """
-    for driver in drivers or extraction_drivers:
-        try:
-            driver(filename, extract_dir, progress_filter)
-        except UnrecognizedFormat:
-            continue
-        else:
-            return
-    else:
-        raise UnrecognizedFormat(
-            "Not a recognized archive type: %s" % filename
-        )
-
-
-def unpack_directory(filename, extract_dir, progress_filter=default_filter):
-    """"Unpack" a directory, using the same interface as for archives
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a directory
-    """
-    if not os.path.isdir(filename):
-        raise UnrecognizedFormat("%s is not a directory" % filename)
-
-    paths = {
-        filename: ('', extract_dir),
-    }
-    for base, dirs, files in os.walk(filename):
-        src, dst = paths[base]
-        for d in dirs:
-            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
-        for f in files:
-            target = os.path.join(dst, f)
-            target = progress_filter(src + f, target)
-            if not target:
-                # skip non-files
-                continue
-            ensure_directory(target)
-            f = os.path.join(base, f)
-            shutil.copyfile(f, target)
-            shutil.copystat(f, target)
-
-
-def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack zip `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
-    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-
-    if not zipfile.is_zipfile(filename):
-        raise UnrecognizedFormat("%s is not a zip file" % (filename,))
-
-    with ContextualZipFile(filename) as z:
-        for info in z.infolist():
-            name = info.filename
-
-            # don't extract absolute paths or ones with .. in them
-            if name.startswith('/') or '..' in name.split('/'):
-                continue
-
-            target = os.path.join(extract_dir, *name.split('/'))
-            target = progress_filter(name, target)
-            if not target:
-                continue
-            if name.endswith('/'):
-                # directory
-                ensure_directory(target)
-            else:
-                # file
-                ensure_directory(target)
-                data = z.read(info.filename)
-                with open(target, 'wb') as f:
-                    f.write(data)
-            unix_attributes = info.external_attr >> 16
-            if unix_attributes:
-                os.chmod(target, unix_attributes)
-
-
-def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
-    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
-
-    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
-    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
-    of the `progress_filter` argument.
-    """
-    try:
-        tarobj = tarfile.open(filename)
-    except tarfile.TarError:
-        raise UnrecognizedFormat(
-            "%s is not a compressed or uncompressed tar file" % (filename,)
-        )
-    with contextlib.closing(tarobj):
-        # don't do any chowning!
-        tarobj.chown = lambda *args: None
-        for member in tarobj:
-            name = member.name
-            # don't extract absolute paths or ones with .. in them
-            if not name.startswith('/') and '..' not in name.split('/'):
-                prelim_dst = os.path.join(extract_dir, *name.split('/'))
-
-                # resolve any links and to extract the link targets as normal
-                # files
-                while member is not None and (member.islnk() or member.issym()):
-                    linkpath = member.linkname
-                    if member.issym():
-                        base = posixpath.dirname(member.name)
-                        linkpath = posixpath.join(base, linkpath)
-                        linkpath = posixpath.normpath(linkpath)
-                    member = tarobj._getmember(linkpath)
-
-                if member is not None and (member.isfile() or member.isdir()):
-                    final_dst = progress_filter(name, prelim_dst)
-                    if final_dst:
-                        if final_dst.endswith(os.sep):
-                            final_dst = final_dst[:-1]
-                        try:
-                            # XXX Ugh
-                            tarobj._extract_member(member, final_dst)
-                        except tarfile.ExtractError:
-                            # chown/chmod/mkfifo/mknode/makedev failed
-                            pass
-        return True
-
-
-extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-32.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-32.exe
deleted file mode 100644
index b1487b781..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-32.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-64.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-64.exe
deleted file mode 100644
index 675e6bf37..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli-64.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli.exe
deleted file mode 100644
index b1487b781..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/cli.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__init__.py
deleted file mode 100644
index efbe9411c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-__all__ = [
-    'alias', 'bdist_egg', 'bdist_rpm', 'build_ext', 'build_py', 'develop',
-    'easy_install', 'egg_info', 'install', 'install_lib', 'rotate', 'saveopts',
-    'sdist', 'setopt', 'test', 'install_egg_info', 'install_scripts',
-    'register', 'bdist_wininst', 'upload_docs', 'upload',
-]
-
-from distutils.command.bdist import bdist
-import sys
-
-from setuptools.command import install_scripts
-
-if 'egg' not in bdist.format_commands:
-    bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
-    bdist.format_commands.append('egg')
-
-del bdist, sys
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a2e2df1b4..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/alias.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/alias.cpython-35.pyc
deleted file mode 100644
index 001abfb99..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/alias.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-35.pyc
deleted file mode 100644
index 8777606bd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-35.pyc
deleted file mode 100644
index d048567b6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_wininst.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_wininst.cpython-35.pyc
deleted file mode 100644
index 6705d4dd6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/bdist_wininst.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_ext.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_ext.cpython-35.pyc
deleted file mode 100644
index 36946f69b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_ext.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_py.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_py.cpython-35.pyc
deleted file mode 100644
index 195d9386d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/build_py.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/develop.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/develop.cpython-35.pyc
deleted file mode 100644
index fd0bbfb2d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/develop.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/easy_install.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/easy_install.cpython-35.pyc
deleted file mode 100644
index 0c8ca7f48..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/easy_install.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/egg_info.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/egg_info.cpython-35.pyc
deleted file mode 100644
index b54454d2a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/egg_info.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install.cpython-35.pyc
deleted file mode 100644
index 871715ce6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-35.pyc
deleted file mode 100644
index 7dc3d655c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_lib.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_lib.cpython-35.pyc
deleted file mode 100644
index b7fa7920e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_lib.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_scripts.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_scripts.cpython-35.pyc
deleted file mode 100644
index ba92af83d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/install_scripts.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/py36compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/py36compat.cpython-35.pyc
deleted file mode 100644
index d6fa4bbab..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/py36compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/register.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/register.cpython-35.pyc
deleted file mode 100644
index 257148b71..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/register.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/rotate.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/rotate.cpython-35.pyc
deleted file mode 100644
index c3f2edf80..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/rotate.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/saveopts.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/saveopts.cpython-35.pyc
deleted file mode 100644
index e7cdc4027..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/saveopts.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/sdist.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/sdist.cpython-35.pyc
deleted file mode 100644
index 5da2b6586..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/sdist.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/setopt.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/setopt.cpython-35.pyc
deleted file mode 100644
index ea4bb845e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/setopt.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/test.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/test.cpython-35.pyc
deleted file mode 100644
index 04dda5ddc..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/test.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload.cpython-35.pyc
deleted file mode 100644
index 91cee6d2d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload_docs.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload_docs.cpython-35.pyc
deleted file mode 100644
index 0e63c156c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/__pycache__/upload_docs.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/alias.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/alias.py
deleted file mode 100644
index 4532b1cc0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/alias.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from distutils.errors import DistutilsOptionError
-
-from setuptools.extern.six.moves import map
-
-from setuptools.command.setopt import edit_config, option_base, config_file
-
-
-def shquote(arg):
-    """Quote an argument for later parsing by shlex.split()"""
-    for c in '"', "'", "\\", "#":
-        if c in arg:
-            return repr(arg)
-    if arg.split() != [arg]:
-        return repr(arg)
-    return arg
-
-
-class alias(option_base):
-    """Define a shortcut that invokes one or more commands"""
-
-    description = "define a shortcut to invoke one or more commands"
-    command_consumes_arguments = True
-
-    user_options = [
-        ('remove', 'r', 'remove (unset) the alias'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.args = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.remove and len(self.args) != 1:
-            raise DistutilsOptionError(
-                "Must specify exactly one argument (the alias name) when "
-                "using --remove"
-            )
-
-    def run(self):
-        aliases = self.distribution.get_option_dict('aliases')
-
-        if not self.args:
-            print("Command Aliases")
-            print("---------------")
-            for alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-            return
-
-        elif len(self.args) == 1:
-            alias, = self.args
-            if self.remove:
-                command = None
-            elif alias in aliases:
-                print("setup.py alias", format_alias(alias, aliases))
-                return
-            else:
-                print("No alias definition found for %r" % alias)
-                return
-        else:
-            alias = self.args[0]
-            command = ' '.join(map(shquote, self.args[1:]))
-
-        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
-
-
-def format_alias(name, aliases):
-    source, command = aliases[name]
-    if source == config_file('global'):
-        source = '--global-config '
-    elif source == config_file('user'):
-        source = '--user-config '
-    elif source == config_file('local'):
-        source = ''
-    else:
-        source = '--filename=%r' % source
-    return source + name + ' ' + command
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_egg.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_egg.py
deleted file mode 100644
index 8cd9dfefe..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_egg.py
+++ /dev/null
@@ -1,472 +0,0 @@
-"""setuptools.command.bdist_egg
-
-Build .egg distributions"""
-
-from distutils.errors import DistutilsSetupError
-from distutils.dir_util import remove_tree, mkpath
-from distutils import log
-from types import CodeType
-import sys
-import os
-import textwrap
-import marshal
-
-from setuptools.extern import six
-
-from pkg_resources import get_build_platform, Distribution, ensure_directory
-from pkg_resources import EntryPoint
-from setuptools.extension import Library
-from setuptools import Command
-
-try:
-    # Python 2.7 or >=3.2
-    from sysconfig import get_path, get_python_version
-
-    def _get_purelib():
-        return get_path("purelib")
-except ImportError:
-    from distutils.sysconfig import get_python_lib, get_python_version
-
-    def _get_purelib():
-        return get_python_lib(False)
-
-
-def strip_module(filename):
-    if '.' in filename:
-        filename = os.path.splitext(filename)[0]
-    if filename.endswith('module'):
-        filename = filename[:-6]
-    return filename
-
-
-def write_stub(resource, pyfile):
-    _stub_template = textwrap.dedent("""
-        def __bootstrap__():
-            global __bootstrap__, __loader__, __file__
-            import sys, pkg_resources, imp
-            __file__ = pkg_resources.resource_filename(__name__, %r)
-            __loader__ = None; del __bootstrap__, __loader__
-            imp.load_dynamic(__name__,__file__)
-        __bootstrap__()
-        """).lstrip()
-    with open(pyfile, 'w') as f:
-        f.write(_stub_template % resource)
-
-
-class bdist_egg(Command):
-    description = "create an \"egg\" distribution"
-
-    user_options = [
-        ('bdist-dir=', 'b',
-         "temporary directory for creating the distribution"),
-        ('plat-name=', 'p', "platform name to embed in generated filenames "
-                            "(default: %s)" % get_build_platform()),
-        ('exclude-source-files', None,
-         "remove all .py files from the generated egg"),
-        ('keep-temp', 'k',
-         "keep the pseudo-installation tree around after " +
-         "creating the distribution archive"),
-        ('dist-dir=', 'd',
-         "directory to put final built distributions in"),
-        ('skip-build', None,
-         "skip rebuilding everything (for testing/debugging)"),
-    ]
-
-    boolean_options = [
-        'keep-temp', 'skip-build', 'exclude-source-files'
-    ]
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.dist_dir = None
-        self.skip_build = 0
-        self.egg_output = None
-        self.exclude_source_files = None
-
-    def finalize_options(self):
-        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
-        self.egg_info = ei_cmd.egg_info
-
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'egg')
-
-        if self.plat_name is None:
-            self.plat_name = get_build_platform()
-
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-
-        if self.egg_output is None:
-
-            # Compute filename of the output egg
-            basename = Distribution(
-                None, None, ei_cmd.egg_name, ei_cmd.egg_version,
-                get_python_version(),
-                self.distribution.has_ext_modules() and self.plat_name
-            ).egg_name()
-
-            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
-
-    def do_install_data(self):
-        # Hack for packages that install data to install's --install-lib
-        self.get_finalized_command('install').install_lib = self.bdist_dir
-
-        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
-        old, self.distribution.data_files = self.distribution.data_files, []
-
-        for item in old:
-            if isinstance(item, tuple) and len(item) == 2:
-                if os.path.isabs(item[0]):
-                    realpath = os.path.realpath(item[0])
-                    normalized = os.path.normcase(realpath)
-                    if normalized == site_packages or normalized.startswith(
-                        site_packages + os.sep
-                    ):
-                        item = realpath[len(site_packages) + 1:], item[1]
-                        # XXX else: raise ???
-            self.distribution.data_files.append(item)
-
-        try:
-            log.info("installing package data to %s", self.bdist_dir)
-            self.call_command('install_data', force=0, root=None)
-        finally:
-            self.distribution.data_files = old
-
-    def get_outputs(self):
-        return [self.egg_output]
-
-    def call_command(self, cmdname, **kw):
-        """Invoke reinitialized command `cmdname` with keyword args"""
-        for dirname in INSTALL_DIRECTORY_ATTRS:
-            kw.setdefault(dirname, self.bdist_dir)
-        kw.setdefault('skip_build', self.skip_build)
-        kw.setdefault('dry_run', self.dry_run)
-        cmd = self.reinitialize_command(cmdname, **kw)
-        self.run_command(cmdname)
-        return cmd
-
-    def run(self):
-        # Generate metadata first
-        self.run_command("egg_info")
-        # We run install_lib before install_data, because some data hacks
-        # pull their data path from the install_lib command.
-        log.info("installing library code to %s", self.bdist_dir)
-        instcmd = self.get_finalized_command('install')
-        old_root = instcmd.root
-        instcmd.root = None
-        if self.distribution.has_c_libraries() and not self.skip_build:
-            self.run_command('build_clib')
-        cmd = self.call_command('install_lib', warn_dir=0)
-        instcmd.root = old_root
-
-        all_outputs, ext_outputs = self.get_ext_outputs()
-        self.stubs = []
-        to_compile = []
-        for (p, ext_name) in enumerate(ext_outputs):
-            filename, ext = os.path.splitext(ext_name)
-            pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
-                                  '.py')
-            self.stubs.append(pyfile)
-            log.info("creating stub loader for %s", ext_name)
-            if not self.dry_run:
-                write_stub(os.path.basename(ext_name), pyfile)
-            to_compile.append(pyfile)
-            ext_outputs[p] = ext_name.replace(os.sep, '/')
-
-        if to_compile:
-            cmd.byte_compile(to_compile)
-        if self.distribution.data_files:
-            self.do_install_data()
-
-        # Make the EGG-INFO directory
-        archive_root = self.bdist_dir
-        egg_info = os.path.join(archive_root, 'EGG-INFO')
-        self.mkpath(egg_info)
-        if self.distribution.scripts:
-            script_dir = os.path.join(egg_info, 'scripts')
-            log.info("installing scripts to %s", script_dir)
-            self.call_command('install_scripts', install_dir=script_dir,
-                              no_ep=1)
-
-        self.copy_metadata_to(egg_info)
-        native_libs = os.path.join(egg_info, "native_libs.txt")
-        if all_outputs:
-            log.info("writing %s", native_libs)
-            if not self.dry_run:
-                ensure_directory(native_libs)
-                libs_file = open(native_libs, 'wt')
-                libs_file.write('\n'.join(all_outputs))
-                libs_file.write('\n')
-                libs_file.close()
-        elif os.path.isfile(native_libs):
-            log.info("removing %s", native_libs)
-            if not self.dry_run:
-                os.unlink(native_libs)
-
-        write_safety_flag(
-            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
-        )
-
-        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
-            log.warn(
-                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
-                "Use the install_requires/extras_require setup() args instead."
-            )
-
-        if self.exclude_source_files:
-            self.zap_pyfiles()
-
-        # Make the archive
-        make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
-                     dry_run=self.dry_run, mode=self.gen_header())
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-        # Add to 'Distribution.dist_files' so that the "upload" command works
-        getattr(self.distribution, 'dist_files', []).append(
-            ('bdist_egg', get_python_version(), self.egg_output))
-
-    def zap_pyfiles(self):
-        log.info("Removing .py files from temporary directory")
-        for base, dirs, files in walk_egg(self.bdist_dir):
-            for name in files:
-                if name.endswith('.py'):
-                    path = os.path.join(base, name)
-                    log.debug("Deleting %s", path)
-                    os.unlink(path)
-
-    def zip_safe(self):
-        safe = getattr(self.distribution, 'zip_safe', None)
-        if safe is not None:
-            return safe
-        log.warn("zip_safe flag not set; analyzing archive contents...")
-        return analyze_egg(self.bdist_dir, self.stubs)
-
-    def gen_header(self):
-        epm = EntryPoint.parse_map(self.distribution.entry_points or '')
-        ep = epm.get('setuptools.installation', {}).get('eggsecutable')
-        if ep is None:
-            return 'w'  # not an eggsecutable, do it the usual way.
-
-        if not ep.attrs or ep.extras:
-            raise DistutilsSetupError(
-                "eggsecutable entry point (%r) cannot have 'extras' "
-                "or refer to a module" % (ep,)
-            )
-
-        pyver = sys.version[:3]
-        pkg = ep.module_name
-        full = '.'.join(ep.attrs)
-        base = ep.attrs[0]
-        basename = os.path.basename(self.egg_output)
-
-        header = (
-            "#!/bin/sh\n"
-            'if [ `basename $0` = "%(basename)s" ]\n'
-            'then exec python%(pyver)s -c "'
-            "import sys, os; sys.path.insert(0, os.path.abspath('$0')); "
-            "from %(pkg)s import %(base)s; sys.exit(%(full)s())"
-            '" "$@"\n'
-            'else\n'
-            '  echo $0 is not the correct name for this egg file.\n'
-            '  echo Please rename it back to %(basename)s and try again.\n'
-            '  exec false\n'
-            'fi\n'
-        ) % locals()
-
-        if not self.dry_run:
-            mkpath(os.path.dirname(self.egg_output), dry_run=self.dry_run)
-            f = open(self.egg_output, 'w')
-            f.write(header)
-            f.close()
-        return 'a'
-
-    def copy_metadata_to(self, target_dir):
-        "Copy metadata (egg info) to the target_dir"
-        # normalize the path (so that a forward-slash in egg_info will
-        # match using startswith below)
-        norm_egg_info = os.path.normpath(self.egg_info)
-        prefix = os.path.join(norm_egg_info, '')
-        for path in self.ei_cmd.filelist.files:
-            if path.startswith(prefix):
-                target = os.path.join(target_dir, path[len(prefix):])
-                ensure_directory(target)
-                self.copy_file(path, target)
-
-    def get_ext_outputs(self):
-        """Get a list of relative paths to C extensions in the output distro"""
-
-        all_outputs = []
-        ext_outputs = []
-
-        paths = {self.bdist_dir: ''}
-        for base, dirs, files in os.walk(self.bdist_dir):
-            for filename in files:
-                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
-                    all_outputs.append(paths[base] + filename)
-            for filename in dirs:
-                paths[os.path.join(base, filename)] = (paths[base] +
-                                                       filename + '/')
-
-        if self.distribution.has_ext_modules():
-            build_cmd = self.get_finalized_command('build_ext')
-            for ext in build_cmd.extensions:
-                if isinstance(ext, Library):
-                    continue
-                fullname = build_cmd.get_ext_fullname(ext.name)
-                filename = build_cmd.get_ext_filename(fullname)
-                if not os.path.basename(filename).startswith('dl-'):
-                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
-                        ext_outputs.append(filename)
-
-        return all_outputs, ext_outputs
-
-
-NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
-
-
-def walk_egg(egg_dir):
-    """Walk an unpacked egg's contents, skipping the metadata directory"""
-    walker = os.walk(egg_dir)
-    base, dirs, files = next(walker)
-    if 'EGG-INFO' in dirs:
-        dirs.remove('EGG-INFO')
-    yield base, dirs, files
-    for bdf in walker:
-        yield bdf
-
-
-def analyze_egg(egg_dir, stubs):
-    # check for existing flag in EGG-INFO
-    for flag, fn in safety_flags.items():
-        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
-            return flag
-    if not can_scan():
-        return False
-    safe = True
-    for base, dirs, files in walk_egg(egg_dir):
-        for name in files:
-            if name.endswith('.py') or name.endswith('.pyw'):
-                continue
-            elif name.endswith('.pyc') or name.endswith('.pyo'):
-                # always scan, even if we already know we're not safe
-                safe = scan_module(egg_dir, base, name, stubs) and safe
-    return safe
-
-
-def write_safety_flag(egg_dir, safe):
-    # Write or remove zip safety flag file(s)
-    for flag, fn in safety_flags.items():
-        fn = os.path.join(egg_dir, fn)
-        if os.path.exists(fn):
-            if safe is None or bool(safe) != flag:
-                os.unlink(fn)
-        elif safe is not None and bool(safe) == flag:
-            f = open(fn, 'wt')
-            f.write('\n')
-            f.close()
-
-
-safety_flags = {
-    True: 'zip-safe',
-    False: 'not-zip-safe',
-}
-
-
-def scan_module(egg_dir, base, name, stubs):
-    """Check whether module possibly uses unsafe-for-zipfile stuff"""
-
-    filename = os.path.join(base, name)
-    if filename[:-1] in stubs:
-        return True  # Extension module
-    pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
-    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
-    if sys.version_info < (3, 3):
-        skip = 8  # skip magic & date
-    else:
-        skip = 12  # skip magic & date & file size
-    f = open(filename, 'rb')
-    f.read(skip)
-    code = marshal.load(f)
-    f.close()
-    safe = True
-    symbols = dict.fromkeys(iter_symbols(code))
-    for bad in ['__file__', '__path__']:
-        if bad in symbols:
-            log.warn("%s: module references %s", module, bad)
-            safe = False
-    if 'inspect' in symbols:
-        for bad in [
-            'getsource', 'getabsfile', 'getsourcefile', 'getfile'
-            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
-            'getinnerframes', 'getouterframes', 'stack', 'trace'
-        ]:
-            if bad in symbols:
-                log.warn("%s: module MAY be using inspect.%s", module, bad)
-                safe = False
-    return safe
-
-
-def iter_symbols(code):
-    """Yield names and strings used by `code` and its nested code objects"""
-    for name in code.co_names:
-        yield name
-    for const in code.co_consts:
-        if isinstance(const, six.string_types):
-            yield const
-        elif isinstance(const, CodeType):
-            for name in iter_symbols(const):
-                yield name
-
-
-def can_scan():
-    if not sys.platform.startswith('java') and sys.platform != 'cli':
-        # CPython, PyPy, etc.
-        return True
-    log.warn("Unable to analyze compiled code on this platform.")
-    log.warn("Please ask the author to include a 'zip_safe'"
-             " setting (either True or False) in the package's setup.py")
-
-
-# Attribute names of options for commands that might need to be convinced to
-# install to the egg build directory
-
-INSTALL_DIRECTORY_ATTRS = [
-    'install_lib', 'install_dir', 'install_data', 'install_base'
-]
-
-
-def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
-                 mode='w'):
-    """Create a zip file from all the files under 'base_dir'.  The output
-    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
-    Python module (if available) or the InfoZIP "zip" utility (if installed
-    and found on the default search path).  If neither tool is available,
-    raises DistutilsExecError.  Returns the name of the output zip file.
-    """
-    import zipfile
-
-    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
-    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
-
-    def visit(z, dirname, names):
-        for name in names:
-            path = os.path.normpath(os.path.join(dirname, name))
-            if os.path.isfile(path):
-                p = path[len(base_dir) + 1:]
-                if not dry_run:
-                    z.write(path, p)
-                log.debug("adding '%s'", p)
-
-    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
-    if not dry_run:
-        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
-        for dirname, dirs, files in os.walk(base_dir):
-            visit(z, dirname, files)
-        z.close()
-    else:
-        for dirname, dirs, files in os.walk(base_dir):
-            visit(None, dirname, files)
-    return zip_filename
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_rpm.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_rpm.py
deleted file mode 100644
index 70730927e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_rpm.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import distutils.command.bdist_rpm as orig
-
-
-class bdist_rpm(orig.bdist_rpm):
-    """
-    Override the default bdist_rpm behavior to do the following:
-
-    1. Run egg_info to ensure the name and version are properly calculated.
-    2. Always run 'install' using --single-version-externally-managed to
-       disable eggs in RPM distributions.
-    3. Replace dash with underscore in the version numbers for better RPM
-       compatibility.
-    """
-
-    def run(self):
-        # ensure distro name is up-to-date
-        self.run_command('egg_info')
-
-        orig.bdist_rpm.run(self)
-
-    def _make_spec_file(self):
-        version = self.distribution.get_version()
-        rpmversion = version.replace('-', '_')
-        spec = orig.bdist_rpm._make_spec_file(self)
-        line23 = '%define version ' + version
-        line24 = '%define version ' + rpmversion
-        spec = [
-            line.replace(
-                "Source0: %{name}-%{version}.tar",
-                "Source0: %{name}-%{unmangled_version}.tar"
-            ).replace(
-                "setup.py install ",
-                "setup.py install --single-version-externally-managed "
-            ).replace(
-                "%setup",
-                "%setup -n %{name}-%{unmangled_version}"
-            ).replace(line23, line24)
-            for line in spec
-        ]
-        insert_loc = spec.index(line24) + 1
-        unmangled_version = "%define unmangled_version " + version
-        spec.insert(insert_loc, unmangled_version)
-        return spec
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_wininst.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_wininst.py
deleted file mode 100644
index 073de97b4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/bdist_wininst.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import distutils.command.bdist_wininst as orig
-
-
-class bdist_wininst(orig.bdist_wininst):
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        """
-        Supplement reinitialize_command to work around
-        http://bugs.python.org/issue20819
-        """
-        cmd = self.distribution.reinitialize_command(
-            command, reinit_subcommands)
-        if command in ('install', 'install_lib'):
-            cmd.install_lib = None
-        return cmd
-
-    def run(self):
-        self._is_running = True
-        try:
-            orig.bdist_wininst.run(self)
-        finally:
-            self._is_running = False
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_ext.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_ext.py
deleted file mode 100644
index 36f53f0dd..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_ext.py
+++ /dev/null
@@ -1,328 +0,0 @@
-import os
-import sys
-import itertools
-import imp
-from distutils.command.build_ext import build_ext as _du_build_ext
-from distutils.file_util import copy_file
-from distutils.ccompiler import new_compiler
-from distutils.sysconfig import customize_compiler, get_config_var
-from distutils.errors import DistutilsError
-from distutils import log
-
-from setuptools.extension import Library
-from setuptools.extern import six
-
-try:
-    # Attempt to use Cython for building extensions, if available
-    from Cython.Distutils.build_ext import build_ext as _build_ext
-except ImportError:
-    _build_ext = _du_build_ext
-
-# make sure _config_vars is initialized
-get_config_var("LDSHARED")
-from distutils.sysconfig import _config_vars as _CONFIG_VARS
-
-
-def _customize_compiler_for_shlib(compiler):
-    if sys.platform == "darwin":
-        # building .dylib requires additional compiler flags on OSX; here we
-        # temporarily substitute the pyconfig.h variables so that distutils'
-        # 'customize_compiler' uses them before we build the shared libraries.
-        tmp = _CONFIG_VARS.copy()
-        try:
-            # XXX Help!  I don't have any idea whether these are right...
-            _CONFIG_VARS['LDSHARED'] = (
-                "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup")
-            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
-            _CONFIG_VARS['SO'] = ".dylib"
-            customize_compiler(compiler)
-        finally:
-            _CONFIG_VARS.clear()
-            _CONFIG_VARS.update(tmp)
-    else:
-        customize_compiler(compiler)
-
-
-have_rtld = False
-use_stubs = False
-libtype = 'shared'
-
-if sys.platform == "darwin":
-    use_stubs = True
-elif os.name != 'nt':
-    try:
-        import dl
-        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
-    except ImportError:
-        pass
-
-if_dl = lambda s: s if have_rtld else ''
-
-
-def get_abi3_suffix():
-    """Return the file extension for an abi3-compliant Extension()"""
-    for suffix, _, _ in (s for s in imp.get_suffixes() if s[2] == imp.C_EXTENSION):
-        if '.abi3' in suffix:  # Unix
-            return suffix
-        elif suffix == '.pyd':  # Windows
-            return suffix
-
-
-class build_ext(_build_ext):
-    def run(self):
-        """Build extensions in build directory, then copy if --inplace"""
-        old_inplace, self.inplace = self.inplace, 0
-        _build_ext.run(self)
-        self.inplace = old_inplace
-        if old_inplace:
-            self.copy_extensions_to_source()
-
-    def copy_extensions_to_source(self):
-        build_py = self.get_finalized_command('build_py')
-        for ext in self.extensions:
-            fullname = self.get_ext_fullname(ext.name)
-            filename = self.get_ext_filename(fullname)
-            modpath = fullname.split('.')
-            package = '.'.join(modpath[:-1])
-            package_dir = build_py.get_package_dir(package)
-            dest_filename = os.path.join(package_dir,
-                                         os.path.basename(filename))
-            src_filename = os.path.join(self.build_lib, filename)
-
-            # Always copy, even if source is older than destination, to ensure
-            # that the right extensions for the current Python/platform are
-            # used.
-            copy_file(
-                src_filename, dest_filename, verbose=self.verbose,
-                dry_run=self.dry_run
-            )
-            if ext._needs_stub:
-                self.write_stub(package_dir or os.curdir, ext, True)
-
-    def get_ext_filename(self, fullname):
-        filename = _build_ext.get_ext_filename(self, fullname)
-        if fullname in self.ext_map:
-            ext = self.ext_map[fullname]
-            use_abi3 = (
-                six.PY3
-                and getattr(ext, 'py_limited_api')
-                and get_abi3_suffix()
-            )
-            if use_abi3:
-                so_ext = _get_config_var_837('EXT_SUFFIX')
-                filename = filename[:-len(so_ext)]
-                filename = filename + get_abi3_suffix()
-            if isinstance(ext, Library):
-                fn, ext = os.path.splitext(filename)
-                return self.shlib_compiler.library_filename(fn, libtype)
-            elif use_stubs and ext._links_to_dynamic:
-                d, fn = os.path.split(filename)
-                return os.path.join(d, 'dl-' + fn)
-        return filename
-
-    def initialize_options(self):
-        _build_ext.initialize_options(self)
-        self.shlib_compiler = None
-        self.shlibs = []
-        self.ext_map = {}
-
-    def finalize_options(self):
-        _build_ext.finalize_options(self)
-        self.extensions = self.extensions or []
-        self.check_extensions_list(self.extensions)
-        self.shlibs = [ext for ext in self.extensions
-                       if isinstance(ext, Library)]
-        if self.shlibs:
-            self.setup_shlib_compiler()
-        for ext in self.extensions:
-            ext._full_name = self.get_ext_fullname(ext.name)
-        for ext in self.extensions:
-            fullname = ext._full_name
-            self.ext_map[fullname] = ext
-
-            # distutils 3.1 will also ask for module names
-            # XXX what to do with conflicts?
-            self.ext_map[fullname.split('.')[-1]] = ext
-
-            ltd = self.shlibs and self.links_to_dynamic(ext) or False
-            ns = ltd and use_stubs and not isinstance(ext, Library)
-            ext._links_to_dynamic = ltd
-            ext._needs_stub = ns
-            filename = ext._file_name = self.get_ext_filename(fullname)
-            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
-            if ltd and libdir not in ext.library_dirs:
-                ext.library_dirs.append(libdir)
-            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
-                ext.runtime_library_dirs.append(os.curdir)
-
-    def setup_shlib_compiler(self):
-        compiler = self.shlib_compiler = new_compiler(
-            compiler=self.compiler, dry_run=self.dry_run, force=self.force
-        )
-        _customize_compiler_for_shlib(compiler)
-
-        if self.include_dirs is not None:
-            compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name, value) in self.define:
-                compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                compiler.undefine_macro(macro)
-        if self.libraries is not None:
-            compiler.set_libraries(self.libraries)
-        if self.library_dirs is not None:
-            compiler.set_library_dirs(self.library_dirs)
-        if self.rpath is not None:
-            compiler.set_runtime_library_dirs(self.rpath)
-        if self.link_objects is not None:
-            compiler.set_link_objects(self.link_objects)
-
-        # hack so distutils' build_extension() builds a library instead
-        compiler.link_shared_object = link_shared_object.__get__(compiler)
-
-    def get_export_symbols(self, ext):
-        if isinstance(ext, Library):
-            return ext.export_symbols
-        return _build_ext.get_export_symbols(self, ext)
-
-    def build_extension(self, ext):
-        ext._convert_pyx_sources_to_lang()
-        _compiler = self.compiler
-        try:
-            if isinstance(ext, Library):
-                self.compiler = self.shlib_compiler
-            _build_ext.build_extension(self, ext)
-            if ext._needs_stub:
-                cmd = self.get_finalized_command('build_py').build_lib
-                self.write_stub(cmd, ext)
-        finally:
-            self.compiler = _compiler
-
-    def links_to_dynamic(self, ext):
-        """Return true if 'ext' links to a dynamic lib in the same package"""
-        # XXX this should check to ensure the lib is actually being built
-        # XXX as dynamic, and not just using a locally-found version or a
-        # XXX static-compiled version
-        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
-        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
-        return any(pkg + libname in libnames for libname in ext.libraries)
-
-    def get_outputs(self):
-        return _build_ext.get_outputs(self) + self.__get_stubs_outputs()
-
-    def __get_stubs_outputs(self):
-        # assemble the base name for each extension that needs a stub
-        ns_ext_bases = (
-            os.path.join(self.build_lib, *ext._full_name.split('.'))
-            for ext in self.extensions
-            if ext._needs_stub
-        )
-        # pair each base with the extension
-        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
-        return list(base + fnext for base, fnext in pairs)
-
-    def __get_output_extensions(self):
-        yield '.py'
-        yield '.pyc'
-        if self.get_finalized_command('build_py').optimize:
-            yield '.pyo'
-
-    def write_stub(self, output_dir, ext, compile=False):
-        log.info("writing stub loader for %s to %s", ext._full_name,
-                 output_dir)
-        stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) +
-                     '.py')
-        if compile and os.path.exists(stub_file):
-            raise DistutilsError(stub_file + " already exists! Please delete.")
-        if not self.dry_run:
-            f = open(stub_file, 'w')
-            f.write(
-                '\n'.join([
-                    "def __bootstrap__():",
-                    "   global __bootstrap__, __file__, __loader__",
-                    "   import sys, os, pkg_resources, imp" + if_dl(", dl"),
-                    "   __file__ = pkg_resources.resource_filename"
-                    "(__name__,%r)"
-                    % os.path.basename(ext._file_name),
-                    "   del __bootstrap__",
-                    "   if '__loader__' in globals():",
-                    "       del __loader__",
-                    if_dl("   old_flags = sys.getdlopenflags()"),
-                    "   old_dir = os.getcwd()",
-                    "   try:",
-                    "     os.chdir(os.path.dirname(__file__))",
-                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
-                    "     imp.load_dynamic(__name__,__file__)",
-                    "   finally:",
-                    if_dl("     sys.setdlopenflags(old_flags)"),
-                    "     os.chdir(old_dir)",
-                    "__bootstrap__()",
-                    ""  # terminal \n
-                ])
-            )
-            f.close()
-        if compile:
-            from distutils.util import byte_compile
-
-            byte_compile([stub_file], optimize=0,
-                         force=True, dry_run=self.dry_run)
-            optimize = self.get_finalized_command('install_lib').optimize
-            if optimize > 0:
-                byte_compile([stub_file], optimize=optimize,
-                             force=True, dry_run=self.dry_run)
-            if os.path.exists(stub_file) and not self.dry_run:
-                os.unlink(stub_file)
-
-
-if use_stubs or os.name == 'nt':
-    # Build shared libraries
-    #
-    def link_shared_object(
-            self, objects, output_libname, output_dir=None, libraries=None,
-            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
-            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
-            target_lang=None):
-        self.link(
-            self.SHARED_LIBRARY, objects, output_libname,
-            output_dir, libraries, library_dirs, runtime_library_dirs,
-            export_symbols, debug, extra_preargs, extra_postargs,
-            build_temp, target_lang
-        )
-else:
-    # Build static libraries everywhere else
-    libtype = 'static'
-
-    def link_shared_object(
-            self, objects, output_libname, output_dir=None, libraries=None,
-            library_dirs=None, runtime_library_dirs=None, export_symbols=None,
-            debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
-            target_lang=None):
-        # XXX we need to either disallow these attrs on Library instances,
-        # or warn/abort here if set, or something...
-        # libraries=None, library_dirs=None, runtime_library_dirs=None,
-        # export_symbols=None, extra_preargs=None, extra_postargs=None,
-        # build_temp=None
-
-        assert output_dir is None  # distutils build_ext doesn't pass this
-        output_dir, filename = os.path.split(output_libname)
-        basename, ext = os.path.splitext(filename)
-        if self.library_filename("x").startswith('lib'):
-            # strip 'lib' prefix; this is kludgy if some platform uses
-            # a different prefix
-            basename = basename[3:]
-
-        self.create_static_lib(
-            objects, basename, output_dir, debug, target_lang
-        )
-
-
-def _get_config_var_837(name):
-    """
-    In https://github.com/pypa/setuptools/pull/837, we discovered
-    Python 3.3.0 exposes the extension suffix under the name 'SO'.
-    """
-    if sys.version_info < (3, 3, 1):
-        name = 'SO'
-    return get_config_var(name)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_py.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_py.py
deleted file mode 100644
index b0314fd41..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/build_py.py
+++ /dev/null
@@ -1,270 +0,0 @@
-from glob import glob
-from distutils.util import convert_path
-import distutils.command.build_py as orig
-import os
-import fnmatch
-import textwrap
-import io
-import distutils.errors
-import itertools
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import map, filter, filterfalse
-
-try:
-    from setuptools.lib2to3_ex import Mixin2to3
-except ImportError:
-
-    class Mixin2to3:
-        def run_2to3(self, files, doctests=True):
-            "do nothing"
-
-
-class build_py(orig.build_py, Mixin2to3):
-    """Enhanced 'build_py' command that includes data files with packages
-
-    The data files are specified via a 'package_data' argument to 'setup()'.
-    See 'setuptools.dist.Distribution' for more details.
-
-    Also, this version of the 'build_py' command allows you to specify both
-    'py_modules' and 'packages' in the same setup operation.
-    """
-
-    def finalize_options(self):
-        orig.build_py.finalize_options(self)
-        self.package_data = self.distribution.package_data
-        self.exclude_package_data = (self.distribution.exclude_package_data or
-                                     {})
-        if 'data_files' in self.__dict__:
-            del self.__dict__['data_files']
-        self.__updated_files = []
-        self.__doctests_2to3 = []
-
-    def run(self):
-        """Build modules, packages, and copy data files to build directory"""
-        if not self.py_modules and not self.packages:
-            return
-
-        if self.py_modules:
-            self.build_modules()
-
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        self.run_2to3(self.__updated_files, False)
-        self.run_2to3(self.__updated_files, True)
-        self.run_2to3(self.__doctests_2to3, True)
-
-        # Only compile actual .py files, using our base class' idea of what our
-        # output files are.
-        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))
-
-    def __getattr__(self, attr):
-        "lazily compute data files"
-        if attr == 'data_files':
-            self.data_files = self._get_data_files()
-            return self.data_files
-        return orig.build_py.__getattr__(self, attr)
-
-    def build_module(self, module, module_file, package):
-        if six.PY2 and isinstance(package, six.string_types):
-            # avoid errors on Python 2 when unicode is passed (#190)
-            package = package.split('.')
-        outfile, copied = orig.build_py.build_module(self, module, module_file,
-                                                     package)
-        if copied:
-            self.__updated_files.append(outfile)
-        return outfile, copied
-
-    def _get_data_files(self):
-        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
-        self.analyze_manifest()
-        return list(map(self._get_pkg_data_files, self.packages or ()))
-
-    def _get_pkg_data_files(self, package):
-        # Locate package source directory
-        src_dir = self.get_package_dir(package)
-
-        # Compute package build directory
-        build_dir = os.path.join(*([self.build_lib] + package.split('.')))
-
-        # Strip directory from globbed filenames
-        filenames = [
-            os.path.relpath(file, src_dir)
-            for file in self.find_data_files(package, src_dir)
-        ]
-        return package, src_dir, build_dir, filenames
-
-    def find_data_files(self, package, src_dir):
-        """Return filenames for package's data files in 'src_dir'"""
-        patterns = self._get_platform_patterns(
-            self.package_data,
-            package,
-            src_dir,
-        )
-        globs_expanded = map(glob, patterns)
-        # flatten the expanded globs into an iterable of matches
-        globs_matches = itertools.chain.from_iterable(globs_expanded)
-        glob_files = filter(os.path.isfile, globs_matches)
-        files = itertools.chain(
-            self.manifest_files.get(package, []),
-            glob_files,
-        )
-        return self.exclude_data_files(package, src_dir, files)
-
-    def build_package_data(self):
-        """Copy data files into build directory"""
-        for package, src_dir, build_dir, filenames in self.data_files:
-            for filename in filenames:
-                target = os.path.join(build_dir, filename)
-                self.mkpath(os.path.dirname(target))
-                srcfile = os.path.join(src_dir, filename)
-                outf, copied = self.copy_file(srcfile, target)
-                srcfile = os.path.abspath(srcfile)
-                if (copied and
-                        srcfile in self.distribution.convert_2to3_doctests):
-                    self.__doctests_2to3.append(outf)
-
-    def analyze_manifest(self):
-        self.manifest_files = mf = {}
-        if not self.distribution.include_package_data:
-            return
-        src_dirs = {}
-        for package in self.packages or ():
-            # Locate package source directory
-            src_dirs[assert_relative(self.get_package_dir(package))] = package
-
-        self.run_command('egg_info')
-        ei_cmd = self.get_finalized_command('egg_info')
-        for path in ei_cmd.filelist.files:
-            d, f = os.path.split(assert_relative(path))
-            prev = None
-            oldf = f
-            while d and d != prev and d not in src_dirs:
-                prev = d
-                d, df = os.path.split(d)
-                f = os.path.join(df, f)
-            if d in src_dirs:
-                if path.endswith('.py') and f == oldf:
-                    continue  # it's a module, not data
-                mf.setdefault(src_dirs[d], []).append(path)
-
-    def get_data_files(self):
-        pass  # Lazily compute data files in _get_data_files() function.
-
-    def check_package(self, package, package_dir):
-        """Check namespace packages' __init__ for declare_namespace"""
-        try:
-            return self.packages_checked[package]
-        except KeyError:
-            pass
-
-        init_py = orig.build_py.check_package(self, package, package_dir)
-        self.packages_checked[package] = init_py
-
-        if not init_py or not self.distribution.namespace_packages:
-            return init_py
-
-        for pkg in self.distribution.namespace_packages:
-            if pkg == package or pkg.startswith(package + '.'):
-                break
-        else:
-            return init_py
-
-        with io.open(init_py, 'rb') as f:
-            contents = f.read()
-        if b'declare_namespace' not in contents:
-            raise distutils.errors.DistutilsError(
-                "Namespace package problem: %s is a namespace package, but "
-                "its\n__init__.py does not call declare_namespace()! Please "
-                'fix it.\n(See the setuptools manual under '
-                '"Namespace Packages" for details.)\n"' % (package,)
-            )
-        return init_py
-
-    def initialize_options(self):
-        self.packages_checked = {}
-        orig.build_py.initialize_options(self)
-
-    def get_package_dir(self, package):
-        res = orig.build_py.get_package_dir(self, package)
-        if self.distribution.src_root is not None:
-            return os.path.join(self.distribution.src_root, res)
-        return res
-
-    def exclude_data_files(self, package, src_dir, files):
-        """Filter filenames for package's data files in 'src_dir'"""
-        files = list(files)
-        patterns = self._get_platform_patterns(
-            self.exclude_package_data,
-            package,
-            src_dir,
-        )
-        match_groups = (
-            fnmatch.filter(files, pattern)
-            for pattern in patterns
-        )
-        # flatten the groups of matches into an iterable of matches
-        matches = itertools.chain.from_iterable(match_groups)
-        bad = set(matches)
-        keepers = (
-            fn
-            for fn in files
-            if fn not in bad
-        )
-        # ditch dupes
-        return list(_unique_everseen(keepers))
-
-    @staticmethod
-    def _get_platform_patterns(spec, package, src_dir):
-        """
-        yield platform-specific path patterns (suitable for glob
-        or fn_match) from a glob-based spec (such as
-        self.package_data or self.exclude_package_data)
-        matching package in src_dir.
-        """
-        raw_patterns = itertools.chain(
-            spec.get('', []),
-            spec.get(package, []),
-        )
-        return (
-            # Each pattern has to be converted to a platform-specific path
-            os.path.join(src_dir, convert_path(pattern))
-            for pattern in raw_patterns
-        )
-
-
-# from Python docs
-def _unique_everseen(iterable, key=None):
-    "List unique elements, preserving order. Remember all elements ever seen."
-    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
-    # unique_everseen('ABBCcAD', str.lower) --> A B C D
-    seen = set()
-    seen_add = seen.add
-    if key is None:
-        for element in filterfalse(seen.__contains__, iterable):
-            seen_add(element)
-            yield element
-    else:
-        for element in iterable:
-            k = key(element)
-            if k not in seen:
-                seen_add(k)
-                yield element
-
-
-def assert_relative(path):
-    if not os.path.isabs(path):
-        return path
-    from distutils.errors import DistutilsSetupError
-
-    msg = textwrap.dedent("""
-        Error: setup script specifies an absolute path:
-
-            %s
-
-        setup() arguments must *always* be /-separated paths relative to the
-        setup.py directory, *never* absolute paths.
-        """).lstrip() % path
-    raise DistutilsSetupError(msg)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/develop.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/develop.py
deleted file mode 100644
index aa82f9592..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/develop.py
+++ /dev/null
@@ -1,201 +0,0 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsError, DistutilsOptionError
-import os
-import glob
-import io
-
-from setuptools.extern import six
-
-from pkg_resources import Distribution, PathMetadata, normalize_path
-from setuptools.command.easy_install import easy_install
-from setuptools import namespaces
-import setuptools
-
-
-class develop(namespaces.DevelopInstaller, easy_install):
-    """Set up package for development"""
-
-    description = "install package in 'development mode'"
-
-    user_options = easy_install.user_options + [
-        ("uninstall", "u", "Uninstall this source package"),
-        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
-    ]
-
-    boolean_options = easy_install.boolean_options + ['uninstall']
-
-    command_consumes_arguments = False  # override base
-
-    def run(self):
-        if self.uninstall:
-            self.multi_version = True
-            self.uninstall_link()
-            self.uninstall_namespaces()
-        else:
-            self.install_for_development()
-        self.warn_deprecated_options()
-
-    def initialize_options(self):
-        self.uninstall = None
-        self.egg_path = None
-        easy_install.initialize_options(self)
-        self.setup_path = None
-        self.always_copy_from = '.'  # always copy eggs installed in curdir
-
-    def finalize_options(self):
-        ei = self.get_finalized_command("egg_info")
-        if ei.broken_egg_info:
-            template = "Please rename %r to %r before using 'develop'"
-            args = ei.egg_info, ei.broken_egg_info
-            raise DistutilsError(template % args)
-        self.args = [ei.egg_name]
-
-        easy_install.finalize_options(self)
-        self.expand_basedirs()
-        self.expand_dirs()
-        # pick up setup-dir .egg files only: no .egg-info
-        self.package_index.scan(glob.glob('*.egg'))
-
-        egg_link_fn = ei.egg_name + '.egg-link'
-        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
-        self.egg_base = ei.egg_base
-        if self.egg_path is None:
-            self.egg_path = os.path.abspath(ei.egg_base)
-
-        target = normalize_path(self.egg_base)
-        egg_path = normalize_path(os.path.join(self.install_dir,
-                                               self.egg_path))
-        if egg_path != target:
-            raise DistutilsOptionError(
-                "--egg-path must be a relative path from the install"
-                " directory to " + target
-            )
-
-        # Make a distribution for the package's source
-        self.dist = Distribution(
-            target,
-            PathMetadata(target, os.path.abspath(ei.egg_info)),
-            project_name=ei.egg_name
-        )
-
-        p = self.egg_base.replace(os.sep, '/')
-        if p != os.curdir:
-            p = '../' * (p.count('/') + 1)
-        self.setup_path = p
-        p = normalize_path(os.path.join(self.install_dir, self.egg_path, p))
-        if p != normalize_path(os.curdir):
-            raise DistutilsOptionError(
-                "Can't get a consistent path to setup script from"
-                " installation directory", p, normalize_path(os.curdir))
-
-    def install_for_development(self):
-        if six.PY3 and getattr(self.distribution, 'use_2to3', False):
-            # If we run 2to3 we can not do this inplace:
-
-            # Ensure metadata is up-to-date
-            self.reinitialize_command('build_py', inplace=0)
-            self.run_command('build_py')
-            bpy_cmd = self.get_finalized_command("build_py")
-            build_path = normalize_path(bpy_cmd.build_lib)
-
-            # Build extensions
-            self.reinitialize_command('egg_info', egg_base=build_path)
-            self.run_command('egg_info')
-
-            self.reinitialize_command('build_ext', inplace=0)
-            self.run_command('build_ext')
-
-            # Fixup egg-link and easy-install.pth
-            ei_cmd = self.get_finalized_command("egg_info")
-            self.egg_path = build_path
-            self.dist.location = build_path
-            # XXX
-            self.dist._provider = PathMetadata(build_path, ei_cmd.egg_info)
-        else:
-            # Without 2to3 inplace works fine:
-            self.run_command('egg_info')
-
-            # Build extensions in-place
-            self.reinitialize_command('build_ext', inplace=1)
-            self.run_command('build_ext')
-
-        self.install_site_py()  # ensure that target dir is site-safe
-        if setuptools.bootstrap_install_from:
-            self.easy_install(setuptools.bootstrap_install_from)
-            setuptools.bootstrap_install_from = None
-
-        self.install_namespaces()
-
-        # create an .egg-link in the installation dir, pointing to our egg
-        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
-        if not self.dry_run:
-            with open(self.egg_link, "w") as f:
-                f.write(self.egg_path + "\n" + self.setup_path)
-        # postprocess the installed distro, fixing up .pth, installing scripts,
-        # and handling requirements
-        self.process_distribution(None, self.dist, not self.no_deps)
-
-    def uninstall_link(self):
-        if os.path.exists(self.egg_link):
-            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
-            egg_link_file = open(self.egg_link)
-            contents = [line.rstrip() for line in egg_link_file]
-            egg_link_file.close()
-            if contents not in ([self.egg_path],
-                                [self.egg_path, self.setup_path]):
-                log.warn("Link points to %s: uninstall aborted", contents)
-                return
-            if not self.dry_run:
-                os.unlink(self.egg_link)
-        if not self.dry_run:
-            self.update_pth(self.dist)  # remove any .pth link to us
-        if self.distribution.scripts:
-            # XXX should also check for entry point scripts!
-            log.warn("Note: you must uninstall or replace scripts manually!")
-
-    def install_egg_scripts(self, dist):
-        if dist is not self.dist:
-            # Installing a dependency, so fall back to normal behavior
-            return easy_install.install_egg_scripts(self, dist)
-
-        # create wrapper scripts in the script dir, pointing to dist.scripts
-
-        # new-style...
-        self.install_wrapper_scripts(dist)
-
-        # ...and old-style
-        for script_name in self.distribution.scripts or []:
-            script_path = os.path.abspath(convert_path(script_name))
-            script_name = os.path.basename(script_path)
-            with io.open(script_path) as strm:
-                script_text = strm.read()
-            self.install_script(dist, script_name, script_text, script_path)
-
-    def install_wrapper_scripts(self, dist):
-        dist = VersionlessRequirement(dist)
-        return easy_install.install_wrapper_scripts(self, dist)
-
-
-class VersionlessRequirement(object):
-    """
-    Adapt a pkg_resources.Distribution to simply return the project
-    name as the 'requirement' so that scripts will work across
-    multiple versions.
-
-    >>> dist = Distribution(project_name='foo', version='1.0')
-    >>> str(dist.as_requirement())
-    'foo==1.0'
-    >>> adapted_dist = VersionlessRequirement(dist)
-    >>> str(adapted_dist.as_requirement())
-    'foo'
-    """
-
-    def __init__(self, dist):
-        self.__dist = dist
-
-    def __getattr__(self, name):
-        return getattr(self.__dist, name)
-
-    def as_requirement(self):
-        return self.project_name
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/easy_install.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/easy_install.py
deleted file mode 100644
index 3bb5a4e8e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/easy_install.py
+++ /dev/null
@@ -1,2347 +0,0 @@
-#!/usr/bin/env python
-"""
-Easy Install
-------------
-
-A tool for doing automatic download/extract/build of distutils-based Python
-packages.  For detailed documentation, see the accompanying EasyInstall.txt
-file, or visit the `EasyInstall home page`__.
-
-__ https://setuptools.readthedocs.io/en/latest/easy_install.html
-
-"""
-
-from glob import glob
-from distutils.util import get_platform
-from distutils.util import convert_path, subst_vars
-from distutils.errors import (
-    DistutilsArgError, DistutilsOptionError,
-    DistutilsError, DistutilsPlatformError,
-)
-from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS
-from distutils import log, dir_util
-from distutils.command.build_scripts import first_line_re
-from distutils.spawn import find_executable
-import sys
-import os
-import zipimport
-import shutil
-import tempfile
-import zipfile
-import re
-import stat
-import random
-import textwrap
-import warnings
-import site
-import struct
-import contextlib
-import subprocess
-import shlex
-import io
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import configparser, map
-
-from setuptools import Command
-from setuptools.sandbox import run_setup
-from setuptools.py31compat import get_path, get_config_vars
-from setuptools.py27compat import rmtree_safe
-from setuptools.command import setopt
-from setuptools.archive_util import unpack_archive
-from setuptools.package_index import (
-    PackageIndex, parse_requirement_arg, URL_SCHEME,
-)
-from setuptools.command import bdist_egg, egg_info
-from pkg_resources import (
-    yield_lines, normalize_path, resource_string, ensure_directory,
-    get_distribution, find_distributions, Environment, Requirement,
-    Distribution, PathMetadata, EggMetadata, WorkingSet, DistributionNotFound,
-    VersionConflict, DEVELOP_DIST,
-)
-import pkg_resources
-
-# Turn on PEP440Warnings
-warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
-
-__all__ = [
-    'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
-    'main', 'get_exe_prefixes',
-]
-
-
-def is_64bit():
-    return struct.calcsize("P") == 8
-
-
-def samefile(p1, p2):
-    """
-    Determine if two paths reference the same file.
-
-    Augments os.path.samefile to work on Windows and
-    suppresses errors if the path doesn't exist.
-    """
-    both_exist = os.path.exists(p1) and os.path.exists(p2)
-    use_samefile = hasattr(os.path, 'samefile') and both_exist
-    if use_samefile:
-        return os.path.samefile(p1, p2)
-    norm_p1 = os.path.normpath(os.path.normcase(p1))
-    norm_p2 = os.path.normpath(os.path.normcase(p2))
-    return norm_p1 == norm_p2
-
-
-if six.PY2:
-
-    def _to_ascii(s):
-        return s
-
-    def isascii(s):
-        try:
-            six.text_type(s, 'ascii')
-            return True
-        except UnicodeError:
-            return False
-else:
-
-    def _to_ascii(s):
-        return s.encode('ascii')
-
-    def isascii(s):
-        try:
-            s.encode('ascii')
-            return True
-        except UnicodeError:
-            return False
-
-
-_one_liner = lambda text: textwrap.dedent(text).strip().replace('\n', '; ')
-
-
-class easy_install(Command):
-    """Manage a download/build/install process"""
-    description = "Find/get/install Python packages"
-    command_consumes_arguments = True
-
-    user_options = [
-        ('prefix=', None, "installation prefix"),
-        ("zip-ok", "z", "install package as a zipfile"),
-        ("multi-version", "m", "make apps have to require() a version"),
-        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
-        ("install-dir=", "d", "install package to DIR"),
-        ("script-dir=", "s", "install scripts to DIR"),
-        ("exclude-scripts", "x", "Don't install scripts"),
-        ("always-copy", "a", "Copy all needed packages to install dir"),
-        ("index-url=", "i", "base URL of Python Package Index"),
-        ("find-links=", "f", "additional URL(s) to search for packages"),
-        ("build-directory=", "b",
-         "download/extract/build in DIR; keep the results"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('record=', None,
-         "filename in which to record list of installed files"),
-        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
-        ('site-dirs=', 'S', "list of directories where .pth files work"),
-        ('editable', 'e', "Install specified packages in editable form"),
-        ('no-deps', 'N', "don't install dependencies"),
-        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
-        ('local-snapshots-ok', 'l',
-         "allow building eggs from local checkouts"),
-        ('version', None, "print version information and exit"),
-        ('install-layout=', None, "installation layout to choose (known values: deb)"),
-        ('force-installation-into-system-dir', '0', "force installation into /usr"),
-        ('no-find-links', None,
-         "Don't load find-links defined in packages being installed")
-    ]
-    boolean_options = [
-        'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
-        'editable',
-        'no-deps', 'local-snapshots-ok', 'version', 'force-installation-into-system-dir'
-    ]
-
-    if site.ENABLE_USER_SITE:
-        help_msg = "install in user site-package '%s'" % site.USER_SITE
-        user_options.append(('user', None, help_msg))
-        boolean_options.append('user')
-
-    negative_opt = {'always-unzip': 'zip-ok'}
-    create_index = PackageIndex
-
-    def initialize_options(self):
-        # the --user option seems to be an opt-in one,
-        # so the default should be False.
-        self.user = 0
-        self.zip_ok = self.local_snapshots_ok = None
-        self.install_dir = self.script_dir = self.exclude_scripts = None
-        self.index_url = None
-        self.find_links = None
-        self.build_directory = None
-        self.args = None
-        self.optimize = self.record = None
-        self.upgrade = self.always_copy = self.multi_version = None
-        self.editable = self.no_deps = self.allow_hosts = None
-        self.root = self.prefix = self.no_report = None
-        self.version = None
-        self.install_purelib = None  # for pure module distributions
-        self.install_platlib = None  # non-pure (dists w/ extensions)
-        self.install_headers = None  # for C/C++ headers
-        self.install_lib = None  # set to either purelib or platlib
-        self.install_scripts = None
-        self.install_data = None
-        self.install_base = None
-        self.install_platbase = None
-        if site.ENABLE_USER_SITE:
-            self.install_userbase = site.USER_BASE
-            self.install_usersite = site.USER_SITE
-        else:
-            self.install_userbase = None
-            self.install_usersite = None
-        self.no_find_links = None
-
-        # Options not specifiable via command line
-        self.package_index = None
-        self.pth_file = self.always_copy_from = None
-        self.site_dirs = None
-        self.installed_projects = {}
-        self.sitepy_installed = False
-        # enable custom installation, known values: deb
-        self.install_layout = None
-        self.force_installation_into_system_dir = None
-        self.multiarch = None
-
-        # Always read easy_install options, even if we are subclassed, or have
-        # an independent instance created.  This ensures that defaults will
-        # always come from the standard configuration file(s)' "easy_install"
-        # section, even if this is a "develop" or "install" command, or some
-        # other embedding.
-        self._dry_run = None
-        self.verbose = self.distribution.verbose
-        self.distribution._set_command_options(
-            self, self.distribution.get_option_dict('easy_install')
-        )
-
-    def delete_blockers(self, blockers):
-        extant_blockers = (
-            filename for filename in blockers
-            if os.path.exists(filename) or os.path.islink(filename)
-        )
-        list(map(self._delete_path, extant_blockers))
-
-    def _delete_path(self, path):
-        log.info("Deleting %s", path)
-        if self.dry_run:
-            return
-
-        is_tree = os.path.isdir(path) and not os.path.islink(path)
-        remover = rmtree if is_tree else os.unlink
-        remover(path)
-
-    @staticmethod
-    def _render_version():
-        """
-        Render the Setuptools version and installation details, then exit.
-        """
-        ver = sys.version[:3]
-        dist = get_distribution('setuptools')
-        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
-        print(tmpl.format(**locals()))
-        raise SystemExit()
-
-    def finalize_options(self):
-        self.version and self._render_version()
-
-        py_version = sys.version.split()[0]
-        prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')
-
-        self.config_vars = {
-            'dist_name': self.distribution.get_name(),
-            'dist_version': self.distribution.get_version(),
-            'dist_fullname': self.distribution.get_fullname(),
-            'py_version': py_version,
-            'py_version_short': py_version[0:3],
-            'py_version_nodot': py_version[0] + py_version[2],
-            'sys_prefix': prefix,
-            'prefix': prefix,
-            'sys_exec_prefix': exec_prefix,
-            'exec_prefix': exec_prefix,
-            # Only python 3.2+ has abiflags
-            'abiflags': getattr(sys, 'abiflags', ''),
-        }
-
-        if site.ENABLE_USER_SITE:
-            self.config_vars['userbase'] = self.install_userbase
-            self.config_vars['usersite'] = self.install_usersite
-
-        self._fix_install_dir_for_user_site()
-
-        self.expand_basedirs()
-        self.expand_dirs()
-
-        if self.install_layout:
-            if not self.install_layout.lower() in ['deb']:
-                raise DistutilsOptionError("unknown value for --install-layout")
-            self.install_layout = self.install_layout.lower()
-
-            import sysconfig
-            if sys.version_info[:2] >= (3, 3):
-                self.multiarch = sysconfig.get_config_var('MULTIARCH')
-
-        self._expand(
-            'install_dir', 'script_dir', 'build_directory',
-            'site_dirs',
-        )
-        # If a non-default installation directory was specified, default the
-        # script directory to match it.
-        if self.script_dir is None:
-            self.script_dir = self.install_dir
-
-        if self.no_find_links is None:
-            self.no_find_links = False
-
-        # Let install_dir get set by install_lib command, which in turn
-        # gets its info from the install command, and takes into account
-        # --prefix and --home and all that other crud.
-        self.set_undefined_options(
-            'install_lib', ('install_dir', 'install_dir')
-        )
-        # Likewise, set default script_dir from 'install_scripts.install_dir'
-        self.set_undefined_options(
-            'install_scripts', ('install_dir', 'script_dir')
-        )
-
-        if self.user and self.install_purelib:
-            self.install_dir = self.install_purelib
-            self.script_dir = self.install_scripts
-
-        if self.prefix == '/usr' and not self.force_installation_into_system_dir:
-            raise DistutilsOptionError("""installation into /usr
-
-Trying to install into the system managed parts of the file system. Please
-consider to install to another location, or use the option
---force-installation-into-system-dir to overwrite this warning.
-""")
-
-        # default --record from the install command
-        self.set_undefined_options('install', ('record', 'record'))
-        # Should this be moved to the if statement below? It's not used
-        # elsewhere
-        normpath = map(normalize_path, sys.path)
-        self.all_site_dirs = get_site_dirs()
-        if self.site_dirs is not None:
-            site_dirs = [
-                os.path.expanduser(s.strip()) for s in
-                self.site_dirs.split(',')
-            ]
-            for d in site_dirs:
-                if not os.path.isdir(d):
-                    log.warn("%s (in --site-dirs) does not exist", d)
-                elif normalize_path(d) not in normpath:
-                    raise DistutilsOptionError(
-                        d + " (in --site-dirs) is not on sys.path"
-                    )
-                else:
-                    self.all_site_dirs.append(normalize_path(d))
-        if not self.editable:
-            self.check_site_dir()
-        self.index_url = self.index_url or "https://pypi.python.org/simple"
-        self.shadow_path = self.all_site_dirs[:]
-        for path_item in self.install_dir, normalize_path(self.script_dir):
-            if path_item not in self.shadow_path:
-                self.shadow_path.insert(0, path_item)
-
-        if self.allow_hosts is not None:
-            hosts = [s.strip() for s in self.allow_hosts.split(',')]
-        else:
-            hosts = ['*']
-        if self.package_index is None:
-            self.package_index = self.create_index(
-                self.index_url, search_path=self.shadow_path, hosts=hosts,
-            )
-        self.local_index = Environment(self.shadow_path + sys.path)
-
-        if self.find_links is not None:
-            if isinstance(self.find_links, six.string_types):
-                self.find_links = self.find_links.split()
-        else:
-            self.find_links = []
-        if self.local_snapshots_ok:
-            self.package_index.scan_egg_links(self.shadow_path + sys.path)
-        if not self.no_find_links:
-            self.package_index.add_find_links(self.find_links)
-        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                if not (0 <= self.optimize <= 2):
-                    raise ValueError
-            except ValueError:
-                raise DistutilsOptionError("--optimize must be 0, 1, or 2")
-
-        if self.editable and not self.build_directory:
-            raise DistutilsArgError(
-                "Must specify a build directory (-b) when using --editable"
-            )
-        if not self.args:
-            raise DistutilsArgError(
-                "No urls, filenames, or requirements specified (see --help)")
-
-        self.outputs = []
-
-    def _fix_install_dir_for_user_site(self):
-        """
-        Fix the install_dir if "--user" was used.
-        """
-        if not self.user or not site.ENABLE_USER_SITE:
-            return
-
-        self.create_home_path()
-        if self.install_userbase is None:
-            msg = "User base directory is not specified"
-            raise DistutilsPlatformError(msg)
-        self.install_base = self.install_platbase = self.install_userbase
-        scheme_name = os.name.replace('posix', 'unix') + '_user'
-        self.select_scheme(scheme_name)
-
-    def _expand_attrs(self, attrs):
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                if os.name == 'posix' or os.name == 'nt':
-                    val = os.path.expanduser(val)
-                val = subst_vars(val, self.config_vars)
-                setattr(self, attr, val)
-
-    def expand_basedirs(self):
-        """Calls `os.path.expanduser` on install_base, install_platbase and
-        root."""
-        self._expand_attrs(['install_base', 'install_platbase', 'root'])
-
-    def expand_dirs(self):
-        """Calls `os.path.expanduser` on install dirs."""
-        dirs = [
-            'install_purelib',
-            'install_platlib',
-            'install_lib',
-            'install_headers',
-            'install_scripts',
-            'install_data',
-        ]
-        self._expand_attrs(dirs)
-
-    def run(self):
-        if self.verbose != self.distribution.verbose:
-            log.set_verbosity(self.verbose)
-        try:
-            for spec in self.args:
-                self.easy_install(spec, not self.no_deps)
-            if self.record:
-                outputs = list(sorted(self.outputs))
-                if self.root:  # strip any package prefix
-                    root_len = len(self.root)
-                    for counter in range(len(outputs)):
-                        outputs[counter] = outputs[counter][root_len:]
-                from distutils import file_util
-
-                self.execute(
-                    file_util.write_file, (self.record, outputs),
-                    "writing list of installed files to '%s'" %
-                    self.record
-                )
-            self.warn_deprecated_options()
-        finally:
-            log.set_verbosity(self.distribution.verbose)
-
-    def pseudo_tempname(self):
-        """Return a pseudo-tempname base in the install directory.
-        This code is intentionally naive; if a malicious party can write to
-        the target directory you're already in deep doodoo.
-        """
-        try:
-            pid = os.getpid()
-        except Exception:
-            pid = random.randint(0, sys.maxsize)
-        return os.path.join(self.install_dir, "test-easy-install-%s" % pid)
-
-    def warn_deprecated_options(self):
-        pass
-
-    def check_site_dir(self):
-        """Verify that self.install_dir is .pth-capable dir, if needed"""
-
-        instdir = normalize_path(self.install_dir)
-        pth_file = os.path.join(instdir, 'easy-install.pth')
-
-        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
-        is_site_dir = instdir in self.all_site_dirs
-
-        if not is_site_dir and not self.multi_version:
-            # No?  Then directly test whether it does .pth file processing
-            is_site_dir = self.check_pth_processing()
-        else:
-            # make sure we can write to target dir
-            testfile = self.pseudo_tempname() + '.write-test'
-            test_exists = os.path.exists(testfile)
-            try:
-                if test_exists:
-                    os.unlink(testfile)
-                open(testfile, 'w').close()
-                os.unlink(testfile)
-            except (OSError, IOError):
-                self.cant_write_to_target()
-
-        if not is_site_dir and not self.multi_version:
-            # Can't install non-multi to non-site dir
-            raise DistutilsError(self.no_default_version_msg())
-
-        if is_site_dir:
-            if self.pth_file is None:
-                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
-        else:
-            self.pth_file = None
-
-        PYTHONPATH = os.environ.get('PYTHONPATH', '').split(os.pathsep)
-        if instdir not in map(normalize_path, filter(None, PYTHONPATH)):
-            # only PYTHONPATH dirs need a site.py, so pretend it's there
-            self.sitepy_installed = True
-        elif self.multi_version and not os.path.exists(pth_file):
-            self.sitepy_installed = True  # don't need site.py in this case
-            self.pth_file = None  # and don't create a .pth file
-        self.install_dir = instdir
-
-    __cant_write_msg = textwrap.dedent("""
-        can't create or remove files in install directory
-
-        The following error occurred while trying to add or remove files in the
-        installation directory:
-
-            %s
-
-        The installation directory you specified (via --install-dir, --prefix, or
-        the distutils default setting) was:
-
-            %s
-        """).lstrip()
-
-    __not_exists_id = textwrap.dedent("""
-        This directory does not currently exist.  Please create it and try again, or
-        choose a different installation directory (using the -d or --install-dir
-        option).
-        """).lstrip()
-
-    __access_msg = textwrap.dedent("""
-        Perhaps your account does not have write access to this directory?  If the
-        installation directory is a system-owned directory, you may need to sign in
-        as the administrator or "root" account.  If you do not have administrative
-        access to this machine, you may wish to choose a different installation
-        directory, preferably one that is listed in your PYTHONPATH environment
-        variable.
-
-        For information on other options, you may wish to consult the
-        documentation at:
-
-          https://setuptools.readthedocs.io/en/latest/easy_install.html
-
-        Please make the appropriate changes for your system and try again.
-        """).lstrip()
-
-    def cant_write_to_target(self):
-        msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,)
-
-        if not os.path.exists(self.install_dir):
-            msg += '\n' + self.__not_exists_id
-        else:
-            msg += '\n' + self.__access_msg
-        raise DistutilsError(msg)
-
-    def check_pth_processing(self):
-        """Empirically verify whether .pth files are supported in inst. dir"""
-        instdir = self.install_dir
-        log.info("Checking .pth file support in %s", instdir)
-        pth_file = self.pseudo_tempname() + ".pth"
-        ok_file = pth_file + '.ok'
-        ok_exists = os.path.exists(ok_file)
-        tmpl = _one_liner("""
-            import os
-            f = open({ok_file!r}, 'w')
-            f.write('OK')
-            f.close()
-            """) + '\n'
-        try:
-            if ok_exists:
-                os.unlink(ok_file)
-            dirname = os.path.dirname(ok_file)
-            if not os.path.exists(dirname):
-                os.makedirs(dirname)
-            f = open(pth_file, 'w')
-        except (OSError, IOError):
-            self.cant_write_to_target()
-        else:
-            try:
-                f.write(tmpl.format(**locals()))
-                f.close()
-                f = None
-                executable = sys.executable
-                if os.name == 'nt':
-                    dirname, basename = os.path.split(executable)
-                    alt = os.path.join(dirname, 'pythonw.exe')
-                    use_alt = (
-                        basename.lower() == 'python.exe' and
-                        os.path.exists(alt)
-                    )
-                    if use_alt:
-                        # use pythonw.exe to avoid opening a console window
-                        executable = alt
-
-                from distutils.spawn import spawn
-
-                spawn([executable, '-E', '-c', 'pass'], 0)
-
-                if os.path.exists(ok_file):
-                    log.info(
-                        "TEST PASSED: %s appears to support .pth files",
-                        instdir
-                    )
-                    return True
-            finally:
-                if f:
-                    f.close()
-                if os.path.exists(ok_file):
-                    os.unlink(ok_file)
-                if os.path.exists(pth_file):
-                    os.unlink(pth_file)
-        if not self.multi_version:
-            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
-        return False
-
-    def install_egg_scripts(self, dist):
-        """Write all the scripts for `dist`, unless scripts are excluded"""
-        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
-            for script_name in dist.metadata_listdir('scripts'):
-                if dist.metadata_isdir('scripts/' + script_name):
-                    # The "script" is a directory, likely a Python 3
-                    # __pycache__ directory, so skip it.
-                    continue
-                self.install_script(
-                    dist, script_name,
-                    dist.get_metadata('scripts/' + script_name)
-                )
-        self.install_wrapper_scripts(dist)
-
-    def add_output(self, path):
-        if os.path.isdir(path):
-            for base, dirs, files in os.walk(path):
-                for filename in files:
-                    self.outputs.append(os.path.join(base, filename))
-        else:
-            self.outputs.append(path)
-
-    def not_editable(self, spec):
-        if self.editable:
-            raise DistutilsArgError(
-                "Invalid argument %r: you can't use filenames or URLs "
-                "with --editable (except via the --find-links option)."
-                % (spec,)
-            )
-
-    def check_editable(self, spec):
-        if not self.editable:
-            return
-
-        if os.path.exists(os.path.join(self.build_directory, spec.key)):
-            raise DistutilsArgError(
-                "%r already exists in %s; can't do a checkout there" %
-                (spec.key, self.build_directory)
-            )
-
-    @contextlib.contextmanager
-    def _tmpdir(self):
-        tmpdir = tempfile.mkdtemp(prefix=six.u("easy_install-"))
-        try:
-            # cast to str as workaround for #709 and #710 and #712
-            yield str(tmpdir)
-        finally:
-            os.path.exists(tmpdir) and rmtree(rmtree_safe(tmpdir))
-
-    def easy_install(self, spec, deps=False):
-        if not self.editable:
-            self.install_site_py()
-
-        with self._tmpdir() as tmpdir:
-            if not isinstance(spec, Requirement):
-                if URL_SCHEME(spec):
-                    # It's a url, download it to tmpdir and process
-                    self.not_editable(spec)
-                    dl = self.package_index.download(spec, tmpdir)
-                    return self.install_item(None, dl, tmpdir, deps, True)
-
-                elif os.path.exists(spec):
-                    # Existing file or directory, just process it directly
-                    self.not_editable(spec)
-                    return self.install_item(None, spec, tmpdir, deps, True)
-                else:
-                    spec = parse_requirement_arg(spec)
-
-            self.check_editable(spec)
-            dist = self.package_index.fetch_distribution(
-                spec, tmpdir, self.upgrade, self.editable,
-                not self.always_copy, self.local_index
-            )
-            if dist is None:
-                msg = "Could not find suitable distribution for %r" % spec
-                if self.always_copy:
-                    msg += " (--always-copy skips system and development eggs)"
-                raise DistutilsError(msg)
-            elif dist.precedence == DEVELOP_DIST:
-                # .egg-info dists don't need installing, just process deps
-                self.process_distribution(spec, dist, deps, "Using")
-                return dist
-            else:
-                return self.install_item(spec, dist.location, tmpdir, deps)
-
-    def install_item(self, spec, download, tmpdir, deps, install_needed=False):
-
-        # Installation is also needed if file in tmpdir or is not an egg
-        install_needed = install_needed or self.always_copy
-        install_needed = install_needed or os.path.dirname(download) == tmpdir
-        install_needed = install_needed or not download.endswith('.egg')
-        install_needed = install_needed or (
-            self.always_copy_from is not None and
-            os.path.dirname(normalize_path(download)) ==
-            normalize_path(self.always_copy_from)
-        )
-
-        if spec and not install_needed:
-            # at this point, we know it's a local .egg, we just don't know if
-            # it's already installed.
-            for dist in self.local_index[spec.project_name]:
-                if dist.location == download:
-                    break
-            else:
-                install_needed = True  # it's not in the local index
-
-        log.info("Processing %s", os.path.basename(download))
-
-        if install_needed:
-            dists = self.install_eggs(spec, download, tmpdir)
-            for dist in dists:
-                self.process_distribution(spec, dist, deps)
-        else:
-            dists = [self.egg_distribution(download)]
-            self.process_distribution(spec, dists[0], deps, "Using")
-
-        if spec is not None:
-            for dist in dists:
-                if dist in spec:
-                    return dist
-
-    def select_scheme(self, name):
-        """Sets the install directories by applying the install schemes."""
-        # it's the caller's problem if they supply a bad name!
-        scheme = INSTALL_SCHEMES[name]
-        for key in SCHEME_KEYS:
-            attrname = 'install_' + key
-            if getattr(self, attrname) is None:
-                setattr(self, attrname, scheme[key])
-
-    def process_distribution(self, requirement, dist, deps=True, *info):
-        self.update_pth(dist)
-        self.package_index.add(dist)
-        if dist in self.local_index[dist.key]:
-            self.local_index.remove(dist)
-        self.local_index.add(dist)
-        self.install_egg_scripts(dist)
-        self.installed_projects[dist.key] = dist
-        log.info(self.installation_report(requirement, dist, *info))
-        if (dist.has_metadata('dependency_links.txt') and
-                not self.no_find_links):
-            self.package_index.add_find_links(
-                dist.get_metadata_lines('dependency_links.txt')
-            )
-        if not deps and not self.always_copy:
-            return
-        elif requirement is not None and dist.key != requirement.key:
-            log.warn("Skipping dependencies for %s", dist)
-            return  # XXX this is not the distribution we were looking for
-        elif requirement is None or dist not in requirement:
-            # if we wound up with a different version, resolve what we've got
-            distreq = dist.as_requirement()
-            requirement = Requirement(str(distreq))
-        log.info("Processing dependencies for %s", requirement)
-        try:
-            distros = WorkingSet([]).resolve(
-                [requirement], self.local_index, self.easy_install
-            )
-        except DistributionNotFound as e:
-            raise DistutilsError(str(e))
-        except VersionConflict as e:
-            raise DistutilsError(e.report())
-        if self.always_copy or self.always_copy_from:
-            # Force all the relevant distros to be copied or activated
-            for dist in distros:
-                if dist.key not in self.installed_projects:
-                    self.easy_install(dist.as_requirement())
-        log.info("Finished processing dependencies for %s", requirement)
-
-    def should_unzip(self, dist):
-        if self.zip_ok is not None:
-            return not self.zip_ok
-        if dist.has_metadata('not-zip-safe'):
-            return True
-        if not dist.has_metadata('zip-safe'):
-            return True
-        return False
-
-    def maybe_move(self, spec, dist_filename, setup_base):
-        dst = os.path.join(self.build_directory, spec.key)
-        if os.path.exists(dst):
-            msg = (
-                "%r already exists in %s; build directory %s will not be kept"
-            )
-            log.warn(msg, spec.key, self.build_directory, setup_base)
-            return setup_base
-        if os.path.isdir(dist_filename):
-            setup_base = dist_filename
-        else:
-            if os.path.dirname(dist_filename) == setup_base:
-                os.unlink(dist_filename)  # get it out of the tmp dir
-            contents = os.listdir(setup_base)
-            if len(contents) == 1:
-                dist_filename = os.path.join(setup_base, contents[0])
-                if os.path.isdir(dist_filename):
-                    # if the only thing there is a directory, move it instead
-                    setup_base = dist_filename
-        ensure_directory(dst)
-        shutil.move(setup_base, dst)
-        return dst
-
-    def install_wrapper_scripts(self, dist):
-        if self.exclude_scripts:
-            return
-        for args in ScriptWriter.best().get_args(dist):
-            self.write_script(*args)
-
-    def install_script(self, dist, script_name, script_text, dev_path=None):
-        """Generate a legacy script wrapper and install it"""
-        spec = str(dist.as_requirement())
-        is_script = is_python_script(script_text, script_name)
-
-        if is_script:
-            body = self._load_template(dev_path) % locals()
-            script_text = ScriptWriter.get_header(script_text) + body
-        self.write_script(script_name, _to_ascii(script_text), 'b')
-
-    @staticmethod
-    def _load_template(dev_path):
-        """
-        There are a couple of template scripts in the package. This
-        function loads one of them and prepares it for use.
-        """
-        # See https://github.com/pypa/setuptools/issues/134 for info
-        # on script file naming and downstream issues with SVR4
-        name = 'script.tmpl'
-        if dev_path:
-            name = name.replace('.tmpl', ' (dev).tmpl')
-
-        raw_bytes = resource_string('setuptools', name)
-        return raw_bytes.decode('utf-8')
-
-    def write_script(self, script_name, contents, mode="t", blockers=()):
-        """Write an executable file to the scripts directory"""
-        self.delete_blockers(  # clean up old .py/.pyw w/o a script
-            [os.path.join(self.script_dir, x) for x in blockers]
-        )
-        log.info("Installing %s script to %s", script_name, self.script_dir)
-        target = os.path.join(self.script_dir, script_name)
-        self.add_output(target)
-
-        mask = current_umask()
-        if not self.dry_run:
-            ensure_directory(target)
-            if os.path.exists(target):
-                os.unlink(target)
-            with open(target, "w" + mode) as f:
-                f.write(contents)
-            chmod(target, 0o777 - mask)
-
-    def install_eggs(self, spec, dist_filename, tmpdir):
-        # .egg dirs or files are already built, so just return them
-        if dist_filename.lower().endswith('.egg'):
-            return [self.install_egg(dist_filename, tmpdir)]
-        elif dist_filename.lower().endswith('.exe'):
-            return [self.install_exe(dist_filename, tmpdir)]
-
-        # Anything else, try to extract and build
-        setup_base = tmpdir
-        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
-            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
-        elif os.path.isdir(dist_filename):
-            setup_base = os.path.abspath(dist_filename)
-
-        if (setup_base.startswith(tmpdir)  # something we downloaded
-                and self.build_directory and spec is not None):
-            setup_base = self.maybe_move(spec, dist_filename, setup_base)
-
-        # Find the setup.py file
-        setup_script = os.path.join(setup_base, 'setup.py')
-
-        if not os.path.exists(setup_script):
-            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
-            if not setups:
-                raise DistutilsError(
-                    "Couldn't find a setup script in %s" %
-                    os.path.abspath(dist_filename)
-                )
-            if len(setups) > 1:
-                raise DistutilsError(
-                    "Multiple setup scripts in %s" %
-                    os.path.abspath(dist_filename)
-                )
-            setup_script = setups[0]
-
-        # Now run it, and return the result
-        if self.editable:
-            log.info(self.report_editable(spec, setup_script))
-            return []
-        else:
-            return self.build_and_install(setup_script, setup_base)
-
-    def egg_distribution(self, egg_path):
-        if os.path.isdir(egg_path):
-            metadata = PathMetadata(egg_path, os.path.join(egg_path,
-                                                           'EGG-INFO'))
-        else:
-            metadata = EggMetadata(zipimport.zipimporter(egg_path))
-        return Distribution.from_filename(egg_path, metadata=metadata)
-
-    def install_egg(self, egg_path, tmpdir):
-        destination = os.path.join(
-            self.install_dir,
-            os.path.basename(egg_path),
-        )
-        destination = os.path.abspath(destination)
-        if not self.dry_run:
-            ensure_directory(destination)
-
-        dist = self.egg_distribution(egg_path)
-        if not samefile(egg_path, destination):
-            if os.path.isdir(destination) and not os.path.islink(destination):
-                dir_util.remove_tree(destination, dry_run=self.dry_run)
-            elif os.path.exists(destination):
-                self.execute(
-                    os.unlink,
-                    (destination,),
-                    "Removing " + destination,
-                )
-            try:
-                new_dist_is_zipped = False
-                if os.path.isdir(egg_path):
-                    if egg_path.startswith(tmpdir):
-                        f, m = shutil.move, "Moving"
-                    else:
-                        f, m = shutil.copytree, "Copying"
-                elif self.should_unzip(dist):
-                    self.mkpath(destination)
-                    f, m = self.unpack_and_compile, "Extracting"
-                else:
-                    new_dist_is_zipped = True
-                    if egg_path.startswith(tmpdir):
-                        f, m = shutil.move, "Moving"
-                    else:
-                        f, m = shutil.copy2, "Copying"
-                self.execute(
-                    f,
-                    (egg_path, destination),
-                    (m + " %s to %s") % (
-                        os.path.basename(egg_path),
-                        os.path.dirname(destination)
-                    ),
-                )
-                update_dist_caches(
-                    destination,
-                    fix_zipimporter_caches=new_dist_is_zipped,
-                )
-            except Exception:
-                update_dist_caches(destination, fix_zipimporter_caches=False)
-                raise
-
-        self.add_output(destination)
-        return self.egg_distribution(destination)
-
-    def install_exe(self, dist_filename, tmpdir):
-        # See if it's valid, get data
-        cfg = extract_wininst_cfg(dist_filename)
-        if cfg is None:
-            raise DistutilsError(
-                "%s is not a valid distutils Windows .exe" % dist_filename
-            )
-        # Create a dummy distribution object until we build the real distro
-        dist = Distribution(
-            None,
-            project_name=cfg.get('metadata', 'name'),
-            version=cfg.get('metadata', 'version'), platform=get_platform(),
-        )
-
-        # Convert the .exe to an unpacked egg
-        egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
-        dist.location = egg_path
-        egg_tmp = egg_path + '.tmp'
-        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
-        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
-        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
-        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
-        self.exe_to_egg(dist_filename, egg_tmp)
-
-        # Write EGG-INFO/PKG-INFO
-        if not os.path.exists(pkg_inf):
-            f = open(pkg_inf, 'w')
-            f.write('Metadata-Version: 1.0\n')
-            for k, v in cfg.items('metadata'):
-                if k != 'target_version':
-                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
-            f.close()
-        script_dir = os.path.join(_egg_info, 'scripts')
-        # delete entry-point scripts to avoid duping
-        self.delete_blockers([
-            os.path.join(script_dir, args[0])
-            for args in ScriptWriter.get_args(dist)
-        ])
-        # Build .egg file from tmpdir
-        bdist_egg.make_zipfile(
-            egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run,
-        )
-        # install the .egg
-        return self.install_egg(egg_path, tmpdir)
-
-    def exe_to_egg(self, dist_filename, egg_tmp):
-        """Extract a bdist_wininst to the directories an egg would use"""
-        # Check for .pth file and set up prefix translations
-        prefixes = get_exe_prefixes(dist_filename)
-        to_compile = []
-        native_libs = []
-        top_level = {}
-
-        def process(src, dst):
-            s = src.lower()
-            for old, new in prefixes:
-                if s.startswith(old):
-                    src = new + src[len(old):]
-                    parts = src.split('/')
-                    dst = os.path.join(egg_tmp, *parts)
-                    dl = dst.lower()
-                    if dl.endswith('.pyd') or dl.endswith('.dll'):
-                        parts[-1] = bdist_egg.strip_module(parts[-1])
-                        top_level[os.path.splitext(parts[0])[0]] = 1
-                        native_libs.append(src)
-                    elif dl.endswith('.py') and old != 'SCRIPTS/':
-                        top_level[os.path.splitext(parts[0])[0]] = 1
-                        to_compile.append(dst)
-                    return dst
-            if not src.endswith('.pth'):
-                log.warn("WARNING: can't process %s", src)
-            return None
-
-        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
-        unpack_archive(dist_filename, egg_tmp, process)
-        stubs = []
-        for res in native_libs:
-            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
-                parts = res.split('/')
-                resource = parts[-1]
-                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
-                pyfile = os.path.join(egg_tmp, *parts)
-                to_compile.append(pyfile)
-                stubs.append(pyfile)
-                bdist_egg.write_stub(resource, pyfile)
-        self.byte_compile(to_compile)  # compile .py's
-        bdist_egg.write_safety_flag(
-            os.path.join(egg_tmp, 'EGG-INFO'),
-            bdist_egg.analyze_egg(egg_tmp, stubs))  # write zip-safety flag
-
-        for name in 'top_level', 'native_libs':
-            if locals()[name]:
-                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
-                if not os.path.exists(txt):
-                    f = open(txt, 'w')
-                    f.write('\n'.join(locals()[name]) + '\n')
-                    f.close()
-
-    __mv_warning = textwrap.dedent("""
-        Because this distribution was installed --multi-version, before you can
-        import modules from this package in an application, you will need to
-        'import pkg_resources' and then use a 'require()' call similar to one of
-        these examples, in order to select the desired version:
-
-            pkg_resources.require("%(name)s")  # latest installed version
-            pkg_resources.require("%(name)s==%(version)s")  # this exact version
-            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
-        """).lstrip()
-
-    __id_warning = textwrap.dedent("""
-        Note also that the installation directory must be on sys.path at runtime for
-        this to work.  (e.g. by being the application's script directory, by being on
-        PYTHONPATH, or by being added to sys.path by your code.)
-        """)
-
-    def installation_report(self, req, dist, what="Installed"):
-        """Helpful installation message for display to package users"""
-        msg = "\n%(what)s %(eggloc)s%(extras)s"
-        if self.multi_version and not self.no_report:
-            msg += '\n' + self.__mv_warning
-            if self.install_dir not in map(normalize_path, sys.path):
-                msg += '\n' + self.__id_warning
-
-        eggloc = dist.location
-        name = dist.project_name
-        version = dist.version
-        extras = ''  # TODO: self.report_extras(req, dist)
-        return msg % locals()
-
-    __editable_msg = textwrap.dedent("""
-        Extracted editable version of %(spec)s to %(dirname)s
-
-        If it uses setuptools in its setup script, you can activate it in
-        "development" mode by going to that directory and running::
-
-            %(python)s setup.py develop
-
-        See the setuptools documentation for the "develop" command for more info.
-        """).lstrip()
-
-    def report_editable(self, spec, setup_script):
-        dirname = os.path.dirname(setup_script)
-        python = sys.executable
-        return '\n' + self.__editable_msg % locals()
-
-    def run_setup(self, setup_script, setup_base, args):
-        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
-        sys.modules.setdefault('distutils.command.egg_info', egg_info)
-
-        args = list(args)
-        if self.verbose > 2:
-            v = 'v' * (self.verbose - 1)
-            args.insert(0, '-' + v)
-        elif self.verbose < 2:
-            args.insert(0, '-q')
-        if self.dry_run:
-            args.insert(0, '-n')
-        log.info(
-            "Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args)
-        )
-        try:
-            run_setup(setup_script, args)
-        except SystemExit as v:
-            raise DistutilsError("Setup script exited with %s" % (v.args[0],))
-
-    def build_and_install(self, setup_script, setup_base):
-        args = ['bdist_egg', '--dist-dir']
-
-        dist_dir = tempfile.mkdtemp(
-            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
-        )
-        try:
-            self._set_fetcher_options(os.path.dirname(setup_script))
-            args.append(dist_dir)
-
-            self.run_setup(setup_script, setup_base, args)
-            all_eggs = Environment([dist_dir])
-            eggs = []
-            for key in all_eggs:
-                for dist in all_eggs[key]:
-                    eggs.append(self.install_egg(dist.location, setup_base))
-            if not eggs and not self.dry_run:
-                log.warn("No eggs found in %s (setup script problem?)",
-                         dist_dir)
-            return eggs
-        finally:
-            rmtree(dist_dir)
-            log.set_verbosity(self.verbose)  # restore our log verbosity
-
-    def _set_fetcher_options(self, base):
-        """
-        When easy_install is about to run bdist_egg on a source dist, that
-        source dist might have 'setup_requires' directives, requiring
-        additional fetching. Ensure the fetcher options given to easy_install
-        are available to that command as well.
-        """
-        # find the fetch options from easy_install and write them out
-        # to the setup.cfg file.
-        ei_opts = self.distribution.get_option_dict('easy_install').copy()
-        fetch_directives = (
-            'find_links', 'site_dirs', 'index_url', 'optimize',
-            'site_dirs', 'allow_hosts',
-        )
-        fetch_options = {}
-        for key, val in ei_opts.items():
-            if key not in fetch_directives:
-                continue
-            fetch_options[key.replace('_', '-')] = val[1]
-        # create a settings dictionary suitable for `edit_config`
-        settings = dict(easy_install=fetch_options)
-        cfg_filename = os.path.join(base, 'setup.cfg')
-        setopt.edit_config(cfg_filename, settings)
-
-    def update_pth(self, dist):
-        if self.pth_file is None:
-            return
-
-        for d in self.pth_file[dist.key]:  # drop old entries
-            if self.multi_version or d.location != dist.location:
-                log.info("Removing %s from easy-install.pth file", d)
-                self.pth_file.remove(d)
-                if d.location in self.shadow_path:
-                    self.shadow_path.remove(d.location)
-
-        if not self.multi_version:
-            if dist.location in self.pth_file.paths:
-                log.info(
-                    "%s is already the active version in easy-install.pth",
-                    dist,
-                )
-            else:
-                log.info("Adding %s to easy-install.pth file", dist)
-                self.pth_file.add(dist)  # add new entry
-                if dist.location not in self.shadow_path:
-                    self.shadow_path.append(dist.location)
-
-        if not self.dry_run:
-
-            self.pth_file.save()
-
-            if dist.key == 'setuptools':
-                # Ensure that setuptools itself never becomes unavailable!
-                # XXX should this check for latest version?
-                filename = os.path.join(self.install_dir, 'setuptools.pth')
-                if os.path.islink(filename):
-                    os.unlink(filename)
-                f = open(filename, 'wt')
-                f.write(self.pth_file.make_relative(dist.location) + '\n')
-                f.close()
-
-    def unpack_progress(self, src, dst):
-        # Progress filter for unpacking
-        log.debug("Unpacking %s to %s", src, dst)
-        return dst  # only unpack-and-compile skips files for dry run
-
-    def unpack_and_compile(self, egg_path, destination):
-        to_compile = []
-        to_chmod = []
-
-        def pf(src, dst):
-            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
-                to_compile.append(dst)
-            elif dst.endswith('.dll') or dst.endswith('.so'):
-                to_chmod.append(dst)
-            self.unpack_progress(src, dst)
-            return not self.dry_run and dst or None
-
-        unpack_archive(egg_path, destination, pf)
-        self.byte_compile(to_compile)
-        if not self.dry_run:
-            for f in to_chmod:
-                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
-                chmod(f, mode)
-
-    def byte_compile(self, to_compile):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-
-        try:
-            # try to make the byte compile messages quieter
-            log.set_verbosity(self.verbose - 1)
-
-            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
-            if self.optimize:
-                byte_compile(
-                    to_compile, optimize=self.optimize, force=1,
-                    dry_run=self.dry_run,
-                )
-        finally:
-            log.set_verbosity(self.verbose)  # restore original verbosity
-
-    __no_default_msg = textwrap.dedent("""
-        bad install directory or PYTHONPATH
-
-        You are attempting to install a package to a directory that is not
-        on PYTHONPATH and which Python does not read ".pth" files from.  The
-        installation directory you specified (via --install-dir, --prefix, or
-        the distutils default setting) was:
-
-            %s
-
-        and your PYTHONPATH environment variable currently contains:
-
-            %r
-
-        Here are some of your options for correcting the problem:
-
-        * You can choose a different installation directory, i.e., one that is
-          on PYTHONPATH or supports .pth files
-
-        * You can add the installation directory to the PYTHONPATH environment
-          variable.  (It must then also be on PYTHONPATH whenever you run
-          Python and want to use the package(s) you are installing.)
-
-        * You can set up the installation directory to support ".pth" files by
-          using one of the approaches described here:
-
-          https://setuptools.readthedocs.io/en/latest/easy_install.html#custom-installation-locations
-
-
-        Please make the appropriate changes for your system and try again.""").lstrip()
-
-    def no_default_version_msg(self):
-        template = self.__no_default_msg
-        return template % (self.install_dir, os.environ.get('PYTHONPATH', ''))
-
-    def install_site_py(self):
-        """Make sure there's a site.py in the target dir, if needed"""
-
-        if self.sitepy_installed:
-            return  # already did it, or don't need to
-
-        sitepy = os.path.join(self.install_dir, "site.py")
-        source = resource_string("setuptools", "site-patch.py")
-        source = source.decode('utf-8')
-        current = ""
-
-        if os.path.exists(sitepy):
-            log.debug("Checking existing site.py in %s", self.install_dir)
-            with io.open(sitepy) as strm:
-                current = strm.read()
-
-            if not current.startswith('def __boot():'):
-                raise DistutilsError(
-                    "%s is not a setuptools-generated site.py; please"
-                    " remove it." % sitepy
-                )
-
-        if current != source:
-            log.info("Creating %s", sitepy)
-            if not self.dry_run:
-                ensure_directory(sitepy)
-                with io.open(sitepy, 'w', encoding='utf-8') as strm:
-                    strm.write(source)
-            self.byte_compile([sitepy])
-
-        self.sitepy_installed = True
-
-    def create_home_path(self):
-        """Create directories under ~."""
-        if not self.user:
-            return
-        home = convert_path(os.path.expanduser("~"))
-        for name, path in six.iteritems(self.config_vars):
-            if path.startswith(home) and not os.path.isdir(path):
-                self.debug_print("os.makedirs('%s', 0o700)" % path)
-                os.makedirs(path, 0o700)
-
-    if sys.version[:3] in ('2.3', '2.4', '2.5') or 'real_prefix' in sys.__dict__:
-        sitedir_name = 'site-packages'
-    else:
-        sitedir_name = 'dist-packages'
-
-    INSTALL_SCHEMES = dict(
-        posix=dict(
-            install_dir='$base/lib/python$py_version_short/site-packages',
-            script_dir='$base/bin',
-        ),
-        unix_local = dict(
-            install_dir = '$base/local/lib/python$py_version_short/%s' % sitedir_name,
-            script_dir  = '$base/local/bin',
-        ),
-        posix_local = dict(
-            install_dir = '$base/local/lib/python$py_version_short/%s' % sitedir_name,
-            script_dir  = '$base/local/bin',
-        ),
-        deb_system = dict(
-            install_dir = '$base/lib/python3/%s' % sitedir_name,
-            script_dir  = '$base/bin',
-        ),
-    )
-
-    DEFAULT_SCHEME = dict(
-        install_dir='$base/Lib/site-packages',
-        script_dir='$base/Scripts',
-    )
-
-    def _expand(self, *attrs):
-        config_vars = self.get_finalized_command('install').config_vars
-
-        if self.prefix or self.install_layout:
-            if self.install_layout and self.install_layout in ['deb']:
-                    scheme_name = "deb_system"
-                    self.prefix = '/usr'
-            elif self.prefix or 'real_prefix' in sys.__dict__:
-                scheme_name = os.name
-            else:
-                scheme_name = "posix_local"
-            # Set default install_dir/scripts from --prefix
-            config_vars = config_vars.copy()
-            config_vars['base'] = self.prefix
-            scheme = self.INSTALL_SCHEMES.get(scheme_name,self.DEFAULT_SCHEME)
-            for attr, val in scheme.items():
-                if getattr(self, attr, None) is None:
-                    setattr(self, attr, val)
-
-        from distutils.util import subst_vars
-
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                val = subst_vars(val, config_vars)
-                if os.name == 'posix':
-                    val = os.path.expanduser(val)
-                setattr(self, attr, val)
-
-
-def get_site_dirs():
-    # return a list of 'site' dirs
-    sitedirs = [_f for _f in os.environ.get('PYTHONPATH',
-                                            '').split(os.pathsep) if _f]
-    prefixes = [sys.prefix]
-    if sys.exec_prefix != sys.prefix:
-        prefixes.append(sys.exec_prefix)
-    for prefix in prefixes:
-        if prefix:
-            if sys.platform in ('os2emx', 'riscos'):
-                sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
-            elif os.sep == '/':
-                sitedirs.extend([
-                    os.path.join(
-                        prefix,
-                        "local/lib",
-                        "python" + sys.version[:3],
-                        "dist-packages",
-                    ),
-                    os.path.join(
-                        prefix,
-                        "lib",
-                        "python" + sys.version[:3],
-                        "dist-packages",
-                    ),
-                    os.path.join(prefix, "lib", "site-python"),
-                ])
-            else:
-                sitedirs.extend([
-                    prefix,
-                    os.path.join(prefix, "lib", "site-packages"),
-                ])
-            if sys.platform == 'darwin':
-                # for framework builds *only* we add the standard Apple
-                # locations. Currently only per-user, but /Library and
-                # /Network/Library could be added too
-                if 'Python.framework' in prefix:
-                    home = os.environ.get('HOME')
-                    if home:
-                        home_sp = os.path.join(
-                            home,
-                            'Library',
-                            'Python',
-                            sys.version[:3],
-                            'site-packages',
-                        )
-                        sitedirs.append(home_sp)
-    lib_paths = get_path('purelib'), get_path('platlib')
-    for site_lib in lib_paths:
-        if site_lib not in sitedirs:
-            sitedirs.append(site_lib)
-
-    if site.ENABLE_USER_SITE:
-        sitedirs.append(site.USER_SITE)
-
-    try:
-        sitedirs.extend(site.getsitepackages())
-    except AttributeError:
-        pass
-
-    sitedirs = list(map(normalize_path, sitedirs))
-
-    return sitedirs
-
-
-def expand_paths(inputs):
-    """Yield sys.path directories that might contain "old-style" packages"""
-
-    seen = {}
-
-    for dirname in inputs:
-        dirname = normalize_path(dirname)
-        if dirname in seen:
-            continue
-
-        seen[dirname] = 1
-        if not os.path.isdir(dirname):
-            continue
-
-        files = os.listdir(dirname)
-        yield dirname, files
-
-        for name in files:
-            if not name.endswith('.pth'):
-                # We only care about the .pth files
-                continue
-            if name in ('easy-install.pth', 'setuptools.pth'):
-                # Ignore .pth files that we control
-                continue
-
-            # Read the .pth file
-            f = open(os.path.join(dirname, name))
-            lines = list(yield_lines(f))
-            f.close()
-
-            # Yield existing non-dupe, non-import directory lines from it
-            for line in lines:
-                if not line.startswith("import"):
-                    line = normalize_path(line.rstrip())
-                    if line not in seen:
-                        seen[line] = 1
-                        if not os.path.isdir(line):
-                            continue
-                        yield line, os.listdir(line)
-
-
-def extract_wininst_cfg(dist_filename):
-    """Extract configuration data from a bdist_wininst .exe
-
-    Returns a configparser.RawConfigParser, or None
-    """
-    f = open(dist_filename, 'rb')
-    try:
-        endrec = zipfile._EndRecData(f)
-        if endrec is None:
-            return None
-
-        prepended = (endrec[9] - endrec[5]) - endrec[6]
-        if prepended < 12:  # no wininst data here
-            return None
-        f.seek(prepended - 12)
-
-        tag, cfglen, bmlen = struct.unpack("<iii", f.read(12))
-        if tag not in (0x1234567A, 0x1234567B):
-            return None  # not a valid tag
-
-        f.seek(prepended - (12 + cfglen))
-        init = {'version': '', 'target_version': ''}
-        cfg = configparser.RawConfigParser(init)
-        try:
-            part = f.read(cfglen)
-            # Read up to the first null byte.
-            config = part.split(b'\0', 1)[0]
-            # Now the config is in bytes, but for RawConfigParser, it should
-            #  be text, so decode it.
-            config = config.decode(sys.getfilesystemencoding())
-            cfg.readfp(six.StringIO(config))
-        except configparser.Error:
-            return None
-        if not cfg.has_section('metadata') or not cfg.has_section('Setup'):
-            return None
-        return cfg
-
-    finally:
-        f.close()
-
-
-def get_exe_prefixes(exe_filename):
-    """Get exe->egg path translations for a given .exe file"""
-
-    prefixes = [
-        ('PURELIB/', ''),
-        ('PLATLIB/pywin32_system32', ''),
-        ('PLATLIB/', ''),
-        ('SCRIPTS/', 'EGG-INFO/scripts/'),
-        ('DATA/lib/site-packages', ''),
-    ]
-    z = zipfile.ZipFile(exe_filename)
-    try:
-        for info in z.infolist():
-            name = info.filename
-            parts = name.split('/')
-            if len(parts) == 3 and parts[2] == 'PKG-INFO':
-                if parts[1].endswith('.egg-info'):
-                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
-                    break
-            if len(parts) != 2 or not name.endswith('.pth'):
-                continue
-            if name.endswith('-nspkg.pth'):
-                continue
-            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
-                contents = z.read(name)
-                if six.PY3:
-                    contents = contents.decode()
-                for pth in yield_lines(contents):
-                    pth = pth.strip().replace('\\', '/')
-                    if not pth.startswith('import'):
-                        prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
-    finally:
-        z.close()
-    prefixes = [(x.lower(), y) for x, y in prefixes]
-    prefixes.sort()
-    prefixes.reverse()
-    return prefixes
-
-
-class PthDistributions(Environment):
-    """A .pth file with Distribution paths in it"""
-
-    dirty = False
-
-    def __init__(self, filename, sitedirs=()):
-        self.filename = filename
-        self.sitedirs = list(map(normalize_path, sitedirs))
-        self.basedir = normalize_path(os.path.dirname(self.filename))
-        self._load()
-        Environment.__init__(self, [], None, None)
-        for path in yield_lines(self.paths):
-            list(map(self.add, find_distributions(path, True)))
-
-    def _load(self):
-        self.paths = []
-        saw_import = False
-        seen = dict.fromkeys(self.sitedirs)
-        if os.path.isfile(self.filename):
-            f = open(self.filename, 'rt')
-            for line in f:
-                if line.startswith('import'):
-                    saw_import = True
-                    continue
-                path = line.rstrip()
-                self.paths.append(path)
-                if not path.strip() or path.strip().startswith('#'):
-                    continue
-                # skip non-existent paths, in case somebody deleted a package
-                # manually, and duplicate paths as well
-                path = self.paths[-1] = normalize_path(
-                    os.path.join(self.basedir, path)
-                )
-                if not os.path.exists(path) or path in seen:
-                    self.paths.pop()  # skip it
-                    self.dirty = True  # we cleaned up, so we're dirty now :)
-                    continue
-                seen[path] = 1
-            f.close()
-
-        if self.paths and not saw_import:
-            self.dirty = True  # ensure anything we touch has import wrappers
-        while self.paths and not self.paths[-1].strip():
-            self.paths.pop()
-
-    def save(self):
-        """Write changed .pth file back to disk"""
-        if not self.dirty:
-            return
-
-        rel_paths = list(map(self.make_relative, self.paths))
-        if rel_paths:
-            log.debug("Saving %s", self.filename)
-            lines = self._wrap_lines(rel_paths)
-            data = '\n'.join(lines) + '\n'
-
-            if os.path.islink(self.filename):
-                os.unlink(self.filename)
-            with open(self.filename, 'wt') as f:
-                f.write(data)
-
-        elif os.path.exists(self.filename):
-            log.debug("Deleting empty %s", self.filename)
-            os.unlink(self.filename)
-
-        self.dirty = False
-
-    @staticmethod
-    def _wrap_lines(lines):
-        return lines
-
-    def add(self, dist):
-        """Add `dist` to the distribution map"""
-        new_path = (
-            dist.location not in self.paths and (
-                dist.location not in self.sitedirs or
-                # account for '.' being in PYTHONPATH
-                dist.location == os.getcwd()
-            )
-        )
-        if new_path:
-            self.paths.append(dist.location)
-            self.dirty = True
-        Environment.add(self, dist)
-
-    def remove(self, dist):
-        """Remove `dist` from the distribution map"""
-        while dist.location in self.paths:
-            self.paths.remove(dist.location)
-            self.dirty = True
-        Environment.remove(self, dist)
-
-    def make_relative(self, path):
-        npath, last = os.path.split(normalize_path(path))
-        baselen = len(self.basedir)
-        parts = [last]
-        sep = os.altsep == '/' and '/' or os.sep
-        while len(npath) >= baselen:
-            if npath == self.basedir:
-                parts.append(os.curdir)
-                parts.reverse()
-                return sep.join(parts)
-            npath, last = os.path.split(npath)
-            parts.append(last)
-        else:
-            return path
-
-
-class RewritePthDistributions(PthDistributions):
-    @classmethod
-    def _wrap_lines(cls, lines):
-        yield cls.prelude
-        for line in lines:
-            yield line
-        yield cls.postlude
-
-    prelude = _one_liner("""
-        import sys
-        sys.__plen = len(sys.path)
-        """)
-    postlude = _one_liner("""
-        import sys
-        new = sys.path[sys.__plen:]
-        del sys.path[sys.__plen:]
-        p = getattr(sys, '__egginsert', 0)
-        sys.path[p:p] = new
-        sys.__egginsert = p + len(new)
-        """)
-
-
-if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
-    PthDistributions = RewritePthDistributions
-
-
-def _first_line_re():
-    """
-    Return a regular expression based on first_line_re suitable for matching
-    strings.
-    """
-    if isinstance(first_line_re.pattern, str):
-        return first_line_re
-
-    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
-    return re.compile(first_line_re.pattern.decode())
-
-
-def auto_chmod(func, arg, exc):
-    if func is os.remove and os.name == 'nt':
-        chmod(arg, stat.S_IWRITE)
-        return func(arg)
-    et, ev, _ = sys.exc_info()
-    six.reraise(et, (ev[0], ev[1] + (" %s %s" % (func, arg))))
-
-
-def update_dist_caches(dist_path, fix_zipimporter_caches):
-    """
-    Fix any globally cached `dist_path` related data
-
-    `dist_path` should be a path of a newly installed egg distribution (zipped
-    or unzipped).
-
-    sys.path_importer_cache contains finder objects that have been cached when
-    importing data from the original distribution. Any such finders need to be
-    cleared since the replacement distribution might be packaged differently,
-    e.g. a zipped egg distribution might get replaced with an unzipped egg
-    folder or vice versa. Having the old finders cached may then cause Python
-    to attempt loading modules from the replacement distribution using an
-    incorrect loader.
-
-    zipimport.zipimporter objects are Python loaders charged with importing
-    data packaged inside zip archives. If stale loaders referencing the
-    original distribution, are left behind, they can fail to load modules from
-    the replacement distribution. E.g. if an old zipimport.zipimporter instance
-    is used to load data from a new zipped egg archive, it may cause the
-    operation to attempt to locate the requested data in the wrong location -
-    one indicated by the original distribution's zip archive directory
-    information. Such an operation may then fail outright, e.g. report having
-    read a 'bad local file header', or even worse, it may fail silently &
-    return invalid data.
-
-    zipimport._zip_directory_cache contains cached zip archive directory
-    information for all existing zipimport.zipimporter instances and all such
-    instances connected to the same archive share the same cached directory
-    information.
-
-    If asked, and the underlying Python implementation allows it, we can fix
-    all existing zipimport.zipimporter instances instead of having to track
-    them down and remove them one by one, by updating their shared cached zip
-    archive directory information. This, of course, assumes that the
-    replacement distribution is packaged as a zipped egg.
-
-    If not asked to fix existing zipimport.zipimporter instances, we still do
-    our best to clear any remaining zipimport.zipimporter related cached data
-    that might somehow later get used when attempting to load data from the new
-    distribution and thus cause such load operations to fail. Note that when
-    tracking down such remaining stale data, we can not catch every conceivable
-    usage from here, and we clear only those that we know of and have found to
-    cause problems if left alive. Any remaining caches should be updated by
-    whomever is in charge of maintaining them, i.e. they should be ready to
-    handle us replacing their zip archives with new distributions at runtime.
-
-    """
-    # There are several other known sources of stale zipimport.zipimporter
-    # instances that we do not clear here, but might if ever given a reason to
-    # do so:
-    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
-    # set') may contain distributions which may in turn contain their
-    #   zipimport.zipimporter loaders.
-    # * Several zipimport.zipimporter loaders held by local variables further
-    #   up the function call stack when running the setuptools installation.
-    # * Already loaded modules may have their __loader__ attribute set to the
-    #   exact loader instance used when importing them. Python 3.4 docs state
-    #   that this information is intended mostly for introspection and so is
-    #   not expected to cause us problems.
-    normalized_path = normalize_path(dist_path)
-    _uncache(normalized_path, sys.path_importer_cache)
-    if fix_zipimporter_caches:
-        _replace_zip_directory_cache_data(normalized_path)
-    else:
-        # Here, even though we do not want to fix existing and now stale
-        # zipimporter cache information, we still want to remove it. Related to
-        # Python's zip archive directory information cache, we clear each of
-        # its stale entries in two phases:
-        #   1. Clear the entry so attempting to access zip archive information
-        #      via any existing stale zipimport.zipimporter instances fails.
-        #   2. Remove the entry from the cache so any newly constructed
-        #      zipimport.zipimporter instances do not end up using old stale
-        #      zip archive directory information.
-        # This whole stale data removal step does not seem strictly necessary,
-        # but has been left in because it was done before we started replacing
-        # the zip archive directory information cache content if possible, and
-        # there are no relevant unit tests that we can depend on to tell us if
-        # this is really needed.
-        _remove_and_clear_zip_directory_cache_data(normalized_path)
-
-
-def _collect_zipimporter_cache_entries(normalized_path, cache):
-    """
-    Return zipimporter cache entry keys related to a given normalized path.
-
-    Alternative path spellings (e.g. those using different character case or
-    those using alternative path separators) related to the same path are
-    included. Any sub-path entries are included as well, i.e. those
-    corresponding to zip archives embedded in other zip archives.
-
-    """
-    result = []
-    prefix_len = len(normalized_path)
-    for p in cache:
-        np = normalize_path(p)
-        if (np.startswith(normalized_path) and
-                np[prefix_len:prefix_len + 1] in (os.sep, '')):
-            result.append(p)
-    return result
-
-
-def _update_zipimporter_cache(normalized_path, cache, updater=None):
-    """
-    Update zipimporter cache data for a given normalized path.
-
-    Any sub-path entries are processed as well, i.e. those corresponding to zip
-    archives embedded in other zip archives.
-
-    Given updater is a callable taking a cache entry key and the original entry
-    (after already removing the entry from the cache), and expected to update
-    the entry and possibly return a new one to be inserted in its place.
-    Returning None indicates that the entry should not be replaced with a new
-    one. If no updater is given, the cache entries are simply removed without
-    any additional processing, the same as if the updater simply returned None.
-
-    """
-    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
-        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
-        # not support the complete dict interface:
-        # * Does not support item assignment, thus not allowing this function
-        #    to be used only for removing existing cache entries.
-        #  * Does not support the dict.pop() method, forcing us to use the
-        #    get/del patterns instead. For more detailed information see the
-        #    following links:
-        #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
-        #      https://bitbucket.org/pypy/pypy/src/dd07756a34a41f674c0cacfbc8ae1d4cc9ea2ae4/pypy/module/zipimport/interp_zipimport.py#cl-99
-        old_entry = cache[p]
-        del cache[p]
-        new_entry = updater and updater(p, old_entry)
-        if new_entry is not None:
-            cache[p] = new_entry
-
-
-def _uncache(normalized_path, cache):
-    _update_zipimporter_cache(normalized_path, cache)
-
-
-def _remove_and_clear_zip_directory_cache_data(normalized_path):
-    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
-        old_entry.clear()
-
-    _update_zipimporter_cache(
-        normalized_path, zipimport._zip_directory_cache,
-        updater=clear_and_remove_cached_zip_archive_directory_data)
-
-
-# PyPy Python implementation does not allow directly writing to the
-# zipimport._zip_directory_cache and so prevents us from attempting to correct
-# its content. The best we can do there is clear the problematic cache content
-# and have PyPy repopulate it as needed. The downside is that if there are any
-# stale zipimport.zipimporter instances laying around, attempting to use them
-# will fail due to not having its zip archive directory information available
-# instead of being automatically corrected to use the new correct zip archive
-# directory information.
-if '__pypy__' in sys.builtin_module_names:
-    _replace_zip_directory_cache_data = \
-        _remove_and_clear_zip_directory_cache_data
-else:
-
-    def _replace_zip_directory_cache_data(normalized_path):
-        def replace_cached_zip_archive_directory_data(path, old_entry):
-            # N.B. In theory, we could load the zip directory information just
-            # once for all updated path spellings, and then copy it locally and
-            # update its contained path strings to contain the correct
-            # spelling, but that seems like a way too invasive move (this cache
-            # structure is not officially documented anywhere and could in
-            # theory change with new Python releases) for no significant
-            # benefit.
-            old_entry.clear()
-            zipimport.zipimporter(path)
-            old_entry.update(zipimport._zip_directory_cache[path])
-            return old_entry
-
-        _update_zipimporter_cache(
-            normalized_path, zipimport._zip_directory_cache,
-            updater=replace_cached_zip_archive_directory_data)
-
-
-def is_python(text, filename='<string>'):
-    "Is this string a valid Python script?"
-    try:
-        compile(text, filename, 'exec')
-    except (SyntaxError, TypeError):
-        return False
-    else:
-        return True
-
-
-def is_sh(executable):
-    """Determine if the specified executable is a .sh (contains a #! line)"""
-    try:
-        with io.open(executable, encoding='latin-1') as fp:
-            magic = fp.read(2)
-    except (OSError, IOError):
-        return executable
-    return magic == '#!'
-
-
-def nt_quote_arg(arg):
-    """Quote a command line argument according to Windows parsing rules"""
-    return subprocess.list2cmdline([arg])
-
-
-def is_python_script(script_text, filename):
-    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
-    """
-    if filename.endswith('.py') or filename.endswith('.pyw'):
-        return True  # extension says it's Python
-    if is_python(script_text, filename):
-        return True  # it's syntactically valid Python
-    if script_text.startswith('#!'):
-        # It begins with a '#!' line, so check if 'python' is in it somewhere
-        return 'python' in script_text.splitlines()[0].lower()
-
-    return False  # Not any Python I can recognize
-
-
-try:
-    from os import chmod as _chmod
-except ImportError:
-    # Jython compatibility
-    def _chmod(*args):
-        pass
-
-
-def chmod(path, mode):
-    log.debug("changing mode of %s to %o", path, mode)
-    try:
-        _chmod(path, mode)
-    except os.error as e:
-        log.debug("chmod failed: %s", e)
-
-
-class CommandSpec(list):
-    """
-    A command spec for a #! header, specified as a list of arguments akin to
-    those passed to Popen.
-    """
-
-    options = []
-    split_args = dict()
-
-    @classmethod
-    def best(cls):
-        """
-        Choose the best CommandSpec class based on environmental conditions.
-        """
-        return cls
-
-    @classmethod
-    def _sys_executable(cls):
-        _default = os.path.normpath(sys.executable)
-        return os.environ.get('__PYVENV_LAUNCHER__', _default)
-
-    @classmethod
-    def from_param(cls, param):
-        """
-        Construct a CommandSpec from a parameter to build_scripts, which may
-        be None.
-        """
-        if isinstance(param, cls):
-            return param
-        if isinstance(param, list):
-            return cls(param)
-        if param is None:
-            return cls.from_environment()
-        # otherwise, assume it's a string.
-        return cls.from_string(param)
-
-    @classmethod
-    def from_environment(cls):
-        return cls([cls._sys_executable()])
-
-    @classmethod
-    def from_string(cls, string):
-        """
-        Construct a command spec from a simple string representing a command
-        line parseable by shlex.split.
-        """
-        items = shlex.split(string, **cls.split_args)
-        return cls(items)
-
-    def install_options(self, script_text):
-        self.options = shlex.split(self._extract_options(script_text))
-        cmdline = subprocess.list2cmdline(self)
-        if not isascii(cmdline):
-            self.options[:0] = ['-x']
-
-    @staticmethod
-    def _extract_options(orig_script):
-        """
-        Extract any options from the first line of the script.
-        """
-        first = (orig_script + '\n').splitlines()[0]
-        match = _first_line_re().match(first)
-        options = match.group(1) or '' if match else ''
-        return options.strip()
-
-    def as_header(self):
-        return self._render(self + list(self.options))
-
-    @staticmethod
-    def _strip_quotes(item):
-        _QUOTES = '"\''
-        for q in _QUOTES:
-            if item.startswith(q) and item.endswith(q):
-                return item[1:-1]
-        return item
-
-    @staticmethod
-    def _render(items):
-        cmdline = subprocess.list2cmdline(
-            CommandSpec._strip_quotes(item.strip()) for item in items)
-        return '#!' + cmdline + '\n'
-
-
-# For pbr compat; will be removed in a future version.
-sys_executable = CommandSpec._sys_executable()
-
-
-class WindowsCommandSpec(CommandSpec):
-    split_args = dict(posix=False)
-
-
-class ScriptWriter(object):
-    """
-    Encapsulates behavior around writing entry point scripts for console and
-    gui apps.
-    """
-
-    template = textwrap.dedent("""
-        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
-        __requires__ = %(spec)r
-        import re
-        import sys
-        from pkg_resources import load_entry_point
-
-        if __name__ == '__main__':
-            sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
-            sys.exit(
-                load_entry_point(%(spec)r, %(group)r, %(name)r)()
-            )
-    """).lstrip()
-
-    command_spec_class = CommandSpec
-
-    @classmethod
-    def get_script_args(cls, dist, executable=None, wininst=False):
-        # for backward compatibility
-        warnings.warn("Use get_args", DeprecationWarning)
-        writer = (WindowsScriptWriter if wininst else ScriptWriter).best()
-        header = cls.get_script_header("", executable, wininst)
-        return writer.get_args(dist, header)
-
-    @classmethod
-    def get_script_header(cls, script_text, executable=None, wininst=False):
-        # for backward compatibility
-        warnings.warn("Use get_header", DeprecationWarning)
-        if wininst:
-            executable = "python.exe"
-        cmd = cls.command_spec_class.best().from_param(executable)
-        cmd.install_options(script_text)
-        return cmd.as_header()
-
-    @classmethod
-    def get_args(cls, dist, header=None):
-        """
-        Yield write_script() argument tuples for a distribution's
-        console_scripts and gui_scripts entry points.
-        """
-        if header is None:
-            header = cls.get_header()
-        spec = str(dist.as_requirement())
-        for type_ in 'console', 'gui':
-            group = type_ + '_scripts'
-            for name, ep in dist.get_entry_map(group).items():
-                cls._ensure_safe_name(name)
-                script_text = cls.template % locals()
-                args = cls._get_script_args(type_, name, header, script_text)
-                for res in args:
-                    yield res
-
-    @staticmethod
-    def _ensure_safe_name(name):
-        """
-        Prevent paths in *_scripts entry point names.
-        """
-        has_path_sep = re.search(r'[\\/]', name)
-        if has_path_sep:
-            raise ValueError("Path separators not allowed in script names")
-
-    @classmethod
-    def get_writer(cls, force_windows):
-        # for backward compatibility
-        warnings.warn("Use best", DeprecationWarning)
-        return WindowsScriptWriter.best() if force_windows else cls.best()
-
-    @classmethod
-    def best(cls):
-        """
-        Select the best ScriptWriter for this environment.
-        """
-        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
-            return WindowsScriptWriter.best()
-        else:
-            return cls
-
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        # Simply write the stub with no extension.
-        yield (name, header + script_text)
-
-    @classmethod
-    def get_header(cls, script_text="", executable=None):
-        """Create a #! line, getting options (if any) from script_text"""
-        cmd = cls.command_spec_class.best().from_param(executable)
-        cmd.install_options(script_text)
-        return cmd.as_header()
-
-
-class WindowsScriptWriter(ScriptWriter):
-    command_spec_class = WindowsCommandSpec
-
-    @classmethod
-    def get_writer(cls):
-        # for backward compatibility
-        warnings.warn("Use best", DeprecationWarning)
-        return cls.best()
-
-    @classmethod
-    def best(cls):
-        """
-        Select the best ScriptWriter suitable for Windows
-        """
-        writer_lookup = dict(
-            executable=WindowsExecutableLauncherWriter,
-            natural=cls,
-        )
-        # for compatibility, use the executable launcher by default
-        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
-        return writer_lookup[launcher]
-
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        "For Windows, add a .py extension"
-        ext = dict(console='.pya', gui='.pyw')[type_]
-        if ext not in os.environ['PATHEXT'].lower().split(';'):
-            msg = (
-                "{ext} not listed in PATHEXT; scripts will not be "
-                "recognized as executables."
-            ).format(**locals())
-            warnings.warn(msg, UserWarning)
-        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
-        old.remove(ext)
-        header = cls._adjust_header(type_, header)
-        blockers = [name + x for x in old]
-        yield name + ext, header + script_text, 't', blockers
-
-    @classmethod
-    def _adjust_header(cls, type_, orig_header):
-        """
-        Make sure 'pythonw' is used for gui and and 'python' is used for
-        console (regardless of what sys.executable is).
-        """
-        pattern = 'pythonw.exe'
-        repl = 'python.exe'
-        if type_ == 'gui':
-            pattern, repl = repl, pattern
-        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
-        new_header = pattern_ob.sub(string=orig_header, repl=repl)
-        return new_header if cls._use_header(new_header) else orig_header
-
-    @staticmethod
-    def _use_header(new_header):
-        """
-        Should _adjust_header use the replaced header?
-
-        On non-windows systems, always use. On
-        Windows systems, only use the replaced header if it resolves
-        to an executable on the system.
-        """
-        clean_header = new_header[2:-1].strip('"')
-        return sys.platform != 'win32' or find_executable(clean_header)
-
-
-class WindowsExecutableLauncherWriter(WindowsScriptWriter):
-    @classmethod
-    def _get_script_args(cls, type_, name, header, script_text):
-        """
-        For Windows, add a .py extension and an .exe launcher
-        """
-        if type_ == 'gui':
-            launcher_type = 'gui'
-            ext = '-script.pyw'
-            old = ['.pyw']
-        else:
-            launcher_type = 'cli'
-            ext = '-script.py'
-            old = ['.py', '.pyc', '.pyo']
-        hdr = cls._adjust_header(type_, header)
-        blockers = [name + x for x in old]
-        yield (name + ext, hdr + script_text, 't', blockers)
-        yield (
-            name + '.exe', get_win_launcher(launcher_type),
-            'b'  # write in binary mode
-        )
-        if not is_64bit():
-            # install a manifest for the launcher to prevent Windows
-            # from detecting it as an installer (which it will for
-            #  launchers like easy_install.exe). Consider only
-            #  adding a manifest for launchers detected as installers.
-            #  See Distribute #143 for details.
-            m_name = name + '.exe.manifest'
-            yield (m_name, load_launcher_manifest(name), 't')
-
-
-# for backward-compatibility
-get_script_args = ScriptWriter.get_script_args
-get_script_header = ScriptWriter.get_script_header
-
-
-def get_win_launcher(type):
-    """
-    Load the Windows launcher (executable) suitable for launching a script.
-
-    `type` should be either 'cli' or 'gui'
-
-    Returns the executable as a byte string.
-    """
-    launcher_fn = '%s.exe' % type
-    if is_64bit():
-        launcher_fn = launcher_fn.replace(".", "-64.")
-    else:
-        launcher_fn = launcher_fn.replace(".", "-32.")
-    return resource_string('setuptools', launcher_fn)
-
-
-def load_launcher_manifest(name):
-    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
-    if six.PY2:
-        return manifest % vars()
-    else:
-        return manifest.decode('utf-8') % vars()
-
-
-def rmtree(path, ignore_errors=False, onerror=auto_chmod):
-    return shutil.rmtree(path, ignore_errors, onerror)
-
-
-def current_umask():
-    tmp = os.umask(0o022)
-    os.umask(tmp)
-    return tmp
-
-
-def bootstrap():
-    # This function is called when setuptools*.egg is run using /bin/sh
-    import setuptools
-
-    argv0 = os.path.dirname(setuptools.__path__[0])
-    sys.argv[0] = argv0
-    sys.argv.append(argv0)
-    main()
-
-
-def main(argv=None, **kw):
-    from setuptools import setup
-    from setuptools.dist import Distribution
-
-    class DistributionWithoutHelpCommands(Distribution):
-        common_usage = ""
-
-        def _show_help(self, *args, **kw):
-            with _patch_usage():
-                Distribution._show_help(self, *args, **kw)
-
-    if argv is None:
-        argv = sys.argv[1:]
-
-    with _patch_usage():
-        setup(
-            script_args=['-q', 'easy_install', '-v'] + argv,
-            script_name=sys.argv[0] or 'easy_install',
-            distclass=DistributionWithoutHelpCommands,
-            **kw
-        )
-
-
-@contextlib.contextmanager
-def _patch_usage():
-    import distutils.core
-    USAGE = textwrap.dedent("""
-        usage: %(script)s [options] requirement_or_url ...
-           or: %(script)s --help
-        """).lstrip()
-
-    def gen_usage(script_name):
-        return USAGE % dict(
-            script=os.path.basename(script_name),
-        )
-
-    saved = distutils.core.gen_usage
-    distutils.core.gen_usage = gen_usage
-    try:
-        yield
-    finally:
-        distutils.core.gen_usage = saved
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/egg_info.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/egg_info.py
deleted file mode 100644
index bc742e3b2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/egg_info.py
+++ /dev/null
@@ -1,692 +0,0 @@
-"""setuptools.command.egg_info
-
-Create a distribution's .egg-info directory and contents"""
-
-from distutils.filelist import FileList as _FileList
-from distutils.errors import DistutilsInternalError
-from distutils.util import convert_path
-from distutils import log
-import distutils.errors
-import distutils.filelist
-import os
-import re
-import sys
-import io
-import warnings
-import time
-import collections
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import map
-
-from setuptools import Command
-from setuptools.command.sdist import sdist
-from setuptools.command.sdist import walk_revctrl
-from setuptools.command.setopt import edit_config
-from setuptools.command import bdist_egg
-from pkg_resources import (
-    parse_requirements, safe_name, parse_version,
-    safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename)
-import setuptools.unicode_utils as unicode_utils
-from setuptools.glob import glob
-
-from pkg_resources.extern import packaging
-
-
-def translate_pattern(glob):
-    """
-    Translate a file path glob like '*.txt' in to a regular expression.
-    This differs from fnmatch.translate which allows wildcards to match
-    directory separators. It also knows about '**/' which matches any number of
-    directories.
-    """
-    pat = ''
-
-    # This will split on '/' within [character classes]. This is deliberate.
-    chunks = glob.split(os.path.sep)
-
-    sep = re.escape(os.sep)
-    valid_char = '[^%s]' % (sep,)
-
-    for c, chunk in enumerate(chunks):
-        last_chunk = c == len(chunks) - 1
-
-        # Chunks that are a literal ** are globstars. They match anything.
-        if chunk == '**':
-            if last_chunk:
-                # Match anything if this is the last component
-                pat += '.*'
-            else:
-                # Match '(name/)*'
-                pat += '(?:%s+%s)*' % (valid_char, sep)
-            continue  # Break here as the whole path component has been handled
-
-        # Find any special characters in the remainder
-        i = 0
-        chunk_len = len(chunk)
-        while i < chunk_len:
-            char = chunk[i]
-            if char == '*':
-                # Match any number of name characters
-                pat += valid_char + '*'
-            elif char == '?':
-                # Match a name character
-                pat += valid_char
-            elif char == '[':
-                # Character class
-                inner_i = i + 1
-                # Skip initial !/] chars
-                if inner_i < chunk_len and chunk[inner_i] == '!':
-                    inner_i = inner_i + 1
-                if inner_i < chunk_len and chunk[inner_i] == ']':
-                    inner_i = inner_i + 1
-
-                # Loop till the closing ] is found
-                while inner_i < chunk_len and chunk[inner_i] != ']':
-                    inner_i = inner_i + 1
-
-                if inner_i >= chunk_len:
-                    # Got to the end of the string without finding a closing ]
-                    # Do not treat this as a matching group, but as a literal [
-                    pat += re.escape(char)
-                else:
-                    # Grab the insides of the [brackets]
-                    inner = chunk[i + 1:inner_i]
-                    char_class = ''
-
-                    # Class negation
-                    if inner[0] == '!':
-                        char_class = '^'
-                        inner = inner[1:]
-
-                    char_class += re.escape(inner)
-                    pat += '[%s]' % (char_class,)
-
-                    # Skip to the end ]
-                    i = inner_i
-            else:
-                pat += re.escape(char)
-            i += 1
-
-        # Join each chunk with the dir separator
-        if not last_chunk:
-            pat += sep
-
-    return re.compile(pat + r'\Z(?ms)')
-
-
-class egg_info(Command):
-    description = "create a distribution's .egg-info directory"
-
-    user_options = [
-        ('egg-base=', 'e', "directory containing .egg-info directories"
-                           " (default: top of the source tree)"),
-        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
-        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
-        ('no-date', 'D', "Don't include date stamp [default]"),
-    ]
-
-    boolean_options = ['tag-date']
-    negative_opt = {
-        'no-date': 'tag-date',
-    }
-
-    def initialize_options(self):
-        self.egg_name = None
-        self.egg_version = None
-        self.egg_base = None
-        self.egg_info = None
-        self.tag_build = None
-        self.tag_date = 0
-        self.broken_egg_info = False
-        self.vtags = None
-
-    ####################################
-    # allow the 'tag_svn_revision' to be detected and
-    # set, supporting sdists built on older Setuptools.
-    @property
-    def tag_svn_revision(self):
-        pass
-
-    @tag_svn_revision.setter
-    def tag_svn_revision(self, value):
-        pass
-    ####################################
-
-    def save_version_info(self, filename):
-        """
-        Materialize the value of date into the
-        build tag. Install build keys in a deterministic order
-        to avoid arbitrary reordering on subsequent builds.
-        """
-        # python 2.6 compatibility
-        odict = getattr(collections, 'OrderedDict', dict)
-        egg_info = odict()
-        # follow the order these keys would have been added
-        # when PYTHONHASHSEED=0
-        egg_info['tag_build'] = self.tags()
-        egg_info['tag_date'] = 0
-        edit_config(filename, dict(egg_info=egg_info))
-
-    def finalize_options(self):
-        self.egg_name = safe_name(self.distribution.get_name())
-        self.vtags = self.tags()
-        self.egg_version = self.tagged_version()
-
-        parsed_version = parse_version(self.egg_version)
-
-        try:
-            is_version = isinstance(parsed_version, packaging.version.Version)
-            spec = (
-                "%s==%s" if is_version else "%s===%s"
-            )
-            list(
-                parse_requirements(spec % (self.egg_name, self.egg_version))
-            )
-        except ValueError:
-            raise distutils.errors.DistutilsOptionError(
-                "Invalid distribution name or version syntax: %s-%s" %
-                (self.egg_name, self.egg_version)
-            )
-
-        if self.egg_base is None:
-            dirs = self.distribution.package_dir
-            self.egg_base = (dirs or {}).get('', os.curdir)
-
-        self.ensure_dirname('egg_base')
-        self.egg_info = to_filename(self.egg_name) + '.egg-info'
-        if self.egg_base != os.curdir:
-            self.egg_info = os.path.join(self.egg_base, self.egg_info)
-        if '-' in self.egg_name:
-            self.check_broken_egg_info()
-
-        # Set package version for the benefit of dumber commands
-        # (e.g. sdist, bdist_wininst, etc.)
-        #
-        self.distribution.metadata.version = self.egg_version
-
-        # If we bootstrapped around the lack of a PKG-INFO, as might be the
-        # case in a fresh checkout, make sure that any special tags get added
-        # to the version info
-        #
-        pd = self.distribution._patched_dist
-        if pd is not None and pd.key == self.egg_name.lower():
-            pd._version = self.egg_version
-            pd._parsed_version = parse_version(self.egg_version)
-            self.distribution._patched_dist = None
-
-    def write_or_delete_file(self, what, filename, data, force=False):
-        """Write `data` to `filename` or delete if empty
-
-        If `data` is non-empty, this routine is the same as ``write_file()``.
-        If `data` is empty but not ``None``, this is the same as calling
-        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
-        unless `filename` exists, in which case a warning is issued about the
-        orphaned file (if `force` is false), or deleted (if `force` is true).
-        """
-        if data:
-            self.write_file(what, filename, data)
-        elif os.path.exists(filename):
-            if data is None and not force:
-                log.warn(
-                    "%s not set in setup(), but %s exists", what, filename
-                )
-                return
-            else:
-                self.delete_file(filename)
-
-    def write_file(self, what, filename, data):
-        """Write `data` to `filename` (if not a dry run) after announcing it
-
-        `what` is used in a log message to identify what is being written
-        to the file.
-        """
-        log.info("writing %s to %s", what, filename)
-        if six.PY3:
-            data = data.encode("utf-8")
-        if not self.dry_run:
-            f = open(filename, 'wb')
-            f.write(data)
-            f.close()
-
-    def delete_file(self, filename):
-        """Delete `filename` (if not a dry run) after announcing it"""
-        log.info("deleting %s", filename)
-        if not self.dry_run:
-            os.unlink(filename)
-
-    def tagged_version(self):
-        version = self.distribution.get_version()
-        # egg_info may be called more than once for a distribution,
-        # in which case the version string already contains all tags.
-        if self.vtags and version.endswith(self.vtags):
-            return safe_version(version)
-        return safe_version(version + self.vtags)
-
-    def run(self):
-        self.mkpath(self.egg_info)
-        installer = self.distribution.fetch_build_egg
-        for ep in iter_entry_points('egg_info.writers'):
-            ep.require(installer=installer)
-            writer = ep.resolve()
-            writer(self, ep.name, os.path.join(self.egg_info, ep.name))
-
-        # Get rid of native_libs.txt if it was put there by older bdist_egg
-        nl = os.path.join(self.egg_info, "native_libs.txt")
-        if os.path.exists(nl):
-            self.delete_file(nl)
-
-        self.find_sources()
-
-    def tags(self):
-        version = ''
-        if self.tag_build:
-            version += self.tag_build
-        if self.tag_date:
-            version += time.strftime("-%Y%m%d")
-        return version
-
-    def find_sources(self):
-        """Generate SOURCES.txt manifest file"""
-        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
-        mm = manifest_maker(self.distribution)
-        mm.manifest = manifest_filename
-        mm.run()
-        self.filelist = mm.filelist
-
-    def check_broken_egg_info(self):
-        bei = self.egg_name + '.egg-info'
-        if self.egg_base != os.curdir:
-            bei = os.path.join(self.egg_base, bei)
-        if os.path.exists(bei):
-            log.warn(
-                "-" * 78 + '\n'
-                "Note: Your current .egg-info directory has a '-' in its name;"
-                '\nthis will not work correctly with "setup.py develop".\n\n'
-                'Please rename %s to %s to correct this problem.\n' + '-' * 78,
-                bei, self.egg_info
-            )
-            self.broken_egg_info = self.egg_info
-            self.egg_info = bei  # make it work for now
-
-
-class FileList(_FileList):
-    # Implementations of the various MANIFEST.in commands
-
-    def process_template_line(self, line):
-        # Parse the line: split it up, make sure the right number of words
-        # is there, and return the relevant words.  'action' is always
-        # defined: it's the first word of the line.  Which of the other
-        # three are defined depends on the action; it'll be either
-        # patterns, (dir and patterns), or (dir_pattern).
-        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
-
-        # OK, now we know that the action is valid and we have the
-        # right number of words on the line for that action -- so we
-        # can proceed with minimal error-checking.
-        if action == 'include':
-            self.debug_print("include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include(pattern):
-                    log.warn("warning: no files found matching '%s'", pattern)
-
-        elif action == 'exclude':
-            self.debug_print("exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude(pattern):
-                    log.warn(("warning: no previously-included files "
-                              "found matching '%s'"), pattern)
-
-        elif action == 'global-include':
-            self.debug_print("global-include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.global_include(pattern):
-                    log.warn(("warning: no files found matching '%s' "
-                              "anywhere in distribution"), pattern)
-
-        elif action == 'global-exclude':
-            self.debug_print("global-exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.global_exclude(pattern):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found anywhere in distribution"),
-                             pattern)
-
-        elif action == 'recursive-include':
-            self.debug_print("recursive-include %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.recursive_include(dir, pattern):
-                    log.warn(("warning: no files found matching '%s' "
-                              "under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'recursive-exclude':
-            self.debug_print("recursive-exclude %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.recursive_exclude(dir, pattern):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'graft':
-            self.debug_print("graft " + dir_pattern)
-            if not self.graft(dir_pattern):
-                log.warn("warning: no directories found matching '%s'",
-                         dir_pattern)
-
-        elif action == 'prune':
-            self.debug_print("prune " + dir_pattern)
-            if not self.prune(dir_pattern):
-                log.warn(("no previously-included directories found "
-                          "matching '%s'"), dir_pattern)
-
-        else:
-            raise DistutilsInternalError(
-                "this cannot happen: invalid action '%s'" % action)
-
-    def _remove_files(self, predicate):
-        """
-        Remove all files from the file list that match the predicate.
-        Return True if any matching files were removed
-        """
-        found = False
-        for i in range(len(self.files) - 1, -1, -1):
-            if predicate(self.files[i]):
-                self.debug_print(" removing " + self.files[i])
-                del self.files[i]
-                found = True
-        return found
-
-    def include(self, pattern):
-        """Include files that match 'pattern'."""
-        found = [f for f in glob(pattern) if not os.path.isdir(f)]
-        self.extend(found)
-        return bool(found)
-
-    def exclude(self, pattern):
-        """Exclude files that match 'pattern'."""
-        match = translate_pattern(pattern)
-        return self._remove_files(match.match)
-
-    def recursive_include(self, dir, pattern):
-        """
-        Include all files anywhere in 'dir/' that match the pattern.
-        """
-        full_pattern = os.path.join(dir, '**', pattern)
-        found = [f for f in glob(full_pattern, recursive=True)
-                 if not os.path.isdir(f)]
-        self.extend(found)
-        return bool(found)
-
-    def recursive_exclude(self, dir, pattern):
-        """
-        Exclude any file anywhere in 'dir/' that match the pattern.
-        """
-        match = translate_pattern(os.path.join(dir, '**', pattern))
-        return self._remove_files(match.match)
-
-    def graft(self, dir):
-        """Include all files from 'dir/'."""
-        found = distutils.filelist.findall(dir)
-        self.extend(found)
-        return bool(found)
-
-    def prune(self, dir):
-        """Filter out files from 'dir/'."""
-        match = translate_pattern(os.path.join(dir, '**'))
-        return self._remove_files(match.match)
-
-    def global_include(self, pattern):
-        """
-        Include all files anywhere in the current directory that match the
-        pattern. This is very inefficient on large file trees.
-        """
-        if self.allfiles is None:
-            self.findall()
-        match = translate_pattern(os.path.join('**', pattern))
-        found = [f for f in self.allfiles if match.match(f)]
-        self.extend(found)
-        return bool(found)
-
-    def global_exclude(self, pattern):
-        """
-        Exclude all files anywhere that match the pattern.
-        """
-        match = translate_pattern(os.path.join('**', pattern))
-        return self._remove_files(match.match)
-
-    def append(self, item):
-        if item.endswith('\r'):  # Fix older sdists built on Windows
-            item = item[:-1]
-        path = convert_path(item)
-
-        if self._safe_path(path):
-            self.files.append(path)
-
-    def extend(self, paths):
-        self.files.extend(filter(self._safe_path, paths))
-
-    def _repair(self):
-        """
-        Replace self.files with only safe paths
-
-        Because some owners of FileList manipulate the underlying
-        ``files`` attribute directly, this method must be called to
-        repair those paths.
-        """
-        self.files = list(filter(self._safe_path, self.files))
-
-    def _safe_path(self, path):
-        enc_warn = "'%s' not %s encodable -- skipping"
-
-        # To avoid accidental trans-codings errors, first to unicode
-        u_path = unicode_utils.filesys_decode(path)
-        if u_path is None:
-            log.warn("'%s' in unexpected encoding -- skipping" % path)
-            return False
-
-        # Must ensure utf-8 encodability
-        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
-        if utf8_path is None:
-            log.warn(enc_warn, path, 'utf-8')
-            return False
-
-        try:
-            # accept is either way checks out
-            if os.path.exists(u_path) or os.path.exists(utf8_path):
-                return True
-        # this will catch any encode errors decoding u_path
-        except UnicodeEncodeError:
-            log.warn(enc_warn, path, sys.getfilesystemencoding())
-
-
-class manifest_maker(sdist):
-    template = "MANIFEST.in"
-
-    def initialize_options(self):
-        self.use_defaults = 1
-        self.prune = 1
-        self.manifest_only = 1
-        self.force_manifest = 1
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        self.filelist = FileList()
-        if not os.path.exists(self.manifest):
-            self.write_manifest()  # it must exist so it'll get in the list
-        self.add_defaults()
-        if os.path.exists(self.template):
-            self.read_template()
-        self.prune_file_list()
-        self.filelist.sort()
-        self.filelist.remove_duplicates()
-        self.write_manifest()
-
-    def _manifest_normalize(self, path):
-        path = unicode_utils.filesys_decode(path)
-        return path.replace(os.sep, '/')
-
-    def write_manifest(self):
-        """
-        Write the file list in 'self.filelist' to the manifest file
-        named by 'self.manifest'.
-        """
-        self.filelist._repair()
-
-        # Now _repairs should encodability, but not unicode
-        files = [self._manifest_normalize(f) for f in self.filelist.files]
-        msg = "writing manifest file '%s'" % self.manifest
-        self.execute(write_file, (self.manifest, files), msg)
-
-    def warn(self, msg):
-        if not self._should_suppress_warning(msg):
-            sdist.warn(self, msg)
-
-    @staticmethod
-    def _should_suppress_warning(msg):
-        """
-        suppress missing-file warnings from sdist
-        """
-        return re.match(r"standard file .*not found", msg)
-
-    def add_defaults(self):
-        sdist.add_defaults(self)
-        self.filelist.append(self.template)
-        self.filelist.append(self.manifest)
-        rcfiles = list(walk_revctrl())
-        if rcfiles:
-            self.filelist.extend(rcfiles)
-        elif os.path.exists(self.manifest):
-            self.read_manifest()
-        ei_cmd = self.get_finalized_command('egg_info')
-        self.filelist.graft(ei_cmd.egg_info)
-
-    def prune_file_list(self):
-        build = self.get_finalized_command('build')
-        base_dir = self.distribution.get_fullname()
-        self.filelist.prune(build.build_base)
-        self.filelist.prune(base_dir)
-        sep = re.escape(os.sep)
-        self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep,
-                                      is_regex=1)
-
-
-def write_file(filename, contents):
-    """Create a file with the specified name and write 'contents' (a
-    sequence of strings without line terminators) to it.
-    """
-    contents = "\n".join(contents)
-
-    # assuming the contents has been vetted for utf-8 encoding
-    contents = contents.encode("utf-8")
-
-    with open(filename, "wb") as f:  # always write POSIX-style manifest
-        f.write(contents)
-
-
-def write_pkg_info(cmd, basename, filename):
-    log.info("writing %s", filename)
-    if not cmd.dry_run:
-        metadata = cmd.distribution.metadata
-        metadata.version, oldver = cmd.egg_version, metadata.version
-        metadata.name, oldname = cmd.egg_name, metadata.name
-        try:
-            # write unescaped data to PKG-INFO, so older pkg_resources
-            # can still parse it
-            metadata.write_pkg_info(cmd.egg_info)
-        finally:
-            metadata.name, metadata.version = oldname, oldver
-
-        safe = getattr(cmd.distribution, 'zip_safe', None)
-
-        bdist_egg.write_safety_flag(cmd.egg_info, safe)
-
-
-def warn_depends_obsolete(cmd, basename, filename):
-    if os.path.exists(filename):
-        log.warn(
-            "WARNING: 'depends.txt' is not used by setuptools 0.6!\n"
-            "Use the install_requires/extras_require setup() args instead."
-        )
-
-
-def _write_requirements(stream, reqs):
-    lines = yield_lines(reqs or ())
-    append_cr = lambda line: line + '\n'
-    lines = map(append_cr, sorted(lines))
-    stream.writelines(lines)
-
-
-def write_requirements(cmd, basename, filename):
-    dist = cmd.distribution
-    data = six.StringIO()
-    _write_requirements(data, dist.install_requires)
-    extras_require = dist.extras_require or {}
-    for extra in sorted(extras_require):
-        data.write('\n[{extra}]\n'.format(**vars()))
-        _write_requirements(data, extras_require[extra])
-    cmd.write_or_delete_file("requirements", filename, data.getvalue())
-
-
-def write_setup_requirements(cmd, basename, filename):
-    data = StringIO()
-    _write_requirements(data, cmd.distribution.setup_requires)
-    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
-
-
-def write_toplevel_names(cmd, basename, filename):
-    pkgs = dict.fromkeys(
-        [
-            k.split('.', 1)[0]
-            for k in cmd.distribution.iter_distribution_names()
-        ]
-    )
-    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
-
-
-def overwrite_arg(cmd, basename, filename):
-    write_arg(cmd, basename, filename, True)
-
-
-def write_arg(cmd, basename, filename, force=False):
-    argname = os.path.splitext(basename)[0]
-    value = getattr(cmd.distribution, argname, None)
-    if value is not None:
-        value = '\n'.join(value) + '\n'
-    cmd.write_or_delete_file(argname, filename, value, force)
-
-
-def write_entries(cmd, basename, filename):
-    ep = cmd.distribution.entry_points
-
-    if isinstance(ep, six.string_types) or ep is None:
-        data = ep
-    elif ep is not None:
-        data = []
-        for section, contents in sorted(ep.items()):
-            if not isinstance(contents, six.string_types):
-                contents = EntryPoint.parse_group(section, contents)
-                contents = '\n'.join(sorted(map(str, contents.values())))
-            data.append('[%s]\n%s\n\n' % (section, contents))
-        data = ''.join(data)
-
-    cmd.write_or_delete_file('entry points', filename, data, True)
-
-
-def get_pkg_info_revision():
-    """
-    Get a -r### off of PKG-INFO Version in case this is an sdist of
-    a subversion revision.
-    """
-    warnings.warn("get_pkg_info_revision is deprecated.", DeprecationWarning)
-    if os.path.exists('PKG-INFO'):
-        with io.open('PKG-INFO') as f:
-            for line in f:
-                match = re.match(r"Version:.*-r(\d+)\s*$", line)
-                if match:
-                    return int(match.group(1))
-    return 0
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install.py
deleted file mode 100644
index 31a5ddb57..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install.py
+++ /dev/null
@@ -1,125 +0,0 @@
-from distutils.errors import DistutilsArgError
-import inspect
-import glob
-import warnings
-import platform
-import distutils.command.install as orig
-
-import setuptools
-
-# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
-# now. See https://github.com/pypa/setuptools/issues/199/
-_install = orig.install
-
-
-class install(orig.install):
-    """Use easy_install to install the package, w/dependencies"""
-
-    user_options = orig.install.user_options + [
-        ('old-and-unmanageable', None, "Try not to use this!"),
-        ('single-version-externally-managed', None,
-         "used by system package builders to create 'flat' eggs"),
-    ]
-    boolean_options = orig.install.boolean_options + [
-        'old-and-unmanageable', 'single-version-externally-managed',
-    ]
-    new_commands = [
-        ('install_egg_info', lambda self: True),
-        ('install_scripts', lambda self: True),
-    ]
-    _nc = dict(new_commands)
-
-    def initialize_options(self):
-        orig.install.initialize_options(self)
-        self.old_and_unmanageable = None
-        self.single_version_externally_managed = None
-
-    def finalize_options(self):
-        orig.install.finalize_options(self)
-        if self.root:
-            self.single_version_externally_managed = True
-        elif self.single_version_externally_managed:
-            if not self.root and not self.record:
-                raise DistutilsArgError(
-                    "You must specify --record or --root when building system"
-                    " packages"
-                )
-
-    def handle_extra_path(self):
-        if self.root or self.single_version_externally_managed:
-            # explicit backward-compatibility mode, allow extra_path to work
-            return orig.install.handle_extra_path(self)
-
-        # Ignore extra_path when installing an egg (or being run by another
-        # command without --root or --single-version-externally-managed
-        self.path_file = None
-        self.extra_dirs = ''
-
-    def run(self):
-        # Explicit request for old-style install?  Just do it
-        if self.old_and_unmanageable or self.single_version_externally_managed:
-            return orig.install.run(self)
-
-        if not self._called_from_setup(inspect.currentframe()):
-            # Run in backward-compatibility mode to support bdist_* commands.
-            orig.install.run(self)
-        else:
-            self.do_egg_install()
-
-    @staticmethod
-    def _called_from_setup(run_frame):
-        """
-        Attempt to detect whether run() was called from setup() or by another
-        command.  If called by setup(), the parent caller will be the
-        'run_command' method in 'distutils.dist', and *its* caller will be
-        the 'run_commands' method.  If called any other way, the
-        immediate caller *might* be 'run_command', but it won't have been
-        called by 'run_commands'. Return True in that case or if a call stack
-        is unavailable. Return False otherwise.
-        """
-        if run_frame is None:
-            msg = "Call stack not available. bdist_* commands may fail."
-            warnings.warn(msg)
-            if platform.python_implementation() == 'IronPython':
-                msg = "For best results, pass -X:Frames to enable call stack."
-                warnings.warn(msg)
-            return True
-        res = inspect.getouterframes(run_frame)[2]
-        caller, = res[:1]
-        info = inspect.getframeinfo(caller)
-        caller_module = caller.f_globals.get('__name__', '')
-        return (
-            caller_module == 'distutils.dist'
-            and info.function == 'run_commands'
-        )
-
-    def do_egg_install(self):
-
-        easy_install = self.distribution.get_command_class('easy_install')
-
-        cmd = easy_install(
-            self.distribution, args="x", root=self.root, record=self.record,
-        )
-        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
-        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed
-
-        # pick up setup-dir .egg files only: no .egg-info
-        cmd.package_index.scan(glob.glob('*.egg'))
-
-        self.run_command('bdist_egg')
-        args = [self.distribution.get_command_obj('bdist_egg').egg_output]
-
-        if setuptools.bootstrap_install_from:
-            # Bootstrap self-installation of setuptools
-            args.insert(0, setuptools.bootstrap_install_from)
-
-        cmd.args = args
-        cmd.run()
-        setuptools.bootstrap_install_from = None
-
-
-# XXX Python 3.1 doesn't see _nc if this is inside the class
-install.sub_commands = (
-    [cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] +
-    install.new_commands
-)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_egg_info.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_egg_info.py
deleted file mode 100644
index 5f405bcad..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_egg_info.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from distutils import log, dir_util
-import os, sys
-
-from setuptools import Command
-from setuptools import namespaces
-from setuptools.archive_util import unpack_archive
-import pkg_resources
-
-
-class install_egg_info(namespaces.Installer, Command):
-    """Install an .egg-info directory for the package"""
-
-    description = "Install an .egg-info directory for the package"
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-    ]
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.install_layout = None
-        self.prefix_option = None
-
-    def finalize_options(self):
-        self.set_undefined_options('install_lib',
-                                   ('install_dir', 'install_dir'))
-        self.set_undefined_options('install',('install_layout','install_layout'))
-        if sys.hexversion > 0x2060000:
-            self.set_undefined_options('install',('prefix_option','prefix_option'))
-        ei_cmd = self.get_finalized_command("egg_info")
-        basename = pkg_resources.Distribution(
-            None, None, ei_cmd.egg_name, ei_cmd.egg_version
-        ).egg_name() + '.egg-info'
-
-        if self.install_layout:
-            if not self.install_layout.lower() in ['deb']:
-                raise DistutilsOptionError("unknown value for --install-layout")
-            self.install_layout = self.install_layout.lower()
-            basename = basename.replace('-py%s' % pkg_resources.PY_MAJOR, '')
-        elif self.prefix_option or 'real_prefix' in sys.__dict__:
-            # don't modify for virtualenv
-            pass
-        else:
-            basename = basename.replace('-py%s' % pkg_resources.PY_MAJOR, '')
-
-        self.source = ei_cmd.egg_info
-        self.target = os.path.join(self.install_dir, basename)
-        self.outputs = []
-
-    def run(self):
-        self.run_command('egg_info')
-        if os.path.isdir(self.target) and not os.path.islink(self.target):
-            dir_util.remove_tree(self.target, dry_run=self.dry_run)
-        elif os.path.exists(self.target):
-            self.execute(os.unlink, (self.target,), "Removing " + self.target)
-        if not self.dry_run:
-            pkg_resources.ensure_directory(self.target)
-        self.execute(
-            self.copytree, (), "Copying %s to %s" % (self.source, self.target)
-        )
-        self.install_namespaces()
-
-    def get_outputs(self):
-        return self.outputs
-
-    def copytree(self):
-        # Copy the .egg-info tree to site-packages
-        def skimmer(src, dst):
-            # filter out source-control directories; note that 'src' is always
-            # a '/'-separated path, regardless of platform.  'dst' is a
-            # platform-specific path.
-            for skip in '.svn/', 'CVS/':
-                if src.startswith(skip) or '/' + skip in src:
-                    return None
-            if self.install_layout and self.install_layout in ['deb'] and src.startswith('SOURCES.txt'):
-                log.info("Skipping SOURCES.txt")
-                return None
-            self.outputs.append(dst)
-            log.debug("Copying %s to %s", src, dst)
-            return dst
-
-        unpack_archive(self.source, self.target, skimmer)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_lib.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_lib.py
deleted file mode 100644
index 578e002d4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_lib.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import os
-import sys
-import imp
-from itertools import product, starmap
-import distutils.command.install_lib as orig
-
-
-class install_lib(orig.install_lib):
-    """Don't add compiled flags to filenames of non-Python files"""
-
-    def initialize_options(self):
-        orig.install_lib.initialize_options(self)
-        self.multiarch = None
-        self.install_layout = None
-
-    def finalize_options(self):
-        orig.install_lib.finalize_options(self)
-        self.set_undefined_options('install',('install_layout','install_layout'))
-        if self.install_layout == 'deb' and sys.version_info[:2] >= (3, 3):
-            import sysconfig
-            self.multiarch = sysconfig.get_config_var('MULTIARCH')
-
-    def run(self):
-        self.build()
-        outfiles = self.install()
-        if outfiles is not None:
-            # always compile, in case we have any extension stubs to deal with
-            self.byte_compile(outfiles)
-
-    def get_exclusions(self):
-        """
-        Return a collections.Sized collections.Container of paths to be
-        excluded for single_version_externally_managed installations.
-        """
-        all_packages = (
-            pkg
-            for ns_pkg in self._get_SVEM_NSPs()
-            for pkg in self._all_packages(ns_pkg)
-        )
-
-        excl_specs = product(all_packages, self._gen_exclusion_paths())
-        return set(starmap(self._exclude_pkg_path, excl_specs))
-
-    def _exclude_pkg_path(self, pkg, exclusion_path):
-        """
-        Given a package name and exclusion path within that package,
-        compute the full exclusion path.
-        """
-        parts = pkg.split('.') + [exclusion_path]
-        return os.path.join(self.install_dir, *parts)
-
-    @staticmethod
-    def _all_packages(pkg_name):
-        """
-        >>> list(install_lib._all_packages('foo.bar.baz'))
-        ['foo.bar.baz', 'foo.bar', 'foo']
-        """
-        while pkg_name:
-            yield pkg_name
-            pkg_name, sep, child = pkg_name.rpartition('.')
-
-    def _get_SVEM_NSPs(self):
-        """
-        Get namespace packages (list) but only for
-        single_version_externally_managed installations and empty otherwise.
-        """
-        # TODO: is it necessary to short-circuit here? i.e. what's the cost
-        # if get_finalized_command is called even when namespace_packages is
-        # False?
-        if not self.distribution.namespace_packages:
-            return []
-
-        install_cmd = self.get_finalized_command('install')
-        svem = install_cmd.single_version_externally_managed
-
-        return self.distribution.namespace_packages if svem else []
-
-    @staticmethod
-    def _gen_exclusion_paths():
-        """
-        Generate file paths to be excluded for namespace packages (bytecode
-        cache files).
-        """
-        # always exclude the package module itself
-        yield '__init__.py'
-
-        yield '__init__.pyc'
-        yield '__init__.pyo'
-
-        if not hasattr(imp, 'get_tag'):
-            return
-
-        base = os.path.join('__pycache__', '__init__.' + imp.get_tag())
-        yield base + '.pyc'
-        yield base + '.pyo'
-        yield base + '.opt-1.pyc'
-        yield base + '.opt-2.pyc'
-
-    def copy_tree(
-            self, infile, outfile,
-            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
-    ):
-        assert preserve_mode and preserve_times and not preserve_symlinks
-        exclude = self.get_exclusions()
-
-        if not exclude:
-            import distutils.dir_util
-            distutils.dir_util._multiarch = self.multiarch
-            return orig.install_lib.copy_tree(self, infile, outfile)
-
-        # Exclude namespace package __init__.py* files from the output
-
-        from setuptools.archive_util import unpack_directory
-        from distutils import log
-
-        outfiles = []
-
-        if self.multiarch:
-            import sysconfig
-            ext_suffix = sysconfig.get_config_var ('EXT_SUFFIX')
-            if ext_suffix.endswith(self.multiarch + ext_suffix[-3:]):
-                new_suffix = None
-            else:
-                new_suffix = "%s-%s%s" % (ext_suffix[:-3], self.multiarch, ext_suffix[-3:])
-
-        def pf(src, dst):
-            if dst in exclude:
-                log.warn("Skipping installation of %s (namespace package)",
-                         dst)
-                return False
-
-            if self.multiarch and new_suffix and dst.endswith(ext_suffix) and not dst.endswith(new_suffix):
-                dst = dst.replace(ext_suffix, new_suffix)
-                log.info("renaming extension to %s", os.path.basename(dst))
-
-            log.info("copying %s -> %s", src, os.path.dirname(dst))
-            outfiles.append(dst)
-            return dst
-
-        unpack_directory(infile, outfile, pf)
-        return outfiles
-
-    def get_outputs(self):
-        outputs = orig.install_lib.get_outputs(self)
-        exclude = self.get_exclusions()
-        if exclude:
-            return [f for f in outputs if f not in exclude]
-        return outputs
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_scripts.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_scripts.py
deleted file mode 100644
index 16234273a..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/install_scripts.py
+++ /dev/null
@@ -1,65 +0,0 @@
-from distutils import log
-import distutils.command.install_scripts as orig
-import os
-import sys
-
-from pkg_resources import Distribution, PathMetadata, ensure_directory
-
-
-class install_scripts(orig.install_scripts):
-    """Do normal script install, plus any egg_info wrapper scripts"""
-
-    def initialize_options(self):
-        orig.install_scripts.initialize_options(self)
-        self.no_ep = False
-
-    def run(self):
-        import setuptools.command.easy_install as ei
-
-        self.run_command("egg_info")
-        if self.distribution.scripts:
-            orig.install_scripts.run(self)  # run first to set up self.outfiles
-        else:
-            self.outfiles = []
-        if self.no_ep:
-            # don't install entry point scripts into .egg file!
-            return
-
-        ei_cmd = self.get_finalized_command("egg_info")
-        dist = Distribution(
-            ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
-            ei_cmd.egg_name, ei_cmd.egg_version,
-        )
-        bs_cmd = self.get_finalized_command('build_scripts')
-        exec_param = getattr(bs_cmd, 'executable', None)
-        bw_cmd = self.get_finalized_command("bdist_wininst")
-        is_wininst = getattr(bw_cmd, '_is_running', False)
-        writer = ei.ScriptWriter
-        if is_wininst:
-            exec_param = "python.exe"
-            writer = ei.WindowsScriptWriter
-        if exec_param == sys.executable:
-            # In case the path to the Python executable contains a space, wrap
-            # it so it's not split up.
-            exec_param = [exec_param]
-        # resolve the writer to the environment
-        writer = writer.best()
-        cmd = writer.command_spec_class.best().from_param(exec_param)
-        for args in writer.get_args(dist, cmd.as_header()):
-            self.write_script(*args)
-
-    def write_script(self, script_name, contents, mode="t", *ignored):
-        """Write an executable file to the scripts directory"""
-        from setuptools.command.easy_install import chmod, current_umask
-
-        log.info("Installing %s script to %s", script_name, self.install_dir)
-        target = os.path.join(self.install_dir, script_name)
-        self.outfiles.append(target)
-
-        mask = current_umask()
-        if not self.dry_run:
-            ensure_directory(target)
-            f = open(target, "w" + mode)
-            f.write(contents)
-            f.close()
-            chmod(target, 0o777 - mask)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/launcher manifest.xml b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/launcher manifest.xml
deleted file mode 100644
index 5972a96d8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/launcher manifest.xml	
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-    <assemblyIdentity version="1.0.0.0"
-                      processorArchitecture="X86"
-                      name="%(name)s"
-                      type="win32"/>
-    <!-- Identify the application security requirements. -->
-    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
-        <security>
-            <requestedPrivileges>
-                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
-            </requestedPrivileges>
-        </security>
-    </trustInfo>
-</assembly>
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/py36compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/py36compat.py
deleted file mode 100644
index 61063e754..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/py36compat.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import os
-from glob import glob
-from distutils.util import convert_path
-from distutils.command import sdist
-
-from setuptools.extern.six.moves import filter
-
-
-class sdist_add_defaults:
-    """
-    Mix-in providing forward-compatibility for functionality as found in
-    distutils on Python 3.7.
-
-    Do not edit the code in this class except to update functionality
-    as implemented in distutils. Instead, override in the subclass.
-    """
-
-    def add_defaults(self):
-        """Add all the default files to self.filelist:
-          - README or README.txt
-          - setup.py
-          - test/test*.py
-          - all pure Python modules mentioned in setup script
-          - all files pointed by package_data (build_py)
-          - all files defined in data_files.
-          - all files defined as scripts.
-          - all C sources listed as part of extensions or C libraries
-            in the setup script (doesn't catch C headers!)
-        Warns if (README or README.txt) or setup.py are missing; everything
-        else is optional.
-        """
-        self._add_defaults_standards()
-        self._add_defaults_optional()
-        self._add_defaults_python()
-        self._add_defaults_data_files()
-        self._add_defaults_ext()
-        self._add_defaults_c_libs()
-        self._add_defaults_scripts()
-
-    @staticmethod
-    def _cs_path_exists(fspath):
-        """
-        Case-sensitive path existence check
-
-        >>> sdist_add_defaults._cs_path_exists(__file__)
-        True
-        >>> sdist_add_defaults._cs_path_exists(__file__.upper())
-        False
-        """
-        if not os.path.exists(fspath):
-            return False
-        # make absolute so we always have a directory
-        abspath = os.path.abspath(fspath)
-        directory, filename = os.path.split(abspath)
-        return filename in os.listdir(directory)
-
-    def _add_defaults_standards(self):
-        standards = [self.READMES, self.distribution.script_name]
-        for fn in standards:
-            if isinstance(fn, tuple):
-                alts = fn
-                got_it = False
-                for fn in alts:
-                    if self._cs_path_exists(fn):
-                        got_it = True
-                        self.filelist.append(fn)
-                        break
-
-                if not got_it:
-                    self.warn("standard file not found: should have one of " +
-                              ', '.join(alts))
-            else:
-                if self._cs_path_exists(fn):
-                    self.filelist.append(fn)
-                else:
-                    self.warn("standard file '%s' not found" % fn)
-
-    def _add_defaults_optional(self):
-        optional = ['test/test*.py', 'setup.cfg']
-        for pattern in optional:
-            files = filter(os.path.isfile, glob(pattern))
-            self.filelist.extend(files)
-
-    def _add_defaults_python(self):
-        # build_py is used to get:
-        #  - python modules
-        #  - files defined in package_data
-        build_py = self.get_finalized_command('build_py')
-
-        # getting python files
-        if self.distribution.has_pure_modules():
-            self.filelist.extend(build_py.get_source_files())
-
-        # getting package_data files
-        # (computed in build_py.data_files by build_py.finalize_options)
-        for pkg, src_dir, build_dir, filenames in build_py.data_files:
-            for filename in filenames:
-                self.filelist.append(os.path.join(src_dir, filename))
-
-    def _add_defaults_data_files(self):
-        # getting distribution.data_files
-        if self.distribution.has_data_files():
-            for item in self.distribution.data_files:
-                if isinstance(item, str):
-                    # plain file
-                    item = convert_path(item)
-                    if os.path.isfile(item):
-                        self.filelist.append(item)
-                else:
-                    # a (dirname, filenames) tuple
-                    dirname, filenames = item
-                    for f in filenames:
-                        f = convert_path(f)
-                        if os.path.isfile(f):
-                            self.filelist.append(f)
-
-    def _add_defaults_ext(self):
-        if self.distribution.has_ext_modules():
-            build_ext = self.get_finalized_command('build_ext')
-            self.filelist.extend(build_ext.get_source_files())
-
-    def _add_defaults_c_libs(self):
-        if self.distribution.has_c_libraries():
-            build_clib = self.get_finalized_command('build_clib')
-            self.filelist.extend(build_clib.get_source_files())
-
-    def _add_defaults_scripts(self):
-        if self.distribution.has_scripts():
-            build_scripts = self.get_finalized_command('build_scripts')
-            self.filelist.extend(build_scripts.get_source_files())
-
-
-if hasattr(sdist.sdist, '_add_defaults_standards'):
-    # disable the functionality already available upstream
-    class sdist_add_defaults:
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/register.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/register.py
deleted file mode 100644
index 8d6336a14..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/register.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import distutils.command.register as orig
-
-
-class register(orig.register):
-    __doc__ = orig.register.__doc__
-
-    def run(self):
-        # Make sure that we are using valid current name/version info
-        self.run_command('egg_info')
-        orig.register.run(self)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/rotate.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/rotate.py
deleted file mode 100644
index b89353f52..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/rotate.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import os
-import shutil
-
-from setuptools.extern import six
-
-from setuptools import Command
-
-
-class rotate(Command):
-    """Delete older distributions"""
-
-    description = "delete older distributions, keeping N newest files"
-    user_options = [
-        ('match=', 'm', "patterns to match (required)"),
-        ('dist-dir=', 'd', "directory where the distributions are"),
-        ('keep=', 'k', "number of matching distributions to keep"),
-    ]
-
-    boolean_options = []
-
-    def initialize_options(self):
-        self.match = None
-        self.dist_dir = None
-        self.keep = None
-
-    def finalize_options(self):
-        if self.match is None:
-            raise DistutilsOptionError(
-                "Must specify one or more (comma-separated) match patterns "
-                "(e.g. '.zip' or '.egg')"
-            )
-        if self.keep is None:
-            raise DistutilsOptionError("Must specify number of files to keep")
-        try:
-            self.keep = int(self.keep)
-        except ValueError:
-            raise DistutilsOptionError("--keep must be an integer")
-        if isinstance(self.match, six.string_types):
-            self.match = [
-                convert_path(p.strip()) for p in self.match.split(',')
-            ]
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-
-    def run(self):
-        self.run_command("egg_info")
-        from glob import glob
-
-        for pattern in self.match:
-            pattern = self.distribution.get_name() + '*' + pattern
-            files = glob(os.path.join(self.dist_dir, pattern))
-            files = [(os.path.getmtime(f), f) for f in files]
-            files.sort()
-            files.reverse()
-
-            log.info("%d file(s) matching %s", len(files), pattern)
-            files = files[self.keep:]
-            for (t, f) in files:
-                log.info("Deleting %s", f)
-                if not self.dry_run:
-                    if os.path.isdir(f):
-                        shutil.rmtree(f)
-                    else:
-                        os.unlink(f)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/saveopts.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/saveopts.py
deleted file mode 100644
index 611cec552..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/saveopts.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from setuptools.command.setopt import edit_config, option_base
-
-
-class saveopts(option_base):
-    """Save command-line options to a file"""
-
-    description = "save supplied options to setup.cfg or other config file"
-
-    def run(self):
-        dist = self.distribution
-        settings = {}
-
-        for cmd in dist.command_options:
-
-            if cmd == 'saveopts':
-                continue  # don't save our own options!
-
-            for opt, (src, val) in dist.get_option_dict(cmd).items():
-                if src == "command line":
-                    settings.setdefault(cmd, {})[opt] = val
-
-        edit_config(self.filename, settings, self.dry_run)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/sdist.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/sdist.py
deleted file mode 100644
index 84e29a1b7..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/sdist.py
+++ /dev/null
@@ -1,206 +0,0 @@
-from distutils import log
-import distutils.command.sdist as orig
-import os
-import sys
-import io
-import contextlib
-
-from setuptools.extern import six
-
-from .py36compat import sdist_add_defaults
-
-import pkg_resources
-
-_default_revctrl = list
-
-
-def walk_revctrl(dirname=''):
-    """Find all files under revision control"""
-    for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
-        for item in ep.load()(dirname):
-            yield item
-
-
-class sdist(sdist_add_defaults, orig.sdist):
-    """Smart sdist that finds anything supported by revision control"""
-
-    user_options = [
-        ('formats=', None,
-         "formats for source distribution (comma-separated list)"),
-        ('keep-temp', 'k',
-         "keep the distribution tree around after creating " +
-         "archive file(s)"),
-        ('dist-dir=', 'd',
-         "directory to put the source distribution archive(s) in "
-         "[default: dist]"),
-    ]
-
-    negative_opt = {}
-
-    READMES = 'README', 'README.rst', 'README.txt'
-
-    def run(self):
-        self.run_command('egg_info')
-        ei_cmd = self.get_finalized_command('egg_info')
-        self.filelist = ei_cmd.filelist
-        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
-        self.check_readme()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        # Call check_metadata only if no 'check' command
-        # (distutils <= 2.6)
-        import distutils.command
-
-        if 'check' not in distutils.command.__all__:
-            self.check_metadata()
-
-        self.make_distribution()
-
-        dist_files = getattr(self.distribution, 'dist_files', [])
-        for file in self.archive_files:
-            data = ('sdist', '', file)
-            if data not in dist_files:
-                dist_files.append(data)
-
-    def initialize_options(self):
-        orig.sdist.initialize_options(self)
-
-        self._default_to_gztar()
-
-    def _default_to_gztar(self):
-        # only needed on Python prior to 3.6.
-        if sys.version_info >= (3, 6, 0, 'beta', 1):
-            return
-        self.formats = ['gztar']
-
-    def make_distribution(self):
-        """
-        Workaround for #516
-        """
-        with self._remove_os_link():
-            orig.sdist.make_distribution(self)
-
-    @staticmethod
-    @contextlib.contextmanager
-    def _remove_os_link():
-        """
-        In a context, remove and restore os.link if it exists
-        """
-
-        class NoValue:
-            pass
-
-        orig_val = getattr(os, 'link', NoValue)
-        try:
-            del os.link
-        except Exception:
-            pass
-        try:
-            yield
-        finally:
-            if orig_val is not NoValue:
-                setattr(os, 'link', orig_val)
-
-    def __read_template_hack(self):
-        # This grody hack closes the template file (MANIFEST.in) if an
-        #  exception occurs during read_template.
-        # Doing so prevents an error when easy_install attempts to delete the
-        #  file.
-        try:
-            orig.sdist.read_template(self)
-        except Exception:
-            _, _, tb = sys.exc_info()
-            tb.tb_next.tb_frame.f_locals['template'].close()
-            raise
-
-    # Beginning with Python 2.7.2, 3.1.4, and 3.2.1, this leaky file handle
-    #  has been fixed, so only override the method if we're using an earlier
-    #  Python.
-    has_leaky_handle = (
-        sys.version_info < (2, 7, 2)
-        or (3, 0) <= sys.version_info < (3, 1, 4)
-        or (3, 2) <= sys.version_info < (3, 2, 1)
-    )
-    if has_leaky_handle:
-        read_template = __read_template_hack
-
-    def _add_defaults_python(self):
-        """getting python files"""
-        if self.distribution.has_pure_modules():
-            build_py = self.get_finalized_command('build_py')
-            self.filelist.extend(build_py.get_source_files())
-            # This functionality is incompatible with include_package_data, and
-            # will in fact create an infinite recursion if include_package_data
-            # is True.  Use of include_package_data will imply that
-            # distutils-style automatic handling of package_data is disabled
-            if not self.distribution.include_package_data:
-                for _, src_dir, _, filenames in build_py.data_files:
-                    self.filelist.extend([os.path.join(src_dir, filename)
-                                          for filename in filenames])
-
-    def _add_defaults_data_files(self):
-        try:
-            if six.PY2:
-                sdist_add_defaults._add_defaults_data_files(self)
-            else:
-                super()._add_defaults_data_files()
-        except TypeError:
-            log.warn("data_files contains unexpected objects")
-
-    def check_readme(self):
-        for f in self.READMES:
-            if os.path.exists(f):
-                return
-        else:
-            self.warn(
-                "standard file not found: should have one of " +
-                ', '.join(self.READMES)
-            )
-
-    def make_release_tree(self, base_dir, files):
-        orig.sdist.make_release_tree(self, base_dir, files)
-
-        # Save any egg_info command line options used to create this sdist
-        dest = os.path.join(base_dir, 'setup.cfg')
-        if hasattr(os, 'link') and os.path.exists(dest):
-            # unlink and re-copy, since it might be hard-linked, and
-            # we don't want to change the source version
-            os.unlink(dest)
-            self.copy_file('setup.cfg', dest)
-
-        self.get_finalized_command('egg_info').save_version_info(dest)
-
-    def _manifest_is_not_generated(self):
-        # check for special comment used in 2.7.1 and higher
-        if not os.path.isfile(self.manifest):
-            return False
-
-        with io.open(self.manifest, 'rb') as fp:
-            first_line = fp.readline()
-        return (first_line !=
-                '# file GENERATED by distutils, do NOT edit\n'.encode())
-
-    def read_manifest(self):
-        """Read the manifest file (named by 'self.manifest') and use it to
-        fill in 'self.filelist', the list of files to include in the source
-        distribution.
-        """
-        log.info("reading manifest file '%s'", self.manifest)
-        manifest = open(self.manifest, 'rb')
-        for line in manifest:
-            # The manifest must contain UTF-8. See #303.
-            if six.PY3:
-                try:
-                    line = line.decode('UTF-8')
-                except UnicodeDecodeError:
-                    log.warn("%r not UTF-8 decodable -- skipping" % line)
-                    continue
-            # ignore comments and blank lines
-            line = line.strip()
-            if line.startswith('#') or not line:
-                continue
-            self.filelist.append(line)
-        manifest.close()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/setopt.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/setopt.py
deleted file mode 100644
index 7e57cc026..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/setopt.py
+++ /dev/null
@@ -1,149 +0,0 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import distutils
-import os
-
-from setuptools.extern.six.moves import configparser
-
-from setuptools import Command
-
-__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
-
-
-def config_file(kind="local"):
-    """Get the filename of the distutils, local, global, or per-user config
-
-    `kind` must be one of "local", "global", or "user"
-    """
-    if kind == 'local':
-        return 'setup.cfg'
-    if kind == 'global':
-        return os.path.join(
-            os.path.dirname(distutils.__file__), 'distutils.cfg'
-        )
-    if kind == 'user':
-        dot = os.name == 'posix' and '.' or ''
-        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
-    raise ValueError(
-        "config_file() type must be 'local', 'global', or 'user'", kind
-    )
-
-
-def edit_config(filename, settings, dry_run=False):
-    """Edit a configuration file to include `settings`
-
-    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
-    command/section name.  A ``None`` value means to delete the entire section,
-    while a dictionary lists settings to be changed or deleted in that section.
-    A setting of ``None`` means to delete that setting.
-    """
-    log.debug("Reading configuration from %s", filename)
-    opts = configparser.RawConfigParser()
-    opts.read([filename])
-    for section, options in settings.items():
-        if options is None:
-            log.info("Deleting section [%s] from %s", section, filename)
-            opts.remove_section(section)
-        else:
-            if not opts.has_section(section):
-                log.debug("Adding new section [%s] to %s", section, filename)
-                opts.add_section(section)
-            for option, value in options.items():
-                if value is None:
-                    log.debug(
-                        "Deleting %s.%s from %s",
-                        section, option, filename
-                    )
-                    opts.remove_option(section, option)
-                    if not opts.options(section):
-                        log.info("Deleting empty [%s] section from %s",
-                                 section, filename)
-                        opts.remove_section(section)
-                else:
-                    log.debug(
-                        "Setting %s.%s to %r in %s",
-                        section, option, value, filename
-                    )
-                    opts.set(section, option, value)
-
-    log.info("Writing %s", filename)
-    if not dry_run:
-        with open(filename, 'w') as f:
-            opts.write(f)
-
-
-class option_base(Command):
-    """Abstract base class for commands that mess with config files"""
-
-    user_options = [
-        ('global-config', 'g',
-         "save options to the site-wide distutils.cfg file"),
-        ('user-config', 'u',
-         "save options to the current user's pydistutils.cfg file"),
-        ('filename=', 'f',
-         "configuration file to use (default=setup.cfg)"),
-    ]
-
-    boolean_options = [
-        'global-config', 'user-config',
-    ]
-
-    def initialize_options(self):
-        self.global_config = None
-        self.user_config = None
-        self.filename = None
-
-    def finalize_options(self):
-        filenames = []
-        if self.global_config:
-            filenames.append(config_file('global'))
-        if self.user_config:
-            filenames.append(config_file('user'))
-        if self.filename is not None:
-            filenames.append(self.filename)
-        if not filenames:
-            filenames.append(config_file('local'))
-        if len(filenames) > 1:
-            raise DistutilsOptionError(
-                "Must specify only one configuration file option",
-                filenames
-            )
-        self.filename, = filenames
-
-
-class setopt(option_base):
-    """Save command-line options to a file"""
-
-    description = "set an option in setup.cfg or another config file"
-
-    user_options = [
-        ('command=', 'c', 'command to set an option for'),
-        ('option=', 'o', 'option to set'),
-        ('set-value=', 's', 'value of the option'),
-        ('remove', 'r', 'remove (unset) the value'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.command = None
-        self.option = None
-        self.set_value = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.command is None or self.option is None:
-            raise DistutilsOptionError("Must specify --command *and* --option")
-        if self.set_value is None and not self.remove:
-            raise DistutilsOptionError("Must specify --set-value or --remove")
-
-    def run(self):
-        edit_config(
-            self.filename, {
-                self.command: {self.option.replace('-', '_'): self.set_value}
-            },
-            self.dry_run
-        )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/test.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/test.py
deleted file mode 100644
index ef0af12f1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/test.py
+++ /dev/null
@@ -1,254 +0,0 @@
-import os
-import operator
-import sys
-import contextlib
-import itertools
-from distutils.errors import DistutilsError, DistutilsOptionError
-from distutils import log
-from unittest import TestLoader
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import map, filter
-
-from pkg_resources import (resource_listdir, resource_exists, normalize_path,
-                           working_set, _namespace_packages,
-                           add_activation_listener, require, EntryPoint)
-from setuptools import Command
-from setuptools.py31compat import unittest_main
-
-
-class ScanningLoader(TestLoader):
-    def loadTestsFromModule(self, module, pattern=None):
-        """Return a suite of all tests cases contained in the given module
-
-        If the module is a package, load tests from all the modules in it.
-        If the module has an ``additional_tests`` function, call it and add
-        the return value to the tests.
-        """
-        tests = []
-        tests.append(TestLoader.loadTestsFromModule(self, module))
-
-        if hasattr(module, "additional_tests"):
-            tests.append(module.additional_tests())
-
-        if hasattr(module, '__path__'):
-            for file in resource_listdir(module.__name__, ''):
-                if file.endswith('.py') and file != '__init__.py':
-                    submodule = module.__name__ + '.' + file[:-3]
-                else:
-                    if resource_exists(module.__name__, file + '/__init__.py'):
-                        submodule = module.__name__ + '.' + file
-                    else:
-                        continue
-                tests.append(self.loadTestsFromName(submodule))
-
-        if len(tests) != 1:
-            return self.suiteClass(tests)
-        else:
-            return tests[0]  # don't create a nested suite for only one return
-
-
-# adapted from jaraco.classes.properties:NonDataProperty
-class NonDataProperty(object):
-    def __init__(self, fget):
-        self.fget = fget
-
-    def __get__(self, obj, objtype=None):
-        if obj is None:
-            return self
-        return self.fget(obj)
-
-
-class test(Command):
-    """Command to run unit tests after in-place build"""
-
-    description = "run unit tests after in-place build"
-
-    user_options = [
-        ('test-module=', 'm', "Run 'test_suite' in specified module"),
-        ('test-suite=', 's',
-         "Test suite to run (e.g. 'some_module.test_suite')"),
-        ('test-runner=', 'r', "Test runner to use"),
-    ]
-
-    def initialize_options(self):
-        self.test_suite = None
-        self.test_module = None
-        self.test_loader = None
-        self.test_runner = None
-
-    def finalize_options(self):
-
-        if self.test_suite and self.test_module:
-            msg = "You may specify a module or a suite, but not both"
-            raise DistutilsOptionError(msg)
-
-        if self.test_suite is None:
-            if self.test_module is None:
-                self.test_suite = self.distribution.test_suite
-            else:
-                self.test_suite = self.test_module + ".test_suite"
-
-        if self.test_loader is None:
-            self.test_loader = getattr(self.distribution, 'test_loader', None)
-        if self.test_loader is None:
-            self.test_loader = "setuptools.command.test:ScanningLoader"
-        if self.test_runner is None:
-            self.test_runner = getattr(self.distribution, 'test_runner', None)
-
-    @NonDataProperty
-    def test_args(self):
-        return list(self._test_args())
-
-    def _test_args(self):
-        if self.verbose:
-            yield '--verbose'
-        if self.test_suite:
-            yield self.test_suite
-
-    def with_project_on_sys_path(self, func):
-        """
-        Backward compatibility for project_on_sys_path context.
-        """
-        with self.project_on_sys_path():
-            func()
-
-    @contextlib.contextmanager
-    def project_on_sys_path(self, include_dists=[]):
-        with_2to3 = six.PY3 and getattr(self.distribution, 'use_2to3', False)
-
-        if with_2to3:
-            # If we run 2to3 we can not do this inplace:
-
-            # Ensure metadata is up-to-date
-            self.reinitialize_command('build_py', inplace=0)
-            self.run_command('build_py')
-            bpy_cmd = self.get_finalized_command("build_py")
-            build_path = normalize_path(bpy_cmd.build_lib)
-
-            # Build extensions
-            self.reinitialize_command('egg_info', egg_base=build_path)
-            self.run_command('egg_info')
-
-            self.reinitialize_command('build_ext', inplace=0)
-            self.run_command('build_ext')
-        else:
-            # Without 2to3 inplace works fine:
-            self.run_command('egg_info')
-
-            # Build extensions in-place
-            self.reinitialize_command('build_ext', inplace=1)
-            self.run_command('build_ext')
-
-        ei_cmd = self.get_finalized_command("egg_info")
-
-        old_path = sys.path[:]
-        old_modules = sys.modules.copy()
-
-        try:
-            project_path = normalize_path(ei_cmd.egg_base)
-            sys.path.insert(0, project_path)
-            working_set.__init__()
-            add_activation_listener(lambda dist: dist.activate())
-            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
-            with self.paths_on_pythonpath([project_path]):
-                yield
-        finally:
-            sys.path[:] = old_path
-            sys.modules.clear()
-            sys.modules.update(old_modules)
-            working_set.__init__()
-
-    @staticmethod
-    @contextlib.contextmanager
-    def paths_on_pythonpath(paths):
-        """
-        Add the indicated paths to the head of the PYTHONPATH environment
-        variable so that subprocesses will also see the packages at
-        these paths.
-
-        Do this in a context that restores the value on exit.
-        """
-        nothing = object()
-        orig_pythonpath = os.environ.get('PYTHONPATH', nothing)
-        current_pythonpath = os.environ.get('PYTHONPATH', '')
-        try:
-            prefix = os.pathsep.join(paths)
-            to_join = filter(None, [prefix, current_pythonpath])
-            new_path = os.pathsep.join(to_join)
-            if new_path:
-                os.environ['PYTHONPATH'] = new_path
-            yield
-        finally:
-            if orig_pythonpath is nothing:
-                os.environ.pop('PYTHONPATH', None)
-            else:
-                os.environ['PYTHONPATH'] = orig_pythonpath
-
-    @staticmethod
-    def install_dists(dist):
-        """
-        Install the requirements indicated by self.distribution and
-        return an iterable of the dists that were built.
-        """
-        ir_d = dist.fetch_build_eggs(dist.install_requires or [])
-        tr_d = dist.fetch_build_eggs(dist.tests_require or [])
-        return itertools.chain(ir_d, tr_d)
-
-    def run(self):
-        installed_dists = self.install_dists(self.distribution)
-
-        cmd = ' '.join(self._argv)
-        if self.dry_run:
-            self.announce('skipping "%s" (dry run)' % cmd)
-            return
-
-        self.announce('running "%s"' % cmd)
-
-        paths = map(operator.attrgetter('location'), installed_dists)
-        with self.paths_on_pythonpath(paths):
-            with self.project_on_sys_path():
-                self.run_tests()
-
-    def run_tests(self):
-        # Purge modules under test from sys.modules. The test loader will
-        # re-import them from the build location. Required when 2to3 is used
-        # with namespace packages.
-        if six.PY3 and getattr(self.distribution, 'use_2to3', False):
-            module = self.test_suite.split('.')[0]
-            if module in _namespace_packages:
-                del_modules = []
-                if module in sys.modules:
-                    del_modules.append(module)
-                module += '.'
-                for name in sys.modules:
-                    if name.startswith(module):
-                        del_modules.append(name)
-                list(map(sys.modules.__delitem__, del_modules))
-
-        exit_kwarg = {} if sys.version_info < (2, 7) else {"exit": False}
-        test = unittest_main(
-            None, None, self._argv,
-            testLoader=self._resolve_as_ep(self.test_loader),
-            testRunner=self._resolve_as_ep(self.test_runner),
-            **exit_kwarg
-        )
-        if not test.result.wasSuccessful():
-            msg = 'Test failed: %s' % test.result
-            self.announce(msg, log.ERROR)
-            raise DistutilsError(msg)
-
-    @property
-    def _argv(self):
-        return ['unittest'] + self.test_args
-
-    @staticmethod
-    def _resolve_as_ep(val):
-        """
-        Load the indicated attribute value, called, as a as if it were
-        specified as an entry point.
-        """
-        if val is None:
-            return
-        parsed = EntryPoint.parse("x=" + val)
-        return parsed.resolve()()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload.py
deleted file mode 100644
index 484baa5a5..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import getpass
-from distutils.command import upload as orig
-
-
-class upload(orig.upload):
-    """
-    Override default upload behavior to obtain password
-    in a variety of different ways.
-    """
-
-    def finalize_options(self):
-        orig.upload.finalize_options(self)
-        # Attempt to obtain password. Short circuit evaluation at the first
-        # sign of success.
-        self.password = (
-            self.password or
-            self._load_password_from_keyring() or
-            self._prompt_for_password()
-        )
-
-    def _load_password_from_keyring(self):
-        """
-        Attempt to load password from keyring. Suppress Exceptions.
-        """
-        try:
-            keyring = __import__('keyring')
-            return keyring.get_password(self.repository, self.username)
-        except Exception:
-            pass
-
-    def _prompt_for_password(self):
-        """
-        Prompt for a password on the tty. Suppress Exceptions.
-        """
-        try:
-            return getpass.getpass()
-        except (Exception, KeyboardInterrupt):
-            pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload_docs.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload_docs.py
deleted file mode 100644
index 269dc2d50..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/command/upload_docs.py
+++ /dev/null
@@ -1,206 +0,0 @@
-# -*- coding: utf-8 -*-
-"""upload_docs
-
-Implements a Distutils 'upload_docs' subcommand (upload documentation to
-PyPI's pythonhosted.org).
-"""
-
-from base64 import standard_b64encode
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import os
-import socket
-import zipfile
-import tempfile
-import shutil
-import itertools
-import functools
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import http_client, urllib
-
-from pkg_resources import iter_entry_points
-from .upload import upload
-
-
-def _encode(s):
-    errors = 'surrogateescape' if six.PY3 else 'strict'
-    return s.encode('utf-8', errors)
-
-
-class upload_docs(upload):
-    # override the default repository as upload_docs isn't
-    # supported by Warehouse (and won't be).
-    DEFAULT_REPOSITORY = 'https://pypi.python.org/pypi/'
-
-    description = 'Upload documentation to PyPI'
-
-    user_options = [
-        ('repository=', 'r',
-         "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY),
-        ('show-response', None,
-         'display full response text from server'),
-        ('upload-dir=', None, 'directory to upload'),
-    ]
-    boolean_options = upload.boolean_options
-
-    def has_sphinx(self):
-        if self.upload_dir is None:
-            for ep in iter_entry_points('distutils.commands', 'build_sphinx'):
-                return True
-
-    sub_commands = [('build_sphinx', has_sphinx)]
-
-    def initialize_options(self):
-        upload.initialize_options(self)
-        self.upload_dir = None
-        self.target_dir = None
-
-    def finalize_options(self):
-        log.warn("Upload_docs command is deprecated. Use RTD instead.")
-        upload.finalize_options(self)
-        if self.upload_dir is None:
-            if self.has_sphinx():
-                build_sphinx = self.get_finalized_command('build_sphinx')
-                self.target_dir = build_sphinx.builder_target_dir
-            else:
-                build = self.get_finalized_command('build')
-                self.target_dir = os.path.join(build.build_base, 'docs')
-        else:
-            self.ensure_dirname('upload_dir')
-            self.target_dir = self.upload_dir
-        self.announce('Using upload directory %s' % self.target_dir)
-
-    def create_zipfile(self, filename):
-        zip_file = zipfile.ZipFile(filename, "w")
-        try:
-            self.mkpath(self.target_dir)  # just in case
-            for root, dirs, files in os.walk(self.target_dir):
-                if root == self.target_dir and not files:
-                    raise DistutilsOptionError(
-                        "no files found in upload directory '%s'"
-                        % self.target_dir)
-                for name in files:
-                    full = os.path.join(root, name)
-                    relative = root[len(self.target_dir):].lstrip(os.path.sep)
-                    dest = os.path.join(relative, name)
-                    zip_file.write(full, dest)
-        finally:
-            zip_file.close()
-
-    def run(self):
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        tmp_dir = tempfile.mkdtemp()
-        name = self.distribution.metadata.get_name()
-        zip_file = os.path.join(tmp_dir, "%s.zip" % name)
-        try:
-            self.create_zipfile(zip_file)
-            self.upload_file(zip_file)
-        finally:
-            shutil.rmtree(tmp_dir)
-
-    @staticmethod
-    def _build_part(item, sep_boundary):
-        key, values = item
-        title = '\nContent-Disposition: form-data; name="%s"' % key
-        # handle multiple entries for the same name
-        if not isinstance(values, list):
-            values = [values]
-        for value in values:
-            if isinstance(value, tuple):
-                title += '; filename="%s"' % value[0]
-                value = value[1]
-            else:
-                value = _encode(value)
-            yield sep_boundary
-            yield _encode(title)
-            yield b"\n\n"
-            yield value
-            if value and value[-1:] == b'\r':
-                yield b'\n'  # write an extra newline (lurve Macs)
-
-    @classmethod
-    def _build_multipart(cls, data):
-        """
-        Build up the MIME payload for the POST data
-        """
-        boundary = b'--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = b'\n--' + boundary
-        end_boundary = sep_boundary + b'--'
-        end_items = end_boundary, b"\n",
-        builder = functools.partial(
-            cls._build_part,
-            sep_boundary=sep_boundary,
-        )
-        part_groups = map(builder, data.items())
-        parts = itertools.chain.from_iterable(part_groups)
-        body_items = itertools.chain(parts, end_items)
-        content_type = 'multipart/form-data; boundary=%s' % boundary
-        return b''.join(body_items), content_type
-
-    def upload_file(self, filename):
-        with open(filename, 'rb') as f:
-            content = f.read()
-        meta = self.distribution.metadata
-        data = {
-            ':action': 'doc_upload',
-            'name': meta.get_name(),
-            'content': (os.path.basename(filename), content),
-        }
-        # set up the authentication
-        credentials = _encode(self.username + ':' + self.password)
-        credentials = standard_b64encode(credentials)
-        if six.PY3:
-            credentials = credentials.decode('ascii')
-        auth = "Basic " + credentials
-
-        body, ct = self._build_multipart(data)
-
-        self.announce("Submitting documentation to %s" % (self.repository),
-                      log.INFO)
-
-        # build the Request
-        # We can't use urllib2 since we need to send the Basic
-        # auth right with the first request
-        schema, netloc, url, params, query, fragments = \
-            urllib.parse.urlparse(self.repository)
-        assert not params and not query and not fragments
-        if schema == 'http':
-            conn = http_client.HTTPConnection(netloc)
-        elif schema == 'https':
-            conn = http_client.HTTPSConnection(netloc)
-        else:
-            raise AssertionError("unsupported schema " + schema)
-
-        data = ''
-        try:
-            conn.connect()
-            conn.putrequest("POST", url)
-            content_type = ct
-            conn.putheader('Content-type', content_type)
-            conn.putheader('Content-length', str(len(body)))
-            conn.putheader('Authorization', auth)
-            conn.endheaders()
-            conn.send(body)
-        except socket.error as e:
-            self.announce(str(e), log.ERROR)
-            return
-
-        r = conn.getresponse()
-        if r.status == 200:
-            self.announce('Server response (%s): %s' % (r.status, r.reason),
-                          log.INFO)
-        elif r.status == 301:
-            location = r.getheader('Location')
-            if location is None:
-                location = 'https://pythonhosted.org/%s/' % meta.get_name()
-            self.announce('Upload successful. Visit %s' % location,
-                          log.INFO)
-        else:
-            self.announce('Upload failed (%s): %s' % (r.status, r.reason),
-                          log.ERROR)
-        if self.show_response:
-            print('-' * 75, r.read(), '-' * 75)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/config.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/config.py
deleted file mode 100644
index d71ff028d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/config.py
+++ /dev/null
@@ -1,558 +0,0 @@
-from __future__ import absolute_import, unicode_literals
-import io
-import os
-import sys
-from collections import defaultdict
-from functools import partial
-
-from distutils.errors import DistutilsOptionError, DistutilsFileError
-from setuptools.py26compat import import_module
-from setuptools.extern.six import string_types
-
-
-def read_configuration(
-        filepath, find_others=False, ignore_option_errors=False):
-    """Read given configuration file and returns options from it as a dict.
-
-    :param str|unicode filepath: Path to configuration file
-        to get options from.
-
-    :param bool find_others: Whether to search for other configuration files
-        which could be on in various places.
-
-    :param bool ignore_option_errors: Whether to silently ignore
-        options, values of which could not be resolved (e.g. due to exceptions
-        in directives such as file:, attr:, etc.).
-        If False exceptions are propagated as expected.
-
-    :rtype: dict
-    """
-    from setuptools.dist import Distribution, _Distribution
-
-    filepath = os.path.abspath(filepath)
-
-    if not os.path.isfile(filepath):
-        raise DistutilsFileError(
-            'Configuration file %s does not exist.' % filepath)
-
-    current_directory = os.getcwd()
-    os.chdir(os.path.dirname(filepath))
-
-    try:
-        dist = Distribution()
-
-        filenames = dist.find_config_files() if find_others else []
-        if filepath not in filenames:
-            filenames.append(filepath)
-
-        _Distribution.parse_config_files(dist, filenames=filenames)
-
-        handlers = parse_configuration(
-            dist, dist.command_options,
-            ignore_option_errors=ignore_option_errors)
-
-    finally:
-        os.chdir(current_directory)
-
-    return configuration_to_dict(handlers)
-
-
-def configuration_to_dict(handlers):
-    """Returns configuration data gathered by given handlers as a dict.
-
-    :param list[ConfigHandler] handlers: Handlers list,
-        usually from parse_configuration()
-
-    :rtype: dict
-    """
-    config_dict = defaultdict(dict)
-
-    for handler in handlers:
-
-        obj_alias = handler.section_prefix
-        target_obj = handler.target_obj
-
-        for option in handler.set_options:
-            getter = getattr(target_obj, 'get_%s' % option, None)
-
-            if getter is None:
-                value = getattr(target_obj, option)
-
-            else:
-                value = getter()
-
-            config_dict[obj_alias][option] = value
-
-    return config_dict
-
-
-def parse_configuration(
-        distribution, command_options, ignore_option_errors=False):
-    """Performs additional parsing of configuration options
-    for a distribution.
-
-    Returns a list of used option handlers.
-
-    :param Distribution distribution:
-    :param dict command_options:
-    :param bool ignore_option_errors: Whether to silently ignore
-        options, values of which could not be resolved (e.g. due to exceptions
-        in directives such as file:, attr:, etc.).
-        If False exceptions are propagated as expected.
-    :rtype: list
-    """
-    meta = ConfigMetadataHandler(
-        distribution.metadata, command_options, ignore_option_errors)
-    meta.parse()
-
-    options = ConfigOptionsHandler(
-        distribution, command_options, ignore_option_errors)
-    options.parse()
-
-    return [meta, options]
-
-
-class ConfigHandler(object):
-    """Handles metadata supplied in configuration files."""
-
-    section_prefix = None
-    """Prefix for config sections handled by this handler.
-    Must be provided by class heirs.
-
-    """
-
-    aliases = {}
-    """Options aliases.
-    For compatibility with various packages. E.g.: d2to1 and pbr.
-    Note: `-` in keys is replaced with `_` by config parser.
-
-    """
-
-    def __init__(self, target_obj, options, ignore_option_errors=False):
-        sections = {}
-
-        section_prefix = self.section_prefix
-        for section_name, section_options in options.items():
-            if not section_name.startswith(section_prefix):
-                continue
-
-            section_name = section_name.replace(section_prefix, '').strip('.')
-            sections[section_name] = section_options
-
-        self.ignore_option_errors = ignore_option_errors
-        self.target_obj = target_obj
-        self.sections = sections
-        self.set_options = []
-
-    @property
-    def parsers(self):
-        """Metadata item name to parser function mapping."""
-        raise NotImplementedError(
-            '%s must provide .parsers property' % self.__class__.__name__)
-
-    def __setitem__(self, option_name, value):
-        unknown = tuple()
-        target_obj = self.target_obj
-
-        # Translate alias into real name.
-        option_name = self.aliases.get(option_name, option_name)
-
-        current_value = getattr(target_obj, option_name, unknown)
-
-        if current_value is unknown:
-            raise KeyError(option_name)
-
-        if current_value:
-            # Already inhabited. Skipping.
-            return
-
-        skip_option = False
-        parser = self.parsers.get(option_name)
-        if parser:
-            try:
-                value = parser(value)
-
-            except Exception:
-                skip_option = True
-                if not self.ignore_option_errors:
-                    raise
-
-        if skip_option:
-            return
-
-        setter = getattr(target_obj, 'set_%s' % option_name, None)
-        if setter is None:
-            setattr(target_obj, option_name, value)
-        else:
-            setter(value)
-
-        self.set_options.append(option_name)
-
-    @classmethod
-    def _parse_list(cls, value, separator=','):
-        """Represents value as a list.
-
-        Value is split either by separator (defaults to comma) or by lines.
-
-        :param value:
-        :param separator: List items separator character.
-        :rtype: list
-        """
-        if isinstance(value, list):  # _get_parser_compound case
-            return value
-
-        if '\n' in value:
-            value = value.splitlines()
-        else:
-            value = value.split(separator)
-
-        return [chunk.strip() for chunk in value if chunk.strip()]
-
-    @classmethod
-    def _parse_dict(cls, value):
-        """Represents value as a dict.
-
-        :param value:
-        :rtype: dict
-        """
-        separator = '='
-        result = {}
-        for line in cls._parse_list(value):
-            key, sep, val = line.partition(separator)
-            if sep != separator:
-                raise DistutilsOptionError(
-                    'Unable to parse option value to dict: %s' % value)
-            result[key.strip()] = val.strip()
-
-        return result
-
-    @classmethod
-    def _parse_bool(cls, value):
-        """Represents value as boolean.
-
-        :param value:
-        :rtype: bool
-        """
-        value = value.lower()
-        return value in ('1', 'true', 'yes')
-
-    @classmethod
-    def _parse_file(cls, value):
-        """Represents value as a string, allowing including text
-        from nearest files using `file:` directive.
-
-        Directive is sandboxed and won't reach anything outside
-        directory with setup.py.
-
-        Examples:
-            include: LICENSE
-            include: src/file.txt
-
-        :param str value:
-        :rtype: str
-        """
-        if not isinstance(value, string_types):
-            return value
-
-        include_directive = 'file:'
-        if not value.startswith(include_directive):
-            return value
-
-        current_directory = os.getcwd()
-
-        filepath = value.replace(include_directive, '').strip()
-        filepath = os.path.abspath(filepath)
-
-        if not filepath.startswith(current_directory):
-            raise DistutilsOptionError(
-                '`file:` directive can not access %s' % filepath)
-
-        if os.path.isfile(filepath):
-            with io.open(filepath, encoding='utf-8') as f:
-                value = f.read()
-
-        return value
-
-    @classmethod
-    def _parse_attr(cls, value):
-        """Represents value as a module attribute.
-
-        Examples:
-            attr: package.attr
-            attr: package.module.attr
-
-        :param str value:
-        :rtype: str
-        """
-        attr_directive = 'attr:'
-        if not value.startswith(attr_directive):
-            return value
-
-        attrs_path = value.replace(attr_directive, '').strip().split('.')
-        attr_name = attrs_path.pop()
-
-        module_name = '.'.join(attrs_path)
-        module_name = module_name or '__init__'
-
-        sys.path.insert(0, os.getcwd())
-        try:
-            module = import_module(module_name)
-            value = getattr(module, attr_name)
-
-        finally:
-            sys.path = sys.path[1:]
-
-        return value
-
-    @classmethod
-    def _get_parser_compound(cls, *parse_methods):
-        """Returns parser function to represents value as a list.
-
-        Parses a value applying given methods one after another.
-
-        :param parse_methods:
-        :rtype: callable
-        """
-        def parse(value):
-            parsed = value
-
-            for method in parse_methods:
-                parsed = method(parsed)
-
-            return parsed
-
-        return parse
-
-    @classmethod
-    def _parse_section_to_dict(cls, section_options, values_parser=None):
-        """Parses section options into a dictionary.
-
-        Optionally applies a given parser to values.
-
-        :param dict section_options:
-        :param callable values_parser:
-        :rtype: dict
-        """
-        value = {}
-        values_parser = values_parser or (lambda val: val)
-        for key, (_, val) in section_options.items():
-            value[key] = values_parser(val)
-        return value
-
-    def parse_section(self, section_options):
-        """Parses configuration file section.
-
-        :param dict section_options:
-        """
-        for (name, (_, value)) in section_options.items():
-            try:
-                self[name] = value
-
-            except KeyError:
-                pass  # Keep silent for a new option may appear anytime.
-
-    def parse(self):
-        """Parses configuration file items from one
-        or more related sections.
-
-        """
-        for section_name, section_options in self.sections.items():
-
-            method_postfix = ''
-            if section_name:  # [section.option] variant
-                method_postfix = '_%s' % section_name
-
-            section_parser_method = getattr(
-                self,
-                # Dots in section names are tranlsated into dunderscores.
-                ('parse_section%s' % method_postfix).replace('.', '__'),
-                None)
-
-            if section_parser_method is None:
-                raise DistutilsOptionError(
-                    'Unsupported distribution option section: [%s.%s]' % (
-                        self.section_prefix, section_name))
-
-            section_parser_method(section_options)
-
-
-class ConfigMetadataHandler(ConfigHandler):
-
-    section_prefix = 'metadata'
-
-    aliases = {
-        'home_page': 'url',
-        'summary': 'description',
-        'classifier': 'classifiers',
-        'platform': 'platforms',
-    }
-
-    strict_mode = False
-    """We need to keep it loose, to be partially compatible with
-    `pbr` and `d2to1` packages which also uses `metadata` section.
-
-    """
-
-    @property
-    def parsers(self):
-        """Metadata item name to parser function mapping."""
-        parse_list = self._parse_list
-        parse_file = self._parse_file
-
-        return {
-            'platforms': parse_list,
-            'keywords': parse_list,
-            'provides': parse_list,
-            'requires': parse_list,
-            'obsoletes': parse_list,
-            'classifiers': self._get_parser_compound(parse_file, parse_list),
-            'license': parse_file,
-            'description': parse_file,
-            'long_description': parse_file,
-            'version': self._parse_version,
-        }
-
-    def parse_section_classifiers(self, section_options):
-        """Parses configuration file section.
-
-        :param dict section_options:
-        """
-        classifiers = []
-        for begin, (_, rest) in section_options.items():
-            classifiers.append('%s :%s' % (begin.title(), rest))
-
-        self['classifiers'] = classifiers
-
-    def _parse_version(self, value):
-        """Parses `version` option value.
-
-        :param value:
-        :rtype: str
-
-        """
-        version = self._parse_attr(value)
-
-        if callable(version):
-            version = version()
-
-        if not isinstance(version, string_types):
-            if hasattr(version, '__iter__'):
-                version = '.'.join(map(str, version))
-            else:
-                version = '%s' % version
-
-        return version
-
-
-class ConfigOptionsHandler(ConfigHandler):
-
-    section_prefix = 'options'
-
-    @property
-    def parsers(self):
-        """Metadata item name to parser function mapping."""
-        parse_list = self._parse_list
-        parse_list_semicolon = partial(self._parse_list, separator=';')
-        parse_bool = self._parse_bool
-        parse_dict = self._parse_dict
-
-        return {
-            'zip_safe': parse_bool,
-            'use_2to3': parse_bool,
-            'include_package_data': parse_bool,
-            'package_dir': parse_dict,
-            'use_2to3_fixers': parse_list,
-            'use_2to3_exclude_fixers': parse_list,
-            'convert_2to3_doctests': parse_list,
-            'scripts': parse_list,
-            'eager_resources': parse_list,
-            'dependency_links': parse_list,
-            'namespace_packages': parse_list,
-            'install_requires': parse_list_semicolon,
-            'setup_requires': parse_list_semicolon,
-            'tests_require': parse_list_semicolon,
-            'packages': self._parse_packages,
-            'entry_points': self._parse_file,
-        }
-
-    def _parse_packages(self, value):
-        """Parses `packages` option value.
-
-        :param value:
-        :rtype: list
-        """
-        find_directive = 'find:'
-
-        if not value.startswith(find_directive):
-            return self._parse_list(value)
-
-        # Read function arguments from a dedicated section.
-        find_kwargs = self.parse_section_packages__find(
-            self.sections.get('packages.find', {}))
-
-        from setuptools import find_packages
-
-        return find_packages(**find_kwargs)
-
-    def parse_section_packages__find(self, section_options):
-        """Parses `packages.find` configuration file section.
-
-        To be used in conjunction with _parse_packages().
-
-        :param dict section_options:
-        """
-        section_data = self._parse_section_to_dict(
-            section_options, self._parse_list)
-
-        valid_keys = ['where', 'include', 'exclude']
-
-        find_kwargs = dict(
-            [(k, v) for k, v in section_data.items() if k in valid_keys and v])
-
-        where = find_kwargs.get('where')
-        if where is not None:
-            find_kwargs['where'] = where[0]  # cast list to single val
-
-        return find_kwargs
-
-    def parse_section_entry_points(self, section_options):
-        """Parses `entry_points` configuration file section.
-
-        :param dict section_options:
-        """
-        parsed = self._parse_section_to_dict(section_options, self._parse_list)
-        self['entry_points'] = parsed
-
-    def _parse_package_data(self, section_options):
-        parsed = self._parse_section_to_dict(section_options, self._parse_list)
-
-        root = parsed.get('*')
-        if root:
-            parsed[''] = root
-            del parsed['*']
-
-        return parsed
-
-    def parse_section_package_data(self, section_options):
-        """Parses `package_data` configuration file section.
-
-        :param dict section_options:
-        """
-        self['package_data'] = self._parse_package_data(section_options)
-
-    def parse_section_exclude_package_data(self, section_options):
-        """Parses `exclude_package_data` configuration file section.
-
-        :param dict section_options:
-        """
-        self['exclude_package_data'] = self._parse_package_data(
-            section_options)
-
-    def parse_section_extras_require(self, section_options):
-        """Parses `extras_require` configuration file section.
-
-        :param dict section_options:
-        """
-        parse_list = partial(self._parse_list, separator=';')
-        self['extras_require'] = self._parse_section_to_dict(
-            section_options, parse_list)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/depends.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/depends.py
deleted file mode 100644
index 45e7052d8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/depends.py
+++ /dev/null
@@ -1,186 +0,0 @@
-import sys
-import imp
-import marshal
-from distutils.version import StrictVersion
-from imp import PKG_DIRECTORY, PY_COMPILED, PY_SOURCE, PY_FROZEN
-
-from .py33compat import Bytecode
-
-
-__all__ = [
-    'Require', 'find_module', 'get_module_constant', 'extract_constant'
-]
-
-
-class Require:
-    """A prerequisite to building or installing a distribution"""
-
-    def __init__(self, name, requested_version, module, homepage='',
-            attribute=None, format=None):
-
-        if format is None and requested_version is not None:
-            format = StrictVersion
-
-        if format is not None:
-            requested_version = format(requested_version)
-            if attribute is None:
-                attribute = '__version__'
-
-        self.__dict__.update(locals())
-        del self.self
-
-    def full_name(self):
-        """Return full package/distribution name, w/version"""
-        if self.requested_version is not None:
-            return '%s-%s' % (self.name, self.requested_version)
-        return self.name
-
-    def version_ok(self, version):
-        """Is 'version' sufficiently up-to-date?"""
-        return self.attribute is None or self.format is None or \
-            str(version) != "unknown" and version >= self.requested_version
-
-    def get_version(self, paths=None, default="unknown"):
-        """Get version number of installed module, 'None', or 'default'
-
-        Search 'paths' for module.  If not found, return 'None'.  If found,
-        return the extracted version attribute, or 'default' if no version
-        attribute was specified, or the value cannot be determined without
-        importing the module.  The version is formatted according to the
-        requirement's version format (if any), unless it is 'None' or the
-        supplied 'default'.
-        """
-
-        if self.attribute is None:
-            try:
-                f, p, i = find_module(self.module, paths)
-                if f:
-                    f.close()
-                return default
-            except ImportError:
-                return None
-
-        v = get_module_constant(self.module, self.attribute, default, paths)
-
-        if v is not None and v is not default and self.format is not None:
-            return self.format(v)
-
-        return v
-
-    def is_present(self, paths=None):
-        """Return true if dependency is present on 'paths'"""
-        return self.get_version(paths) is not None
-
-    def is_current(self, paths=None):
-        """Return true if dependency is present and up-to-date on 'paths'"""
-        version = self.get_version(paths)
-        if version is None:
-            return False
-        return self.version_ok(version)
-
-
-def find_module(module, paths=None):
-    """Just like 'imp.find_module()', but with package support"""
-
-    parts = module.split('.')
-
-    while parts:
-        part = parts.pop(0)
-        f, path, (suffix, mode, kind) = info = imp.find_module(part, paths)
-
-        if kind == PKG_DIRECTORY:
-            parts = parts or ['__init__']
-            paths = [path]
-
-        elif parts:
-            raise ImportError("Can't find %r in %s" % (parts, module))
-
-    return info
-
-
-def get_module_constant(module, symbol, default=-1, paths=None):
-    """Find 'module' by searching 'paths', and extract 'symbol'
-
-    Return 'None' if 'module' does not exist on 'paths', or it does not define
-    'symbol'.  If the module defines 'symbol' as a constant, return the
-    constant.  Otherwise, return 'default'."""
-
-    try:
-        f, path, (suffix, mode, kind) = find_module(module, paths)
-    except ImportError:
-        # Module doesn't exist
-        return None
-
-    try:
-        if kind == PY_COMPILED:
-            f.read(8)  # skip magic & date
-            code = marshal.load(f)
-        elif kind == PY_FROZEN:
-            code = imp.get_frozen_object(module)
-        elif kind == PY_SOURCE:
-            code = compile(f.read(), path, 'exec')
-        else:
-            # Not something we can parse; we'll have to import it.  :(
-            if module not in sys.modules:
-                imp.load_module(module, f, path, (suffix, mode, kind))
-            return getattr(sys.modules[module], symbol, None)
-
-    finally:
-        if f:
-            f.close()
-
-    return extract_constant(code, symbol, default)
-
-
-def extract_constant(code, symbol, default=-1):
-    """Extract the constant value of 'symbol' from 'code'
-
-    If the name 'symbol' is bound to a constant value by the Python code
-    object 'code', return that value.  If 'symbol' is bound to an expression,
-    return 'default'.  Otherwise, return 'None'.
-
-    Return value is based on the first assignment to 'symbol'.  'symbol' must
-    be a global, or at least a non-"fast" local in the code block.  That is,
-    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
-    must be present in 'code.co_names'.
-    """
-    if symbol not in code.co_names:
-        # name's not there, can't possibly be an assignment
-        return None
-
-    name_idx = list(code.co_names).index(symbol)
-
-    STORE_NAME = 90
-    STORE_GLOBAL = 97
-    LOAD_CONST = 100
-
-    const = default
-
-    for byte_code in Bytecode(code):
-        op = byte_code.opcode
-        arg = byte_code.arg
-
-        if op == LOAD_CONST:
-            const = code.co_consts[arg]
-        elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
-            return const
-        else:
-            const = default
-
-
-def _update_globals():
-    """
-    Patch the globals to remove the objects not available on some platforms.
-
-    XXX it'd be better to test assertions about bytecode instead.
-    """
-
-    if not sys.platform.startswith('java') and sys.platform != 'cli':
-        return
-    incompatible = 'extract_constant', 'get_module_constant'
-    for name in incompatible:
-        del globals()[name]
-        __all__.remove(name)
-
-
-_update_globals()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/dist.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/dist.py
deleted file mode 100644
index 159464be2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/dist.py
+++ /dev/null
@@ -1,925 +0,0 @@
-__all__ = ['Distribution']
-
-import re
-import os
-import warnings
-import numbers
-import distutils.log
-import distutils.core
-import distutils.cmd
-import distutils.dist
-from distutils.errors import (DistutilsOptionError, DistutilsPlatformError,
-    DistutilsSetupError)
-from distutils.util import rfc822_escape
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import map
-from pkg_resources.extern import packaging
-
-from setuptools.depends import Require
-from setuptools import windows_support
-from setuptools.monkey import get_unpatched
-from setuptools.config import parse_configuration
-import pkg_resources
-from .py36compat import Distribution_parse_config_files
-
-
-def _get_unpatched(cls):
-    warnings.warn("Do not call this function", DeprecationWarning)
-    return get_unpatched(cls)
-
-
-# Based on Python 3.5 version
-def write_pkg_file(self, file):
-    """Write the PKG-INFO format data to a file object.
-    """
-    version = '1.0'
-    if (self.provides or self.requires or self.obsoletes or
-            self.classifiers or self.download_url):
-        version = '1.1'
-    # Setuptools specific for PEP 345
-    if hasattr(self, 'python_requires'):
-        version = '1.2'
-
-    file.write('Metadata-Version: %s\n' % version)
-    file.write('Name: %s\n' % self.get_name())
-    file.write('Version: %s\n' % self.get_version())
-    file.write('Summary: %s\n' % self.get_description())
-    file.write('Home-page: %s\n' % self.get_url())
-    file.write('Author: %s\n' % self.get_contact())
-    file.write('Author-email: %s\n' % self.get_contact_email())
-    file.write('License: %s\n' % self.get_license())
-    if self.download_url:
-        file.write('Download-URL: %s\n' % self.download_url)
-
-    long_desc = rfc822_escape(self.get_long_description())
-    file.write('Description: %s\n' % long_desc)
-
-    keywords = ','.join(self.get_keywords())
-    if keywords:
-        file.write('Keywords: %s\n' % keywords)
-
-    self._write_list(file, 'Platform', self.get_platforms())
-    self._write_list(file, 'Classifier', self.get_classifiers())
-
-    # PEP 314
-    self._write_list(file, 'Requires', self.get_requires())
-    self._write_list(file, 'Provides', self.get_provides())
-    self._write_list(file, 'Obsoletes', self.get_obsoletes())
-
-    # Setuptools specific for PEP 345
-    if hasattr(self, 'python_requires'):
-        file.write('Requires-Python: %s\n' % self.python_requires)
-
-
-# from Python 3.4
-def write_pkg_info(self, base_dir):
-    """Write the PKG-INFO file into the release tree.
-    """
-    with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
-              encoding='UTF-8') as pkg_info:
-        self.write_pkg_file(pkg_info)
-
-
-sequence = tuple, list
-
-
-def check_importable(dist, attr, value):
-    try:
-        ep = pkg_resources.EntryPoint.parse('x=' + value)
-        assert not ep.extras
-    except (TypeError, ValueError, AttributeError, AssertionError):
-        raise DistutilsSetupError(
-            "%r must be importable 'module:attrs' string (got %r)"
-            % (attr, value)
-        )
-
-
-def assert_string_list(dist, attr, value):
-    """Verify that value is a string list or None"""
-    try:
-        assert ''.join(value) != value
-    except (TypeError, ValueError, AttributeError, AssertionError):
-        raise DistutilsSetupError(
-            "%r must be a list of strings (got %r)" % (attr, value)
-        )
-
-
-def check_nsp(dist, attr, value):
-    """Verify that namespace packages are valid"""
-    ns_packages = value
-    assert_string_list(dist, attr, ns_packages)
-    for nsp in ns_packages:
-        if not dist.has_contents_for(nsp):
-            raise DistutilsSetupError(
-                "Distribution contains no modules or packages for " +
-                "namespace package %r" % nsp
-            )
-        parent, sep, child = nsp.rpartition('.')
-        if parent and parent not in ns_packages:
-            distutils.log.warn(
-                "WARNING: %r is declared as a package namespace, but %r"
-                " is not: please correct this in setup.py", nsp, parent
-            )
-
-
-def check_extras(dist, attr, value):
-    """Verify that extras_require mapping is valid"""
-    try:
-        for k, v in value.items():
-            if ':' in k:
-                k, m = k.split(':', 1)
-                if pkg_resources.invalid_marker(m):
-                    raise DistutilsSetupError("Invalid environment marker: " + m)
-            list(pkg_resources.parse_requirements(v))
-    except (TypeError, ValueError, AttributeError):
-        raise DistutilsSetupError(
-            "'extras_require' must be a dictionary whose values are "
-            "strings or lists of strings containing valid project/version "
-            "requirement specifiers."
-        )
-
-
-def assert_bool(dist, attr, value):
-    """Verify that value is True, False, 0, or 1"""
-    if bool(value) != value:
-        tmpl = "{attr!r} must be a boolean value (got {value!r})"
-        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
-
-
-def check_requirements(dist, attr, value):
-    """Verify that install_requires is a valid requirements list"""
-    try:
-        list(pkg_resources.parse_requirements(value))
-    except (TypeError, ValueError) as error:
-        tmpl = (
-            "{attr!r} must be a string or list of strings "
-            "containing valid project/version requirement specifiers; {error}"
-        )
-        raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
-
-
-def check_specifier(dist, attr, value):
-    """Verify that value is a valid version specifier"""
-    try:
-        packaging.specifiers.SpecifierSet(value)
-    except packaging.specifiers.InvalidSpecifier as error:
-        tmpl = (
-            "{attr!r} must be a string or list of strings "
-            "containing valid version specifiers; {error}"
-        )
-        raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
-
-
-def check_entry_points(dist, attr, value):
-    """Verify that entry_points map is parseable"""
-    try:
-        pkg_resources.EntryPoint.parse_map(value)
-    except ValueError as e:
-        raise DistutilsSetupError(e)
-
-
-def check_test_suite(dist, attr, value):
-    if not isinstance(value, six.string_types):
-        raise DistutilsSetupError("test_suite must be a string")
-
-
-def check_package_data(dist, attr, value):
-    """Verify that value is a dictionary of package names to glob lists"""
-    if isinstance(value, dict):
-        for k, v in value.items():
-            if not isinstance(k, str):
-                break
-            try:
-                iter(v)
-            except TypeError:
-                break
-        else:
-            return
-    raise DistutilsSetupError(
-        attr + " must be a dictionary mapping package names to lists of "
-        "wildcard patterns"
-    )
-
-
-def check_packages(dist, attr, value):
-    for pkgname in value:
-        if not re.match(r'\w+(\.\w+)*', pkgname):
-            distutils.log.warn(
-                "WARNING: %r not a valid package name; please use only "
-                ".-separated package names in setup.py", pkgname
-            )
-
-
-_Distribution = get_unpatched(distutils.core.Distribution)
-
-
-class Distribution(Distribution_parse_config_files, _Distribution):
-    """Distribution with support for features, tests, and package data
-
-    This is an enhanced version of 'distutils.dist.Distribution' that
-    effectively adds the following new optional keyword arguments to 'setup()':
-
-     'install_requires' -- a string or sequence of strings specifying project
-        versions that the distribution requires when installed, in the format
-        used by 'pkg_resources.require()'.  They will be installed
-        automatically when the package is installed.  If you wish to use
-        packages that are not available in PyPI, or want to give your users an
-        alternate download location, you can add a 'find_links' option to the
-        '[easy_install]' section of your project's 'setup.cfg' file, and then
-        setuptools will scan the listed web pages for links that satisfy the
-        requirements.
-
-     'extras_require' -- a dictionary mapping names of optional "extras" to the
-        additional requirement(s) that using those extras incurs. For example,
-        this::
-
-            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
-
-        indicates that the distribution can optionally provide an extra
-        capability called "reST", but it can only be used if docutils and
-        reSTedit are installed.  If the user installs your package using
-        EasyInstall and requests one of your extras, the corresponding
-        additional requirements will be installed if needed.
-
-     'features' **deprecated** -- a dictionary mapping option names to
-        'setuptools.Feature'
-        objects.  Features are a portion of the distribution that can be
-        included or excluded based on user options, inter-feature dependencies,
-        and availability on the current system.  Excluded features are omitted
-        from all setup commands, including source and binary distributions, so
-        you can create multiple distributions from the same source tree.
-        Feature names should be valid Python identifiers, except that they may
-        contain the '-' (minus) sign.  Features can be included or excluded
-        via the command line options '--with-X' and '--without-X', where 'X' is
-        the name of the feature.  Whether a feature is included by default, and
-        whether you are allowed to control this from the command line, is
-        determined by the Feature object.  See the 'Feature' class for more
-        information.
-
-     'test_suite' -- the name of a test suite to run for the 'test' command.
-        If the user runs 'python setup.py test', the package will be installed,
-        and the named test suite will be run.  The format is the same as
-        would be used on a 'unittest.py' command line.  That is, it is the
-        dotted name of an object to import and call to generate a test suite.
-
-     'package_data' -- a dictionary mapping package names to lists of filenames
-        or globs to use to find data files contained in the named packages.
-        If the dictionary has filenames or globs listed under '""' (the empty
-        string), those names will be searched for in every package, in addition
-        to any names for the specific package.  Data files found using these
-        names/globs will be installed along with the package, in the same
-        location as the package.  Note that globs are allowed to reference
-        the contents of non-package subdirectories, as long as you use '/' as
-        a path separator.  (Globs are automatically converted to
-        platform-specific paths at runtime.)
-
-    In addition to these new keywords, this class also has several new methods
-    for manipulating the distribution's contents.  For example, the 'include()'
-    and 'exclude()' methods can be thought of as in-place add and subtract
-    commands that add or remove packages, modules, extensions, and so on from
-    the distribution.  They are used by the feature subsystem to configure the
-    distribution for the included and excluded features.
-    """
-
-    _patched_dist = None
-
-    def patch_missing_pkg_info(self, attrs):
-        # Fake up a replacement for the data that would normally come from
-        # PKG-INFO, but which might not yet be built if this is a fresh
-        # checkout.
-        #
-        if not attrs or 'name' not in attrs or 'version' not in attrs:
-            return
-        key = pkg_resources.safe_name(str(attrs['name'])).lower()
-        dist = pkg_resources.working_set.by_key.get(key)
-        if dist is not None and not dist.has_metadata('PKG-INFO'):
-            dist._version = pkg_resources.safe_version(str(attrs['version']))
-            self._patched_dist = dist
-
-    def __init__(self, attrs=None):
-        have_package_data = hasattr(self, "package_data")
-        if not have_package_data:
-            self.package_data = {}
-        _attrs_dict = attrs or {}
-        if 'features' in _attrs_dict or 'require_features' in _attrs_dict:
-            Feature.warn_deprecated()
-        self.require_features = []
-        self.features = {}
-        self.dist_files = []
-        self.src_root = attrs and attrs.pop("src_root", None)
-        self.patch_missing_pkg_info(attrs)
-        # Make sure we have any eggs needed to interpret 'attrs'
-        if attrs is not None:
-            self.dependency_links = attrs.pop('dependency_links', [])
-            assert_string_list(self, 'dependency_links', self.dependency_links)
-        if attrs and 'setup_requires' in attrs:
-            self.fetch_build_eggs(attrs['setup_requires'])
-        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
-            vars(self).setdefault(ep.name, None)
-        _Distribution.__init__(self, attrs)
-        if isinstance(self.metadata.version, numbers.Number):
-            # Some people apparently take "version number" too literally :)
-            self.metadata.version = str(self.metadata.version)
-
-        if self.metadata.version is not None:
-            try:
-                ver = packaging.version.Version(self.metadata.version)
-                normalized_version = str(ver)
-                if self.metadata.version != normalized_version:
-                    warnings.warn(
-                        "Normalizing '%s' to '%s'" % (
-                            self.metadata.version,
-                            normalized_version,
-                        )
-                    )
-                    self.metadata.version = normalized_version
-            except (packaging.version.InvalidVersion, TypeError):
-                warnings.warn(
-                    "The version specified (%r) is an invalid version, this "
-                    "may not work as expected with newer versions of "
-                    "setuptools, pip, and PyPI. Please see PEP 440 for more "
-                    "details." % self.metadata.version
-                )
-        if getattr(self, 'python_requires', None):
-            self.metadata.python_requires = self.python_requires
-
-    def parse_config_files(self, filenames=None):
-        """Parses configuration files from various levels
-        and loads configuration.
-
-        """
-        _Distribution.parse_config_files(self, filenames=filenames)
-
-        parse_configuration(self, self.command_options)
-
-    def parse_command_line(self):
-        """Process features after parsing command line options"""
-        result = _Distribution.parse_command_line(self)
-        if self.features:
-            self._finalize_features()
-        return result
-
-    def _feature_attrname(self, name):
-        """Convert feature name to corresponding option attribute name"""
-        return 'with_' + name.replace('-', '_')
-
-    def fetch_build_eggs(self, requires):
-        """Resolve pre-setup requirements"""
-        resolved_dists = pkg_resources.working_set.resolve(
-            pkg_resources.parse_requirements(requires),
-            installer=self.fetch_build_egg,
-            replace_conflicting=True,
-        )
-        for dist in resolved_dists:
-            pkg_resources.working_set.add(dist, replace=True)
-        return resolved_dists
-
-    def finalize_options(self):
-        _Distribution.finalize_options(self)
-        if self.features:
-            self._set_global_opts_from_features()
-
-        for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
-            value = getattr(self, ep.name, None)
-            if value is not None:
-                ep.require(installer=self.fetch_build_egg)
-                ep.load()(self, ep.name, value)
-        if getattr(self, 'convert_2to3_doctests', None):
-            # XXX may convert to set here when we can rely on set being builtin
-            self.convert_2to3_doctests = [os.path.abspath(p) for p in self.convert_2to3_doctests]
-        else:
-            self.convert_2to3_doctests = []
-
-    def get_egg_cache_dir(self):
-        egg_cache_dir = os.path.join(os.curdir, '.eggs')
-        if not os.path.exists(egg_cache_dir):
-            os.mkdir(egg_cache_dir)
-            windows_support.hide_file(egg_cache_dir)
-            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
-            with open(readme_txt_filename, 'w') as f:
-                f.write('This directory contains eggs that were downloaded '
-                        'by setuptools to build, test, and run plug-ins.\n\n')
-                f.write('This directory caches those eggs to prevent '
-                        'repeated downloads.\n\n')
-                f.write('However, it is safe to delete this directory.\n\n')
-
-        return egg_cache_dir
-
-    def fetch_build_egg(self, req):
-        """Fetch an egg needed for building"""
-
-        try:
-            cmd = self._egg_fetcher
-            cmd.package_index.to_scan = []
-        except AttributeError:
-            from setuptools.command.easy_install import easy_install
-            dist = self.__class__({'script_args': ['easy_install']})
-            dist.parse_config_files()
-            opts = dist.get_option_dict('easy_install')
-            keep = (
-                'find_links', 'site_dirs', 'index_url', 'optimize',
-                'site_dirs', 'allow_hosts'
-            )
-            for key in list(opts):
-                if key not in keep:
-                    del opts[key]  # don't use any other settings
-            if self.dependency_links:
-                links = self.dependency_links[:]
-                if 'find_links' in opts:
-                    links = opts['find_links'][1].split() + links
-                opts['find_links'] = ('setup', links)
-            install_dir = self.get_egg_cache_dir()
-            cmd = easy_install(
-                dist, args=["x"], install_dir=install_dir, exclude_scripts=True,
-                always_copy=False, build_directory=None, editable=False,
-                upgrade=False, multi_version=True, no_report=True, user=False
-            )
-            cmd.ensure_finalized()
-            self._egg_fetcher = cmd
-        return cmd.easy_install(req)
-
-    def _set_global_opts_from_features(self):
-        """Add --with-X/--without-X options based on optional features"""
-
-        go = []
-        no = self.negative_opt.copy()
-
-        for name, feature in self.features.items():
-            self._set_feature(name, None)
-            feature.validate(self)
-
-            if feature.optional:
-                descr = feature.description
-                incdef = ' (default)'
-                excdef = ''
-                if not feature.include_by_default():
-                    excdef, incdef = incdef, excdef
-
-                go.append(('with-' + name, None, 'include ' + descr + incdef))
-                go.append(('without-' + name, None, 'exclude ' + descr + excdef))
-                no['without-' + name] = 'with-' + name
-
-        self.global_options = self.feature_options = go + self.global_options
-        self.negative_opt = self.feature_negopt = no
-
-    def _finalize_features(self):
-        """Add/remove features and resolve dependencies between them"""
-
-        # First, flag all the enabled items (and thus their dependencies)
-        for name, feature in self.features.items():
-            enabled = self.feature_is_included(name)
-            if enabled or (enabled is None and feature.include_by_default()):
-                feature.include_in(self)
-                self._set_feature(name, 1)
-
-        # Then disable the rest, so that off-by-default features don't
-        # get flagged as errors when they're required by an enabled feature
-        for name, feature in self.features.items():
-            if not self.feature_is_included(name):
-                feature.exclude_from(self)
-                self._set_feature(name, 0)
-
-    def get_command_class(self, command):
-        """Pluggable version of get_command_class()"""
-        if command in self.cmdclass:
-            return self.cmdclass[command]
-
-        for ep in pkg_resources.iter_entry_points('distutils.commands', command):
-            ep.require(installer=self.fetch_build_egg)
-            self.cmdclass[command] = cmdclass = ep.load()
-            return cmdclass
-        else:
-            return _Distribution.get_command_class(self, command)
-
-    def print_commands(self):
-        for ep in pkg_resources.iter_entry_points('distutils.commands'):
-            if ep.name not in self.cmdclass:
-                # don't require extras as the commands won't be invoked
-                cmdclass = ep.resolve()
-                self.cmdclass[ep.name] = cmdclass
-        return _Distribution.print_commands(self)
-
-    def get_command_list(self):
-        for ep in pkg_resources.iter_entry_points('distutils.commands'):
-            if ep.name not in self.cmdclass:
-                # don't require extras as the commands won't be invoked
-                cmdclass = ep.resolve()
-                self.cmdclass[ep.name] = cmdclass
-        return _Distribution.get_command_list(self)
-
-    def _set_feature(self, name, status):
-        """Set feature's inclusion status"""
-        setattr(self, self._feature_attrname(name), status)
-
-    def feature_is_included(self, name):
-        """Return 1 if feature is included, 0 if excluded, 'None' if unknown"""
-        return getattr(self, self._feature_attrname(name))
-
-    def include_feature(self, name):
-        """Request inclusion of feature named 'name'"""
-
-        if self.feature_is_included(name) == 0:
-            descr = self.features[name].description
-            raise DistutilsOptionError(
-                descr + " is required, but was excluded or is not available"
-            )
-        self.features[name].include_in(self)
-        self._set_feature(name, 1)
-
-    def include(self, **attrs):
-        """Add items to distribution that are named in keyword arguments
-
-        For example, 'dist.exclude(py_modules=["x"])' would add 'x' to
-        the distribution's 'py_modules' attribute, if it was not already
-        there.
-
-        Currently, this method only supports inclusion for attributes that are
-        lists or tuples.  If you need to add support for adding to other
-        attributes in this or a subclass, you can add an '_include_X' method,
-        where 'X' is the name of the attribute.  The method will be called with
-        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})'
-        will try to call 'dist._include_foo({"bar":"baz"})', which can then
-        handle whatever special inclusion logic is needed.
-        """
-        for k, v in attrs.items():
-            include = getattr(self, '_include_' + k, None)
-            if include:
-                include(v)
-            else:
-                self._include_misc(k, v)
-
-    def exclude_package(self, package):
-        """Remove packages, modules, and extensions in named package"""
-
-        pfx = package + '.'
-        if self.packages:
-            self.packages = [
-                p for p in self.packages
-                if p != package and not p.startswith(pfx)
-            ]
-
-        if self.py_modules:
-            self.py_modules = [
-                p for p in self.py_modules
-                if p != package and not p.startswith(pfx)
-            ]
-
-        if self.ext_modules:
-            self.ext_modules = [
-                p for p in self.ext_modules
-                if p.name != package and not p.name.startswith(pfx)
-            ]
-
-    def has_contents_for(self, package):
-        """Return true if 'exclude_package(package)' would do something"""
-
-        pfx = package + '.'
-
-        for p in self.iter_distribution_names():
-            if p == package or p.startswith(pfx):
-                return True
-
-    def _exclude_misc(self, name, value):
-        """Handle 'exclude()' for list/tuple attrs without a special handler"""
-        if not isinstance(value, sequence):
-            raise DistutilsSetupError(
-                "%s: setting must be a list or tuple (%r)" % (name, value)
-            )
-        try:
-            old = getattr(self, name)
-        except AttributeError:
-            raise DistutilsSetupError(
-                "%s: No such distribution setting" % name
-            )
-        if old is not None and not isinstance(old, sequence):
-            raise DistutilsSetupError(
-                name + ": this setting cannot be changed via include/exclude"
-            )
-        elif old:
-            setattr(self, name, [item for item in old if item not in value])
-
-    def _include_misc(self, name, value):
-        """Handle 'include()' for list/tuple attrs without a special handler"""
-
-        if not isinstance(value, sequence):
-            raise DistutilsSetupError(
-                "%s: setting must be a list (%r)" % (name, value)
-            )
-        try:
-            old = getattr(self, name)
-        except AttributeError:
-            raise DistutilsSetupError(
-                "%s: No such distribution setting" % name
-            )
-        if old is None:
-            setattr(self, name, value)
-        elif not isinstance(old, sequence):
-            raise DistutilsSetupError(
-                name + ": this setting cannot be changed via include/exclude"
-            )
-        else:
-            setattr(self, name, old + [item for item in value if item not in old])
-
-    def exclude(self, **attrs):
-        """Remove items from distribution that are named in keyword arguments
-
-        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
-        the distribution's 'py_modules' attribute.  Excluding packages uses
-        the 'exclude_package()' method, so all of the package's contained
-        packages, modules, and extensions are also excluded.
-
-        Currently, this method only supports exclusion from attributes that are
-        lists or tuples.  If you need to add support for excluding from other
-        attributes in this or a subclass, you can add an '_exclude_X' method,
-        where 'X' is the name of the attribute.  The method will be called with
-        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})'
-        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
-        handle whatever special exclusion logic is needed.
-        """
-        for k, v in attrs.items():
-            exclude = getattr(self, '_exclude_' + k, None)
-            if exclude:
-                exclude(v)
-            else:
-                self._exclude_misc(k, v)
-
-    def _exclude_packages(self, packages):
-        if not isinstance(packages, sequence):
-            raise DistutilsSetupError(
-                "packages: setting must be a list or tuple (%r)" % (packages,)
-            )
-        list(map(self.exclude_package, packages))
-
-    def _parse_command_opts(self, parser, args):
-        # Remove --with-X/--without-X options when processing command args
-        self.global_options = self.__class__.global_options
-        self.negative_opt = self.__class__.negative_opt
-
-        # First, expand any aliases
-        command = args[0]
-        aliases = self.get_option_dict('aliases')
-        while command in aliases:
-            src, alias = aliases[command]
-            del aliases[command]  # ensure each alias can expand only once!
-            import shlex
-            args[:1] = shlex.split(alias, True)
-            command = args[0]
-
-        nargs = _Distribution._parse_command_opts(self, parser, args)
-
-        # Handle commands that want to consume all remaining arguments
-        cmd_class = self.get_command_class(command)
-        if getattr(cmd_class, 'command_consumes_arguments', None):
-            self.get_option_dict(command)['args'] = ("command line", nargs)
-            if nargs is not None:
-                return []
-
-        return nargs
-
-    def get_cmdline_options(self):
-        """Return a '{cmd: {opt:val}}' map of all command-line options
-
-        Option names are all long, but do not include the leading '--', and
-        contain dashes rather than underscores.  If the option doesn't take
-        an argument (e.g. '--quiet'), the 'val' is 'None'.
-
-        Note that options provided by config files are intentionally excluded.
-        """
-
-        d = {}
-
-        for cmd, opts in self.command_options.items():
-
-            for opt, (src, val) in opts.items():
-
-                if src != "command line":
-                    continue
-
-                opt = opt.replace('_', '-')
-
-                if val == 0:
-                    cmdobj = self.get_command_obj(cmd)
-                    neg_opt = self.negative_opt.copy()
-                    neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
-                    for neg, pos in neg_opt.items():
-                        if pos == opt:
-                            opt = neg
-                            val = None
-                            break
-                    else:
-                        raise AssertionError("Shouldn't be able to get here")
-
-                elif val == 1:
-                    val = None
-
-                d.setdefault(cmd, {})[opt] = val
-
-        return d
-
-    def iter_distribution_names(self):
-        """Yield all packages, modules, and extension names in distribution"""
-
-        for pkg in self.packages or ():
-            yield pkg
-
-        for module in self.py_modules or ():
-            yield module
-
-        for ext in self.ext_modules or ():
-            if isinstance(ext, tuple):
-                name, buildinfo = ext
-            else:
-                name = ext.name
-            if name.endswith('module'):
-                name = name[:-6]
-            yield name
-
-    def handle_display_options(self, option_order):
-        """If there were any non-global "display-only" options
-        (--help-commands or the metadata display options) on the command
-        line, display the requested info and return true; else return
-        false.
-        """
-        import sys
-
-        if six.PY2 or self.help_commands:
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Stdout may be StringIO (e.g. in tests)
-        import io
-        if not isinstance(sys.stdout, io.TextIOWrapper):
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Don't wrap stdout if utf-8 is already the encoding. Provides
-        #  workaround for #334.
-        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
-            return _Distribution.handle_display_options(self, option_order)
-
-        # Print metadata in UTF-8 no matter the platform
-        encoding = sys.stdout.encoding
-        errors = sys.stdout.errors
-        newline = sys.platform != 'win32' and '\n' or None
-        line_buffering = sys.stdout.line_buffering
-
-        sys.stdout = io.TextIOWrapper(
-            sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
-        try:
-            return _Distribution.handle_display_options(self, option_order)
-        finally:
-            sys.stdout = io.TextIOWrapper(
-                sys.stdout.detach(), encoding, errors, newline, line_buffering)
-
-
-class Feature:
-    """
-    **deprecated** -- The `Feature` facility was never completely implemented
-    or supported, `has reported issues
-    <https://github.com/pypa/setuptools/issues/58>`_ and will be removed in
-    a future version.
-
-    A subset of the distribution that can be excluded if unneeded/wanted
-
-    Features are created using these keyword arguments:
-
-      'description' -- a short, human readable description of the feature, to
-         be used in error messages, and option help messages.
-
-      'standard' -- if true, the feature is included by default if it is
-         available on the current system.  Otherwise, the feature is only
-         included if requested via a command line '--with-X' option, or if
-         another included feature requires it.  The default setting is 'False'.
-
-      'available' -- if true, the feature is available for installation on the
-         current system.  The default setting is 'True'.
-
-      'optional' -- if true, the feature's inclusion can be controlled from the
-         command line, using the '--with-X' or '--without-X' options.  If
-         false, the feature's inclusion status is determined automatically,
-         based on 'availabile', 'standard', and whether any other feature
-         requires it.  The default setting is 'True'.
-
-      'require_features' -- a string or sequence of strings naming features
-         that should also be included if this feature is included.  Defaults to
-         empty list.  May also contain 'Require' objects that should be
-         added/removed from the distribution.
-
-      'remove' -- a string or list of strings naming packages to be removed
-         from the distribution if this feature is *not* included.  If the
-         feature *is* included, this argument is ignored.  This argument exists
-         to support removing features that "crosscut" a distribution, such as
-         defining a 'tests' feature that removes all the 'tests' subpackages
-         provided by other features.  The default for this argument is an empty
-         list.  (Note: the named package(s) or modules must exist in the base
-         distribution when the 'setup()' function is initially called.)
-
-      other keywords -- any other keyword arguments are saved, and passed to
-         the distribution's 'include()' and 'exclude()' methods when the
-         feature is included or excluded, respectively.  So, for example, you
-         could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be
-         added or removed from the distribution as appropriate.
-
-    A feature must include at least one 'requires', 'remove', or other
-    keyword argument.  Otherwise, it can't affect the distribution in any way.
-    Note also that you can subclass 'Feature' to create your own specialized
-    feature types that modify the distribution in other ways when included or
-    excluded.  See the docstrings for the various methods here for more detail.
-    Aside from the methods, the only feature attributes that distributions look
-    at are 'description' and 'optional'.
-    """
-
-    @staticmethod
-    def warn_deprecated():
-        warnings.warn(
-            "Features are deprecated and will be removed in a future "
-                "version. See https://github.com/pypa/setuptools/issues/65.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-
-    def __init__(self, description, standard=False, available=True,
-            optional=True, require_features=(), remove=(), **extras):
-        self.warn_deprecated()
-
-        self.description = description
-        self.standard = standard
-        self.available = available
-        self.optional = optional
-        if isinstance(require_features, (str, Require)):
-            require_features = require_features,
-
-        self.require_features = [
-            r for r in require_features if isinstance(r, str)
-        ]
-        er = [r for r in require_features if not isinstance(r, str)]
-        if er:
-            extras['require_features'] = er
-
-        if isinstance(remove, str):
-            remove = remove,
-        self.remove = remove
-        self.extras = extras
-
-        if not remove and not require_features and not extras:
-            raise DistutilsSetupError(
-                "Feature %s: must define 'require_features', 'remove', or at least one"
-                " of 'packages', 'py_modules', etc."
-            )
-
-    def include_by_default(self):
-        """Should this feature be included by default?"""
-        return self.available and self.standard
-
-    def include_in(self, dist):
-        """Ensure feature and its requirements are included in distribution
-
-        You may override this in a subclass to perform additional operations on
-        the distribution.  Note that this method may be called more than once
-        per feature, and so should be idempotent.
-
-        """
-
-        if not self.available:
-            raise DistutilsPlatformError(
-                self.description + " is required, "
-                "but is not available on this platform"
-            )
-
-        dist.include(**self.extras)
-
-        for f in self.require_features:
-            dist.include_feature(f)
-
-    def exclude_from(self, dist):
-        """Ensure feature is excluded from distribution
-
-        You may override this in a subclass to perform additional operations on
-        the distribution.  This method will be called at most once per
-        feature, and only after all included features have been asked to
-        include themselves.
-        """
-
-        dist.exclude(**self.extras)
-
-        if self.remove:
-            for item in self.remove:
-                dist.exclude_package(item)
-
-    def validate(self, dist):
-        """Verify that feature makes sense in context of distribution
-
-        This method is called by the distribution just before it parses its
-        command line.  It checks to ensure that the 'remove' attribute, if any,
-        contains only valid package/module names that are present in the base
-        distribution when 'setup()' is called.  You may override it in a
-        subclass to perform any other required validation of the feature
-        against a target distribution.
-        """
-
-        for item in self.remove:
-            if not dist.has_contents_for(item):
-                raise DistutilsSetupError(
-                    "%s wants to be able to remove %s, but the distribution"
-                    " doesn't contain any packages or modules under %s"
-                    % (self.description, item, item)
-                )
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extension.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extension.py
deleted file mode 100644
index 29468894f..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extension.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import re
-import functools
-import distutils.core
-import distutils.errors
-import distutils.extension
-
-from setuptools.extern.six.moves import map
-
-from .monkey import get_unpatched
-
-
-def _have_cython():
-    """
-    Return True if Cython can be imported.
-    """
-    cython_impl = 'Cython.Distutils.build_ext'
-    try:
-        # from (cython_impl) import build_ext
-        __import__(cython_impl, fromlist=['build_ext']).build_ext
-        return True
-    except Exception:
-        pass
-    return False
-
-
-# for compatibility
-have_pyrex = _have_cython
-
-_Extension = get_unpatched(distutils.core.Extension)
-
-
-class Extension(_Extension):
-    """Extension that uses '.c' files in place of '.pyx' files"""
-
-    def __init__(self, name, sources, *args, **kw):
-        # The *args is needed for compatibility as calls may use positional
-        # arguments. py_limited_api may be set only via keyword.
-        self.py_limited_api = kw.pop("py_limited_api", False)
-        _Extension.__init__(self, name, sources, *args, **kw)
-
-    def _convert_pyx_sources_to_lang(self):
-        """
-        Replace sources with .pyx extensions to sources with the target
-        language extension. This mechanism allows language authors to supply
-        pre-converted sources but to prefer the .pyx sources.
-        """
-        if _have_cython():
-            # the build has Cython, so allow it to compile the .pyx files
-            return
-        lang = self.language or ''
-        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
-        sub = functools.partial(re.sub, '.pyx$', target_ext)
-        self.sources = list(map(sub, self.sources))
-
-
-class Library(Extension):
-    """Just like a regular Extension, but built as a library instead"""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__init__.py
deleted file mode 100644
index 2cd08b7ed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from pkg_resources.extern import VendorImporter
-
-names = 'six',
-VendorImporter(__name__, names, 'pkg_resources._vendor').install()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 459d64759..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/extern/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/glob.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/glob.py
deleted file mode 100644
index 6c781de34..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/glob.py
+++ /dev/null
@@ -1,176 +0,0 @@
-"""
-Filename globbing utility. Mostly a copy of `glob` from Python 3.5.
-
-Changes include:
- * `yield from` and PEP3102 `*` removed.
- * `bytes` changed to `six.binary_type`.
- * Hidden files are not ignored.
-"""
-
-import os
-import re
-import fnmatch
-from setuptools.extern.six import binary_type
-
-__all__ = ["glob", "iglob", "escape"]
-
-
-def glob(pathname, recursive=False):
-    """Return a list of paths matching a pathname pattern.
-
-    The pattern may contain simple shell-style wildcards a la
-    fnmatch. However, unlike fnmatch, filenames starting with a
-    dot are special cases that are not matched by '*' and '?'
-    patterns.
-
-    If recursive is true, the pattern '**' will match any files and
-    zero or more directories and subdirectories.
-    """
-    return list(iglob(pathname, recursive=recursive))
-
-
-def iglob(pathname, recursive=False):
-    """Return an iterator which yields the paths matching a pathname pattern.
-
-    The pattern may contain simple shell-style wildcards a la
-    fnmatch. However, unlike fnmatch, filenames starting with a
-    dot are special cases that are not matched by '*' and '?'
-    patterns.
-
-    If recursive is true, the pattern '**' will match any files and
-    zero or more directories and subdirectories.
-    """
-    it = _iglob(pathname, recursive)
-    if recursive and _isrecursive(pathname):
-        s = next(it)  # skip empty string
-        assert not s
-    return it
-
-
-def _iglob(pathname, recursive):
-    dirname, basename = os.path.split(pathname)
-    if not has_magic(pathname):
-        if basename:
-            if os.path.lexists(pathname):
-                yield pathname
-        else:
-            # Patterns ending with a slash should match only directories
-            if os.path.isdir(dirname):
-                yield pathname
-        return
-    if not dirname:
-        if recursive and _isrecursive(basename):
-            for x in glob2(dirname, basename):
-                yield x
-        else:
-            for x in glob1(dirname, basename):
-                yield x
-        return
-    # `os.path.split()` returns the argument itself as a dirname if it is a
-    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path
-    # contains magic characters (i.e. r'\\?\C:').
-    if dirname != pathname and has_magic(dirname):
-        dirs = _iglob(dirname, recursive)
-    else:
-        dirs = [dirname]
-    if has_magic(basename):
-        if recursive and _isrecursive(basename):
-            glob_in_dir = glob2
-        else:
-            glob_in_dir = glob1
-    else:
-        glob_in_dir = glob0
-    for dirname in dirs:
-        for name in glob_in_dir(dirname, basename):
-            yield os.path.join(dirname, name)
-
-
-# These 2 helper functions non-recursively glob inside a literal directory.
-# They return a list of basenames. `glob1` accepts a pattern while `glob0`
-# takes a literal basename (so it only has to check for its existence).
-
-
-def glob1(dirname, pattern):
-    if not dirname:
-        if isinstance(pattern, binary_type):
-            dirname = os.curdir.encode('ASCII')
-        else:
-            dirname = os.curdir
-    try:
-        names = os.listdir(dirname)
-    except OSError:
-        return []
-    return fnmatch.filter(names, pattern)
-
-
-def glob0(dirname, basename):
-    if not basename:
-        # `os.path.split()` returns an empty basename for paths ending with a
-        # directory separator.  'q*x/' should match only directories.
-        if os.path.isdir(dirname):
-            return [basename]
-    else:
-        if os.path.lexists(os.path.join(dirname, basename)):
-            return [basename]
-    return []
-
-
-# This helper function recursively yields relative pathnames inside a literal
-# directory.
-
-
-def glob2(dirname, pattern):
-    assert _isrecursive(pattern)
-    yield pattern[:0]
-    for x in _rlistdir(dirname):
-        yield x
-
-
-# Recursively yields relative pathnames inside a literal directory.
-def _rlistdir(dirname):
-    if not dirname:
-        if isinstance(dirname, binary_type):
-            dirname = binary_type(os.curdir, 'ASCII')
-        else:
-            dirname = os.curdir
-    try:
-        names = os.listdir(dirname)
-    except os.error:
-        return
-    for x in names:
-        yield x
-        path = os.path.join(dirname, x) if dirname else x
-        for y in _rlistdir(path):
-            yield os.path.join(x, y)
-
-
-magic_check = re.compile('([*?[])')
-magic_check_bytes = re.compile(b'([*?[])')
-
-
-def has_magic(s):
-    if isinstance(s, binary_type):
-        match = magic_check_bytes.search(s)
-    else:
-        match = magic_check.search(s)
-    return match is not None
-
-
-def _isrecursive(pattern):
-    if isinstance(pattern, binary_type):
-        return pattern == b'**'
-    else:
-        return pattern == '**'
-
-
-def escape(pathname):
-    """Escape all special characters.
-    """
-    # Escaping is done by wrapping any of "*?[" between square brackets.
-    # Metacharacters do not work in the drive part and shouldn't be escaped.
-    drive, pathname = os.path.splitdrive(pathname)
-    if isinstance(pathname, binary_type):
-        pathname = magic_check_bytes.sub(br'[\1]', pathname)
-    else:
-        pathname = magic_check.sub(r'[\1]', pathname)
-    return drive + pathname
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-32.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-32.exe
deleted file mode 100644
index f8d350965..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-32.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-64.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-64.exe
deleted file mode 100644
index 330c51a5d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui-64.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui.exe b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui.exe
deleted file mode 100644
index f8d350965..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/gui.exe and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/launch.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/launch.py
deleted file mode 100644
index 308283ea9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/launch.py
+++ /dev/null
@@ -1,35 +0,0 @@
-"""
-Launch the Python script on the command line after
-setuptools is bootstrapped via import.
-"""
-
-# Note that setuptools gets imported implicitly by the
-# invocation of this script using python -m setuptools.launch
-
-import tokenize
-import sys
-
-
-def run():
-    """
-    Run the script in sys.argv[1] as if it had
-    been invoked naturally.
-    """
-    __builtins__
-    script_name = sys.argv[1]
-    namespace = dict(
-        __file__=script_name,
-        __name__='__main__',
-        __doc__=None,
-    )
-    sys.argv[:] = sys.argv[1:]
-
-    open_ = getattr(tokenize, 'open', open)
-    script = open_(script_name).read()
-    norm_script = script.replace('\\r\\n', '\\n')
-    code = compile(norm_script, script_name, 'exec')
-    exec(code, namespace)
-
-
-if __name__ == '__main__':
-    run()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/lib2to3_ex.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/lib2to3_ex.py
deleted file mode 100644
index 4b1a73feb..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/lib2to3_ex.py
+++ /dev/null
@@ -1,62 +0,0 @@
-"""
-Customized Mixin2to3 support:
-
- - adds support for converting doctests
-
-
-This module raises an ImportError on Python 2.
-"""
-
-from distutils.util import Mixin2to3 as _Mixin2to3
-from distutils import log
-from lib2to3.refactor import RefactoringTool, get_fixers_from_package
-
-import setuptools
-
-
-class DistutilsRefactoringTool(RefactoringTool):
-    def log_error(self, msg, *args, **kw):
-        log.error(msg, *args)
-
-    def log_message(self, msg, *args):
-        log.info(msg, *args)
-
-    def log_debug(self, msg, *args):
-        log.debug(msg, *args)
-
-
-class Mixin2to3(_Mixin2to3):
-    def run_2to3(self, files, doctests=False):
-        # See of the distribution option has been set, otherwise check the
-        # setuptools default.
-        if self.distribution.use_2to3 is not True:
-            return
-        if not files:
-            return
-        log.info("Fixing " + " ".join(files))
-        self.__build_fixer_names()
-        self.__exclude_fixers()
-        if doctests:
-            if setuptools.run_2to3_on_doctests:
-                r = DistutilsRefactoringTool(self.fixer_names)
-                r.refactor(files, write=True, doctests_only=True)
-        else:
-            _Mixin2to3.run_2to3(self, files)
-
-    def __build_fixer_names(self):
-        if self.fixer_names:
-            return
-        self.fixer_names = []
-        for p in setuptools.lib2to3_fixer_packages:
-            self.fixer_names.extend(get_fixers_from_package(p))
-        if self.distribution.use_2to3_fixers is not None:
-            for p in self.distribution.use_2to3_fixers:
-                self.fixer_names.extend(get_fixers_from_package(p))
-
-    def __exclude_fixers(self):
-        excluded_fixers = getattr(self, 'exclude_fixers', [])
-        if self.distribution.use_2to3_exclude_fixers is not None:
-            excluded_fixers.extend(self.distribution.use_2to3_exclude_fixers)
-        for fixer_name in excluded_fixers:
-            if fixer_name in self.fixer_names:
-                self.fixer_names.remove(fixer_name)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/monkey.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/monkey.py
deleted file mode 100644
index dbe9a6176..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/monkey.py
+++ /dev/null
@@ -1,191 +0,0 @@
-"""
-Monkey patching of distutils.
-"""
-
-import sys
-import distutils.filelist
-import platform
-import types
-import functools
-import inspect
-
-from .py26compat import import_module
-from setuptools.extern import six
-
-import setuptools
-
-__all__ = []
-"""
-Everything is private. Contact the project team
-if you think you need this functionality.
-"""
-
-
-def get_unpatched(item):
-    lookup = (
-        get_unpatched_class if isinstance(item, six.class_types) else
-        get_unpatched_function if isinstance(item, types.FunctionType) else
-        lambda item: None
-    )
-    return lookup(item)
-
-
-def get_unpatched_class(cls):
-    """Protect against re-patching the distutils if reloaded
-
-    Also ensures that no other distutils extension monkeypatched the distutils
-    first.
-    """
-    external_bases = (
-        cls
-        for cls in inspect.getmro(cls)
-        if not cls.__module__.startswith('setuptools')
-    )
-    base = next(external_bases)
-    if not base.__module__.startswith('distutils'):
-        msg = "distutils has already been patched by %r" % cls
-        raise AssertionError(msg)
-    return base
-
-
-def patch_all():
-    # we can't patch distutils.cmd, alas
-    distutils.core.Command = setuptools.Command
-
-    has_issue_12885 = (
-        sys.version_info < (3, 4, 6)
-        or
-        (3, 5) < sys.version_info <= (3, 5, 3)
-        or
-        (3, 6) < sys.version_info
-    )
-
-    if has_issue_12885:
-        # fix findall bug in distutils (http://bugs.python.org/issue12885)
-        distutils.filelist.findall = setuptools.findall
-
-    needs_warehouse = (
-        sys.version_info < (2, 7, 13)
-        or
-        (3, 0) < sys.version_info < (3, 3, 7)
-        or
-        (3, 4) < sys.version_info < (3, 4, 6)
-        or
-        (3, 5) < sys.version_info <= (3, 5, 3)
-        or
-        (3, 6) < sys.version_info
-    )
-
-    if needs_warehouse:
-        warehouse = 'https://upload.pypi.org/legacy/'
-        distutils.config.PyPIRCCommand.DEFAULT_REPOSITORY = warehouse
-
-    _patch_distribution_metadata_write_pkg_file()
-    _patch_distribution_metadata_write_pkg_info()
-
-    # Install Distribution throughout the distutils
-    for module in distutils.dist, distutils.core, distutils.cmd:
-        module.Distribution = setuptools.dist.Distribution
-
-    # Install the patched Extension
-    distutils.core.Extension = setuptools.extension.Extension
-    distutils.extension.Extension = setuptools.extension.Extension
-    if 'distutils.command.build_ext' in sys.modules:
-        sys.modules['distutils.command.build_ext'].Extension = (
-            setuptools.extension.Extension
-        )
-
-    patch_for_msvc_specialized_compiler()
-
-
-def _patch_distribution_metadata_write_pkg_file():
-    """Patch write_pkg_file to also write Requires-Python/Requires-External"""
-    distutils.dist.DistributionMetadata.write_pkg_file = (
-        setuptools.dist.write_pkg_file
-    )
-
-
-def _patch_distribution_metadata_write_pkg_info():
-    """
-    Workaround issue #197 - Python 3 prior to 3.2.2 uses an environment-local
-    encoding to save the pkg_info. Monkey-patch its write_pkg_info method to
-    correct this undesirable behavior.
-    """
-    environment_local = (3,) <= sys.version_info[:3] < (3, 2, 2)
-    if not environment_local:
-        return
-
-    distutils.dist.DistributionMetadata.write_pkg_info = (
-        setuptools.dist.write_pkg_info
-    )
-
-
-def patch_func(replacement, target_mod, func_name):
-    """
-    Patch func_name in target_mod with replacement
-
-    Important - original must be resolved by name to avoid
-    patching an already patched function.
-    """
-    original = getattr(target_mod, func_name)
-
-    # set the 'unpatched' attribute on the replacement to
-    # point to the original.
-    vars(replacement).setdefault('unpatched', original)
-
-    # replace the function in the original module
-    setattr(target_mod, func_name, replacement)
-
-
-def get_unpatched_function(candidate):
-    return getattr(candidate, 'unpatched')
-
-
-def patch_for_msvc_specialized_compiler():
-    """
-    Patch functions in distutils to use standalone Microsoft Visual C++
-    compilers.
-    """
-    # import late to avoid circular imports on Python < 3.5
-    msvc = import_module('setuptools.msvc')
-
-    if platform.system() != 'Windows':
-        # Compilers only availables on Microsoft Windows
-        return
-
-    def patch_params(mod_name, func_name):
-        """
-        Prepare the parameters for patch_func to patch indicated function.
-        """
-        repl_prefix = 'msvc9_' if 'msvc9' in mod_name else 'msvc14_'
-        repl_name = repl_prefix + func_name.lstrip('_')
-        repl = getattr(msvc, repl_name)
-        mod = import_module(mod_name)
-        if not hasattr(mod, func_name):
-            raise ImportError(func_name)
-        return repl, mod, func_name
-
-    # Python 2.7 to 3.4
-    msvc9 = functools.partial(patch_params, 'distutils.msvc9compiler')
-
-    # Python 3.5+
-    msvc14 = functools.partial(patch_params, 'distutils._msvccompiler')
-
-    try:
-        # Patch distutils.msvc9compiler
-        patch_func(*msvc9('find_vcvarsall'))
-        patch_func(*msvc9('query_vcvarsall'))
-    except ImportError:
-        pass
-
-    try:
-        # Patch distutils._msvccompiler._get_vc_env
-        patch_func(*msvc14('_get_vc_env'))
-    except ImportError:
-        pass
-
-    try:
-        # Patch distutils._msvccompiler.gen_lib_options for Numpy
-        patch_func(*msvc14('gen_lib_options'))
-    except ImportError:
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/msvc.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/msvc.py
deleted file mode 100644
index 447ddb382..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/msvc.py
+++ /dev/null
@@ -1,1193 +0,0 @@
-"""
-Improved support for Microsoft Visual C++ compilers.
-
-Known supported compilers:
---------------------------
-Microsoft Visual C++ 9.0:
-    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64);
-    Microsoft Windows SDK 7.0 (x86, x64, ia64);
-    Microsoft Windows SDK 6.1 (x86, x64, ia64)
-
-Microsoft Visual C++ 10.0:
-    Microsoft Windows SDK 7.1 (x86, x64, ia64)
-
-Microsoft Visual C++ 14.0:
-    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
-"""
-
-import os
-import sys
-import platform
-import itertools
-import distutils.errors
-from pkg_resources.extern.packaging.version import LegacyVersion
-
-from setuptools.extern.six.moves import filterfalse
-
-from .monkey import get_unpatched
-
-if platform.system() == 'Windows':
-    from setuptools.extern.six.moves import winreg
-    safe_env = os.environ
-else:
-    """
-    Mock winreg and environ so the module can be imported
-    on this platform.
-    """
-
-    class winreg:
-        HKEY_USERS = None
-        HKEY_CURRENT_USER = None
-        HKEY_LOCAL_MACHINE = None
-        HKEY_CLASSES_ROOT = None
-
-    safe_env = dict()
-
-try:
-    from distutils.msvc9compiler import Reg
-except ImportError:
-    pass
-
-
-def msvc9_find_vcvarsall(version):
-    """
-    Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
-    compiler build for Python (VCForPython). Fall back to original behavior
-    when the standalone compiler is not available.
-
-    Redirect the path of "vcvarsall.bat".
-
-    Known supported compilers
-    -------------------------
-    Microsoft Visual C++ 9.0:
-        Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
-
-    Parameters
-    ----------
-    version: float
-        Required Microsoft Visual C++ version.
-
-    Return
-    ------
-    vcvarsall.bat path: str
-    """
-    VC_BASE = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
-    key = VC_BASE % ('', version)
-    try:
-        # Per-user installs register the compiler path here
-        productdir = Reg.get_value(key, "installdir")
-    except KeyError:
-        try:
-            # All-user installs on a 64-bit system register here
-            key = VC_BASE % ('Wow6432Node\\', version)
-            productdir = Reg.get_value(key, "installdir")
-        except KeyError:
-            productdir = None
-
-    if productdir:
-        vcvarsall = os.path.os.path.join(productdir, "vcvarsall.bat")
-        if os.path.isfile(vcvarsall):
-            return vcvarsall
-
-    return get_unpatched(msvc9_find_vcvarsall)(version)
-
-
-def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
-    """
-    Patched "distutils.msvc9compiler.query_vcvarsall" for support standalones
-    compilers.
-
-    Set environment without use of "vcvarsall.bat".
-
-    Known supported compilers
-    -------------------------
-    Microsoft Visual C++ 9.0:
-        Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64);
-        Microsoft Windows SDK 7.0 (x86, x64, ia64);
-        Microsoft Windows SDK 6.1 (x86, x64, ia64)
-
-    Microsoft Visual C++ 10.0:
-        Microsoft Windows SDK 7.1 (x86, x64, ia64)
-
-    Parameters
-    ----------
-    ver: float
-        Required Microsoft Visual C++ version.
-    arch: str
-        Target architecture.
-
-    Return
-    ------
-    environment: dict
-    """
-    # Try to get environement from vcvarsall.bat (Classical way)
-    try:
-        orig = get_unpatched(msvc9_query_vcvarsall)
-        return orig(ver, arch, *args, **kwargs)
-    except distutils.errors.DistutilsPlatformError:
-        # Pass error if Vcvarsall.bat is missing
-        pass
-    except ValueError:
-        # Pass error if environment not set after executing vcvarsall.bat
-        pass
-
-    # If error, try to set environment directly
-    try:
-        return EnvironmentInfo(arch, ver).return_env()
-    except distutils.errors.DistutilsPlatformError as exc:
-        _augment_exception(exc, ver, arch)
-        raise
-
-
-def msvc14_get_vc_env(plat_spec):
-    """
-    Patched "distutils._msvccompiler._get_vc_env" for support standalones
-    compilers.
-
-    Set environment without use of "vcvarsall.bat".
-
-    Known supported compilers
-    -------------------------
-    Microsoft Visual C++ 14.0:
-        Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
-
-    Parameters
-    ----------
-    plat_spec: str
-        Target architecture.
-
-    Return
-    ------
-    environment: dict
-    """
-    # Try to get environment from vcvarsall.bat (Classical way)
-    try:
-        return get_unpatched(msvc14_get_vc_env)(plat_spec)
-    except distutils.errors.DistutilsPlatformError:
-        # Pass error Vcvarsall.bat is missing
-        pass
-
-    # If error, try to set environment directly
-    try:
-        return EnvironmentInfo(plat_spec, vc_min_ver=14.0).return_env()
-    except distutils.errors.DistutilsPlatformError as exc:
-        _augment_exception(exc, 14.0)
-        raise
-
-
-def msvc14_gen_lib_options(*args, **kwargs):
-    """
-    Patched "distutils._msvccompiler.gen_lib_options" for fix
-    compatibility between "numpy.distutils" and "distutils._msvccompiler"
-    (for Numpy < 1.11.2)
-    """
-    if "numpy.distutils" in sys.modules:
-        import numpy as np
-        if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'):
-            return np.distutils.ccompiler.gen_lib_options(*args, **kwargs)
-    return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)
-
-
-def _augment_exception(exc, version, arch=''):
-    """
-    Add details to the exception message to help guide the user
-    as to what action will resolve it.
-    """
-    # Error if MSVC++ directory not found or environment not set
-    message = exc.args[0]
-
-    if "vcvarsall" in message.lower() or "visual c" in message.lower():
-        # Special error message if MSVC++ not installed
-        tmpl = 'Microsoft Visual C++ {version:0.1f} is required.'
-        message = tmpl.format(**locals())
-        msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
-        if version == 9.0:
-            if arch.lower().find('ia64') > -1:
-                # For VC++ 9.0, if IA64 support is needed, redirect user
-                # to Windows SDK 7.0
-                message += ' Get it with "Microsoft Windows SDK 7.0": '
-                message += msdownload % 3138
-            else:
-                # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
-                # This redirection link is maintained by Microsoft.
-                # Contact vspython@microsoft.com if it needs updating.
-                message += ' Get it from http://aka.ms/vcpython27'
-        elif version == 10.0:
-            # For VC++ 10.0 Redirect user to Windows SDK 7.1
-            message += ' Get it with "Microsoft Windows SDK 7.1": '
-            message += msdownload % 8279
-        elif version >= 14.0:
-            # For VC++ 14.0 Redirect user to Visual C++ Build Tools
-            message += (' Get it with "Microsoft Visual C++ Build Tools": '
-                        r'http://landinghub.visualstudio.com/'
-                        'visual-cpp-build-tools')
-
-    exc.args = (message, )
-
-
-class PlatformInfo:
-    """
-    Current and Target Architectures informations.
-
-    Parameters
-    ----------
-    arch: str
-        Target architecture.
-    """
-    current_cpu = safe_env.get('processor_architecture', '').lower()
-
-    def __init__(self, arch):
-        self.arch = arch.lower().replace('x64', 'amd64')
-
-    @property
-    def target_cpu(self):
-        return self.arch[self.arch.find('_') + 1:]
-
-    def target_is_x86(self):
-        return self.target_cpu == 'x86'
-
-    def current_is_x86(self):
-        return self.current_cpu == 'x86'
-
-    def current_dir(self, hidex86=False, x64=False):
-        """
-        Current platform specific subfolder.
-
-        Parameters
-        ----------
-        hidex86: bool
-            return '' and not '\x86' if architecture is x86.
-        x64: bool
-            return '\x64' and not '\amd64' if architecture is amd64.
-
-        Return
-        ------
-        subfolder: str
-            '\target', or '' (see hidex86 parameter)
-        """
-        return (
-            '' if (self.current_cpu == 'x86' and hidex86) else
-            r'\x64' if (self.current_cpu == 'amd64' and x64) else
-            r'\%s' % self.current_cpu
-        )
-
-    def target_dir(self, hidex86=False, x64=False):
-        """
-        Target platform specific subfolder.
-
-        Parameters
-        ----------
-        hidex86: bool
-            return '' and not '\x86' if architecture is x86.
-        x64: bool
-            return '\x64' and not '\amd64' if architecture is amd64.
-
-        Return
-        ------
-        subfolder: str
-            '\current', or '' (see hidex86 parameter)
-        """
-        return (
-            '' if (self.target_cpu == 'x86' and hidex86) else
-            r'\x64' if (self.target_cpu == 'amd64' and x64) else
-            r'\%s' % self.target_cpu
-        )
-
-    def cross_dir(self, forcex86=False):
-        """
-        Cross platform specific subfolder.
-
-        Parameters
-        ----------
-        forcex86: bool
-            Use 'x86' as current architecture even if current acritecture is
-            not x86.
-
-        Return
-        ------
-        subfolder: str
-            '' if target architecture is current architecture,
-            '\current_target' if not.
-        """
-        current = 'x86' if forcex86 else self.current_cpu
-        return (
-            '' if self.target_cpu == current else
-            self.target_dir().replace('\\', '\\%s_' % current)
-        )
-
-
-class RegistryInfo:
-    """
-    Microsoft Visual Studio related registry informations.
-
-    Parameters
-    ----------
-    platform_info: PlatformInfo
-        "PlatformInfo" instance.
-    """
-    HKEYS = (winreg.HKEY_USERS,
-             winreg.HKEY_CURRENT_USER,
-             winreg.HKEY_LOCAL_MACHINE,
-             winreg.HKEY_CLASSES_ROOT)
-
-    def __init__(self, platform_info):
-        self.pi = platform_info
-
-    @property
-    def visualstudio(self):
-        """
-        Microsoft Visual Studio root registry key.
-        """
-        return 'VisualStudio'
-
-    @property
-    def sxs(self):
-        """
-        Microsoft Visual Studio SxS registry key.
-        """
-        return os.path.join(self.visualstudio, 'SxS')
-
-    @property
-    def vc(self):
-        """
-        Microsoft Visual C++ VC7 registry key.
-        """
-        return os.path.join(self.sxs, 'VC7')
-
-    @property
-    def vs(self):
-        """
-        Microsoft Visual Studio VS7 registry key.
-        """
-        return os.path.join(self.sxs, 'VS7')
-
-    @property
-    def vc_for_python(self):
-        """
-        Microsoft Visual C++ for Python registry key.
-        """
-        return r'DevDiv\VCForPython'
-
-    @property
-    def microsoft_sdk(self):
-        """
-        Microsoft SDK registry key.
-        """
-        return 'Microsoft SDKs'
-
-    @property
-    def windows_sdk(self):
-        """
-        Microsoft Windows/Platform SDK registry key.
-        """
-        return os.path.join(self.microsoft_sdk, 'Windows')
-
-    @property
-    def netfx_sdk(self):
-        """
-        Microsoft .NET Framework SDK registry key.
-        """
-        return os.path.join(self.microsoft_sdk, 'NETFXSDK')
-
-    @property
-    def windows_kits_roots(self):
-        """
-        Microsoft Windows Kits Roots registry key.
-        """
-        return r'Windows Kits\Installed Roots'
-
-    def microsoft(self, key, x86=False):
-        """
-        Return key in Microsoft software registry.
-
-        Parameters
-        ----------
-        key: str
-            Registry key path where look.
-        x86: str
-            Force x86 software registry.
-
-        Return
-        ------
-        str: value
-        """
-        node64 = '' if self.pi.current_is_x86() or x86 else r'\Wow6432Node'
-        return os.path.join('Software', node64, 'Microsoft', key)
-
-    def lookup(self, key, name):
-        """
-        Look for values in registry in Microsoft software registry.
-
-        Parameters
-        ----------
-        key: str
-            Registry key path where look.
-        name: str
-            Value name to find.
-
-        Return
-        ------
-        str: value
-        """
-        KEY_READ = winreg.KEY_READ
-        openkey = winreg.OpenKey
-        ms = self.microsoft
-        for hkey in self.HKEYS:
-            try:
-                bkey = openkey(hkey, ms(key), 0, KEY_READ)
-            except (OSError, IOError):
-                if not self.pi.current_is_x86():
-                    try:
-                        bkey = openkey(hkey, ms(key, True), 0, KEY_READ)
-                    except (OSError, IOError):
-                        continue
-                else:
-                    continue
-            try:
-                return winreg.QueryValueEx(bkey, name)[0]
-            except (OSError, IOError):
-                pass
-
-
-class SystemInfo:
-    """
-    Microsoft Windows and Visual Studio related system inormations.
-
-    Parameters
-    ----------
-    registry_info: RegistryInfo
-        "RegistryInfo" instance.
-    vc_ver: float
-        Required Microsoft Visual C++ version.
-    """
-
-    # Variables and properties in this class use originals CamelCase variables
-    # names from Microsoft source files for more easy comparaison.
-    WinDir = safe_env.get('WinDir', '')
-    ProgramFiles = safe_env.get('ProgramFiles', '')
-    ProgramFilesx86 = safe_env.get('ProgramFiles(x86)', ProgramFiles)
-
-    def __init__(self, registry_info, vc_ver=None):
-        self.ri = registry_info
-        self.pi = self.ri.pi
-        if vc_ver:
-            self.vc_ver = vc_ver
-        else:
-            try:
-                self.vc_ver = self.find_available_vc_vers()[-1]
-            except IndexError:
-                err = 'No Microsoft Visual C++ version found'
-                raise distutils.errors.DistutilsPlatformError(err)
-
-    def find_available_vc_vers(self):
-        """
-        Find all available Microsoft Visual C++ versions.
-        """
-        vckeys = (self.ri.vc, self.ri.vc_for_python)
-        vc_vers = []
-        for hkey in self.ri.HKEYS:
-            for key in vckeys:
-                try:
-                    bkey = winreg.OpenKey(hkey, key, 0, winreg.KEY_READ)
-                except (OSError, IOError):
-                    continue
-                subkeys, values, _ = winreg.QueryInfoKey(bkey)
-                for i in range(values):
-                    try:
-                        ver = float(winreg.EnumValue(bkey, i)[0])
-                        if ver not in vc_vers:
-                            vc_vers.append(ver)
-                    except ValueError:
-                        pass
-                for i in range(subkeys):
-                    try:
-                        ver = float(winreg.EnumKey(bkey, i))
-                        if ver not in vc_vers:
-                            vc_vers.append(ver)
-                    except ValueError:
-                        pass
-        return sorted(vc_vers)
-
-    @property
-    def VSInstallDir(self):
-        """
-        Microsoft Visual Studio directory.
-        """
-        # Default path
-        name = 'Microsoft Visual Studio %0.1f' % self.vc_ver
-        default = os.path.join(self.ProgramFilesx86, name)
-
-        # Try to get path from registry, if fail use default path
-        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vc_ver) or default
-
-    @property
-    def VCInstallDir(self):
-        """
-        Microsoft Visual C++ directory.
-        """
-        # Default path
-        default = r'Microsoft Visual Studio %0.1f\VC' % self.vc_ver
-        guess_vc = os.path.join(self.ProgramFilesx86, default)
-
-        # Try to get "VC++ for Python" path from registry as default path
-        reg_path = os.path.join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
-        python_vc = self.ri.lookup(reg_path, 'installdir')
-        default_vc = os.path.join(python_vc, 'VC') if python_vc else guess_vc
-
-        # Try to get path from registry, if fail use default path
-        path = self.ri.lookup(self.ri.vc, '%0.1f' % self.vc_ver) or default_vc
-
-        if not os.path.isdir(path):
-            msg = 'Microsoft Visual C++ directory not found'
-            raise distutils.errors.DistutilsPlatformError(msg)
-
-        return path
-
-    @property
-    def WindowsSdkVersion(self):
-        """
-        Microsoft Windows SDK versions.
-        """
-        # Set Windows SDK versions for specified MSVC++ version
-        if self.vc_ver <= 9.0:
-            return ('7.0', '6.1', '6.0a')
-        elif self.vc_ver == 10.0:
-            return ('7.1', '7.0a')
-        elif self.vc_ver == 11.0:
-            return ('8.0', '8.0a')
-        elif self.vc_ver == 12.0:
-            return ('8.1', '8.1a')
-        elif self.vc_ver >= 14.0:
-            return ('10.0', '8.1')
-
-    @property
-    def WindowsSdkDir(self):
-        """
-        Microsoft Windows SDK directory.
-        """
-        sdkdir = ''
-        for ver in self.WindowsSdkVersion:
-            # Try to get it from registry
-            loc = os.path.join(self.ri.windows_sdk, 'v%s' % ver)
-            sdkdir = self.ri.lookup(loc, 'installationfolder')
-            if sdkdir:
-                break
-        if not sdkdir or not os.path.isdir(sdkdir):
-            # Try to get "VC++ for Python" version from registry
-            path = os.path.join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
-            install_base = self.ri.lookup(path, 'installdir')
-            if install_base:
-                sdkdir = os.path.join(install_base, 'WinSDK')
-        if not sdkdir or not os.path.isdir(sdkdir):
-            # If fail, use default new path
-            for ver in self.WindowsSdkVersion:
-                intver = ver[:ver.rfind('.')]
-                path = r'Microsoft SDKs\Windows Kits\%s' % (intver)
-                d = os.path.join(self.ProgramFiles, path)
-                if os.path.isdir(d):
-                    sdkdir = d
-        if not sdkdir or not os.path.isdir(sdkdir):
-            # If fail, use default old path
-            for ver in self.WindowsSdkVersion:
-                path = r'Microsoft SDKs\Windows\v%s' % ver
-                d = os.path.join(self.ProgramFiles, path)
-                if os.path.isdir(d):
-                    sdkdir = d
-        if not sdkdir:
-            # If fail, use Platform SDK
-            sdkdir = os.path.join(self.VCInstallDir, 'PlatformSDK')
-        return sdkdir
-
-    @property
-    def WindowsSDKExecutablePath(self):
-        """
-        Microsoft Windows SDK executable directory.
-        """
-        # Find WinSDK NetFx Tools registry dir name
-        if self.vc_ver <= 11.0:
-            netfxver = 35
-            arch = ''
-        else:
-            netfxver = 40
-            hidex86 = True if self.vc_ver <= 12.0 else False
-            arch = self.pi.current_dir(x64=True, hidex86=hidex86)
-        fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))
-
-        # liste all possibles registry paths
-        regpaths = []
-        if self.vc_ver >= 14.0:
-            for ver in self.NetFxSdkVersion:
-                regpaths += [os.path.join(self.ri.netfx_sdk, ver, fx)]
-
-        for ver in self.WindowsSdkVersion:
-            regpaths += [os.path.join(self.ri.windows_sdk, 'v%sA' % ver, fx)]
-
-        # Return installation folder from the more recent path
-        for path in regpaths:
-            execpath = self.ri.lookup(path, 'installationfolder')
-            if execpath:
-                break
-        return execpath
-
-    @property
-    def FSharpInstallDir(self):
-        """
-        Microsoft Visual F# directory.
-        """
-        path = r'%0.1f\Setup\F#' % self.vc_ver
-        path = os.path.join(self.ri.visualstudio, path)
-        return self.ri.lookup(path, 'productdir') or ''
-
-    @property
-    def UniversalCRTSdkDir(self):
-        """
-        Microsoft Universal CRT SDK directory.
-        """
-        # Set Kit Roots versions for specified MSVC++ version
-        if self.vc_ver >= 14.0:
-            vers = ('10', '81')
-        else:
-            vers = ()
-
-        # Find path of the more recent Kit
-        for ver in vers:
-            sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
-                                    'kitsroot%s' % ver)
-            if sdkdir:
-                break
-        return sdkdir or ''
-
-    @property
-    def NetFxSdkVersion(self):
-        """
-        Microsoft .NET Framework SDK versions.
-        """
-        # Set FxSdk versions for specified MSVC++ version
-        if self.vc_ver >= 14.0:
-            return ('4.6.1', '4.6')
-        else:
-            return ()
-
-    @property
-    def NetFxSdkDir(self):
-        """
-        Microsoft .NET Framework SDK directory.
-        """
-        for ver in self.NetFxSdkVersion:
-            loc = os.path.join(self.ri.netfx_sdk, ver)
-            sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
-            if sdkdir:
-                break
-        return sdkdir or ''
-
-    @property
-    def FrameworkDir32(self):
-        """
-        Microsoft .NET Framework 32bit directory.
-        """
-        # Default path
-        guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework')
-
-        # Try to get path from registry, if fail use default path
-        return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw
-
-    @property
-    def FrameworkDir64(self):
-        """
-        Microsoft .NET Framework 64bit directory.
-        """
-        # Default path
-        guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework64')
-
-        # Try to get path from registry, if fail use default path
-        return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw
-
-    @property
-    def FrameworkVersion32(self):
-        """
-        Microsoft .NET Framework 32bit versions.
-        """
-        return self._find_dot_net_versions(32)
-
-    @property
-    def FrameworkVersion64(self):
-        """
-        Microsoft .NET Framework 64bit versions.
-        """
-        return self._find_dot_net_versions(64)
-
-    def _find_dot_net_versions(self, bits=32):
-        """
-        Find Microsoft .NET Framework versions.
-
-        Parameters
-        ----------
-        bits: int
-            Platform number of bits: 32 or 64.
-        """
-        # Find actual .NET version
-        ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits) or ''
-
-        # Set .NET versions for specified MSVC++ version
-        if self.vc_ver >= 12.0:
-            frameworkver = (ver, 'v4.0')
-        elif self.vc_ver >= 10.0:
-            frameworkver = ('v4.0.30319' if ver.lower()[:2] != 'v4' else ver,
-                            'v3.5')
-        elif self.vc_ver == 9.0:
-            frameworkver = ('v3.5', 'v2.0.50727')
-        if self.vc_ver == 8.0:
-            frameworkver = ('v3.0', 'v2.0.50727')
-        return frameworkver
-
-
-class EnvironmentInfo:
-    """
-    Return environment variables for specified Microsoft Visual C++ version
-    and platform : Lib, Include, Path and libpath.
-
-    This function is compatible with Microsoft Visual C++ 9.0 to 14.0.
-
-    Script created by analysing Microsoft environment configuration files like
-    "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...
-
-    Parameters
-    ----------
-    arch: str
-        Target architecture.
-    vc_ver: float
-        Required Microsoft Visual C++ version. If not set, autodetect the last
-        version.
-    vc_min_ver: float
-        Minimum Microsoft Visual C++ version.
-    """
-
-    # Variables and properties in this class use originals CamelCase variables
-    # names from Microsoft source files for more easy comparaison.
-
-    def __init__(self, arch, vc_ver=None, vc_min_ver=None):
-        self.pi = PlatformInfo(arch)
-        self.ri = RegistryInfo(self.pi)
-        self.si = SystemInfo(self.ri, vc_ver)
-
-        if vc_min_ver:
-            if self.vc_ver < vc_min_ver:
-                err = 'No suitable Microsoft Visual C++ version found'
-                raise distutils.errors.DistutilsPlatformError(err)
-
-    @property
-    def vc_ver(self):
-        """
-        Microsoft Visual C++ version.
-        """
-        return self.si.vc_ver
-
-    @property
-    def VSTools(self):
-        """
-        Microsoft Visual Studio Tools
-        """
-        paths = [r'Common7\IDE', r'Common7\Tools']
-
-        if self.vc_ver >= 14.0:
-            arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
-            paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
-            paths += [r'Team Tools\Performance Tools']
-            paths += [r'Team Tools\Performance Tools%s' % arch_subdir]
-
-        return [os.path.join(self.si.VSInstallDir, path) for path in paths]
-
-    @property
-    def VCIncludes(self):
-        """
-        Microsoft Visual C++ & Microsoft Foundation Class Includes
-        """
-        return [os.path.join(self.si.VCInstallDir, 'Include'),
-                os.path.join(self.si.VCInstallDir, r'ATLMFC\Include')]
-
-    @property
-    def VCLibraries(self):
-        """
-        Microsoft Visual C++ & Microsoft Foundation Class Libraries
-        """
-        arch_subdir = self.pi.target_dir(hidex86=True)
-        paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]
-
-        if self.vc_ver >= 14.0:
-            paths += [r'Lib\store%s' % arch_subdir]
-
-        return [os.path.join(self.si.VCInstallDir, path) for path in paths]
-
-    @property
-    def VCStoreRefs(self):
-        """
-        Microsoft Visual C++ store references Libraries
-        """
-        if self.vc_ver < 14.0:
-            return []
-        return [os.path.join(self.si.VCInstallDir, r'Lib\store\references')]
-
-    @property
-    def VCTools(self):
-        """
-        Microsoft Visual C++ Tools
-        """
-        si = self.si
-        tools = [os.path.join(si.VCInstallDir, 'VCPackages')]
-
-        forcex86 = True if self.vc_ver <= 10.0 else False
-        arch_subdir = self.pi.cross_dir(forcex86)
-        if arch_subdir:
-            tools += [os.path.join(si.VCInstallDir, 'Bin%s' % arch_subdir)]
-
-        if self.vc_ver >= 14.0:
-            path = 'Bin%s' % self.pi.current_dir(hidex86=True)
-            tools += [os.path.join(si.VCInstallDir, path)]
-
-        else:
-            tools += [os.path.join(si.VCInstallDir, 'Bin')]
-
-        return tools
-
-    @property
-    def OSLibraries(self):
-        """
-        Microsoft Windows SDK Libraries
-        """
-        if self.vc_ver <= 10.0:
-            arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
-            return [os.path.join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]
-
-        else:
-            arch_subdir = self.pi.target_dir(x64=True)
-            lib = os.path.join(self.si.WindowsSdkDir, 'lib')
-            libver = self._get_content_dirname(lib)
-            return [os.path.join(lib, '%sum%s' % (libver, arch_subdir))]
-
-    @property
-    def OSIncludes(self):
-        """
-        Microsoft Windows SDK Include
-        """
-        include = os.path.join(self.si.WindowsSdkDir, 'include')
-
-        if self.vc_ver <= 10.0:
-            return [include, os.path.join(include, 'gl')]
-
-        else:
-            if self.vc_ver >= 14.0:
-                sdkver = self._get_content_dirname(include)
-            else:
-                sdkver = ''
-            return [os.path.join(include, '%sshared' % sdkver),
-                    os.path.join(include, '%sum' % sdkver),
-                    os.path.join(include, '%swinrt' % sdkver)]
-
-    @property
-    def OSLibpath(self):
-        """
-        Microsoft Windows SDK Libraries Paths
-        """
-        ref = os.path.join(self.si.WindowsSdkDir, 'References')
-        libpath = []
-
-        if self.vc_ver <= 9.0:
-            libpath += self.OSLibraries
-
-        if self.vc_ver >= 11.0:
-            libpath += [os.path.join(ref, r'CommonConfiguration\Neutral')]
-
-        if self.vc_ver >= 14.0:
-            libpath += [
-                ref,
-                os.path.join(self.si.WindowsSdkDir, 'UnionMetadata'),
-                os.path.join(
-                    ref,
-                    'Windows.Foundation.UniversalApiContract',
-                    '1.0.0.0',
-                ),
-                os.path.join(
-                    ref,
-                    'Windows.Foundation.FoundationContract',
-                    '1.0.0.0',
-                ),
-                os.path.join(
-                    ref,
-                    'Windows.Networking.Connectivity.WwanContract',
-                    '1.0.0.0',
-                ),
-                os.path.join(
-                    self.si.WindowsSdkDir,
-                    'ExtensionSDKs',
-                    'Microsoft.VCLibs',
-                    '%0.1f' % self.vc_ver,
-                    'References',
-                    'CommonConfiguration',
-                    'neutral',
-                ),
-            ]
-        return libpath
-
-    @property
-    def SdkTools(self):
-        """
-        Microsoft Windows SDK Tools
-        """
-        bin_dir = 'Bin' if self.vc_ver <= 11.0 else r'Bin\x86'
-        tools = [os.path.join(self.si.WindowsSdkDir, bin_dir)]
-
-        if not self.pi.current_is_x86():
-            arch_subdir = self.pi.current_dir(x64=True)
-            path = 'Bin%s' % arch_subdir
-            tools += [os.path.join(self.si.WindowsSdkDir, path)]
-
-        if self.vc_ver == 10.0 or self.vc_ver == 11.0:
-            if self.pi.target_is_x86():
-                arch_subdir = ''
-            else:
-                arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
-            path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
-            tools += [os.path.join(self.si.WindowsSdkDir, path)]
-
-        if self.si.WindowsSDKExecutablePath:
-            tools += [self.si.WindowsSDKExecutablePath]
-
-        return tools
-
-    @property
-    def SdkSetup(self):
-        """
-        Microsoft Windows SDK Setup
-        """
-        if self.vc_ver > 9.0:
-            return []
-
-        return [os.path.join(self.si.WindowsSdkDir, 'Setup')]
-
-    @property
-    def FxTools(self):
-        """
-        Microsoft .NET Framework Tools
-        """
-        pi = self.pi
-        si = self.si
-
-        if self.vc_ver <= 10.0:
-            include32 = True
-            include64 = not pi.target_is_x86() and not pi.current_is_x86()
-        else:
-            include32 = pi.target_is_x86() or pi.current_is_x86()
-            include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'
-
-        tools = []
-        if include32:
-            tools += [os.path.join(si.FrameworkDir32, ver)
-                      for ver in si.FrameworkVersion32]
-        if include64:
-            tools += [os.path.join(si.FrameworkDir64, ver)
-                      for ver in si.FrameworkVersion64]
-        return tools
-
-    @property
-    def NetFxSDKLibraries(self):
-        """
-        Microsoft .Net Framework SDK Libraries
-        """
-        if self.vc_ver < 14.0 or not self.si.NetFxSdkDir:
-            return []
-
-        arch_subdir = self.pi.target_dir(x64=True)
-        return [os.path.join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]
-
-    @property
-    def NetFxSDKIncludes(self):
-        """
-        Microsoft .Net Framework SDK Includes
-        """
-        if self.vc_ver < 14.0 or not self.si.NetFxSdkDir:
-            return []
-
-        return [os.path.join(self.si.NetFxSdkDir, r'include\um')]
-
-    @property
-    def VsTDb(self):
-        """
-        Microsoft Visual Studio Team System Database
-        """
-        return [os.path.join(self.si.VSInstallDir, r'VSTSDB\Deploy')]
-
-    @property
-    def MSBuild(self):
-        """
-        Microsoft Build Engine
-        """
-        if self.vc_ver < 12.0:
-            return []
-
-        arch_subdir = self.pi.current_dir(hidex86=True)
-        path = r'MSBuild\%0.1f\bin%s' % (self.vc_ver, arch_subdir)
-        return [os.path.join(self.si.ProgramFilesx86, path)]
-
-    @property
-    def HTMLHelpWorkshop(self):
-        """
-        Microsoft HTML Help Workshop
-        """
-        if self.vc_ver < 11.0:
-            return []
-
-        return [os.path.join(self.si.ProgramFilesx86, 'HTML Help Workshop')]
-
-    @property
-    def UCRTLibraries(self):
-        """
-        Microsoft Universal CRT Libraries
-        """
-        if self.vc_ver < 14.0:
-            return []
-
-        arch_subdir = self.pi.target_dir(x64=True)
-        lib = os.path.join(self.si.UniversalCRTSdkDir, 'lib')
-        ucrtver = self._get_content_dirname(lib)
-        return [os.path.join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]
-
-    @property
-    def UCRTIncludes(self):
-        """
-        Microsoft Universal CRT Include
-        """
-        if self.vc_ver < 14.0:
-            return []
-
-        include = os.path.join(self.si.UniversalCRTSdkDir, 'include')
-        ucrtver = self._get_content_dirname(include)
-        return [os.path.join(include, '%sucrt' % ucrtver)]
-
-    @property
-    def FSharp(self):
-        """
-        Microsoft Visual F#
-        """
-        if self.vc_ver < 11.0 and self.vc_ver > 12.0:
-            return []
-
-        return self.si.FSharpInstallDir
-
-    @property
-    def VCRuntimeRedist(self):
-        """
-        Microsoft Visual C++ runtime redistribuable dll
-        """
-        arch_subdir = self.pi.target_dir(x64=True)
-        vcruntime = 'redist%s\\Microsoft.VC%d0.CRT\\vcruntime%d0.dll'
-        vcruntime = vcruntime % (arch_subdir, self.vc_ver, self.vc_ver)
-        return os.path.join(self.si.VCInstallDir, vcruntime)
-
-    def return_env(self, exists=True):
-        """
-        Return environment dict.
-
-        Parameters
-        ----------
-        exists: bool
-            It True, only return existing paths.
-        """
-        env = dict(
-            include=self._build_paths('include',
-                                      [self.VCIncludes,
-                                       self.OSIncludes,
-                                       self.UCRTIncludes,
-                                       self.NetFxSDKIncludes],
-                                      exists),
-            lib=self._build_paths('lib',
-                                  [self.VCLibraries,
-                                   self.OSLibraries,
-                                   self.FxTools,
-                                   self.UCRTLibraries,
-                                   self.NetFxSDKLibraries],
-                                  exists),
-            libpath=self._build_paths('libpath',
-                                      [self.VCLibraries,
-                                       self.FxTools,
-                                       self.VCStoreRefs,
-                                       self.OSLibpath],
-                                      exists),
-            path=self._build_paths('path',
-                                   [self.VCTools,
-                                    self.VSTools,
-                                    self.VsTDb,
-                                    self.SdkTools,
-                                    self.SdkSetup,
-                                    self.FxTools,
-                                    self.MSBuild,
-                                    self.HTMLHelpWorkshop,
-                                    self.FSharp],
-                                   exists),
-        )
-        if self.vc_ver >= 14 and os.path.isfile(self.VCRuntimeRedist):
-            env['py_vcruntime_redist'] = self.VCRuntimeRedist
-        return env
-
-    def _build_paths(self, name, spec_path_lists, exists):
-        """
-        Given an environment variable name and specified paths,
-        return a pathsep-separated string of paths containing
-        unique, extant, directories from those paths and from
-        the environment variable. Raise an error if no paths
-        are resolved.
-        """
-        # flatten spec_path_lists
-        spec_paths = itertools.chain.from_iterable(spec_path_lists)
-        env_paths = safe_env.get(name, '').split(os.pathsep)
-        paths = itertools.chain(spec_paths, env_paths)
-        extant_paths = list(filter(os.path.isdir, paths)) if exists else paths
-        if not extant_paths:
-            msg = "%s environment variable is empty" % name.upper()
-            raise distutils.errors.DistutilsPlatformError(msg)
-        unique_paths = self._unique_everseen(extant_paths)
-        return os.pathsep.join(unique_paths)
-
-    # from Python docs
-    def _unique_everseen(self, iterable, key=None):
-        """
-        List unique elements, preserving order.
-        Remember all elements ever seen.
-
-        _unique_everseen('AAAABBBCCDAABBB') --> A B C D
-
-        _unique_everseen('ABBCcAD', str.lower) --> A B C D
-        """
-        seen = set()
-        seen_add = seen.add
-        if key is None:
-            for element in filterfalse(seen.__contains__, iterable):
-                seen_add(element)
-                yield element
-        else:
-            for element in iterable:
-                k = key(element)
-                if k not in seen:
-                    seen_add(k)
-                    yield element
-
-    def _get_content_dirname(self, path):
-        """
-        Return name of the first dir in path or '' if no dir found.
-
-        Parameters
-        ----------
-        path: str
-            Path where search dir.
-
-        Return
-        ------
-        foldername: str
-            "name\" or ""
-        """
-        try:
-            name = os.listdir(path)
-            if name:
-                return '%s\\' % name[0]
-            return ''
-        except (OSError, IOError):
-            return ''
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/namespaces.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/namespaces.py
deleted file mode 100644
index bd17d9e7c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/namespaces.py
+++ /dev/null
@@ -1,107 +0,0 @@
-import os
-from distutils import log
-import itertools
-
-from setuptools.extern.six.moves import map
-
-
-flatten = itertools.chain.from_iterable
-
-
-class Installer:
-
-    nspkg_ext = '-nspkg.pth'
-
-    def install_namespaces(self):
-        nsp = self._get_all_ns_packages()
-        if not nsp:
-            return
-        filename, ext = os.path.splitext(self._get_target())
-        filename += self.nspkg_ext
-        self.outputs.append(filename)
-        log.info("Installing %s", filename)
-        lines = map(self._gen_nspkg_line, nsp)
-
-        if self.dry_run:
-            # always generate the lines, even in dry run
-            list(lines)
-            return
-
-        with open(filename, 'wt') as f:
-            f.writelines(lines)
-
-    def uninstall_namespaces(self):
-        filename, ext = os.path.splitext(self._get_target())
-        filename += self.nspkg_ext
-        if not os.path.exists(filename):
-            return
-        log.info("Removing %s", filename)
-        os.remove(filename)
-
-    def _get_target(self):
-        return self.target
-
-    _nspkg_tmpl = (
-        "import sys, types, os",
-        "has_mfs = sys.version_info > (3, 5)",
-        "p = os.path.join(%(root)s, *%(pth)r)",
-        "importlib = has_mfs and __import__('importlib.util')",
-        "has_mfs and __import__('importlib.machinery')",
-        "m = has_mfs and "
-            "sys.modules.setdefault(%(pkg)r, "
-                "importlib.util.module_from_spec("
-                    "importlib.machinery.PathFinder.find_spec(%(pkg)r, "
-                        "[os.path.dirname(p)])))",
-        "m = m or not has_mfs and "
-            "sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))",
-        "mp = (m or []) and m.__dict__.setdefault('__path__',[])",
-        "(p not in mp) and mp.append(p)",
-    )
-    "lines for the namespace installer"
-
-    _nspkg_tmpl_multi = (
-        'm and setattr(sys.modules[%(parent)r], %(child)r, m)',
-    )
-    "additional line(s) when a parent package is indicated"
-
-    def _get_root(self):
-        return "sys._getframe(1).f_locals['sitedir']"
-
-    def _gen_nspkg_line(self, pkg):
-        # ensure pkg is not a unicode string under Python 2.7
-        pkg = str(pkg)
-        pth = tuple(pkg.split('.'))
-        root = self._get_root()
-        tmpl_lines = self._nspkg_tmpl
-        parent, sep, child = pkg.rpartition('.')
-        if parent:
-            tmpl_lines += self._nspkg_tmpl_multi
-        return ';'.join(tmpl_lines) % locals() + '\n'
-
-    def _get_all_ns_packages(self):
-        """Return sorted list of all package namespaces"""
-        pkgs = self.distribution.namespace_packages or []
-        return sorted(flatten(map(self._pkg_names, pkgs)))
-
-    @staticmethod
-    def _pkg_names(pkg):
-        """
-        Given a namespace package, yield the components of that
-        package.
-
-        >>> names = Installer._pkg_names('a.b.c')
-        >>> set(names) == set(['a', 'a.b', 'a.b.c'])
-        True
-        """
-        parts = pkg.split('.')
-        while parts:
-            yield '.'.join(parts)
-            parts.pop()
-
-
-class DevelopInstaller(Installer):
-    def _get_root(self):
-        return repr(str(self.egg_path))
-
-    def _get_target(self):
-        return self.egg_link
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/package_index.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/package_index.py
deleted file mode 100644
index 45fac01a4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/package_index.py
+++ /dev/null
@@ -1,1115 +0,0 @@
-"""PyPI and direct package downloading"""
-import sys
-import os
-import re
-import shutil
-import socket
-import base64
-import hashlib
-import itertools
-from functools import wraps
-
-try:
-    from urllib.parse import splituser
-except ImportError:
-    from urllib2 import splituser
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import urllib, http_client, configparser, map
-
-import setuptools
-from pkg_resources import (
-    CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
-    Environment, find_distributions, safe_name, safe_version,
-    to_filename, Requirement, DEVELOP_DIST,
-)
-from setuptools import ssl_support
-from distutils import log
-from distutils.errors import DistutilsError
-from fnmatch import translate
-from setuptools.py26compat import strip_fragment
-from setuptools.py27compat import get_all_headers
-
-EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.]+)$')
-HREF = re.compile("""href\\s*=\\s*['"]?([^'"> ]+)""", re.I)
-# this is here to fix emacs' cruddy broken syntax highlighting
-PYPI_MD5 = re.compile(
-    '<a href="([^"#]+)">([^<]+)</a>\n\s+\\(<a (?:title="MD5 hash"\n\s+)'
-    'href="[^?]+\?:action=show_md5&amp;digest=([0-9a-f]{32})">md5</a>\\)'
-)
-URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
-EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
-
-__all__ = [
-    'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
-    'interpret_distro_name',
-]
-
-_SOCKET_TIMEOUT = 15
-
-_tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
-user_agent = _tmpl.format(py_major=sys.version[:3], setuptools=setuptools)
-
-
-def parse_requirement_arg(spec):
-    try:
-        return Requirement.parse(spec)
-    except ValueError:
-        raise DistutilsError(
-            "Not a URL, existing file, or requirement spec: %r" % (spec,)
-        )
-
-
-def parse_bdist_wininst(name):
-    """Return (base,pyversion) or (None,None) for possible .exe name"""
-
-    lower = name.lower()
-    base, py_ver, plat = None, None, None
-
-    if lower.endswith('.exe'):
-        if lower.endswith('.win32.exe'):
-            base = name[:-10]
-            plat = 'win32'
-        elif lower.startswith('.win32-py', -16):
-            py_ver = name[-7:-4]
-            base = name[:-16]
-            plat = 'win32'
-        elif lower.endswith('.win-amd64.exe'):
-            base = name[:-14]
-            plat = 'win-amd64'
-        elif lower.startswith('.win-amd64-py', -20):
-            py_ver = name[-7:-4]
-            base = name[:-20]
-            plat = 'win-amd64'
-    return base, py_ver, plat
-
-
-def egg_info_for_url(url):
-    parts = urllib.parse.urlparse(url)
-    scheme, server, path, parameters, query, fragment = parts
-    base = urllib.parse.unquote(path.split('/')[-1])
-    if server == 'sourceforge.net' and base == 'download':  # XXX Yuck
-        base = urllib.parse.unquote(path.split('/')[-2])
-    if '#' in base:
-        base, fragment = base.split('#', 1)
-    return base, fragment
-
-
-def distros_for_url(url, metadata=None):
-    """Yield egg or source distribution objects that might be found at a URL"""
-    base, fragment = egg_info_for_url(url)
-    for dist in distros_for_location(url, base, metadata):
-        yield dist
-    if fragment:
-        match = EGG_FRAGMENT.match(fragment)
-        if match:
-            for dist in interpret_distro_name(
-                url, match.group(1), metadata, precedence=CHECKOUT_DIST
-            ):
-                yield dist
-
-
-def distros_for_location(location, basename, metadata=None):
-    """Yield egg or source distribution objects based on basename"""
-    if basename.endswith('.egg.zip'):
-        basename = basename[:-4]  # strip the .zip
-    if basename.endswith('.egg') and '-' in basename:
-        # only one, unambiguous interpretation
-        return [Distribution.from_location(location, basename, metadata)]
-    if basename.endswith('.exe'):
-        win_base, py_ver, platform = parse_bdist_wininst(basename)
-        if win_base is not None:
-            return interpret_distro_name(
-                location, win_base, metadata, py_ver, BINARY_DIST, platform
-            )
-    # Try source distro extensions (.zip, .tgz, etc.)
-    #
-    for ext in EXTENSIONS:
-        if basename.endswith(ext):
-            basename = basename[:-len(ext)]
-            return interpret_distro_name(location, basename, metadata)
-    return []  # no extension matched
-
-
-def distros_for_filename(filename, metadata=None):
-    """Yield possible egg or source distribution objects based on a filename"""
-    return distros_for_location(
-        normalize_path(filename), os.path.basename(filename), metadata
-    )
-
-
-def interpret_distro_name(
-        location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
-        platform=None
-        ):
-    """Generate alternative interpretations of a source distro name
-
-    Note: if `location` is a filesystem filename, you should call
-    ``pkg_resources.normalize_path()`` on it before passing it to this
-    routine!
-    """
-    # Generate alternative interpretations of a source distro name
-    # Because some packages are ambiguous as to name/versions split
-    # e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
-    # So, we generate each possible interepretation (e.g. "adns, python-1.1.0"
-    # "adns-python, 1.1.0", and "adns-python-1.1.0, no version").  In practice,
-    # the spurious interpretations should be ignored, because in the event
-    # there's also an "adns" package, the spurious "python-1.1.0" version will
-    # compare lower than any numeric version number, and is therefore unlikely
-    # to match a request for it.  It's still a potential problem, though, and
-    # in the long run PyPI and the distutils should go for "safe" names and
-    # versions in distribution archive names (sdist and bdist).
-
-    parts = basename.split('-')
-    if not py_version and any(re.match('py\d\.\d$', p) for p in parts[2:]):
-        # it is a bdist_dumb, not an sdist -- bail out
-        return
-
-    for p in range(1, len(parts) + 1):
-        yield Distribution(
-            location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
-            py_version=py_version, precedence=precedence,
-            platform=platform
-        )
-
-
-# From Python 2.7 docs
-def unique_everseen(iterable, key=None):
-    "List unique elements, preserving order. Remember all elements ever seen."
-    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
-    # unique_everseen('ABBCcAD', str.lower) --> A B C D
-    seen = set()
-    seen_add = seen.add
-    if key is None:
-        for element in six.moves.filterfalse(seen.__contains__, iterable):
-            seen_add(element)
-            yield element
-    else:
-        for element in iterable:
-            k = key(element)
-            if k not in seen:
-                seen_add(k)
-                yield element
-
-
-def unique_values(func):
-    """
-    Wrap a function returning an iterable such that the resulting iterable
-    only ever yields unique items.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return unique_everseen(func(*args, **kwargs))
-
-    return wrapper
-
-
-REL = re.compile("""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
-# this line is here to fix emacs' cruddy broken syntax highlighting
-
-
-@unique_values
-def find_external_links(url, page):
-    """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""
-
-    for match in REL.finditer(page):
-        tag, rel = match.groups()
-        rels = set(map(str.strip, rel.lower().split(',')))
-        if 'homepage' in rels or 'download' in rels:
-            for match in HREF.finditer(tag):
-                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
-    for tag in ("<th>Home Page", "<th>Download URL"):
-        pos = page.find(tag)
-        if pos != -1:
-            match = HREF.search(page, pos)
-            if match:
-                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
-
-
-class ContentChecker(object):
-    """
-    A null content checker that defines the interface for checking content
-    """
-
-    def feed(self, block):
-        """
-        Feed a block of data to the hash.
-        """
-        return
-
-    def is_valid(self):
-        """
-        Check the hash. Return False if validation fails.
-        """
-        return True
-
-    def report(self, reporter, template):
-        """
-        Call reporter with information about the checker (hash name)
-        substituted into the template.
-        """
-        return
-
-
-class HashChecker(ContentChecker):
-    pattern = re.compile(
-        r'(?P<hash_name>sha1|sha224|sha384|sha256|sha512|md5)='
-        r'(?P<expected>[a-f0-9]+)'
-    )
-
-    def __init__(self, hash_name, expected):
-        self.hash_name = hash_name
-        self.hash = hashlib.new(hash_name)
-        self.expected = expected
-
-    @classmethod
-    def from_url(cls, url):
-        "Construct a (possibly null) ContentChecker from a URL"
-        fragment = urllib.parse.urlparse(url)[-1]
-        if not fragment:
-            return ContentChecker()
-        match = cls.pattern.search(fragment)
-        if not match:
-            return ContentChecker()
-        return cls(**match.groupdict())
-
-    def feed(self, block):
-        self.hash.update(block)
-
-    def is_valid(self):
-        return self.hash.hexdigest() == self.expected
-
-    def report(self, reporter, template):
-        msg = template % self.hash_name
-        return reporter(msg)
-
-
-class PackageIndex(Environment):
-    """A distribution index that scans web pages for download URLs"""
-
-    def __init__(
-            self, index_url="https://pypi.python.org/simple", hosts=('*',),
-            ca_bundle=None, verify_ssl=True, *args, **kw
-            ):
-        Environment.__init__(self, *args, **kw)
-        self.index_url = index_url + "/" [:not index_url.endswith('/')]
-        self.scanned_urls = {}
-        self.fetched_urls = {}
-        self.package_pages = {}
-        self.allows = re.compile('|'.join(map(translate, hosts))).match
-        self.to_scan = []
-        use_ssl = (
-            verify_ssl
-            and ssl_support.is_available
-            and (ca_bundle or ssl_support.find_ca_bundle())
-        )
-        if use_ssl:
-            self.opener = ssl_support.opener_for(ca_bundle)
-        else:
-            self.opener = urllib.request.urlopen
-
-    def process_url(self, url, retrieve=False):
-        """Evaluate a URL as a possible download, and maybe retrieve it"""
-        if url in self.scanned_urls and not retrieve:
-            return
-        self.scanned_urls[url] = True
-        if not URL_SCHEME(url):
-            self.process_filename(url)
-            return
-        else:
-            dists = list(distros_for_url(url))
-            if dists:
-                if not self.url_ok(url):
-                    return
-                self.debug("Found link: %s", url)
-
-        if dists or not retrieve or url in self.fetched_urls:
-            list(map(self.add, dists))
-            return  # don't need the actual page
-
-        if not self.url_ok(url):
-            self.fetched_urls[url] = True
-            return
-
-        self.info("Reading %s", url)
-        self.fetched_urls[url] = True  # prevent multiple fetch attempts
-        tmpl = "Download error on %s: %%s -- Some packages may not be found!"
-        f = self.open_url(url, tmpl % url)
-        if f is None:
-            return
-        self.fetched_urls[f.url] = True
-        if 'html' not in f.headers.get('content-type', '').lower():
-            f.close()  # not html, we can't process it
-            return
-
-        base = f.url  # handle redirects
-        page = f.read()
-        if not isinstance(page, str):  # We are in Python 3 and got bytes. We want str.
-            if isinstance(f, urllib.error.HTTPError):
-                # Errors have no charset, assume latin1:
-                charset = 'latin-1'
-            else:
-                charset = f.headers.get_param('charset') or 'latin-1'
-            page = page.decode(charset, "ignore")
-        f.close()
-        for match in HREF.finditer(page):
-            link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
-            self.process_url(link)
-        if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
-            page = self.process_index(url, page)
-
-    def process_filename(self, fn, nested=False):
-        # process filenames or directories
-        if not os.path.exists(fn):
-            self.warn("Not found: %s", fn)
-            return
-
-        if os.path.isdir(fn) and not nested:
-            path = os.path.realpath(fn)
-            for item in os.listdir(path):
-                self.process_filename(os.path.join(path, item), True)
-
-        dists = distros_for_filename(fn)
-        if dists:
-            self.debug("Found: %s", fn)
-            list(map(self.add, dists))
-
-    def url_ok(self, url, fatal=False):
-        s = URL_SCHEME(url)
-        is_file = s and s.group(1).lower() == 'file'
-        if is_file or self.allows(urllib.parse.urlparse(url)[1]):
-            return True
-        msg = ("\nNote: Bypassing %s (disallowed host; see "
-            "http://bit.ly/1dg9ijs for details).\n")
-        if fatal:
-            raise DistutilsError(msg % url)
-        else:
-            self.warn(msg, url)
-
-    def scan_egg_links(self, search_path):
-        dirs = filter(os.path.isdir, search_path)
-        egg_links = (
-            (path, entry)
-            for path in dirs
-            for entry in os.listdir(path)
-            if entry.endswith('.egg-link')
-        )
-        list(itertools.starmap(self.scan_egg_link, egg_links))
-
-    def scan_egg_link(self, path, entry):
-        with open(os.path.join(path, entry)) as raw_lines:
-            # filter non-empty lines
-            lines = list(filter(None, map(str.strip, raw_lines)))
-
-        if len(lines) != 2:
-            # format is not recognized; punt
-            return
-
-        egg_path, setup_path = lines
-
-        for dist in find_distributions(os.path.join(path, egg_path)):
-            dist.location = os.path.join(path, *lines)
-            dist.precedence = SOURCE_DIST
-            self.add(dist)
-
-    def process_index(self, url, page):
-        """Process the contents of a PyPI page"""
-
-        def scan(link):
-            # Process a URL to see if it's for a package page
-            if link.startswith(self.index_url):
-                parts = list(map(
-                    urllib.parse.unquote, link[len(self.index_url):].split('/')
-                ))
-                if len(parts) == 2 and '#' not in parts[1]:
-                    # it's a package page, sanitize and index it
-                    pkg = safe_name(parts[0])
-                    ver = safe_version(parts[1])
-                    self.package_pages.setdefault(pkg.lower(), {})[link] = True
-                    return to_filename(pkg), to_filename(ver)
-            return None, None
-
-        # process an index page into the package-page index
-        for match in HREF.finditer(page):
-            try:
-                scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
-            except ValueError:
-                pass
-
-        pkg, ver = scan(url)  # ensure this page is in the page index
-        if pkg:
-            # process individual package page
-            for new_url in find_external_links(url, page):
-                # Process the found URL
-                base, frag = egg_info_for_url(new_url)
-                if base.endswith('.py') and not frag:
-                    if ver:
-                        new_url += '#egg=%s-%s' % (pkg, ver)
-                    else:
-                        self.need_version_info(url)
-                self.scan_url(new_url)
-
-            return PYPI_MD5.sub(
-                lambda m: '<a href="%s#md5=%s">%s</a>' % m.group(1, 3, 2), page
-            )
-        else:
-            return ""  # no sense double-scanning non-package pages
-
-    def need_version_info(self, url):
-        self.scan_all(
-            "Page at %s links to .py file(s) without version info; an index "
-            "scan is required.", url
-        )
-
-    def scan_all(self, msg=None, *args):
-        if self.index_url not in self.fetched_urls:
-            if msg:
-                self.warn(msg, *args)
-            self.info(
-                "Scanning index of all packages (this may take a while)"
-            )
-        self.scan_url(self.index_url)
-
-    def find_packages(self, requirement):
-        self.scan_url(self.index_url + requirement.unsafe_name + '/')
-
-        if not self.package_pages.get(requirement.key):
-            # Fall back to safe version of the name
-            self.scan_url(self.index_url + requirement.project_name + '/')
-
-        if not self.package_pages.get(requirement.key):
-            # We couldn't find the target package, so search the index page too
-            self.not_found_in_index(requirement)
-
-        for url in list(self.package_pages.get(requirement.key, ())):
-            # scan each page that might be related to the desired package
-            self.scan_url(url)
-
-    def obtain(self, requirement, installer=None):
-        self.prescan()
-        self.find_packages(requirement)
-        for dist in self[requirement.key]:
-            if dist in requirement:
-                return dist
-            self.debug("%s does not match %s", requirement, dist)
-        return super(PackageIndex, self).obtain(requirement, installer)
-
-    def check_hash(self, checker, filename, tfp):
-        """
-        checker is a ContentChecker
-        """
-        checker.report(self.debug,
-            "Validating %%s checksum for %s" % filename)
-        if not checker.is_valid():
-            tfp.close()
-            os.unlink(filename)
-            raise DistutilsError(
-                "%s validation failed for %s; "
-                "possible download problem?" % (
-                                checker.hash.name, os.path.basename(filename))
-            )
-
-    def add_find_links(self, urls):
-        """Add `urls` to the list that will be prescanned for searches"""
-        for url in urls:
-            if (
-                self.to_scan is None  # if we have already "gone online"
-                or not URL_SCHEME(url)  # or it's a local file/directory
-                or url.startswith('file:')
-                or list(distros_for_url(url))  # or a direct package link
-            ):
-                # then go ahead and process it now
-                self.scan_url(url)
-            else:
-                # otherwise, defer retrieval till later
-                self.to_scan.append(url)
-
-    def prescan(self):
-        """Scan urls scheduled for prescanning (e.g. --find-links)"""
-        if self.to_scan:
-            list(map(self.scan_url, self.to_scan))
-        self.to_scan = None  # from now on, go ahead and process immediately
-
-    def not_found_in_index(self, requirement):
-        if self[requirement.key]:  # we've seen at least one distro
-            meth, msg = self.info, "Couldn't retrieve index page for %r"
-        else:  # no distros seen for this name, might be misspelled
-            meth, msg = (self.warn,
-                "Couldn't find index page for %r (maybe misspelled?)")
-        meth(msg, requirement.unsafe_name)
-        self.scan_all()
-
-    def download(self, spec, tmpdir):
-        """Locate and/or download `spec` to `tmpdir`, returning a local path
-
-        `spec` may be a ``Requirement`` object, or a string containing a URL,
-        an existing local filename, or a project/version requirement spec
-        (i.e. the string form of a ``Requirement`` object).  If it is the URL
-        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
-        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
-        automatically created alongside the downloaded file.
-
-        If `spec` is a ``Requirement`` object or a string containing a
-        project/version requirement spec, this method returns the location of
-        a matching distribution (possibly after downloading it to `tmpdir`).
-        If `spec` is a locally existing file or directory name, it is simply
-        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath
-        of `tmpdir`, and the local filename is returned.  Various errors may be
-        raised if a problem occurs during downloading.
-        """
-        if not isinstance(spec, Requirement):
-            scheme = URL_SCHEME(spec)
-            if scheme:
-                # It's a url, download it to tmpdir
-                found = self._download_url(scheme.group(1), spec, tmpdir)
-                base, fragment = egg_info_for_url(spec)
-                if base.endswith('.py'):
-                    found = self.gen_setup(found, fragment, tmpdir)
-                return found
-            elif os.path.exists(spec):
-                # Existing file or directory, just return it
-                return spec
-            else:
-                spec = parse_requirement_arg(spec)
-        return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)
-
-    def fetch_distribution(
-            self, requirement, tmpdir, force_scan=False, source=False,
-            develop_ok=False, local_index=None
-            ):
-        """Obtain a distribution suitable for fulfilling `requirement`
-
-        `requirement` must be a ``pkg_resources.Requirement`` instance.
-        If necessary, or if the `force_scan` flag is set, the requirement is
-        searched for in the (online) package index as well as the locally
-        installed packages.  If a distribution matching `requirement` is found,
-        the returned distribution's ``location`` is the value you would have
-        gotten from calling the ``download()`` method with the matching
-        distribution's URL or filename.  If no matching distribution is found,
-        ``None`` is returned.
-
-        If the `source` flag is set, only source distributions and source
-        checkout links will be considered.  Unless the `develop_ok` flag is
-        set, development and system eggs (i.e., those using the ``.egg-info``
-        format) will be ignored.
-        """
-        # process a Requirement
-        self.info("Searching for %s", requirement)
-        skipped = {}
-        dist = None
-
-        def find(req, env=None):
-            if env is None:
-                env = self
-            # Find a matching distribution; may be called more than once
-
-            for dist in env[req.key]:
-
-                if dist.precedence == DEVELOP_DIST and not develop_ok:
-                    if dist not in skipped:
-                        self.warn("Skipping development or system egg: %s", dist)
-                        skipped[dist] = 1
-                    continue
-
-                if dist in req and (dist.precedence <= SOURCE_DIST or not source):
-                    dist.download_location = self.download(dist.location, tmpdir)
-                    if os.path.exists(dist.download_location):
-                        return dist
-
-        if force_scan:
-            self.prescan()
-            self.find_packages(requirement)
-            dist = find(requirement)
-
-        if not dist and local_index is not None:
-            dist = find(requirement, local_index)
-
-        if dist is None:
-            if self.to_scan is not None:
-                self.prescan()
-            dist = find(requirement)
-
-        if dist is None and not force_scan:
-            self.find_packages(requirement)
-            dist = find(requirement)
-
-        if dist is None:
-            self.warn(
-                "No local packages or working download links found for %s%s",
-                (source and "a source distribution of " or ""),
-                requirement,
-            )
-        else:
-            self.info("Best match: %s", dist)
-            return dist.clone(location=dist.download_location)
-
-    def fetch(self, requirement, tmpdir, force_scan=False, source=False):
-        """Obtain a file suitable for fulfilling `requirement`
-
-        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For
-        backward compatibility, this routine is identical but returns the
-        ``location`` of the downloaded distribution instead of a distribution
-        object.
-        """
-        dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
-        if dist is not None:
-            return dist.location
-        return None
-
-    def gen_setup(self, filename, fragment, tmpdir):
-        match = EGG_FRAGMENT.match(fragment)
-        dists = match and [
-            d for d in
-            interpret_distro_name(filename, match.group(1), None) if d.version
-        ] or []
-
-        if len(dists) == 1:  # unambiguous ``#egg`` fragment
-            basename = os.path.basename(filename)
-
-            # Make sure the file has been downloaded to the temp dir.
-            if os.path.dirname(filename) != tmpdir:
-                dst = os.path.join(tmpdir, basename)
-                from setuptools.command.easy_install import samefile
-                if not samefile(filename, dst):
-                    shutil.copy2(filename, dst)
-                    filename = dst
-
-            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
-                file.write(
-                    "from setuptools import setup\n"
-                    "setup(name=%r, version=%r, py_modules=[%r])\n"
-                    % (
-                        dists[0].project_name, dists[0].version,
-                        os.path.splitext(basename)[0]
-                    )
-                )
-            return filename
-
-        elif match:
-            raise DistutilsError(
-                "Can't unambiguously interpret project/version identifier %r; "
-                "any dashes in the name or version should be escaped using "
-                "underscores. %r" % (fragment, dists)
-            )
-        else:
-            raise DistutilsError(
-                "Can't process plain .py files without an '#egg=name-version'"
-                " suffix to enable automatic setup script generation."
-            )
-
-    dl_blocksize = 8192
-
-    def _download_to(self, url, filename):
-        self.info("Downloading %s", url)
-        # Download the file
-        fp, info = None, None
-        try:
-            checker = HashChecker.from_url(url)
-            fp = self.open_url(strip_fragment(url))
-            if isinstance(fp, urllib.error.HTTPError):
-                raise DistutilsError(
-                    "Can't download %s: %s %s" % (url, fp.code, fp.msg)
-                )
-            headers = fp.info()
-            blocknum = 0
-            bs = self.dl_blocksize
-            size = -1
-            if "content-length" in headers:
-                # Some servers return multiple Content-Length headers :(
-                sizes = get_all_headers(headers, 'Content-Length')
-                size = max(map(int, sizes))
-                self.reporthook(url, filename, blocknum, bs, size)
-            with open(filename, 'wb') as tfp:
-                while True:
-                    block = fp.read(bs)
-                    if block:
-                        checker.feed(block)
-                        tfp.write(block)
-                        blocknum += 1
-                        self.reporthook(url, filename, blocknum, bs, size)
-                    else:
-                        break
-                self.check_hash(checker, filename, tfp)
-            return headers
-        finally:
-            if fp:
-                fp.close()
-
-    def reporthook(self, url, filename, blocknum, blksize, size):
-        pass  # no-op
-
-    def open_url(self, url, warning=None):
-        if url.startswith('file:'):
-            return local_open(url)
-        try:
-            return open_with_auth(url, self.opener)
-        except (ValueError, http_client.InvalidURL) as v:
-            msg = ' '.join([str(arg) for arg in v.args])
-            if warning:
-                self.warn(warning, msg)
-            else:
-                raise DistutilsError('%s %s' % (url, msg))
-        except urllib.error.HTTPError as v:
-            return v
-        except urllib.error.URLError as v:
-            if warning:
-                self.warn(warning, v.reason)
-            else:
-                raise DistutilsError("Download error for %s: %s"
-                                     % (url, v.reason))
-        except http_client.BadStatusLine as v:
-            if warning:
-                self.warn(warning, v.line)
-            else:
-                raise DistutilsError(
-                    '%s returned a bad status line. The server might be '
-                    'down, %s' %
-                    (url, v.line)
-                )
-        except (http_client.HTTPException, socket.error) as v:
-            if warning:
-                self.warn(warning, v)
-            else:
-                raise DistutilsError("Download error for %s: %s"
-                                     % (url, v))
-
-    def _download_url(self, scheme, url, tmpdir):
-        # Determine download filename
-        #
-        name, fragment = egg_info_for_url(url)
-        if name:
-            while '..' in name:
-                name = name.replace('..', '.').replace('\\', '_')
-        else:
-            name = "__downloaded__"  # default if URL has no path contents
-
-        if name.endswith('.egg.zip'):
-            name = name[:-4]  # strip the extra .zip before download
-
-        filename = os.path.join(tmpdir, name)
-
-        # Download the file
-        #
-        if scheme == 'svn' or scheme.startswith('svn+'):
-            return self._download_svn(url, filename)
-        elif scheme == 'git' or scheme.startswith('git+'):
-            return self._download_git(url, filename)
-        elif scheme.startswith('hg+'):
-            return self._download_hg(url, filename)
-        elif scheme == 'file':
-            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
-        else:
-            self.url_ok(url, True)  # raises error if not allowed
-            return self._attempt_download(url, filename)
-
-    def scan_url(self, url):
-        self.process_url(url, True)
-
-    def _attempt_download(self, url, filename):
-        headers = self._download_to(url, filename)
-        if 'html' in headers.get('content-type', '').lower():
-            return self._download_html(url, headers, filename)
-        else:
-            return filename
-
-    def _download_html(self, url, headers, filename):
-        file = open(filename)
-        for line in file:
-            if line.strip():
-                # Check for a subversion index page
-                if re.search(r'<title>([^- ]+ - )?Revision \d+:', line):
-                    # it's a subversion index page:
-                    file.close()
-                    os.unlink(filename)
-                    return self._download_svn(url, filename)
-                break  # not an index page
-        file.close()
-        os.unlink(filename)
-        raise DistutilsError("Unexpected HTML page found at " + url)
-
-    def _download_svn(self, url, filename):
-        url = url.split('#', 1)[0]  # remove any fragment for svn's sake
-        creds = ''
-        if url.lower().startswith('svn:') and '@' in url:
-            scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
-            if not netloc and path.startswith('//') and '/' in path[2:]:
-                netloc, path = path[2:].split('/', 1)
-                auth, host = splituser(netloc)
-                if auth:
-                    if ':' in auth:
-                        user, pw = auth.split(':', 1)
-                        creds = " --username=%s --password=%s" % (user, pw)
-                    else:
-                        creds = " --username=" + auth
-                    netloc = host
-                    parts = scheme, netloc, url, p, q, f
-                    url = urllib.parse.urlunparse(parts)
-        self.info("Doing subversion checkout from %s to %s", url, filename)
-        os.system("svn checkout%s -q %s %s" % (creds, url, filename))
-        return filename
-
-    @staticmethod
-    def _vcs_split_rev_from_url(url, pop_prefix=False):
-        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
-
-        scheme = scheme.split('+', 1)[-1]
-
-        # Some fragment identification fails
-        path = path.split('#', 1)[0]
-
-        rev = None
-        if '@' in path:
-            path, rev = path.rsplit('@', 1)
-
-        # Also, discard fragment
-        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))
-
-        return url, rev
-
-    def _download_git(self, url, filename):
-        filename = filename.split('#', 1)[0]
-        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
-        self.info("Doing git clone from %s to %s", url, filename)
-        os.system("git clone --quiet %s %s" % (url, filename))
-
-        if rev is not None:
-            self.info("Checking out %s", rev)
-            os.system("(cd %s && git checkout --quiet %s)" % (
-                filename,
-                rev,
-            ))
-
-        return filename
-
-    def _download_hg(self, url, filename):
-        filename = filename.split('#', 1)[0]
-        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
-
-        self.info("Doing hg clone from %s to %s", url, filename)
-        os.system("hg clone --quiet %s %s" % (url, filename))
-
-        if rev is not None:
-            self.info("Updating to %s", rev)
-            os.system("(cd %s && hg up -C -r %s >&-)" % (
-                filename,
-                rev,
-            ))
-
-        return filename
-
-    def debug(self, msg, *args):
-        log.debug(msg, *args)
-
-    def info(self, msg, *args):
-        log.info(msg, *args)
-
-    def warn(self, msg, *args):
-        log.warn(msg, *args)
-
-
-# This pattern matches a character entity reference (a decimal numeric
-# references, a hexadecimal numeric reference, or a named reference).
-entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
-
-
-def uchr(c):
-    if not isinstance(c, int):
-        return c
-    if c > 255:
-        return six.unichr(c)
-    return chr(c)
-
-
-def decode_entity(match):
-    what = match.group(1)
-    if what.startswith('#x'):
-        what = int(what[2:], 16)
-    elif what.startswith('#'):
-        what = int(what[1:])
-    else:
-        what = six.moves.html_entities.name2codepoint.get(what, match.group(0))
-    return uchr(what)
-
-
-def htmldecode(text):
-    """Decode HTML entities in the given text."""
-    return entity_sub(decode_entity, text)
-
-
-def socket_timeout(timeout=15):
-    def _socket_timeout(func):
-        def _socket_timeout(*args, **kwargs):
-            old_timeout = socket.getdefaulttimeout()
-            socket.setdefaulttimeout(timeout)
-            try:
-                return func(*args, **kwargs)
-            finally:
-                socket.setdefaulttimeout(old_timeout)
-
-        return _socket_timeout
-
-    return _socket_timeout
-
-
-def _encode_auth(auth):
-    """
-    A function compatible with Python 2.3-3.3 that will encode
-    auth from a URL suitable for an HTTP header.
-    >>> str(_encode_auth('username%3Apassword'))
-    'dXNlcm5hbWU6cGFzc3dvcmQ='
-
-    Long auth strings should not cause a newline to be inserted.
-    >>> long_auth = 'username:' + 'password'*10
-    >>> chr(10) in str(_encode_auth(long_auth))
-    False
-    """
-    auth_s = urllib.parse.unquote(auth)
-    # convert to bytes
-    auth_bytes = auth_s.encode()
-    # use the legacy interface for Python 2.3 support
-    encoded_bytes = base64.encodestring(auth_bytes)
-    # convert back to a string
-    encoded = encoded_bytes.decode()
-    # strip the trailing carriage return
-    return encoded.replace('\n', '')
-
-
-class Credential(object):
-    """
-    A username/password pair. Use like a namedtuple.
-    """
-
-    def __init__(self, username, password):
-        self.username = username
-        self.password = password
-
-    def __iter__(self):
-        yield self.username
-        yield self.password
-
-    def __str__(self):
-        return '%(username)s:%(password)s' % vars(self)
-
-
-class PyPIConfig(configparser.RawConfigParser):
-    def __init__(self):
-        """
-        Load from ~/.pypirc
-        """
-        defaults = dict.fromkeys(['username', 'password', 'repository'], '')
-        configparser.RawConfigParser.__init__(self, defaults)
-
-        rc = os.path.join(os.path.expanduser('~'), '.pypirc')
-        if os.path.exists(rc):
-            self.read(rc)
-
-    @property
-    def creds_by_repository(self):
-        sections_with_repositories = [
-            section for section in self.sections()
-            if self.get(section, 'repository').strip()
-        ]
-
-        return dict(map(self._get_repo_cred, sections_with_repositories))
-
-    def _get_repo_cred(self, section):
-        repo = self.get(section, 'repository').strip()
-        return repo, Credential(
-            self.get(section, 'username').strip(),
-            self.get(section, 'password').strip(),
-        )
-
-    def find_credential(self, url):
-        """
-        If the URL indicated appears to be a repository defined in this
-        config, return the credential for that repository.
-        """
-        for repository, cred in self.creds_by_repository.items():
-            if url.startswith(repository):
-                return cred
-
-
-def open_with_auth(url, opener=urllib.request.urlopen):
-    """Open a urllib2 request, handling HTTP authentication"""
-
-    scheme, netloc, path, params, query, frag = urllib.parse.urlparse(url)
-
-    # Double scheme does not raise on Mac OS X as revealed by a
-    # failing test. We would expect "nonnumeric port". Refs #20.
-    if netloc.endswith(':'):
-        raise http_client.InvalidURL("nonnumeric port: ''")
-
-    if scheme in ('http', 'https'):
-        auth, host = splituser(netloc)
-    else:
-        auth = None
-
-    if not auth:
-        cred = PyPIConfig().find_credential(url)
-        if cred:
-            auth = str(cred)
-            info = cred.username, url
-            log.info('Authenticating as %s for %s (from .pypirc)', *info)
-
-    if auth:
-        auth = "Basic " + _encode_auth(auth)
-        parts = scheme, host, path, params, query, frag
-        new_url = urllib.parse.urlunparse(parts)
-        request = urllib.request.Request(new_url)
-        request.add_header("Authorization", auth)
-    else:
-        request = urllib.request.Request(url)
-
-    request.add_header('User-Agent', user_agent)
-    fp = opener(request)
-
-    if auth:
-        # Put authentication info back into request URL if same host,
-        # so that links found on the page will work
-        s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
-        if s2 == scheme and h2 == host:
-            parts = s2, netloc, path2, param2, query2, frag2
-            fp.url = urllib.parse.urlunparse(parts)
-
-    return fp
-
-
-# adding a timeout to avoid freezing package_index
-open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)
-
-
-def fix_sf_url(url):
-    return url  # backward compatibility
-
-
-def local_open(url):
-    """Read a local path, with special support for directories"""
-    scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
-    filename = urllib.request.url2pathname(path)
-    if os.path.isfile(filename):
-        return urllib.request.urlopen(url)
-    elif path.endswith('/') and os.path.isdir(filename):
-        files = []
-        for f in os.listdir(filename):
-            filepath = os.path.join(filename, f)
-            if f == 'index.html':
-                with open(filepath, 'r') as fp:
-                    body = fp.read()
-                break
-            elif os.path.isdir(filepath):
-                f += '/'
-            files.append('<a href="{name}">{name}</a>'.format(name=f))
-        else:
-            tmpl = ("<html><head><title>{url}</title>"
-                "</head><body>{files}</body></html>")
-            body = tmpl.format(url=url, files='\n'.join(files))
-        status, message = 200, "OK"
-    else:
-        status, message, body = 404, "Path not found", "Not found"
-
-    headers = {'content-type': 'text/html'}
-    body_stream = six.StringIO(body)
-    return urllib.error.HTTPError(url, status, message, headers, body_stream)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py26compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py26compat.py
deleted file mode 100644
index 4d3add8ca..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py26compat.py
+++ /dev/null
@@ -1,31 +0,0 @@
-"""
-Compatibility Support for Python 2.6 and earlier
-"""
-
-import sys
-
-try:
-    from urllib.parse import splittag
-except ImportError:
-    from urllib import splittag
-
-
-def strip_fragment(url):
-    """
-    In `Python 8280 <http://bugs.python.org/issue8280>`_, Python 2.7 and
-    later was patched to disregard the fragment when making URL requests.
-    Do the same for Python 2.6 and earlier.
-    """
-    url, fragment = splittag(url)
-    return url
-
-
-if sys.version_info >= (2, 7):
-    strip_fragment = lambda x: x
-
-try:
-    from importlib import import_module
-except ImportError:
-
-    def import_module(module_name):
-        return __import__(module_name, fromlist=['__name__'])
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py27compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py27compat.py
deleted file mode 100644
index a71a936e1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py27compat.py
+++ /dev/null
@@ -1,29 +0,0 @@
-"""
-Compatibility Support for Python 2.7 and earlier
-"""
-
-import sys
-import platform
-
-
-def get_all_headers(message, key):
-    """
-    Given an HTTPMessage, return all headers matching a given key.
-    """
-    return message.get_all(key)
-
-
-if sys.version_info < (3,):
-
-    def get_all_headers(message, key):
-        return message.getheaders(key)
-
-
-linux_py2_ascii = (
-	platform.system() == 'Linux' and
-	sys.getfilesystemencoding() == 'ascii' and
-	sys.version_info < (3,)
-)
-
-rmtree_safe = str if linux_py2_ascii else lambda x: x
-"""Workaround for http://bugs.python.org/issue24672"""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py31compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py31compat.py
deleted file mode 100644
index 44b025d4b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py31compat.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import sys
-import unittest
-
-__all__ = ['get_config_vars', 'get_path']
-
-try:
-    # Python 2.7 or >=3.2
-    from sysconfig import get_config_vars, get_path
-except ImportError:
-    from distutils.sysconfig import get_config_vars, get_python_lib
-
-    def get_path(name):
-        if name not in ('platlib', 'purelib'):
-            raise ValueError("Name must be purelib or platlib")
-        return get_python_lib(name == 'platlib')
-
-
-try:
-    # Python >=3.2
-    from tempfile import TemporaryDirectory
-except ImportError:
-    import shutil
-    import tempfile
-
-    class TemporaryDirectory(object):
-        """
-        Very simple temporary directory context manager.
-        Will try to delete afterward, but will also ignore OS and similar
-        errors on deletion.
-        """
-
-        def __init__(self):
-            self.name = None  # Handle mkdtemp raising an exception
-            self.name = tempfile.mkdtemp()
-
-        def __enter__(self):
-            return self.name
-
-        def __exit__(self, exctype, excvalue, exctrace):
-            try:
-                shutil.rmtree(self.name, True)
-            except OSError:  # removal errors are not the only possible
-                pass
-            self.name = None
-
-
-unittest_main = unittest.main
-
-_PY31 = (3, 1) <= sys.version_info[:2] < (3, 2)
-if _PY31:
-    # on Python 3.1, translate testRunner==None to TextTestRunner
-    # for compatibility with Python 2.6, 2.7, and 3.2+
-    def unittest_main(*args, **kwargs):
-        if 'testRunner' in kwargs and kwargs['testRunner'] is None:
-            kwargs['testRunner'] = unittest.TextTestRunner
-        return unittest.main(*args, **kwargs)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py33compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py33compat.py
deleted file mode 100644
index af64d5d1e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py33compat.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import dis
-import array
-import collections
-
-from setuptools.extern import six
-
-
-OpArg = collections.namedtuple('OpArg', 'opcode arg')
-
-
-class Bytecode_compat(object):
-    def __init__(self, code):
-        self.code = code
-
-    def __iter__(self):
-        """Yield '(op,arg)' pair for each operation in code object 'code'"""
-
-        bytes = array.array('b', self.code.co_code)
-        eof = len(self.code.co_code)
-
-        ptr = 0
-        extended_arg = 0
-
-        while ptr < eof:
-
-            op = bytes[ptr]
-
-            if op >= dis.HAVE_ARGUMENT:
-
-                arg = bytes[ptr + 1] + bytes[ptr + 2] * 256 + extended_arg
-                ptr += 3
-
-                if op == dis.EXTENDED_ARG:
-                    long_type = six.integer_types[-1]
-                    extended_arg = arg * long_type(65536)
-                    continue
-
-            else:
-                arg = None
-                ptr += 1
-
-            yield OpArg(op, arg)
-
-
-Bytecode = getattr(dis, 'Bytecode', Bytecode_compat)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py36compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py36compat.py
deleted file mode 100644
index f52796964..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/py36compat.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import sys
-from distutils.errors import DistutilsOptionError
-from distutils.util import strtobool
-from distutils.debug import DEBUG
-
-
-class Distribution_parse_config_files:
-    """
-    Mix-in providing forward-compatibility for functionality to be
-    included by default on Python 3.7.
-
-    Do not edit the code in this class except to update functionality
-    as implemented in distutils.
-    """
-    def parse_config_files(self, filenames=None):
-        from configparser import ConfigParser
-
-        # Ignore install directory options if we have a venv
-        if sys.prefix != sys.base_prefix:
-            ignore_options = [
-                'install-base', 'install-platbase', 'install-lib',
-                'install-platlib', 'install-purelib', 'install-headers',
-                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
-                'home', 'user', 'root']
-        else:
-            ignore_options = []
-
-        ignore_options = frozenset(ignore_options)
-
-        if filenames is None:
-            filenames = self.find_config_files()
-
-        if DEBUG:
-            self.announce("Distribution.parse_config_files():")
-
-        parser = ConfigParser(interpolation=None)
-        for filename in filenames:
-            if DEBUG:
-                self.announce("  reading %s" % filename)
-            parser.read(filename)
-            for section in parser.sections():
-                options = parser.options(section)
-                opt_dict = self.get_option_dict(section)
-
-                for opt in options:
-                    if opt != '__name__' and opt not in ignore_options:
-                        val = parser.get(section,opt)
-                        opt = opt.replace('-', '_')
-                        opt_dict[opt] = (filename, val)
-
-            # Make the ConfigParser forget everything (so we retain
-            # the original filenames that options come from)
-            parser.__init__()
-
-        # If there was a "global" section in the config file, use it
-        # to set Distribution options.
-
-        if 'global' in self.command_options:
-            for (opt, (src, val)) in self.command_options['global'].items():
-                alias = self.negative_opt.get(opt)
-                try:
-                    if alias:
-                        setattr(self, alias, not strtobool(val))
-                    elif opt in ('verbose', 'dry_run'): # ugh!
-                        setattr(self, opt, strtobool(val))
-                    else:
-                        setattr(self, opt, val)
-                except ValueError as msg:
-                    raise DistutilsOptionError(msg)
-
-
-if sys.version_info < (3,):
-    # Python 2 behavior is sufficient
-    class Distribution_parse_config_files:
-        pass
-
-
-if False:
-    # When updated behavior is available upstream,
-    # disable override here.
-    class Distribution_parse_config_files:
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/sandbox.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/sandbox.py
deleted file mode 100644
index 817a3afaa..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/sandbox.py
+++ /dev/null
@@ -1,491 +0,0 @@
-import os
-import sys
-import tempfile
-import operator
-import functools
-import itertools
-import re
-import contextlib
-import pickle
-
-from setuptools.extern import six
-from setuptools.extern.six.moves import builtins, map
-
-import pkg_resources
-
-if sys.platform.startswith('java'):
-    import org.python.modules.posix.PosixModule as _os
-else:
-    _os = sys.modules[os.name]
-try:
-    _file = file
-except NameError:
-    _file = None
-_open = open
-from distutils.errors import DistutilsError
-from pkg_resources import working_set
-
-__all__ = [
-    "AbstractSandbox", "DirectorySandbox", "SandboxViolation", "run_setup",
-]
-
-
-def _execfile(filename, globals, locals=None):
-    """
-    Python 3 implementation of execfile.
-    """
-    mode = 'rb'
-    with open(filename, mode) as stream:
-        script = stream.read()
-    # compile() function in Python 2.6 and 3.1 requires LF line endings.
-    if sys.version_info[:2] < (2, 7) or sys.version_info[:2] >= (3, 0) and sys.version_info[:2] < (3, 2):
-        script = script.replace(b'\r\n', b'\n')
-        script = script.replace(b'\r', b'\n')
-    if locals is None:
-        locals = globals
-    code = compile(script, filename, 'exec')
-    exec(code, globals, locals)
-
-
-@contextlib.contextmanager
-def save_argv(repl=None):
-    saved = sys.argv[:]
-    if repl is not None:
-        sys.argv[:] = repl
-    try:
-        yield saved
-    finally:
-        sys.argv[:] = saved
-
-
-@contextlib.contextmanager
-def save_path():
-    saved = sys.path[:]
-    try:
-        yield saved
-    finally:
-        sys.path[:] = saved
-
-
-@contextlib.contextmanager
-def override_temp(replacement):
-    """
-    Monkey-patch tempfile.tempdir with replacement, ensuring it exists
-    """
-    if not os.path.isdir(replacement):
-        os.makedirs(replacement)
-
-    saved = tempfile.tempdir
-
-    tempfile.tempdir = replacement
-
-    try:
-        yield
-    finally:
-        tempfile.tempdir = saved
-
-
-@contextlib.contextmanager
-def pushd(target):
-    saved = os.getcwd()
-    os.chdir(target)
-    try:
-        yield saved
-    finally:
-        os.chdir(saved)
-
-
-class UnpickleableException(Exception):
-    """
-    An exception representing another Exception that could not be pickled.
-    """
-
-    @staticmethod
-    def dump(type, exc):
-        """
-        Always return a dumped (pickled) type and exc. If exc can't be pickled,
-        wrap it in UnpickleableException first.
-        """
-        try:
-            return pickle.dumps(type), pickle.dumps(exc)
-        except Exception:
-            # get UnpickleableException inside the sandbox
-            from setuptools.sandbox import UnpickleableException as cls
-            return cls.dump(cls, cls(repr(exc)))
-
-
-class ExceptionSaver:
-    """
-    A Context Manager that will save an exception, serialized, and restore it
-    later.
-    """
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, exc, tb):
-        if not exc:
-            return
-
-        # dump the exception
-        self._saved = UnpickleableException.dump(type, exc)
-        self._tb = tb
-
-        # suppress the exception
-        return True
-
-    def resume(self):
-        "restore and re-raise any exception"
-
-        if '_saved' not in vars(self):
-            return
-
-        type, exc = map(pickle.loads, self._saved)
-        six.reraise(type, exc, self._tb)
-
-
-@contextlib.contextmanager
-def save_modules():
-    """
-    Context in which imported modules are saved.
-
-    Translates exceptions internal to the context into the equivalent exception
-    outside the context.
-    """
-    saved = sys.modules.copy()
-    with ExceptionSaver() as saved_exc:
-        yield saved
-
-    sys.modules.update(saved)
-    # remove any modules imported since
-    del_modules = (
-        mod_name for mod_name in sys.modules
-        if mod_name not in saved
-        # exclude any encodings modules. See #285
-        and not mod_name.startswith('encodings.')
-    )
-    _clear_modules(del_modules)
-
-    saved_exc.resume()
-
-
-def _clear_modules(module_names):
-    for mod_name in list(module_names):
-        del sys.modules[mod_name]
-
-
-@contextlib.contextmanager
-def save_pkg_resources_state():
-    saved = pkg_resources.__getstate__()
-    try:
-        yield saved
-    finally:
-        pkg_resources.__setstate__(saved)
-
-
-@contextlib.contextmanager
-def setup_context(setup_dir):
-    temp_dir = os.path.join(setup_dir, 'temp')
-    with save_pkg_resources_state():
-        with save_modules():
-            hide_setuptools()
-            with save_path():
-                with save_argv():
-                    with override_temp(temp_dir):
-                        with pushd(setup_dir):
-                            # ensure setuptools commands are available
-                            __import__('setuptools')
-                            yield
-
-
-def _needs_hiding(mod_name):
-    """
-    >>> _needs_hiding('setuptools')
-    True
-    >>> _needs_hiding('pkg_resources')
-    True
-    >>> _needs_hiding('setuptools_plugin')
-    False
-    >>> _needs_hiding('setuptools.__init__')
-    True
-    >>> _needs_hiding('distutils')
-    True
-    >>> _needs_hiding('os')
-    False
-    >>> _needs_hiding('Cython')
-    True
-    """
-    pattern = re.compile('(setuptools|pkg_resources|distutils|Cython)(\.|$)')
-    return bool(pattern.match(mod_name))
-
-
-def hide_setuptools():
-    """
-    Remove references to setuptools' modules from sys.modules to allow the
-    invocation to import the most appropriate setuptools. This technique is
-    necessary to avoid issues such as #315 where setuptools upgrading itself
-    would fail to find a function declared in the metadata.
-    """
-    modules = filter(_needs_hiding, sys.modules)
-    _clear_modules(modules)
-
-
-def run_setup(setup_script, args):
-    """Run a distutils setup script, sandboxed in its directory"""
-    setup_dir = os.path.abspath(os.path.dirname(setup_script))
-    with setup_context(setup_dir):
-        try:
-            sys.argv[:] = [setup_script] + list(args)
-            sys.path.insert(0, setup_dir)
-            # reset to include setup dir, w/clean callback list
-            working_set.__init__()
-            working_set.callbacks.append(lambda dist: dist.activate())
-
-            # __file__ should be a byte string on Python 2 (#712)
-            dunder_file = (
-                setup_script
-                if isinstance(setup_script, str) else
-                setup_script.encode(sys.getfilesystemencoding())
-            )
-
-            def runner():
-                ns = dict(__file__=dunder_file, __name__='__main__')
-                _execfile(setup_script, ns)
-
-            DirectorySandbox(setup_dir).run(runner)
-        except SystemExit as v:
-            if v.args and v.args[0]:
-                raise
-            # Normal exit, just return
-
-
-class AbstractSandbox:
-    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts"""
-
-    _active = False
-
-    def __init__(self):
-        self._attrs = [
-            name for name in dir(_os)
-            if not name.startswith('_') and hasattr(self, name)
-        ]
-
-    def _copy(self, source):
-        for name in self._attrs:
-            setattr(os, name, getattr(source, name))
-
-    def run(self, func):
-        """Run 'func' under os sandboxing"""
-        try:
-            self._copy(self)
-            if _file:
-                builtins.file = self._file
-            builtins.open = self._open
-            self._active = True
-            return func()
-        finally:
-            self._active = False
-            if _file:
-                builtins.file = _file
-            builtins.open = _open
-            self._copy(_os)
-
-    def _mk_dual_path_wrapper(name):
-        original = getattr(_os, name)
-
-        def wrap(self, src, dst, *args, **kw):
-            if self._active:
-                src, dst = self._remap_pair(name, src, dst, *args, **kw)
-            return original(src, dst, *args, **kw)
-
-        return wrap
-
-    for name in ["rename", "link", "symlink"]:
-        if hasattr(_os, name):
-            locals()[name] = _mk_dual_path_wrapper(name)
-
-    def _mk_single_path_wrapper(name, original=None):
-        original = original or getattr(_os, name)
-
-        def wrap(self, path, *args, **kw):
-            if self._active:
-                path = self._remap_input(name, path, *args, **kw)
-            return original(path, *args, **kw)
-
-        return wrap
-
-    if _file:
-        _file = _mk_single_path_wrapper('file', _file)
-    _open = _mk_single_path_wrapper('open', _open)
-    for name in [
-        "stat", "listdir", "chdir", "open", "chmod", "chown", "mkdir",
-        "remove", "unlink", "rmdir", "utime", "lchown", "chroot", "lstat",
-        "startfile", "mkfifo", "mknod", "pathconf", "access"
-    ]:
-        if hasattr(_os, name):
-            locals()[name] = _mk_single_path_wrapper(name)
-
-    def _mk_single_with_return(name):
-        original = getattr(_os, name)
-
-        def wrap(self, path, *args, **kw):
-            if self._active:
-                path = self._remap_input(name, path, *args, **kw)
-                return self._remap_output(name, original(path, *args, **kw))
-            return original(path, *args, **kw)
-
-        return wrap
-
-    for name in ['readlink', 'tempnam']:
-        if hasattr(_os, name):
-            locals()[name] = _mk_single_with_return(name)
-
-    def _mk_query(name):
-        original = getattr(_os, name)
-
-        def wrap(self, *args, **kw):
-            retval = original(*args, **kw)
-            if self._active:
-                return self._remap_output(name, retval)
-            return retval
-
-        return wrap
-
-    for name in ['getcwd', 'tmpnam']:
-        if hasattr(_os, name):
-            locals()[name] = _mk_query(name)
-
-    def _validate_path(self, path):
-        """Called to remap or validate any path, whether input or output"""
-        return path
-
-    def _remap_input(self, operation, path, *args, **kw):
-        """Called for path inputs"""
-        return self._validate_path(path)
-
-    def _remap_output(self, operation, path):
-        """Called for path outputs"""
-        return self._validate_path(path)
-
-    def _remap_pair(self, operation, src, dst, *args, **kw):
-        """Called for path pairs like rename, link, and symlink operations"""
-        return (
-            self._remap_input(operation + '-from', src, *args, **kw),
-            self._remap_input(operation + '-to', dst, *args, **kw)
-        )
-
-
-if hasattr(os, 'devnull'):
-    _EXCEPTIONS = [os.devnull,]
-else:
-    _EXCEPTIONS = []
-
-
-class DirectorySandbox(AbstractSandbox):
-    """Restrict operations to a single subdirectory - pseudo-chroot"""
-
-    write_ops = dict.fromkeys([
-        "open", "chmod", "chown", "mkdir", "remove", "unlink", "rmdir",
-        "utime", "lchown", "chroot", "mkfifo", "mknod", "tempnam",
-    ])
-
-    _exception_patterns = [
-        # Allow lib2to3 to attempt to save a pickled grammar object (#121)
-        '.*lib2to3.*\.pickle$',
-    ]
-    "exempt writing to paths that match the pattern"
-
-    def __init__(self, sandbox, exceptions=_EXCEPTIONS):
-        self._sandbox = os.path.normcase(os.path.realpath(sandbox))
-        self._prefix = os.path.join(self._sandbox, '')
-        self._exceptions = [
-            os.path.normcase(os.path.realpath(path))
-            for path in exceptions
-        ]
-        AbstractSandbox.__init__(self)
-
-    def _violation(self, operation, *args, **kw):
-        from setuptools.sandbox import SandboxViolation
-        raise SandboxViolation(operation, args, kw)
-
-    if _file:
-
-        def _file(self, path, mode='r', *args, **kw):
-            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
-                self._violation("file", path, mode, *args, **kw)
-            return _file(path, mode, *args, **kw)
-
-    def _open(self, path, mode='r', *args, **kw):
-        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
-            self._violation("open", path, mode, *args, **kw)
-        return _open(path, mode, *args, **kw)
-
-    def tmpnam(self):
-        self._violation("tmpnam")
-
-    def _ok(self, path):
-        active = self._active
-        try:
-            self._active = False
-            realpath = os.path.normcase(os.path.realpath(path))
-            return (
-                self._exempted(realpath)
-                or realpath == self._sandbox
-                or realpath.startswith(self._prefix)
-            )
-        finally:
-            self._active = active
-
-    def _exempted(self, filepath):
-        start_matches = (
-            filepath.startswith(exception)
-            for exception in self._exceptions
-        )
-        pattern_matches = (
-            re.match(pattern, filepath)
-            for pattern in self._exception_patterns
-        )
-        candidates = itertools.chain(start_matches, pattern_matches)
-        return any(candidates)
-
-    def _remap_input(self, operation, path, *args, **kw):
-        """Called for path inputs"""
-        if operation in self.write_ops and not self._ok(path):
-            self._violation(operation, os.path.realpath(path), *args, **kw)
-        return path
-
-    def _remap_pair(self, operation, src, dst, *args, **kw):
-        """Called for path pairs like rename, link, and symlink operations"""
-        if not self._ok(src) or not self._ok(dst):
-            self._violation(operation, src, dst, *args, **kw)
-        return (src, dst)
-
-    def open(self, file, flags, mode=0o777, *args, **kw):
-        """Called for low-level os.open()"""
-        if flags & WRITE_FLAGS and not self._ok(file):
-            self._violation("os.open", file, flags, mode, *args, **kw)
-        return _os.open(file, flags, mode, *args, **kw)
-
-
-WRITE_FLAGS = functools.reduce(
-    operator.or_, [getattr(_os, a, 0) for a in
-        "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()]
-)
-
-
-class SandboxViolation(DistutilsError):
-    """A setup script attempted to modify the filesystem outside the sandbox"""
-
-    def __str__(self):
-        return """SandboxViolation: %s%r %s
-
-The package setup script has attempted to modify files on your system
-that are not within the EasyInstall build area, and has been aborted.
-
-This package cannot be safely installed by EasyInstall, and may not
-support alternate installation locations even if you run its setup
-script by hand.  Please inform the package's author and the EasyInstall
-maintainers to find out if a fix or workaround is available.""" % self.args
-
-
-#
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script (dev).tmpl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script (dev).tmpl
deleted file mode 100644
index d58b1bb5b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script (dev).tmpl	
+++ /dev/null
@@ -1,5 +0,0 @@
-# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
-__requires__ = %(spec)r
-__import__('pkg_resources').require(%(spec)r)
-__file__ = %(dev_path)r
-exec(compile(open(__file__).read(), __file__, 'exec'))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script.tmpl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script.tmpl
deleted file mode 100644
index ff5efbcab..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/script.tmpl
+++ /dev/null
@@ -1,3 +0,0 @@
-# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
-__requires__ = %(spec)r
-__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/site-patch.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/site-patch.py
deleted file mode 100644
index 0d2d2ff8d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/site-patch.py
+++ /dev/null
@@ -1,74 +0,0 @@
-def __boot():
-    import sys
-    import os
-    PYTHONPATH = os.environ.get('PYTHONPATH')
-    if PYTHONPATH is None or (sys.platform == 'win32' and not PYTHONPATH):
-        PYTHONPATH = []
-    else:
-        PYTHONPATH = PYTHONPATH.split(os.pathsep)
-
-    pic = getattr(sys, 'path_importer_cache', {})
-    stdpath = sys.path[len(PYTHONPATH):]
-    mydir = os.path.dirname(__file__)
-
-    for item in stdpath:
-        if item == mydir or not item:
-            continue  # skip if current dir. on Windows, or my own directory
-        importer = pic.get(item)
-        if importer is not None:
-            loader = importer.find_module('site')
-            if loader is not None:
-                # This should actually reload the current module
-                loader.load_module('site')
-                break
-        else:
-            try:
-                import imp  # Avoid import loop in Python >= 3.3
-                stream, path, descr = imp.find_module('site', [item])
-            except ImportError:
-                continue
-            if stream is None:
-                continue
-            try:
-                # This should actually reload the current module
-                imp.load_module('site', stream, path, descr)
-            finally:
-                stream.close()
-            break
-    else:
-        raise ImportError("Couldn't find the real 'site' module")
-
-    known_paths = dict([(makepath(item)[1], 1) for item in sys.path])  # 2.2 comp
-
-    oldpos = getattr(sys, '__egginsert', 0)  # save old insertion position
-    sys.__egginsert = 0  # and reset the current one
-
-    for item in PYTHONPATH:
-        addsitedir(item)
-
-    sys.__egginsert += oldpos  # restore effective old position
-
-    d, nd = makepath(stdpath[0])
-    insert_at = None
-    new_path = []
-
-    for item in sys.path:
-        p, np = makepath(item)
-
-        if np == nd and insert_at is None:
-            # We've hit the first 'system' path entry, so added entries go here
-            insert_at = len(new_path)
-
-        if np in known_paths or insert_at is None:
-            new_path.append(item)
-        else:
-            # new path after the insert point, back-insert it
-            new_path.insert(insert_at, item)
-            insert_at += 1
-
-    sys.path[:] = new_path
-
-
-if __name__ == 'site':
-    __boot()
-    del __boot
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/ssl_support.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/ssl_support.py
deleted file mode 100644
index 72b18ef26..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/ssl_support.py
+++ /dev/null
@@ -1,255 +0,0 @@
-import os
-import socket
-import atexit
-import re
-import functools
-
-from setuptools.extern.six.moves import urllib, http_client, map, filter
-
-from pkg_resources import ResolutionError, ExtractionError
-
-try:
-    import ssl
-except ImportError:
-    ssl = None
-
-__all__ = [
-    'VerifyingHTTPSHandler', 'find_ca_bundle', 'is_available', 'cert_paths',
-    'opener_for'
-]
-
-cert_paths = """
-/etc/pki/tls/certs/ca-bundle.crt
-/etc/ssl/certs/ca-certificates.crt
-/usr/share/ssl/certs/ca-bundle.crt
-/usr/local/share/certs/ca-root.crt
-/etc/ssl/cert.pem
-/System/Library/OpenSSL/certs/cert.pem
-/usr/local/share/certs/ca-root-nss.crt
-/etc/ssl/ca-bundle.pem
-""".strip().split()
-
-try:
-    HTTPSHandler = urllib.request.HTTPSHandler
-    HTTPSConnection = http_client.HTTPSConnection
-except AttributeError:
-    HTTPSHandler = HTTPSConnection = object
-
-is_available = ssl is not None and object not in (HTTPSHandler, HTTPSConnection)
-
-
-try:
-    from ssl import CertificateError, match_hostname
-except ImportError:
-    try:
-        from backports.ssl_match_hostname import CertificateError
-        from backports.ssl_match_hostname import match_hostname
-    except ImportError:
-        CertificateError = None
-        match_hostname = None
-
-if not CertificateError:
-
-    class CertificateError(ValueError):
-        pass
-
-
-if not match_hostname:
-
-    def _dnsname_match(dn, hostname, max_wildcards=1):
-        """Matching according to RFC 6125, section 6.4.3
-
-        http://tools.ietf.org/html/rfc6125#section-6.4.3
-        """
-        pats = []
-        if not dn:
-            return False
-
-        # Ported from python3-syntax:
-        # leftmost, *remainder = dn.split(r'.')
-        parts = dn.split(r'.')
-        leftmost = parts[0]
-        remainder = parts[1:]
-
-        wildcards = leftmost.count('*')
-        if wildcards > max_wildcards:
-            # Issue #17980: avoid denials of service by refusing more
-            # than one wildcard per fragment.  A survey of established
-            # policy among SSL implementations showed it to be a
-            # reasonable choice.
-            raise CertificateError(
-                "too many wildcards in certificate DNS name: " + repr(dn))
-
-        # speed up common case w/o wildcards
-        if not wildcards:
-            return dn.lower() == hostname.lower()
-
-        # RFC 6125, section 6.4.3, subitem 1.
-        # The client SHOULD NOT attempt to match a presented identifier in which
-        # the wildcard character comprises a label other than the left-most label.
-        if leftmost == '*':
-            # When '*' is a fragment by itself, it matches a non-empty dotless
-            # fragment.
-            pats.append('[^.]+')
-        elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
-            # RFC 6125, section 6.4.3, subitem 3.
-            # The client SHOULD NOT attempt to match a presented identifier
-            # where the wildcard character is embedded within an A-label or
-            # U-label of an internationalized domain name.
-            pats.append(re.escape(leftmost))
-        else:
-            # Otherwise, '*' matches any dotless string, e.g. www*
-            pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
-
-        # add the remaining fragments, ignore any wildcards
-        for frag in remainder:
-            pats.append(re.escape(frag))
-
-        pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
-        return pat.match(hostname)
-
-    def match_hostname(cert, hostname):
-        """Verify that *cert* (in decoded format as returned by
-        SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
-        rules are followed, but IP addresses are not accepted for *hostname*.
-
-        CertificateError is raised on failure. On success, the function
-        returns nothing.
-        """
-        if not cert:
-            raise ValueError("empty or no certificate")
-        dnsnames = []
-        san = cert.get('subjectAltName', ())
-        for key, value in san:
-            if key == 'DNS':
-                if _dnsname_match(value, hostname):
-                    return
-                dnsnames.append(value)
-        if not dnsnames:
-            # The subject is only checked when there is no dNSName entry
-            # in subjectAltName
-            for sub in cert.get('subject', ()):
-                for key, value in sub:
-                    # XXX according to RFC 2818, the most specific Common Name
-                    # must be used.
-                    if key == 'commonName':
-                        if _dnsname_match(value, hostname):
-                            return
-                        dnsnames.append(value)
-        if len(dnsnames) > 1:
-            raise CertificateError("hostname %r "
-                "doesn't match either of %s"
-                % (hostname, ', '.join(map(repr, dnsnames))))
-        elif len(dnsnames) == 1:
-            raise CertificateError("hostname %r "
-                "doesn't match %r"
-                % (hostname, dnsnames[0]))
-        else:
-            raise CertificateError("no appropriate commonName or "
-                "subjectAltName fields were found")
-
-
-class VerifyingHTTPSHandler(HTTPSHandler):
-    """Simple verifying handler: no auth, subclasses, timeouts, etc."""
-
-    def __init__(self, ca_bundle):
-        self.ca_bundle = ca_bundle
-        HTTPSHandler.__init__(self)
-
-    def https_open(self, req):
-        return self.do_open(
-            lambda host, **kw: VerifyingHTTPSConn(host, self.ca_bundle, **kw), req
-        )
-
-
-class VerifyingHTTPSConn(HTTPSConnection):
-    """Simple verifying connection: no auth, subclasses, timeouts, etc."""
-
-    def __init__(self, host, ca_bundle, **kw):
-        HTTPSConnection.__init__(self, host, **kw)
-        self.ca_bundle = ca_bundle
-
-    def connect(self):
-        sock = socket.create_connection(
-            (self.host, self.port), getattr(self, 'source_address', None)
-        )
-
-        # Handle the socket if a (proxy) tunnel is present
-        if hasattr(self, '_tunnel') and getattr(self, '_tunnel_host', None):
-            self.sock = sock
-            self._tunnel()
-            # http://bugs.python.org/issue7776: Python>=3.4.1 and >=2.7.7
-            # change self.host to mean the proxy server host when tunneling is
-            # being used. Adapt, since we are interested in the destination
-            # host for the match_hostname() comparison.
-            actual_host = self._tunnel_host
-        else:
-            actual_host = self.host
-
-        self.sock = ssl.wrap_socket(
-            sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.ca_bundle
-        )
-        try:
-            match_hostname(self.sock.getpeercert(), actual_host)
-        except CertificateError:
-            self.sock.shutdown(socket.SHUT_RDWR)
-            self.sock.close()
-            raise
-
-
-def opener_for(ca_bundle=None):
-    """Get a urlopen() replacement that uses ca_bundle for verification"""
-    return urllib.request.build_opener(
-        VerifyingHTTPSHandler(ca_bundle or find_ca_bundle())
-    ).open
-
-
-# from jaraco.functools
-def once(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        if not hasattr(func, 'always_returns'):
-            func.always_returns = func(*args, **kwargs)
-        return func.always_returns
-    return wrapper
-
-
-@once
-def get_win_certfile():
-    try:
-        import wincertstore
-    except ImportError:
-        return None
-
-    class CertFile(wincertstore.CertFile):
-        def __init__(self):
-            super(CertFile, self).__init__()
-            atexit.register(self.close)
-
-        def close(self):
-            try:
-                super(CertFile, self).close()
-            except OSError:
-                pass
-
-    _wincerts = CertFile()
-    _wincerts.addstore('CA')
-    _wincerts.addstore('ROOT')
-    return _wincerts.name
-
-
-def find_ca_bundle():
-    """Return an existing CA bundle path, or None"""
-    extant_cert_paths = filter(os.path.isfile, cert_paths)
-    return (
-        get_win_certfile()
-        or next(extant_cert_paths, None)
-        or _certifi_where()
-    )
-
-
-def _certifi_where():
-    try:
-        return __import__('certifi').where()
-    except (ImportError, ResolutionError, ExtractionError):
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/unicode_utils.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/unicode_utils.py
deleted file mode 100644
index 7c63efd20..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/unicode_utils.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import unicodedata
-import sys
-
-from setuptools.extern import six
-
-
-# HFS Plus uses decomposed UTF-8
-def decompose(path):
-    if isinstance(path, six.text_type):
-        return unicodedata.normalize('NFD', path)
-    try:
-        path = path.decode('utf-8')
-        path = unicodedata.normalize('NFD', path)
-        path = path.encode('utf-8')
-    except UnicodeError:
-        pass  # Not UTF-8
-    return path
-
-
-def filesys_decode(path):
-    """
-    Ensure that the given path is decoded,
-    NONE when no expected encoding works
-    """
-
-    if isinstance(path, six.text_type):
-        return path
-
-    fs_enc = sys.getfilesystemencoding() or 'utf-8'
-    candidates = fs_enc, 'utf-8'
-
-    for enc in candidates:
-        try:
-            return path.decode(enc)
-        except UnicodeDecodeError:
-            continue
-
-
-def try_encode(string, enc):
-    "turn unicode encoding into a functional routine"
-    try:
-        return string.encode(enc)
-    except UnicodeEncodeError:
-        return None
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/version.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/version.py
deleted file mode 100644
index 95e186965..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/version.py
+++ /dev/null
@@ -1,6 +0,0 @@
-import pkg_resources
-
-try:
-    __version__ = pkg_resources.get_distribution('setuptools').version
-except Exception:
-    __version__ = 'unknown'
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/windows_support.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/windows_support.py
deleted file mode 100644
index cb977cff9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/setuptools/windows_support.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import platform
-import ctypes
-
-
-def windows_only(func):
-    if platform.system() != 'Windows':
-        return lambda *args, **kwargs: None
-    return func
-
-
-@windows_only
-def hide_file(path):
-    """
-    Set the hidden attribute on a file or directory.
-
-    From http://stackoverflow.com/questions/19622133/
-
-    `path` must be text.
-    """
-    __import__('ctypes.wintypes')
-    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
-    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
-    SetFileAttributes.restype = ctypes.wintypes.BOOL
-
-    FILE_ATTRIBUTE_HIDDEN = 0x02
-
-    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
-    if not ret:
-        raise ctypes.WinError()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__init__.py
deleted file mode 100644
index 56404f4c1..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__init__.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug
-    ~~~~~~~~
-
-    Werkzeug is the Swiss Army knife of Python web development.
-
-    It provides useful classes and functions for any WSGI application to make
-    the life of a python web developer much easier.  All of the provided
-    classes are independent from each other so you can mix it with any other
-    library.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from types import ModuleType
-import sys
-
-from werkzeug._compat import iteritems
-
-__version__ = '0.14.1'
-
-
-# This import magic raises concerns quite often which is why the implementation
-# and motivation is explained here in detail now.
-#
-# The majority of the functions and classes provided by Werkzeug work on the
-# HTTP and WSGI layer.  There is no useful grouping for those which is why
-# they are all importable from "werkzeug" instead of the modules where they are
-# implemented.  The downside of that is, that now everything would be loaded at
-# once, even if unused.
-#
-# The implementation of a lazy-loading module in this file replaces the
-# werkzeug package when imported from within.  Attribute access to the werkzeug
-# module will then lazily import from the modules that implement the objects.
-
-
-# import mapping to objects in other modules
-all_by_module = {
-    'werkzeug.debug': ['DebuggedApplication'],
-    'werkzeug.local': ['Local', 'LocalManager', 'LocalProxy', 'LocalStack',
-                       'release_local'],
-    'werkzeug.serving': ['run_simple'],
-    'werkzeug.test': ['Client', 'EnvironBuilder', 'create_environ',
-                      'run_wsgi_app'],
-    'werkzeug.testapp': ['test_app'],
-    'werkzeug.exceptions': ['abort', 'Aborter'],
-    'werkzeug.urls': ['url_decode', 'url_encode', 'url_quote',
-                      'url_quote_plus', 'url_unquote', 'url_unquote_plus',
-                      'url_fix', 'Href', 'iri_to_uri', 'uri_to_iri'],
-    'werkzeug.formparser': ['parse_form_data'],
-    'werkzeug.utils': ['escape', 'environ_property', 'append_slash_redirect',
-                       'redirect', 'cached_property', 'import_string',
-                       'dump_cookie', 'parse_cookie', 'unescape',
-                       'format_string', 'find_modules', 'header_property',
-                       'html', 'xhtml', 'HTMLBuilder', 'validate_arguments',
-                       'ArgumentValidationError', 'bind_arguments',
-                       'secure_filename'],
-    'werkzeug.wsgi': ['get_current_url', 'get_host', 'pop_path_info',
-                      'peek_path_info', 'SharedDataMiddleware',
-                      'DispatcherMiddleware', 'ClosingIterator', 'FileWrapper',
-                      'make_line_iter', 'LimitedStream', 'responder',
-                      'wrap_file', 'extract_path_info'],
-    'werkzeug.datastructures': ['MultiDict', 'CombinedMultiDict', 'Headers',
-                                'EnvironHeaders', 'ImmutableList',
-                                'ImmutableDict', 'ImmutableMultiDict',
-                                'TypeConversionDict',
-                                'ImmutableTypeConversionDict', 'Accept',
-                                'MIMEAccept', 'CharsetAccept',
-                                'LanguageAccept', 'RequestCacheControl',
-                                'ResponseCacheControl', 'ETags', 'HeaderSet',
-                                'WWWAuthenticate', 'Authorization',
-                                'FileMultiDict', 'CallbackDict', 'FileStorage',
-                                'OrderedMultiDict', 'ImmutableOrderedMultiDict'
-                                ],
-    'werkzeug.useragents':  ['UserAgent'],
-    'werkzeug.http': ['parse_etags', 'parse_date', 'http_date', 'cookie_date',
-                      'parse_cache_control_header', 'is_resource_modified',
-                      'parse_accept_header', 'parse_set_header', 'quote_etag',
-                      'unquote_etag', 'generate_etag', 'dump_header',
-                      'parse_list_header', 'parse_dict_header',
-                      'parse_authorization_header',
-                      'parse_www_authenticate_header', 'remove_entity_headers',
-                      'is_entity_header', 'remove_hop_by_hop_headers',
-                      'parse_options_header', 'dump_options_header',
-                      'is_hop_by_hop_header', 'unquote_header_value',
-                      'quote_header_value', 'HTTP_STATUS_CODES'],
-    'werkzeug.wrappers': ['BaseResponse', 'BaseRequest', 'Request', 'Response',
-                          'AcceptMixin', 'ETagRequestMixin',
-                          'ETagResponseMixin', 'ResponseStreamMixin',
-                          'CommonResponseDescriptorsMixin', 'UserAgentMixin',
-                          'AuthorizationMixin', 'WWWAuthenticateMixin',
-                          'CommonRequestDescriptorsMixin'],
-    'werkzeug.security': ['generate_password_hash', 'check_password_hash'],
-    # the undocumented easteregg ;-)
-    'werkzeug._internal': ['_easteregg']
-}
-
-# modules that should be imported when accessed as attributes of werkzeug
-attribute_modules = frozenset(['exceptions', 'routing'])
-
-
-object_origins = {}
-for module, items in iteritems(all_by_module):
-    for item in items:
-        object_origins[item] = module
-
-
-class module(ModuleType):
-
-    """Automatically import objects from the modules."""
-
-    def __getattr__(self, name):
-        if name in object_origins:
-            module = __import__(object_origins[name], None, None, [name])
-            for extra_name in all_by_module[module.__name__]:
-                setattr(self, extra_name, getattr(module, extra_name))
-            return getattr(module, name)
-        elif name in attribute_modules:
-            __import__('werkzeug.' + name)
-        return ModuleType.__getattribute__(self, name)
-
-    def __dir__(self):
-        """Just show what we want to show."""
-        result = list(new_module.__all__)
-        result.extend(('__file__', '__doc__', '__all__',
-                       '__docformat__', '__name__', '__path__',
-                       '__package__', '__version__'))
-        return result
-
-# keep a reference to this module so that it's not garbage collected
-old_module = sys.modules['werkzeug']
-
-
-# setup the new module and patch it into the dict of loaded modules
-new_module = sys.modules['werkzeug'] = module('werkzeug')
-new_module.__dict__.update({
-    '__file__':         __file__,
-    '__package__':      'werkzeug',
-    '__path__':         __path__,
-    '__doc__':          __doc__,
-    '__version__':      __version__,
-    '__all__':          tuple(object_origins) + tuple(attribute_modules),
-    '__docformat__':    'restructuredtext en'
-})
-
-
-# Due to bootstrapping issues we need to import exceptions here.
-# Don't ask :-(
-__import__('werkzeug.exceptions')
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 2dfd8901a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_compat.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_compat.cpython-35.pyc
deleted file mode 100644
index b26fb3e45..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_compat.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_internal.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_internal.cpython-35.pyc
deleted file mode 100644
index 8b22a1a48..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_internal.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_reloader.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_reloader.cpython-35.pyc
deleted file mode 100644
index 2d6b7c36b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/_reloader.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/datastructures.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/datastructures.cpython-35.pyc
deleted file mode 100644
index 8b92fd7f0..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/datastructures.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/exceptions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/exceptions.cpython-35.pyc
deleted file mode 100644
index a72d77fc6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/exceptions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/filesystem.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/filesystem.cpython-35.pyc
deleted file mode 100644
index 0c22f251d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/filesystem.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/formparser.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/formparser.cpython-35.pyc
deleted file mode 100644
index d0ad04900..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/formparser.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/http.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/http.cpython-35.pyc
deleted file mode 100644
index 9c9bcba7a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/http.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/local.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/local.cpython-35.pyc
deleted file mode 100644
index 4a5761f95..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/local.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/posixemulation.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/posixemulation.cpython-35.pyc
deleted file mode 100644
index ecef4f3e1..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/posixemulation.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/routing.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/routing.cpython-35.pyc
deleted file mode 100644
index 1e14f20f3..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/routing.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/script.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/script.cpython-35.pyc
deleted file mode 100644
index 30404daf8..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/script.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/security.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/security.cpython-35.pyc
deleted file mode 100644
index 3352a960d..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/security.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/serving.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/serving.cpython-35.pyc
deleted file mode 100644
index 0b7092922..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/serving.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/test.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/test.cpython-35.pyc
deleted file mode 100644
index d92c06c85..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/test.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/testapp.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/testapp.cpython-35.pyc
deleted file mode 100644
index 7d9a914a2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/testapp.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/urls.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/urls.cpython-35.pyc
deleted file mode 100644
index e451cb9e7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/urls.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/useragents.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/useragents.cpython-35.pyc
deleted file mode 100644
index d633ebf69..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/useragents.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/utils.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/utils.cpython-35.pyc
deleted file mode 100644
index a8426a3fe..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/utils.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/websocket.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/websocket.cpython-35.pyc
deleted file mode 100644
index f00bf625c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/websocket.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wrappers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wrappers.cpython-35.pyc
deleted file mode 100644
index 44cf5fff5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wrappers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wsgi.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wsgi.cpython-35.pyc
deleted file mode 100644
index 763b3495f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/__pycache__/wsgi.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_compat.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_compat.py
deleted file mode 100644
index fda038b97..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_compat.py
+++ /dev/null
@@ -1,206 +0,0 @@
-# flake8: noqa
-# This whole file is full of lint errors
-import codecs
-import sys
-import operator
-import functools
-import warnings
-
-try:
-    import builtins
-except ImportError:
-    import __builtin__ as builtins
-
-
-PY2 = sys.version_info[0] == 2
-WIN = sys.platform.startswith('win')
-
-_identity = lambda x: x
-
-if PY2:
-    unichr = unichr
-    text_type = unicode
-    string_types = (str, unicode)
-    integer_types = (int, long)
-
-    iterkeys = lambda d, *args, **kwargs: d.iterkeys(*args, **kwargs)
-    itervalues = lambda d, *args, **kwargs: d.itervalues(*args, **kwargs)
-    iteritems = lambda d, *args, **kwargs: d.iteritems(*args, **kwargs)
-
-    iterlists = lambda d, *args, **kwargs: d.iterlists(*args, **kwargs)
-    iterlistvalues = lambda d, *args, **kwargs: d.iterlistvalues(*args, **kwargs)
-
-    int_to_byte = chr
-    iter_bytes = iter
-
-    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
-
-    def fix_tuple_repr(obj):
-        def __repr__(self):
-            cls = self.__class__
-            return '%s(%s)' % (cls.__name__, ', '.join(
-                '%s=%r' % (field, self[index])
-                for index, field in enumerate(cls._fields)
-            ))
-        obj.__repr__ = __repr__
-        return obj
-
-    def implements_iterator(cls):
-        cls.next = cls.__next__
-        del cls.__next__
-        return cls
-
-    def implements_to_string(cls):
-        cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
-        return cls
-
-    def native_string_result(func):
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs).encode('utf-8')
-        return functools.update_wrapper(wrapper, func)
-
-    def implements_bool(cls):
-        cls.__nonzero__ = cls.__bool__
-        del cls.__bool__
-        return cls
-
-    from itertools import imap, izip, ifilter
-    range_type = xrange
-
-    from StringIO import StringIO
-    from cStringIO import StringIO as BytesIO
-    NativeStringIO = BytesIO
-
-    def make_literal_wrapper(reference):
-        return _identity
-
-    def normalize_string_tuple(tup):
-        """Normalizes a string tuple to a common type. Following Python 2
-        rules, upgrades to unicode are implicit.
-        """
-        if any(isinstance(x, text_type) for x in tup):
-            return tuple(to_unicode(x) for x in tup)
-        return tup
-
-    def try_coerce_native(s):
-        """Try to coerce a unicode string to native if possible. Otherwise,
-        leave it as unicode.
-        """
-        try:
-            return to_native(s)
-        except UnicodeError:
-            return s
-
-    wsgi_get_bytes = _identity
-
-    def wsgi_decoding_dance(s, charset='utf-8', errors='replace'):
-        return s.decode(charset, errors)
-
-    def wsgi_encoding_dance(s, charset='utf-8', errors='replace'):
-        if isinstance(s, bytes):
-            return s
-        return s.encode(charset, errors)
-
-    def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
-        if x is None:
-            return None
-        if isinstance(x, (bytes, bytearray, buffer)):
-            return bytes(x)
-        if isinstance(x, unicode):
-            return x.encode(charset, errors)
-        raise TypeError('Expected bytes')
-
-    def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
-        if x is None or isinstance(x, str):
-            return x
-        return x.encode(charset, errors)
-
-else:
-    unichr = chr
-    text_type = str
-    string_types = (str, )
-    integer_types = (int, )
-
-    iterkeys = lambda d, *args, **kwargs: iter(d.keys(*args, **kwargs))
-    itervalues = lambda d, *args, **kwargs: iter(d.values(*args, **kwargs))
-    iteritems = lambda d, *args, **kwargs: iter(d.items(*args, **kwargs))
-
-    iterlists = lambda d, *args, **kwargs: iter(d.lists(*args, **kwargs))
-    iterlistvalues = lambda d, *args, **kwargs: iter(d.listvalues(*args, **kwargs))
-
-    int_to_byte = operator.methodcaller('to_bytes', 1, 'big')
-    iter_bytes = functools.partial(map, int_to_byte)
-
-    def reraise(tp, value, tb=None):
-        if value.__traceback__ is not tb:
-            raise value.with_traceback(tb)
-        raise value
-
-    fix_tuple_repr = _identity
-    implements_iterator = _identity
-    implements_to_string = _identity
-    implements_bool = _identity
-    native_string_result = _identity
-    imap = map
-    izip = zip
-    ifilter = filter
-    range_type = range
-
-    from io import StringIO, BytesIO
-    NativeStringIO = StringIO
-
-    _latin1_encode = operator.methodcaller('encode', 'latin1')
-
-    def make_literal_wrapper(reference):
-        if isinstance(reference, text_type):
-            return _identity
-        return _latin1_encode
-
-    def normalize_string_tuple(tup):
-        """Ensures that all types in the tuple are either strings
-        or bytes.
-        """
-        tupiter = iter(tup)
-        is_text = isinstance(next(tupiter, None), text_type)
-        for arg in tupiter:
-            if isinstance(arg, text_type) != is_text:
-                raise TypeError('Cannot mix str and bytes arguments (got %s)'
-                                % repr(tup))
-        return tup
-
-    try_coerce_native = _identity
-    wsgi_get_bytes = _latin1_encode
-
-    def wsgi_decoding_dance(s, charset='utf-8', errors='replace'):
-        return s.encode('latin1').decode(charset, errors)
-
-    def wsgi_encoding_dance(s, charset='utf-8', errors='replace'):
-        if isinstance(s, text_type):
-            s = s.encode(charset)
-        return s.decode('latin1', errors)
-
-    def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
-        if x is None:
-            return None
-        if isinstance(x, (bytes, bytearray, memoryview)):  # noqa
-            return bytes(x)
-        if isinstance(x, str):
-            return x.encode(charset, errors)
-        raise TypeError('Expected bytes')
-
-    def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
-        if x is None or isinstance(x, str):
-            return x
-        return x.decode(charset, errors)
-
-
-def to_unicode(x, charset=sys.getdefaultencoding(), errors='strict',
-               allow_none_charset=False):
-    if x is None:
-        return None
-    if not isinstance(x, bytes):
-        return text_type(x)
-    if charset is None and allow_none_charset:
-        return x
-    return x.decode(charset, errors)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_internal.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_internal.py
deleted file mode 100644
index 28bfd9fe4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_internal.py
+++ /dev/null
@@ -1,419 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug._internal
-    ~~~~~~~~~~~~~~~~~~
-
-    This module provides internally used helpers and constants.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import string
-import inspect
-from weakref import WeakKeyDictionary
-from datetime import datetime, date
-from itertools import chain
-
-from werkzeug._compat import iter_bytes, text_type, BytesIO, int_to_byte, \
-    range_type, integer_types
-
-
-_logger = None
-_empty_stream = BytesIO()
-_signature_cache = WeakKeyDictionary()
-_epoch_ord = date(1970, 1, 1).toordinal()
-_cookie_params = set((b'expires', b'path', b'comment',
-                      b'max-age', b'secure', b'httponly',
-                      b'version'))
-_legal_cookie_chars = (string.ascii_letters +
-                       string.digits +
-                       u"/=!#$%&'*+-.^_`|~:").encode('ascii')
-
-_cookie_quoting_map = {
-    b',': b'\\054',
-    b';': b'\\073',
-    b'"': b'\\"',
-    b'\\': b'\\\\',
-}
-for _i in chain(range_type(32), range_type(127, 256)):
-    _cookie_quoting_map[int_to_byte(_i)] = ('\\%03o' % _i).encode('latin1')
-
-
-_octal_re = re.compile(br'\\[0-3][0-7][0-7]')
-_quote_re = re.compile(br'[\\].')
-_legal_cookie_chars_re = br'[\w\d!#%&\'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=]'
-_cookie_re = re.compile(br"""
-    (?P<key>[^=;]+)
-    (?:\s*=\s*
-        (?P<val>
-            "(?:[^\\"]|\\.)*" |
-             (?:.*?)
-        )
-    )?
-    \s*;
-""", flags=re.VERBOSE)
-
-
-class _Missing(object):
-
-    def __repr__(self):
-        return 'no value'
-
-    def __reduce__(self):
-        return '_missing'
-
-_missing = _Missing()
-
-
-def _get_environ(obj):
-    env = getattr(obj, 'environ', obj)
-    assert isinstance(env, dict), \
-        '%r is not a WSGI environment (has to be a dict)' % type(obj).__name__
-    return env
-
-
-def _log(type, message, *args, **kwargs):
-    """Log into the internal werkzeug logger."""
-    global _logger
-    if _logger is None:
-        import logging
-        _logger = logging.getLogger('werkzeug')
-        # Only set up a default log handler if the
-        # end-user application didn't set anything up.
-        if not logging.root.handlers and _logger.level == logging.NOTSET:
-            _logger.setLevel(logging.INFO)
-            handler = logging.StreamHandler()
-            _logger.addHandler(handler)
-    getattr(_logger, type)(message.rstrip(), *args, **kwargs)
-
-
-def _parse_signature(func):
-    """Return a signature object for the function."""
-    if hasattr(func, 'im_func'):
-        func = func.im_func
-
-    # if we have a cached validator for this function, return it
-    parse = _signature_cache.get(func)
-    if parse is not None:
-        return parse
-
-    # inspect the function signature and collect all the information
-    if hasattr(inspect, 'getfullargspec'):
-        tup = inspect.getfullargspec(func)
-    else:
-        tup = inspect.getargspec(func)
-    positional, vararg_var, kwarg_var, defaults = tup[:4]
-    defaults = defaults or ()
-    arg_count = len(positional)
-    arguments = []
-    for idx, name in enumerate(positional):
-        if isinstance(name, list):
-            raise TypeError('cannot parse functions that unpack tuples '
-                            'in the function signature')
-        try:
-            default = defaults[idx - arg_count]
-        except IndexError:
-            param = (name, False, None)
-        else:
-            param = (name, True, default)
-        arguments.append(param)
-    arguments = tuple(arguments)
-
-    def parse(args, kwargs):
-        new_args = []
-        missing = []
-        extra = {}
-
-        # consume as many arguments as positional as possible
-        for idx, (name, has_default, default) in enumerate(arguments):
-            try:
-                new_args.append(args[idx])
-            except IndexError:
-                try:
-                    new_args.append(kwargs.pop(name))
-                except KeyError:
-                    if has_default:
-                        new_args.append(default)
-                    else:
-                        missing.append(name)
-            else:
-                if name in kwargs:
-                    extra[name] = kwargs.pop(name)
-
-        # handle extra arguments
-        extra_positional = args[arg_count:]
-        if vararg_var is not None:
-            new_args.extend(extra_positional)
-            extra_positional = ()
-        if kwargs and kwarg_var is None:
-            extra.update(kwargs)
-            kwargs = {}
-
-        return new_args, kwargs, missing, extra, extra_positional, \
-            arguments, vararg_var, kwarg_var
-    _signature_cache[func] = parse
-    return parse
-
-
-def _date_to_unix(arg):
-    """Converts a timetuple, integer or datetime object into the seconds from
-    epoch in utc.
-    """
-    if isinstance(arg, datetime):
-        arg = arg.utctimetuple()
-    elif isinstance(arg, integer_types + (float,)):
-        return int(arg)
-    year, month, day, hour, minute, second = arg[:6]
-    days = date(year, month, 1).toordinal() - _epoch_ord + day - 1
-    hours = days * 24 + hour
-    minutes = hours * 60 + minute
-    seconds = minutes * 60 + second
-    return seconds
-
-
-class _DictAccessorProperty(object):
-
-    """Baseclass for `environ_property` and `header_property`."""
-    read_only = False
-
-    def __init__(self, name, default=None, load_func=None, dump_func=None,
-                 read_only=None, doc=None):
-        self.name = name
-        self.default = default
-        self.load_func = load_func
-        self.dump_func = dump_func
-        if read_only is not None:
-            self.read_only = read_only
-        self.__doc__ = doc
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        storage = self.lookup(obj)
-        if self.name not in storage:
-            return self.default
-        rv = storage[self.name]
-        if self.load_func is not None:
-            try:
-                rv = self.load_func(rv)
-            except (ValueError, TypeError):
-                rv = self.default
-        return rv
-
-    def __set__(self, obj, value):
-        if self.read_only:
-            raise AttributeError('read only property')
-        if self.dump_func is not None:
-            value = self.dump_func(value)
-        self.lookup(obj)[self.name] = value
-
-    def __delete__(self, obj):
-        if self.read_only:
-            raise AttributeError('read only property')
-        self.lookup(obj).pop(self.name, None)
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            self.__class__.__name__,
-            self.name
-        )
-
-
-def _cookie_quote(b):
-    buf = bytearray()
-    all_legal = True
-    _lookup = _cookie_quoting_map.get
-    _push = buf.extend
-
-    for char in iter_bytes(b):
-        if char not in _legal_cookie_chars:
-            all_legal = False
-            char = _lookup(char, char)
-        _push(char)
-
-    if all_legal:
-        return bytes(buf)
-    return bytes(b'"' + buf + b'"')
-
-
-def _cookie_unquote(b):
-    if len(b) < 2:
-        return b
-    if b[:1] != b'"' or b[-1:] != b'"':
-        return b
-
-    b = b[1:-1]
-
-    i = 0
-    n = len(b)
-    rv = bytearray()
-    _push = rv.extend
-
-    while 0 <= i < n:
-        o_match = _octal_re.search(b, i)
-        q_match = _quote_re.search(b, i)
-        if not o_match and not q_match:
-            rv.extend(b[i:])
-            break
-        j = k = -1
-        if o_match:
-            j = o_match.start(0)
-        if q_match:
-            k = q_match.start(0)
-        if q_match and (not o_match or k < j):
-            _push(b[i:k])
-            _push(b[k + 1:k + 2])
-            i = k + 2
-        else:
-            _push(b[i:j])
-            rv.append(int(b[j + 1:j + 4], 8))
-            i = j + 4
-
-    return bytes(rv)
-
-
-def _cookie_parse_impl(b):
-    """Lowlevel cookie parsing facility that operates on bytes."""
-    i = 0
-    n = len(b)
-
-    while i < n:
-        match = _cookie_re.search(b + b';', i)
-        if not match:
-            break
-
-        key = match.group('key').strip()
-        value = match.group('val') or b''
-        i = match.end(0)
-
-        # Ignore parameters.  We have no interest in them.
-        if key.lower() not in _cookie_params:
-            yield _cookie_unquote(key), _cookie_unquote(value)
-
-
-def _encode_idna(domain):
-    # If we're given bytes, make sure they fit into ASCII
-    if not isinstance(domain, text_type):
-        domain.decode('ascii')
-        return domain
-
-    # Otherwise check if it's already ascii, then return
-    try:
-        return domain.encode('ascii')
-    except UnicodeError:
-        pass
-
-    # Otherwise encode each part separately
-    parts = domain.split('.')
-    for idx, part in enumerate(parts):
-        parts[idx] = part.encode('idna')
-    return b'.'.join(parts)
-
-
-def _decode_idna(domain):
-    # If the input is a string try to encode it to ascii to
-    # do the idna decoding.  if that fails because of an
-    # unicode error, then we already have a decoded idna domain
-    if isinstance(domain, text_type):
-        try:
-            domain = domain.encode('ascii')
-        except UnicodeError:
-            return domain
-
-    # Decode each part separately.  If a part fails, try to
-    # decode it with ascii and silently ignore errors.  This makes
-    # most sense because the idna codec does not have error handling
-    parts = domain.split(b'.')
-    for idx, part in enumerate(parts):
-        try:
-            parts[idx] = part.decode('idna')
-        except UnicodeError:
-            parts[idx] = part.decode('ascii', 'ignore')
-
-    return '.'.join(parts)
-
-
-def _make_cookie_domain(domain):
-    if domain is None:
-        return None
-    domain = _encode_idna(domain)
-    if b':' in domain:
-        domain = domain.split(b':', 1)[0]
-    if b'.' in domain:
-        return domain
-    raise ValueError(
-        'Setting \'domain\' for a cookie on a server running locally (ex: '
-        'localhost) is not supported by complying browsers. You should '
-        'have something like: \'127.0.0.1 localhost dev.localhost\' on '
-        'your hosts file and then point your server to run on '
-        '\'dev.localhost\' and also set \'domain\' for \'dev.localhost\''
-    )
-
-
-def _easteregg(app=None):
-    """Like the name says.  But who knows how it works?"""
-    def bzzzzzzz(gyver):
-        import base64
-        import zlib
-        return zlib.decompress(base64.b64decode(gyver)).decode('ascii')
-    gyver = u'\n'.join([x + (77 - len(x)) * u' ' for x in bzzzzzzz(b'''
-eJyFlzuOJDkMRP06xRjymKgDJCDQStBYT8BCgK4gTwfQ2fcFs2a2FzvZk+hvlcRvRJD148efHt9m
-9Xz94dRY5hGt1nrYcXx7us9qlcP9HHNh28rz8dZj+q4rynVFFPdlY4zH873NKCexrDM6zxxRymzz
-4QIxzK4bth1PV7+uHn6WXZ5C4ka/+prFzx3zWLMHAVZb8RRUxtFXI5DTQ2n3Hi2sNI+HK43AOWSY
-jmEzE4naFp58PdzhPMdslLVWHTGUVpSxImw+pS/D+JhzLfdS1j7PzUMxij+mc2U0I9zcbZ/HcZxc
-q1QjvvcThMYFnp93agEx392ZdLJWXbi/Ca4Oivl4h/Y1ErEqP+lrg7Xa4qnUKu5UE9UUA4xeqLJ5
-jWlPKJvR2yhRI7xFPdzPuc6adXu6ovwXwRPXXnZHxlPtkSkqWHilsOrGrvcVWXgGP3daXomCj317
-8P2UOw/NnA0OOikZyFf3zZ76eN9QXNwYdD8f8/LdBRFg0BO3bB+Pe/+G8er8tDJv83XTkj7WeMBJ
-v/rnAfdO51d6sFglfi8U7zbnr0u9tyJHhFZNXYfH8Iafv2Oa+DT6l8u9UYlajV/hcEgk1x8E8L/r
-XJXl2SK+GJCxtnyhVKv6GFCEB1OO3f9YWAIEbwcRWv/6RPpsEzOkXURMN37J0PoCSYeBnJQd9Giu
-LxYQJNlYPSo/iTQwgaihbART7Fcyem2tTSCcwNCs85MOOpJtXhXDe0E7zgZJkcxWTar/zEjdIVCk
-iXy87FW6j5aGZhttDBoAZ3vnmlkx4q4mMmCdLtnHkBXFMCReqthSGkQ+MDXLLCpXwBs0t+sIhsDI
-tjBB8MwqYQpLygZ56rRHHpw+OAVyGgaGRHWy2QfXez+ZQQTTBkmRXdV/A9LwH6XGZpEAZU8rs4pE
-1R4FQ3Uwt8RKEtRc0/CrANUoes3EzM6WYcFyskGZ6UTHJWenBDS7h163Eo2bpzqxNE9aVgEM2CqI
-GAJe9Yra4P5qKmta27VjzYdR04Vc7KHeY4vs61C0nbywFmcSXYjzBHdiEjraS7PGG2jHHTpJUMxN
-Jlxr3pUuFvlBWLJGE3GcA1/1xxLcHmlO+LAXbhrXah1tD6Ze+uqFGdZa5FM+3eHcKNaEarutAQ0A
-QMAZHV+ve6LxAwWnXbbSXEG2DmCX5ijeLCKj5lhVFBrMm+ryOttCAeFpUdZyQLAQkA06RLs56rzG
-8MID55vqr/g64Qr/wqwlE0TVxgoiZhHrbY2h1iuuyUVg1nlkpDrQ7Vm1xIkI5XRKLedN9EjzVchu
-jQhXcVkjVdgP2O99QShpdvXWoSwkp5uMwyjt3jiWCqWGSiaaPAzohjPanXVLbM3x0dNskJsaCEyz
-DTKIs+7WKJD4ZcJGfMhLFBf6hlbnNkLEePF8Cx2o2kwmYF4+MzAxa6i+6xIQkswOqGO+3x9NaZX8
-MrZRaFZpLeVTYI9F/djY6DDVVs340nZGmwrDqTCiiqD5luj3OzwpmQCiQhdRYowUYEA3i1WWGwL4
-GCtSoO4XbIPFeKGU13XPkDf5IdimLpAvi2kVDVQbzOOa4KAXMFlpi/hV8F6IDe0Y2reg3PuNKT3i
-RYhZqtkQZqSB2Qm0SGtjAw7RDwaM1roESC8HWiPxkoOy0lLTRFG39kvbLZbU9gFKFRvixDZBJmpi
-Xyq3RE5lW00EJjaqwp/v3EByMSpVZYsEIJ4APaHmVtpGSieV5CALOtNUAzTBiw81GLgC0quyzf6c
-NlWknzJeCsJ5fup2R4d8CYGN77mu5vnO1UqbfElZ9E6cR6zbHjgsr9ly18fXjZoPeDjPuzlWbFwS
-pdvPkhntFvkc13qb9094LL5NrA3NIq3r9eNnop9DizWOqCEbyRBFJTHn6Tt3CG1o8a4HevYh0XiJ
-sR0AVVHuGuMOIfbuQ/OKBkGRC6NJ4u7sbPX8bG/n5sNIOQ6/Y/BX3IwRlTSabtZpYLB85lYtkkgm
-p1qXK3Du2mnr5INXmT/78KI12n11EFBkJHHp0wJyLe9MvPNUGYsf+170maayRoy2lURGHAIapSpQ
-krEDuNoJCHNlZYhKpvw4mspVWxqo415n8cD62N9+EfHrAvqQnINStetek7RY2Urv8nxsnGaZfRr/
-nhXbJ6m/yl1LzYqscDZA9QHLNbdaSTTr+kFg3bC0iYbX/eQy0Bv3h4B50/SGYzKAXkCeOLI3bcAt
-mj2Z/FM1vQWgDynsRwNvrWnJHlespkrp8+vO1jNaibm+PhqXPPv30YwDZ6jApe3wUjFQobghvW9p
-7f2zLkGNv8b191cD/3vs9Q833z8t''').splitlines()])
-
-    def easteregged(environ, start_response):
-        def injecting_start_response(status, headers, exc_info=None):
-            headers.append(('X-Powered-By', 'Werkzeug'))
-            return start_response(status, headers, exc_info)
-        if app is not None and environ.get('QUERY_STRING') != 'macgybarchakku':
-            return app(environ, injecting_start_response)
-        injecting_start_response('200 OK', [('Content-Type', 'text/html')])
-        return [(u'''
-<!DOCTYPE html>
-<html>
-<head>
-<title>About Werkzeug</title>
-<style type="text/css">
-  body { font: 15px Georgia, serif; text-align: center; }
-  a { color: #333; text-decoration: none; }
-  h1 { font-size: 30px; margin: 20px 0 10px 0; }
-  p { margin: 0 0 30px 0; }
-  pre { font: 11px 'Consolas', 'Monaco', monospace; line-height: 0.95; }
-</style>
-</head>
-<body>
-<h1><a href="http://werkzeug.pocoo.org/">Werkzeug</a></h1>
-<p>the Swiss Army knife of Python web development.</p>
-<pre>%s\n\n\n</pre>
-</body>
-</html>''' % gyver).encode('latin1')]
-    return easteregged
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_reloader.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_reloader.py
deleted file mode 100644
index 0d23dba4e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/_reloader.py
+++ /dev/null
@@ -1,277 +0,0 @@
-import os
-import sys
-import time
-import subprocess
-import threading
-from itertools import chain
-
-from werkzeug._internal import _log
-from werkzeug._compat import PY2, iteritems, text_type
-
-
-def _iter_module_files():
-    """This iterates over all relevant Python files.  It goes through all
-    loaded files from modules, all files in folders of already loaded modules
-    as well as all files reachable through a package.
-    """
-    # The list call is necessary on Python 3 in case the module
-    # dictionary modifies during iteration.
-    for module in list(sys.modules.values()):
-        if module is None:
-            continue
-        filename = getattr(module, '__file__', None)
-        if filename:
-            if os.path.isdir(filename) and \
-               os.path.exists(os.path.join(filename, "__init__.py")):
-                filename = os.path.join(filename, "__init__.py")
-
-            old = None
-            while not os.path.isfile(filename):
-                old = filename
-                filename = os.path.dirname(filename)
-                if filename == old:
-                    break
-            else:
-                if filename[-4:] in ('.pyc', '.pyo'):
-                    filename = filename[:-1]
-                yield filename
-
-
-def _find_observable_paths(extra_files=None):
-    """Finds all paths that should be observed."""
-    rv = set(os.path.dirname(os.path.abspath(x))
-             if os.path.isfile(x) else os.path.abspath(x)
-             for x in sys.path)
-
-    for filename in extra_files or ():
-        rv.add(os.path.dirname(os.path.abspath(filename)))
-
-    for module in list(sys.modules.values()):
-        fn = getattr(module, '__file__', None)
-        if fn is None:
-            continue
-        fn = os.path.abspath(fn)
-        rv.add(os.path.dirname(fn))
-
-    return _find_common_roots(rv)
-
-
-def _get_args_for_reloading():
-    """Returns the executable. This contains a workaround for windows
-    if the executable is incorrectly reported to not have the .exe
-    extension which can cause bugs on reloading.
-    """
-    rv = [sys.executable]
-    py_script = sys.argv[0]
-    if os.name == 'nt' and not os.path.exists(py_script) and \
-       os.path.exists(py_script + '.exe'):
-        py_script += '.exe'
-    if os.path.splitext(rv[0])[1] == '.exe' and os.path.splitext(py_script)[1] == '.exe':
-        rv.pop(0)
-    rv.append(py_script)
-    rv.extend(sys.argv[1:])
-    return rv
-
-
-def _find_common_roots(paths):
-    """Out of some paths it finds the common roots that need monitoring."""
-    paths = [x.split(os.path.sep) for x in paths]
-    root = {}
-    for chunks in sorted(paths, key=len, reverse=True):
-        node = root
-        for chunk in chunks:
-            node = node.setdefault(chunk, {})
-        node.clear()
-
-    rv = set()
-
-    def _walk(node, path):
-        for prefix, child in iteritems(node):
-            _walk(child, path + (prefix,))
-        if not node:
-            rv.add('/'.join(path))
-    _walk(root, ())
-    return rv
-
-
-class ReloaderLoop(object):
-    name = None
-
-    # monkeypatched by testsuite. wrapping with `staticmethod` is required in
-    # case time.sleep has been replaced by a non-c function (e.g. by
-    # `eventlet.monkey_patch`) before we get here
-    _sleep = staticmethod(time.sleep)
-
-    def __init__(self, extra_files=None, interval=1):
-        self.extra_files = set(os.path.abspath(x)
-                               for x in extra_files or ())
-        self.interval = interval
-
-    def run(self):
-        pass
-
-    def restart_with_reloader(self):
-        """Spawn a new Python interpreter with the same arguments as this one,
-        but running the reloader thread.
-        """
-        while 1:
-            _log('info', ' * Restarting with %s' % self.name)
-            args = _get_args_for_reloading()
-            new_environ = os.environ.copy()
-            new_environ['WERKZEUG_RUN_MAIN'] = 'true'
-
-            # a weird bug on windows. sometimes unicode strings end up in the
-            # environment and subprocess.call does not like this, encode them
-            # to latin1 and continue.
-            if os.name == 'nt' and PY2:
-                for key, value in iteritems(new_environ):
-                    if isinstance(value, text_type):
-                        new_environ[key] = value.encode('iso-8859-1')
-
-            exit_code = subprocess.call(args, env=new_environ,
-                                        close_fds=False)
-            if exit_code != 3:
-                return exit_code
-
-    def trigger_reload(self, filename):
-        self.log_reload(filename)
-        sys.exit(3)
-
-    def log_reload(self, filename):
-        filename = os.path.abspath(filename)
-        _log('info', ' * Detected change in %r, reloading' % filename)
-
-
-class StatReloaderLoop(ReloaderLoop):
-    name = 'stat'
-
-    def run(self):
-        mtimes = {}
-        while 1:
-            for filename in chain(_iter_module_files(),
-                                  self.extra_files):
-                try:
-                    mtime = os.stat(filename).st_mtime
-                except OSError:
-                    continue
-
-                old_time = mtimes.get(filename)
-                if old_time is None:
-                    mtimes[filename] = mtime
-                    continue
-                elif mtime > old_time:
-                    self.trigger_reload(filename)
-            self._sleep(self.interval)
-
-
-class WatchdogReloaderLoop(ReloaderLoop):
-
-    def __init__(self, *args, **kwargs):
-        ReloaderLoop.__init__(self, *args, **kwargs)
-        from watchdog.observers import Observer
-        from watchdog.events import FileSystemEventHandler
-        self.observable_paths = set()
-
-        def _check_modification(filename):
-            if filename in self.extra_files:
-                self.trigger_reload(filename)
-            dirname = os.path.dirname(filename)
-            if dirname.startswith(tuple(self.observable_paths)):
-                if filename.endswith(('.pyc', '.pyo', '.py')):
-                    self.trigger_reload(filename)
-
-        class _CustomHandler(FileSystemEventHandler):
-
-            def on_created(self, event):
-                _check_modification(event.src_path)
-
-            def on_modified(self, event):
-                _check_modification(event.src_path)
-
-            def on_moved(self, event):
-                _check_modification(event.src_path)
-                _check_modification(event.dest_path)
-
-            def on_deleted(self, event):
-                _check_modification(event.src_path)
-
-        reloader_name = Observer.__name__.lower()
-        if reloader_name.endswith('observer'):
-            reloader_name = reloader_name[:-8]
-        reloader_name += ' reloader'
-
-        self.name = reloader_name
-
-        self.observer_class = Observer
-        self.event_handler = _CustomHandler()
-        self.should_reload = False
-
-    def trigger_reload(self, filename):
-        # This is called inside an event handler, which means throwing
-        # SystemExit has no effect.
-        # https://github.com/gorakhargosh/watchdog/issues/294
-        self.should_reload = True
-        self.log_reload(filename)
-
-    def run(self):
-        watches = {}
-        observer = self.observer_class()
-        observer.start()
-
-        try:
-            while not self.should_reload:
-                to_delete = set(watches)
-                paths = _find_observable_paths(self.extra_files)
-                for path in paths:
-                    if path not in watches:
-                        try:
-                            watches[path] = observer.schedule(
-                                self.event_handler, path, recursive=True)
-                        except OSError:
-                            # Clear this path from list of watches We don't want
-                            # the same error message showing again in the next
-                            # iteration.
-                            watches[path] = None
-                    to_delete.discard(path)
-                for path in to_delete:
-                    watch = watches.pop(path, None)
-                    if watch is not None:
-                        observer.unschedule(watch)
-                self.observable_paths = paths
-                self._sleep(self.interval)
-        finally:
-            observer.stop()
-            observer.join()
-
-        sys.exit(3)
-
-
-reloader_loops = {
-    'stat': StatReloaderLoop,
-    'watchdog': WatchdogReloaderLoop,
-}
-
-try:
-    __import__('watchdog.observers')
-except ImportError:
-    reloader_loops['auto'] = reloader_loops['stat']
-else:
-    reloader_loops['auto'] = reloader_loops['watchdog']
-
-
-def run_with_reloader(main_func, extra_files=None, interval=1,
-                      reloader_type='auto'):
-    """Run the given function in an independent python interpreter."""
-    import signal
-    reloader = reloader_loops[reloader_type](extra_files, interval)
-    signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))
-    try:
-        if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
-            t = threading.Thread(target=main_func, args=())
-            t.setDaemon(True)
-            t.start()
-            reloader.run()
-        else:
-            sys.exit(reloader.restart_with_reloader())
-    except KeyboardInterrupt:
-        pass
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__init__.py
deleted file mode 100644
index 3e572ebed..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib
-    ~~~~~~~~~~~~~~~~
-
-    Contains user-submitted code that other users may find useful, but which
-    is not part of the Werkzeug core.  Anyone can write code for inclusion in
-    the `contrib` package.  All modules in this package are distributed as an
-    add-on library and thus are not part of Werkzeug itself.
-
-    This file itself is mostly for informational purposes and to tell the
-    Python interpreter that `contrib` is a package.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index d6714d242..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/atom.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/atom.cpython-35.pyc
deleted file mode 100644
index 11d4c34ce..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/atom.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/cache.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/cache.cpython-35.pyc
deleted file mode 100644
index 08e6c5e6e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/cache.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/fixers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/fixers.cpython-35.pyc
deleted file mode 100644
index 65697c081..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/fixers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/iterio.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/iterio.cpython-35.pyc
deleted file mode 100644
index 67dd1670e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/iterio.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/jsrouting.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/jsrouting.cpython-35.pyc
deleted file mode 100644
index 00fadda06..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/jsrouting.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/limiter.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/limiter.cpython-35.pyc
deleted file mode 100644
index 067ff49e2..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/limiter.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/lint.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/lint.cpython-35.pyc
deleted file mode 100644
index 62437db4c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/lint.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/profiler.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/profiler.cpython-35.pyc
deleted file mode 100644
index 6d628fec0..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/profiler.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/securecookie.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/securecookie.cpython-35.pyc
deleted file mode 100644
index d0d121b1e..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/securecookie.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/sessions.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/sessions.cpython-35.pyc
deleted file mode 100644
index c17973596..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/sessions.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/testtools.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/testtools.cpython-35.pyc
deleted file mode 100644
index 1e8fc56b5..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/testtools.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/wrappers.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/wrappers.cpython-35.pyc
deleted file mode 100644
index 202d58be6..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/__pycache__/wrappers.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/atom.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/atom.py
deleted file mode 100644
index 51d1a4e64..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/atom.py
+++ /dev/null
@@ -1,355 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.atom
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    This module provides a class called :class:`AtomFeed` which can be
-    used to generate feeds in the Atom syndication format (see :rfc:`4287`).
-
-    Example::
-
-        def atom_feed(request):
-            feed = AtomFeed("My Blog", feed_url=request.url,
-                            url=request.host_url,
-                            subtitle="My example blog for a feed test.")
-            for post in Post.query.limit(10).all():
-                feed.add(post.title, post.body, content_type='html',
-                         author=post.author, url=post.url, id=post.uid,
-                         updated=post.last_update, published=post.pub_date)
-            return feed.get_response()
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from datetime import datetime
-
-from werkzeug.utils import escape
-from werkzeug.wrappers import BaseResponse
-from werkzeug._compat import implements_to_string, string_types
-
-
-XHTML_NAMESPACE = 'http://www.w3.org/1999/xhtml'
-
-
-def _make_text_block(name, content, content_type=None):
-    """Helper function for the builder that creates an XML text block."""
-    if content_type == 'xhtml':
-        return u'<%s type="xhtml"><div xmlns="%s">%s</div></%s>\n' % \
-               (name, XHTML_NAMESPACE, content, name)
-    if not content_type:
-        return u'<%s>%s</%s>\n' % (name, escape(content), name)
-    return u'<%s type="%s">%s</%s>\n' % (name, content_type,
-                                         escape(content), name)
-
-
-def format_iso8601(obj):
-    """Format a datetime object for iso8601"""
-    iso8601 = obj.isoformat()
-    if obj.tzinfo:
-        return iso8601
-    return iso8601 + 'Z'
-
-
-@implements_to_string
-class AtomFeed(object):
-
-    """A helper class that creates Atom feeds.
-
-    :param title: the title of the feed. Required.
-    :param title_type: the type attribute for the title element.  One of
-                       ``'html'``, ``'text'`` or ``'xhtml'``.
-    :param url: the url for the feed (not the url *of* the feed)
-    :param id: a globally unique id for the feed.  Must be an URI.  If
-               not present the `feed_url` is used, but one of both is
-               required.
-    :param updated: the time the feed was modified the last time.  Must
-                    be a :class:`datetime.datetime` object.  If not
-                    present the latest entry's `updated` is used.
-                    Treated as UTC if naive datetime.
-    :param feed_url: the URL to the feed.  Should be the URL that was
-                     requested.
-    :param author: the author of the feed.  Must be either a string (the
-                   name) or a dict with name (required) and uri or
-                   email (both optional).  Can be a list of (may be
-                   mixed, too) strings and dicts, too, if there are
-                   multiple authors. Required if not every entry has an
-                   author element.
-    :param icon: an icon for the feed.
-    :param logo: a logo for the feed.
-    :param rights: copyright information for the feed.
-    :param rights_type: the type attribute for the rights element.  One of
-                        ``'html'``, ``'text'`` or ``'xhtml'``.  Default is
-                        ``'text'``.
-    :param subtitle: a short description of the feed.
-    :param subtitle_type: the type attribute for the subtitle element.
-                          One of ``'text'``, ``'html'``, ``'text'``
-                          or ``'xhtml'``.  Default is ``'text'``.
-    :param links: additional links.  Must be a list of dictionaries with
-                  href (required) and rel, type, hreflang, title, length
-                  (all optional)
-    :param generator: the software that generated this feed.  This must be
-                      a tuple in the form ``(name, url, version)``.  If
-                      you don't want to specify one of them, set the item
-                      to `None`.
-    :param entries: a list with the entries for the feed. Entries can also
-                    be added later with :meth:`add`.
-
-    For more information on the elements see
-    http://www.atomenabled.org/developers/syndication/
-
-    Everywhere where a list is demanded, any iterable can be used.
-    """
-
-    default_generator = ('Werkzeug', None, None)
-
-    def __init__(self, title=None, entries=None, **kwargs):
-        self.title = title
-        self.title_type = kwargs.get('title_type', 'text')
-        self.url = kwargs.get('url')
-        self.feed_url = kwargs.get('feed_url', self.url)
-        self.id = kwargs.get('id', self.feed_url)
-        self.updated = kwargs.get('updated')
-        self.author = kwargs.get('author', ())
-        self.icon = kwargs.get('icon')
-        self.logo = kwargs.get('logo')
-        self.rights = kwargs.get('rights')
-        self.rights_type = kwargs.get('rights_type')
-        self.subtitle = kwargs.get('subtitle')
-        self.subtitle_type = kwargs.get('subtitle_type', 'text')
-        self.generator = kwargs.get('generator')
-        if self.generator is None:
-            self.generator = self.default_generator
-        self.links = kwargs.get('links', [])
-        self.entries = entries and list(entries) or []
-
-        if not hasattr(self.author, '__iter__') \
-           or isinstance(self.author, string_types + (dict,)):
-            self.author = [self.author]
-        for i, author in enumerate(self.author):
-            if not isinstance(author, dict):
-                self.author[i] = {'name': author}
-
-        if not self.title:
-            raise ValueError('title is required')
-        if not self.id:
-            raise ValueError('id is required')
-        for author in self.author:
-            if 'name' not in author:
-                raise TypeError('author must contain at least a name')
-
-    def add(self, *args, **kwargs):
-        """Add a new entry to the feed.  This function can either be called
-        with a :class:`FeedEntry` or some keyword and positional arguments
-        that are forwarded to the :class:`FeedEntry` constructor.
-        """
-        if len(args) == 1 and not kwargs and isinstance(args[0], FeedEntry):
-            self.entries.append(args[0])
-        else:
-            kwargs['feed_url'] = self.feed_url
-            self.entries.append(FeedEntry(*args, **kwargs))
-
-    def __repr__(self):
-        return '<%s %r (%d entries)>' % (
-            self.__class__.__name__,
-            self.title,
-            len(self.entries)
-        )
-
-    def generate(self):
-        """Return a generator that yields pieces of XML."""
-        # atom demands either an author element in every entry or a global one
-        if not self.author:
-            if any(not e.author for e in self.entries):
-                self.author = ({'name': 'Unknown author'},)
-
-        if not self.updated:
-            dates = sorted([entry.updated for entry in self.entries])
-            self.updated = dates and dates[-1] or datetime.utcnow()
-
-        yield u'<?xml version="1.0" encoding="utf-8"?>\n'
-        yield u'<feed xmlns="http://www.w3.org/2005/Atom">\n'
-        yield '  ' + _make_text_block('title', self.title, self.title_type)
-        yield u'  <id>%s</id>\n' % escape(self.id)
-        yield u'  <updated>%s</updated>\n' % format_iso8601(self.updated)
-        if self.url:
-            yield u'  <link href="%s" />\n' % escape(self.url)
-        if self.feed_url:
-            yield u'  <link href="%s" rel="self" />\n' % \
-                escape(self.feed_url)
-        for link in self.links:
-            yield u'  <link %s/>\n' % ''.join('%s="%s" ' %
-                                              (k, escape(link[k])) for k in link)
-        for author in self.author:
-            yield u'  <author>\n'
-            yield u'    <name>%s</name>\n' % escape(author['name'])
-            if 'uri' in author:
-                yield u'    <uri>%s</uri>\n' % escape(author['uri'])
-            if 'email' in author:
-                yield '    <email>%s</email>\n' % escape(author['email'])
-            yield '  </author>\n'
-        if self.subtitle:
-            yield '  ' + _make_text_block('subtitle', self.subtitle,
-                                          self.subtitle_type)
-        if self.icon:
-            yield u'  <icon>%s</icon>\n' % escape(self.icon)
-        if self.logo:
-            yield u'  <logo>%s</logo>\n' % escape(self.logo)
-        if self.rights:
-            yield '  ' + _make_text_block('rights', self.rights,
-                                          self.rights_type)
-        generator_name, generator_url, generator_version = self.generator
-        if generator_name or generator_url or generator_version:
-            tmp = [u'  <generator']
-            if generator_url:
-                tmp.append(u' uri="%s"' % escape(generator_url))
-            if generator_version:
-                tmp.append(u' version="%s"' % escape(generator_version))
-            tmp.append(u'>%s</generator>\n' % escape(generator_name))
-            yield u''.join(tmp)
-        for entry in self.entries:
-            for line in entry.generate():
-                yield u'  ' + line
-        yield u'</feed>\n'
-
-    def to_string(self):
-        """Convert the feed into a string."""
-        return u''.join(self.generate())
-
-    def get_response(self):
-        """Return a response object for the feed."""
-        return BaseResponse(self.to_string(), mimetype='application/atom+xml')
-
-    def __call__(self, environ, start_response):
-        """Use the class as WSGI response object."""
-        return self.get_response()(environ, start_response)
-
-    def __str__(self):
-        return self.to_string()
-
-
-@implements_to_string
-class FeedEntry(object):
-
-    """Represents a single entry in a feed.
-
-    :param title: the title of the entry. Required.
-    :param title_type: the type attribute for the title element.  One of
-                       ``'html'``, ``'text'`` or ``'xhtml'``.
-    :param content: the content of the entry.
-    :param content_type: the type attribute for the content element.  One
-                         of ``'html'``, ``'text'`` or ``'xhtml'``.
-    :param summary: a summary of the entry's content.
-    :param summary_type: the type attribute for the summary element.  One
-                         of ``'html'``, ``'text'`` or ``'xhtml'``.
-    :param url: the url for the entry.
-    :param id: a globally unique id for the entry.  Must be an URI.  If
-               not present the URL is used, but one of both is required.
-    :param updated: the time the entry was modified the last time.  Must
-                    be a :class:`datetime.datetime` object.  Treated as
-                    UTC if naive datetime. Required.
-    :param author: the author of the entry.  Must be either a string (the
-                   name) or a dict with name (required) and uri or
-                   email (both optional).  Can be a list of (may be
-                   mixed, too) strings and dicts, too, if there are
-                   multiple authors. Required if the feed does not have an
-                   author element.
-    :param published: the time the entry was initially published.  Must
-                      be a :class:`datetime.datetime` object.  Treated as
-                      UTC if naive datetime.
-    :param rights: copyright information for the entry.
-    :param rights_type: the type attribute for the rights element.  One of
-                        ``'html'``, ``'text'`` or ``'xhtml'``.  Default is
-                        ``'text'``.
-    :param links: additional links.  Must be a list of dictionaries with
-                  href (required) and rel, type, hreflang, title, length
-                  (all optional)
-    :param categories: categories for the entry. Must be a list of dictionaries
-                       with term (required), scheme and label (all optional)
-    :param xml_base: The xml base (url) for this feed item.  If not provided
-                     it will default to the item url.
-
-    For more information on the elements see
-    http://www.atomenabled.org/developers/syndication/
-
-    Everywhere where a list is demanded, any iterable can be used.
-    """
-
-    def __init__(self, title=None, content=None, feed_url=None, **kwargs):
-        self.title = title
-        self.title_type = kwargs.get('title_type', 'text')
-        self.content = content
-        self.content_type = kwargs.get('content_type', 'html')
-        self.url = kwargs.get('url')
-        self.id = kwargs.get('id', self.url)
-        self.updated = kwargs.get('updated')
-        self.summary = kwargs.get('summary')
-        self.summary_type = kwargs.get('summary_type', 'html')
-        self.author = kwargs.get('author', ())
-        self.published = kwargs.get('published')
-        self.rights = kwargs.get('rights')
-        self.links = kwargs.get('links', [])
-        self.categories = kwargs.get('categories', [])
-        self.xml_base = kwargs.get('xml_base', feed_url)
-
-        if not hasattr(self.author, '__iter__') \
-           or isinstance(self.author, string_types + (dict,)):
-            self.author = [self.author]
-        for i, author in enumerate(self.author):
-            if not isinstance(author, dict):
-                self.author[i] = {'name': author}
-
-        if not self.title:
-            raise ValueError('title is required')
-        if not self.id:
-            raise ValueError('id is required')
-        if not self.updated:
-            raise ValueError('updated is required')
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self.title
-        )
-
-    def generate(self):
-        """Yields pieces of ATOM XML."""
-        base = ''
-        if self.xml_base:
-            base = ' xml:base="%s"' % escape(self.xml_base)
-        yield u'<entry%s>\n' % base
-        yield u'  ' + _make_text_block('title', self.title, self.title_type)
-        yield u'  <id>%s</id>\n' % escape(self.id)
-        yield u'  <updated>%s</updated>\n' % format_iso8601(self.updated)
-        if self.published:
-            yield u'  <published>%s</published>\n' % \
-                  format_iso8601(self.published)
-        if self.url:
-            yield u'  <link href="%s" />\n' % escape(self.url)
-        for author in self.author:
-            yield u'  <author>\n'
-            yield u'    <name>%s</name>\n' % escape(author['name'])
-            if 'uri' in author:
-                yield u'    <uri>%s</uri>\n' % escape(author['uri'])
-            if 'email' in author:
-                yield u'    <email>%s</email>\n' % escape(author['email'])
-            yield u'  </author>\n'
-        for link in self.links:
-            yield u'  <link %s/>\n' % ''.join('%s="%s" ' %
-                                              (k, escape(link[k])) for k in link)
-        for category in self.categories:
-            yield u'  <category %s/>\n' % ''.join('%s="%s" ' %
-                                                  (k, escape(category[k])) for k in category)
-        if self.summary:
-            yield u'  ' + _make_text_block('summary', self.summary,
-                                           self.summary_type)
-        if self.content:
-            yield u'  ' + _make_text_block('content', self.content,
-                                           self.content_type)
-        yield u'</entry>\n'
-
-    def to_string(self):
-        """Convert the feed item into a unicode object."""
-        return u''.join(self.generate())
-
-    def __str__(self):
-        return self.to_string()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/cache.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/cache.py
deleted file mode 100644
index 179ba24a8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/cache.py
+++ /dev/null
@@ -1,913 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.cache
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    The main problem with dynamic Web sites is, well, they're dynamic.  Each
-    time a user requests a page, the webserver executes a lot of code, queries
-    the database, renders templates until the visitor gets the page he sees.
-
-    This is a lot more expensive than just loading a file from the file system
-    and sending it to the visitor.
-
-    For most Web applications, this overhead isn't a big deal but once it
-    becomes, you will be glad to have a cache system in place.
-
-    How Caching Works
-    =================
-
-    Caching is pretty simple.  Basically you have a cache object lurking around
-    somewhere that is connected to a remote cache or the file system or
-    something else.  When the request comes in you check if the current page
-    is already in the cache and if so, you're returning it from the cache.
-    Otherwise you generate the page and put it into the cache. (Or a fragment
-    of the page, you don't have to cache the full thing)
-
-    Here is a simple example of how to cache a sidebar for 5 minutes::
-
-        def get_sidebar(user):
-            identifier = 'sidebar_for/user%d' % user.id
-            value = cache.get(identifier)
-            if value is not None:
-                return value
-            value = generate_sidebar_for(user=user)
-            cache.set(identifier, value, timeout=60 * 5)
-            return value
-
-    Creating a Cache Object
-    =======================
-
-    To create a cache object you just import the cache system of your choice
-    from the cache module and instantiate it.  Then you can start working
-    with that object:
-
-    >>> from werkzeug.contrib.cache import SimpleCache
-    >>> c = SimpleCache()
-    >>> c.set("foo", "value")
-    >>> c.get("foo")
-    'value'
-    >>> c.get("missing") is None
-    True
-
-    Please keep in mind that you have to create the cache and put it somewhere
-    you have access to it (either as a module global you can import or you just
-    put it into your WSGI application).
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import re
-import errno
-import tempfile
-import platform
-from hashlib import md5
-from time import time
-try:
-    import cPickle as pickle
-except ImportError:  # pragma: no cover
-    import pickle
-
-from werkzeug._compat import iteritems, string_types, text_type, \
-    integer_types, to_native
-from werkzeug.posixemulation import rename
-
-
-def _items(mappingorseq):
-    """Wrapper for efficient iteration over mappings represented by dicts
-    or sequences::
-
-        >>> for k, v in _items((i, i*i) for i in xrange(5)):
-        ...    assert k*k == v
-
-        >>> for k, v in _items(dict((i, i*i) for i in xrange(5))):
-        ...    assert k*k == v
-
-    """
-    if hasattr(mappingorseq, 'items'):
-        return iteritems(mappingorseq)
-    return mappingorseq
-
-
-class BaseCache(object):
-
-    """Baseclass for the cache systems.  All the cache systems implement this
-    API or a superset of it.
-
-    :param default_timeout: the default timeout (in seconds) that is used if
-                            no timeout is specified on :meth:`set`. A timeout
-                            of 0 indicates that the cache never expires.
-    """
-
-    def __init__(self, default_timeout=300):
-        self.default_timeout = default_timeout
-
-    def _normalize_timeout(self, timeout):
-        if timeout is None:
-            timeout = self.default_timeout
-        return timeout
-
-    def get(self, key):
-        """Look up key in the cache and return the value for it.
-
-        :param key: the key to be looked up.
-        :returns: The value if it exists and is readable, else ``None``.
-        """
-        return None
-
-    def delete(self, key):
-        """Delete `key` from the cache.
-
-        :param key: the key to delete.
-        :returns: Whether the key existed and has been deleted.
-        :rtype: boolean
-        """
-        return True
-
-    def get_many(self, *keys):
-        """Returns a list of values for the given keys.
-        For each key an item in the list is created::
-
-            foo, bar = cache.get_many("foo", "bar")
-
-        Has the same error handling as :meth:`get`.
-
-        :param keys: The function accepts multiple keys as positional
-                     arguments.
-        """
-        return [self.get(k) for k in keys]
-
-    def get_dict(self, *keys):
-        """Like :meth:`get_many` but return a dict::
-
-            d = cache.get_dict("foo", "bar")
-            foo = d["foo"]
-            bar = d["bar"]
-
-        :param keys: The function accepts multiple keys as positional
-                     arguments.
-        """
-        return dict(zip(keys, self.get_many(*keys)))
-
-    def set(self, key, value, timeout=None):
-        """Add a new key/value to the cache (overwrites value, if key already
-        exists in the cache).
-
-        :param key: the key to set
-        :param value: the value for the key
-        :param timeout: the cache timeout for the key in seconds (if not
-                        specified, it uses the default timeout). A timeout of
-                        0 idicates that the cache never expires.
-        :returns: ``True`` if key has been updated, ``False`` for backend
-                  errors. Pickling errors, however, will raise a subclass of
-                  ``pickle.PickleError``.
-        :rtype: boolean
-        """
-        return True
-
-    def add(self, key, value, timeout=None):
-        """Works like :meth:`set` but does not overwrite the values of already
-        existing keys.
-
-        :param key: the key to set
-        :param value: the value for the key
-        :param timeout: the cache timeout for the key in seconds (if not
-                        specified, it uses the default timeout). A timeout of
-                        0 idicates that the cache never expires.
-        :returns: Same as :meth:`set`, but also ``False`` for already
-                  existing keys.
-        :rtype: boolean
-        """
-        return True
-
-    def set_many(self, mapping, timeout=None):
-        """Sets multiple keys and values from a mapping.
-
-        :param mapping: a mapping with the keys/values to set.
-        :param timeout: the cache timeout for the key in seconds (if not
-                        specified, it uses the default timeout). A timeout of
-                        0 idicates that the cache never expires.
-        :returns: Whether all given keys have been set.
-        :rtype: boolean
-        """
-        rv = True
-        for key, value in _items(mapping):
-            if not self.set(key, value, timeout):
-                rv = False
-        return rv
-
-    def delete_many(self, *keys):
-        """Deletes multiple keys at once.
-
-        :param keys: The function accepts multiple keys as positional
-                     arguments.
-        :returns: Whether all given keys have been deleted.
-        :rtype: boolean
-        """
-        return all(self.delete(key) for key in keys)
-
-    def has(self, key):
-        """Checks if a key exists in the cache without returning it. This is a
-        cheap operation that bypasses loading the actual data on the backend.
-
-        This method is optional and may not be implemented on all caches.
-
-        :param key: the key to check
-        """
-        raise NotImplementedError(
-            '%s doesn\'t have an efficient implementation of `has`. That '
-            'means it is impossible to check whether a key exists without '
-            'fully loading the key\'s data. Consider using `self.get` '
-            'explicitly if you don\'t care about performance.'
-        )
-
-    def clear(self):
-        """Clears the cache.  Keep in mind that not all caches support
-        completely clearing the cache.
-
-        :returns: Whether the cache has been cleared.
-        :rtype: boolean
-        """
-        return True
-
-    def inc(self, key, delta=1):
-        """Increments the value of a key by `delta`.  If the key does
-        not yet exist it is initialized with `delta`.
-
-        For supporting caches this is an atomic operation.
-
-        :param key: the key to increment.
-        :param delta: the delta to add.
-        :returns: The new value or ``None`` for backend errors.
-        """
-        value = (self.get(key) or 0) + delta
-        return value if self.set(key, value) else None
-
-    def dec(self, key, delta=1):
-        """Decrements the value of a key by `delta`.  If the key does
-        not yet exist it is initialized with `-delta`.
-
-        For supporting caches this is an atomic operation.
-
-        :param key: the key to increment.
-        :param delta: the delta to subtract.
-        :returns: The new value or `None` for backend errors.
-        """
-        value = (self.get(key) or 0) - delta
-        return value if self.set(key, value) else None
-
-
-class NullCache(BaseCache):
-
-    """A cache that doesn't cache.  This can be useful for unit testing.
-
-    :param default_timeout: a dummy parameter that is ignored but exists
-                            for API compatibility with other caches.
-    """
-
-    def has(self, key):
-        return False
-
-
-class SimpleCache(BaseCache):
-
-    """Simple memory cache for single process environments.  This class exists
-    mainly for the development server and is not 100% thread safe.  It tries
-    to use as many atomic operations as possible and no locks for simplicity
-    but it could happen under heavy load that keys are added multiple times.
-
-    :param threshold: the maximum number of items the cache stores before
-                      it starts deleting some.
-    :param default_timeout: the default timeout that is used if no timeout is
-                            specified on :meth:`~BaseCache.set`. A timeout of
-                            0 indicates that the cache never expires.
-    """
-
-    def __init__(self, threshold=500, default_timeout=300):
-        BaseCache.__init__(self, default_timeout)
-        self._cache = {}
-        self.clear = self._cache.clear
-        self._threshold = threshold
-
-    def _prune(self):
-        if len(self._cache) > self._threshold:
-            now = time()
-            toremove = []
-            for idx, (key, (expires, _)) in enumerate(self._cache.items()):
-                if (expires != 0 and expires <= now) or idx % 3 == 0:
-                    toremove.append(key)
-            for key in toremove:
-                self._cache.pop(key, None)
-
-    def _normalize_timeout(self, timeout):
-        timeout = BaseCache._normalize_timeout(self, timeout)
-        if timeout > 0:
-            timeout = time() + timeout
-        return timeout
-
-    def get(self, key):
-        try:
-            expires, value = self._cache[key]
-            if expires == 0 or expires > time():
-                return pickle.loads(value)
-        except (KeyError, pickle.PickleError):
-            return None
-
-    def set(self, key, value, timeout=None):
-        expires = self._normalize_timeout(timeout)
-        self._prune()
-        self._cache[key] = (expires, pickle.dumps(value,
-                                                  pickle.HIGHEST_PROTOCOL))
-        return True
-
-    def add(self, key, value, timeout=None):
-        expires = self._normalize_timeout(timeout)
-        self._prune()
-        item = (expires, pickle.dumps(value,
-                                      pickle.HIGHEST_PROTOCOL))
-        if key in self._cache:
-            return False
-        self._cache.setdefault(key, item)
-        return True
-
-    def delete(self, key):
-        return self._cache.pop(key, None) is not None
-
-    def has(self, key):
-        try:
-            expires, value = self._cache[key]
-            return expires == 0 or expires > time()
-        except KeyError:
-            return False
-
-_test_memcached_key = re.compile(r'[^\x00-\x21\xff]{1,250}$').match
-
-
-class MemcachedCache(BaseCache):
-
-    """A cache that uses memcached as backend.
-
-    The first argument can either be an object that resembles the API of a
-    :class:`memcache.Client` or a tuple/list of server addresses. In the
-    event that a tuple/list is passed, Werkzeug tries to import the best
-    available memcache library.
-
-    This cache looks into the following packages/modules to find bindings for
-    memcached:
-
-        - ``pylibmc``
-        - ``google.appengine.api.memcached``
-        - ``memcached``
-        - ``libmc``
-
-    Implementation notes:  This cache backend works around some limitations in
-    memcached to simplify the interface.  For example unicode keys are encoded
-    to utf-8 on the fly.  Methods such as :meth:`~BaseCache.get_dict` return
-    the keys in the same format as passed.  Furthermore all get methods
-    silently ignore key errors to not cause problems when untrusted user data
-    is passed to the get methods which is often the case in web applications.
-
-    :param servers: a list or tuple of server addresses or alternatively
-                    a :class:`memcache.Client` or a compatible client.
-    :param default_timeout: the default timeout that is used if no timeout is
-                            specified on :meth:`~BaseCache.set`. A timeout of
-                            0 indicates that the cache never expires.
-    :param key_prefix: a prefix that is added before all keys.  This makes it
-                       possible to use the same memcached server for different
-                       applications.  Keep in mind that
-                       :meth:`~BaseCache.clear` will also clear keys with a
-                       different prefix.
-    """
-
-    def __init__(self, servers=None, default_timeout=300, key_prefix=None):
-        BaseCache.__init__(self, default_timeout)
-        if servers is None or isinstance(servers, (list, tuple)):
-            if servers is None:
-                servers = ['127.0.0.1:11211']
-            self._client = self.import_preferred_memcache_lib(servers)
-            if self._client is None:
-                raise RuntimeError('no memcache module found')
-        else:
-            # NOTE: servers is actually an already initialized memcache
-            # client.
-            self._client = servers
-
-        self.key_prefix = to_native(key_prefix)
-
-    def _normalize_key(self, key):
-        key = to_native(key, 'utf-8')
-        if self.key_prefix:
-            key = self.key_prefix + key
-        return key
-
-    def _normalize_timeout(self, timeout):
-        timeout = BaseCache._normalize_timeout(self, timeout)
-        if timeout > 0:
-            timeout = int(time()) + timeout
-        return timeout
-
-    def get(self, key):
-        key = self._normalize_key(key)
-        # memcached doesn't support keys longer than that.  Because often
-        # checks for so long keys can occur because it's tested from user
-        # submitted data etc we fail silently for getting.
-        if _test_memcached_key(key):
-            return self._client.get(key)
-
-    def get_dict(self, *keys):
-        key_mapping = {}
-        have_encoded_keys = False
-        for key in keys:
-            encoded_key = self._normalize_key(key)
-            if not isinstance(key, str):
-                have_encoded_keys = True
-            if _test_memcached_key(key):
-                key_mapping[encoded_key] = key
-        _keys = list(key_mapping)
-        d = rv = self._client.get_multi(_keys)
-        if have_encoded_keys or self.key_prefix:
-            rv = {}
-            for key, value in iteritems(d):
-                rv[key_mapping[key]] = value
-        if len(rv) < len(keys):
-            for key in keys:
-                if key not in rv:
-                    rv[key] = None
-        return rv
-
-    def add(self, key, value, timeout=None):
-        key = self._normalize_key(key)
-        timeout = self._normalize_timeout(timeout)
-        return self._client.add(key, value, timeout)
-
-    def set(self, key, value, timeout=None):
-        key = self._normalize_key(key)
-        timeout = self._normalize_timeout(timeout)
-        return self._client.set(key, value, timeout)
-
-    def get_many(self, *keys):
-        d = self.get_dict(*keys)
-        return [d[key] for key in keys]
-
-    def set_many(self, mapping, timeout=None):
-        new_mapping = {}
-        for key, value in _items(mapping):
-            key = self._normalize_key(key)
-            new_mapping[key] = value
-
-        timeout = self._normalize_timeout(timeout)
-        failed_keys = self._client.set_multi(new_mapping, timeout)
-        return not failed_keys
-
-    def delete(self, key):
-        key = self._normalize_key(key)
-        if _test_memcached_key(key):
-            return self._client.delete(key)
-
-    def delete_many(self, *keys):
-        new_keys = []
-        for key in keys:
-            key = self._normalize_key(key)
-            if _test_memcached_key(key):
-                new_keys.append(key)
-        return self._client.delete_multi(new_keys)
-
-    def has(self, key):
-        key = self._normalize_key(key)
-        if _test_memcached_key(key):
-            return self._client.append(key, '')
-        return False
-
-    def clear(self):
-        return self._client.flush_all()
-
-    def inc(self, key, delta=1):
-        key = self._normalize_key(key)
-        return self._client.incr(key, delta)
-
-    def dec(self, key, delta=1):
-        key = self._normalize_key(key)
-        return self._client.decr(key, delta)
-
-    def import_preferred_memcache_lib(self, servers):
-        """Returns an initialized memcache client.  Used by the constructor."""
-        try:
-            import pylibmc
-        except ImportError:
-            pass
-        else:
-            return pylibmc.Client(servers)
-
-        try:
-            from google.appengine.api import memcache
-        except ImportError:
-            pass
-        else:
-            return memcache.Client()
-
-        try:
-            import memcache
-        except ImportError:
-            pass
-        else:
-            return memcache.Client(servers)
-
-        try:
-            import libmc
-        except ImportError:
-            pass
-        else:
-            return libmc.Client(servers)
-
-
-# backwards compatibility
-GAEMemcachedCache = MemcachedCache
-
-
-class RedisCache(BaseCache):
-
-    """Uses the Redis key-value store as a cache backend.
-
-    The first argument can be either a string denoting address of the Redis
-    server or an object resembling an instance of a redis.Redis class.
-
-    Note: Python Redis API already takes care of encoding unicode strings on
-    the fly.
-
-    .. versionadded:: 0.7
-
-    .. versionadded:: 0.8
-       `key_prefix` was added.
-
-    .. versionchanged:: 0.8
-       This cache backend now properly serializes objects.
-
-    .. versionchanged:: 0.8.3
-       This cache backend now supports password authentication.
-
-    .. versionchanged:: 0.10
-        ``**kwargs`` is now passed to the redis object.
-
-    :param host: address of the Redis server or an object which API is
-                 compatible with the official Python Redis client (redis-py).
-    :param port: port number on which Redis server listens for connections.
-    :param password: password authentication for the Redis server.
-    :param db: db (zero-based numeric index) on Redis Server to connect.
-    :param default_timeout: the default timeout that is used if no timeout is
-                            specified on :meth:`~BaseCache.set`. A timeout of
-                            0 indicates that the cache never expires.
-    :param key_prefix: A prefix that should be added to all keys.
-
-    Any additional keyword arguments will be passed to ``redis.Redis``.
-    """
-
-    def __init__(self, host='localhost', port=6379, password=None,
-                 db=0, default_timeout=300, key_prefix=None, **kwargs):
-        BaseCache.__init__(self, default_timeout)
-        if host is None:
-            raise ValueError('RedisCache host parameter may not be None')
-        if isinstance(host, string_types):
-            try:
-                import redis
-            except ImportError:
-                raise RuntimeError('no redis module found')
-            if kwargs.get('decode_responses', None):
-                raise ValueError('decode_responses is not supported by '
-                                 'RedisCache.')
-            self._client = redis.Redis(host=host, port=port, password=password,
-                                       db=db, **kwargs)
-        else:
-            self._client = host
-        self.key_prefix = key_prefix or ''
-
-    def _normalize_timeout(self, timeout):
-        timeout = BaseCache._normalize_timeout(self, timeout)
-        if timeout == 0:
-            timeout = -1
-        return timeout
-
-    def dump_object(self, value):
-        """Dumps an object into a string for redis.  By default it serializes
-        integers as regular string and pickle dumps everything else.
-        """
-        t = type(value)
-        if t in integer_types:
-            return str(value).encode('ascii')
-        return b'!' + pickle.dumps(value)
-
-    def load_object(self, value):
-        """The reversal of :meth:`dump_object`.  This might be called with
-        None.
-        """
-        if value is None:
-            return None
-        if value.startswith(b'!'):
-            try:
-                return pickle.loads(value[1:])
-            except pickle.PickleError:
-                return None
-        try:
-            return int(value)
-        except ValueError:
-            # before 0.8 we did not have serialization.  Still support that.
-            return value
-
-    def get(self, key):
-        return self.load_object(self._client.get(self.key_prefix + key))
-
-    def get_many(self, *keys):
-        if self.key_prefix:
-            keys = [self.key_prefix + key for key in keys]
-        return [self.load_object(x) for x in self._client.mget(keys)]
-
-    def set(self, key, value, timeout=None):
-        timeout = self._normalize_timeout(timeout)
-        dump = self.dump_object(value)
-        if timeout == -1:
-            result = self._client.set(name=self.key_prefix + key,
-                                      value=dump)
-        else:
-            result = self._client.setex(name=self.key_prefix + key,
-                                        value=dump, time=timeout)
-        return result
-
-    def add(self, key, value, timeout=None):
-        timeout = self._normalize_timeout(timeout)
-        dump = self.dump_object(value)
-        return (
-            self._client.setnx(name=self.key_prefix + key, value=dump) and
-            self._client.expire(name=self.key_prefix + key, time=timeout)
-        )
-
-    def set_many(self, mapping, timeout=None):
-        timeout = self._normalize_timeout(timeout)
-        # Use transaction=False to batch without calling redis MULTI
-        # which is not supported by twemproxy
-        pipe = self._client.pipeline(transaction=False)
-
-        for key, value in _items(mapping):
-            dump = self.dump_object(value)
-            if timeout == -1:
-                pipe.set(name=self.key_prefix + key, value=dump)
-            else:
-                pipe.setex(name=self.key_prefix + key, value=dump,
-                           time=timeout)
-        return pipe.execute()
-
-    def delete(self, key):
-        return self._client.delete(self.key_prefix + key)
-
-    def delete_many(self, *keys):
-        if not keys:
-            return
-        if self.key_prefix:
-            keys = [self.key_prefix + key for key in keys]
-        return self._client.delete(*keys)
-
-    def has(self, key):
-        return self._client.exists(self.key_prefix + key)
-
-    def clear(self):
-        status = False
-        if self.key_prefix:
-            keys = self._client.keys(self.key_prefix + '*')
-            if keys:
-                status = self._client.delete(*keys)
-        else:
-            status = self._client.flushdb()
-        return status
-
-    def inc(self, key, delta=1):
-        return self._client.incr(name=self.key_prefix + key, amount=delta)
-
-    def dec(self, key, delta=1):
-        return self._client.decr(name=self.key_prefix + key, amount=delta)
-
-
-class FileSystemCache(BaseCache):
-
-    """A cache that stores the items on the file system.  This cache depends
-    on being the only user of the `cache_dir`.  Make absolutely sure that
-    nobody but this cache stores files there or otherwise the cache will
-    randomly delete files therein.
-
-    :param cache_dir: the directory where cache files are stored.
-    :param threshold: the maximum number of items the cache stores before
-                      it starts deleting some. A threshold value of 0
-                      indicates no threshold.
-    :param default_timeout: the default timeout that is used if no timeout is
-                            specified on :meth:`~BaseCache.set`. A timeout of
-                            0 indicates that the cache never expires.
-    :param mode: the file mode wanted for the cache files, default 0600
-    """
-
-    #: used for temporary files by the FileSystemCache
-    _fs_transaction_suffix = '.__wz_cache'
-    #: keep amount of files in a cache element
-    _fs_count_file = '__wz_cache_count'
-
-    def __init__(self, cache_dir, threshold=500, default_timeout=300,
-                 mode=0o600):
-        BaseCache.__init__(self, default_timeout)
-        self._path = cache_dir
-        self._threshold = threshold
-        self._mode = mode
-
-        try:
-            os.makedirs(self._path)
-        except OSError as ex:
-            if ex.errno != errno.EEXIST:
-                raise
-
-        self._update_count(value=len(self._list_dir()))
-
-    @property
-    def _file_count(self):
-        return self.get(self._fs_count_file) or 0
-
-    def _update_count(self, delta=None, value=None):
-        # If we have no threshold, don't count files
-        if self._threshold == 0:
-            return
-
-        if delta:
-            new_count = self._file_count + delta
-        else:
-            new_count = value or 0
-        self.set(self._fs_count_file, new_count, mgmt_element=True)
-
-    def _normalize_timeout(self, timeout):
-        timeout = BaseCache._normalize_timeout(self, timeout)
-        if timeout != 0:
-            timeout = time() + timeout
-        return int(timeout)
-
-    def _list_dir(self):
-        """return a list of (fully qualified) cache filenames
-        """
-        mgmt_files = [self._get_filename(name).split('/')[-1]
-                      for name in (self._fs_count_file,)]
-        return [os.path.join(self._path, fn) for fn in os.listdir(self._path)
-                if not fn.endswith(self._fs_transaction_suffix)
-                and fn not in mgmt_files]
-
-    def _prune(self):
-        if self._threshold == 0 or not self._file_count > self._threshold:
-            return
-
-        entries = self._list_dir()
-        now = time()
-        for idx, fname in enumerate(entries):
-            try:
-                remove = False
-                with open(fname, 'rb') as f:
-                    expires = pickle.load(f)
-                remove = (expires != 0 and expires <= now) or idx % 3 == 0
-
-                if remove:
-                    os.remove(fname)
-            except (IOError, OSError):
-                pass
-        self._update_count(value=len(self._list_dir()))
-
-    def clear(self):
-        for fname in self._list_dir():
-            try:
-                os.remove(fname)
-            except (IOError, OSError):
-                self._update_count(value=len(self._list_dir()))
-                return False
-        self._update_count(value=0)
-        return True
-
-    def _get_filename(self, key):
-        if isinstance(key, text_type):
-            key = key.encode('utf-8')  # XXX unicode review
-        hash = md5(key).hexdigest()
-        return os.path.join(self._path, hash)
-
-    def get(self, key):
-        filename = self._get_filename(key)
-        try:
-            with open(filename, 'rb') as f:
-                pickle_time = pickle.load(f)
-                if pickle_time == 0 or pickle_time >= time():
-                    return pickle.load(f)
-                else:
-                    os.remove(filename)
-                    return None
-        except (IOError, OSError, pickle.PickleError):
-            return None
-
-    def add(self, key, value, timeout=None):
-        filename = self._get_filename(key)
-        if not os.path.exists(filename):
-            return self.set(key, value, timeout)
-        return False
-
-    def set(self, key, value, timeout=None, mgmt_element=False):
-        # Management elements have no timeout
-        if mgmt_element:
-            timeout = 0
-
-        # Don't prune on management element update, to avoid loop
-        else:
-            self._prune()
-
-        timeout = self._normalize_timeout(timeout)
-        filename = self._get_filename(key)
-        try:
-            fd, tmp = tempfile.mkstemp(suffix=self._fs_transaction_suffix,
-                                       dir=self._path)
-            with os.fdopen(fd, 'wb') as f:
-                pickle.dump(timeout, f, 1)
-                pickle.dump(value, f, pickle.HIGHEST_PROTOCOL)
-            rename(tmp, filename)
-            os.chmod(filename, self._mode)
-        except (IOError, OSError):
-            return False
-        else:
-            # Management elements should not count towards threshold
-            if not mgmt_element:
-                self._update_count(delta=1)
-            return True
-
-    def delete(self, key, mgmt_element=False):
-        try:
-            os.remove(self._get_filename(key))
-        except (IOError, OSError):
-            return False
-        else:
-            # Management elements should not count towards threshold
-            if not mgmt_element:
-                self._update_count(delta=-1)
-            return True
-
-    def has(self, key):
-        filename = self._get_filename(key)
-        try:
-            with open(filename, 'rb') as f:
-                pickle_time = pickle.load(f)
-                if pickle_time == 0 or pickle_time >= time():
-                    return True
-                else:
-                    os.remove(filename)
-                    return False
-        except (IOError, OSError, pickle.PickleError):
-            return False
-
-
-class UWSGICache(BaseCache):
-    """ Implements the cache using uWSGI's caching framework.
-
-    .. note::
-        This class cannot be used when running under PyPy, because the uWSGI
-        API implementation for PyPy is lacking the needed functionality.
-
-    :param default_timeout: The default timeout in seconds.
-    :param cache: The name of the caching instance to connect to, for
-        example: mycache@localhost:3031, defaults to an empty string, which
-        means uWSGI will cache in the local instance. If the cache is in the
-        same instance as the werkzeug app, you only have to provide the name of
-        the cache.
-    """
-    def __init__(self, default_timeout=300, cache=''):
-        BaseCache.__init__(self, default_timeout)
-
-        if platform.python_implementation() == 'PyPy':
-            raise RuntimeError("uWSGI caching does not work under PyPy, see "
-                               "the docs for more details.")
-
-        try:
-            import uwsgi
-            self._uwsgi = uwsgi
-        except ImportError:
-            raise RuntimeError("uWSGI could not be imported, are you "
-                               "running under uWSGI?")
-
-        self.cache = cache
-
-    def get(self, key):
-        rv = self._uwsgi.cache_get(key, self.cache)
-        if rv is None:
-            return
-        return pickle.loads(rv)
-
-    def delete(self, key):
-        return self._uwsgi.cache_del(key, self.cache)
-
-    def set(self, key, value, timeout=None):
-        return self._uwsgi.cache_update(key, pickle.dumps(value),
-                                        self._normalize_timeout(timeout),
-                                        self.cache)
-
-    def add(self, key, value, timeout=None):
-        return self._uwsgi.cache_set(key, pickle.dumps(value),
-                                     self._normalize_timeout(timeout),
-                                     self.cache)
-
-    def clear(self):
-        return self._uwsgi.cache_clear(self.cache)
-
-    def has(self, key):
-        return self._uwsgi.cache_exists(key, self.cache) is not None
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/fixers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/fixers.py
deleted file mode 100644
index b88a861b2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/fixers.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.fixers
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    .. versionadded:: 0.5
-
-    This module includes various helpers that fix bugs in web servers.  They may
-    be necessary for some versions of a buggy web server but not others.  We try
-    to stay updated with the status of the bugs as good as possible but you have
-    to make sure whether they fix the problem you encounter.
-
-    If you notice bugs in webservers not fixed in this module consider
-    contributing a patch.
-
-    :copyright: Copyright 2009 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-try:
-    from urllib import unquote
-except ImportError:
-    from urllib.parse import unquote
-
-from werkzeug.http import parse_options_header, parse_cache_control_header, \
-    parse_set_header
-from werkzeug.useragents import UserAgent
-from werkzeug.datastructures import Headers, ResponseCacheControl
-
-
-class CGIRootFix(object):
-
-    """Wrap the application in this middleware if you are using FastCGI or CGI
-    and you have problems with your app root being set to the cgi script's path
-    instead of the path users are going to visit
-
-    .. versionchanged:: 0.9
-       Added `app_root` parameter and renamed from `LighttpdCGIRootFix`.
-
-    :param app: the WSGI application
-    :param app_root: Defaulting to ``'/'``, you can set this to something else
-        if your app is mounted somewhere else.
-    """
-
-    def __init__(self, app, app_root='/'):
-        self.app = app
-        self.app_root = app_root
-
-    def __call__(self, environ, start_response):
-        # only set PATH_INFO for older versions of Lighty or if no
-        # server software is provided.  That's because the test was
-        # added in newer Werkzeug versions and we don't want to break
-        # people's code if they are using this fixer in a test that
-        # does not set the SERVER_SOFTWARE key.
-        if 'SERVER_SOFTWARE' not in environ or \
-           environ['SERVER_SOFTWARE'] < 'lighttpd/1.4.28':
-            environ['PATH_INFO'] = environ.get('SCRIPT_NAME', '') + \
-                environ.get('PATH_INFO', '')
-        environ['SCRIPT_NAME'] = self.app_root.strip('/')
-        return self.app(environ, start_response)
-
-# backwards compatibility
-LighttpdCGIRootFix = CGIRootFix
-
-
-class PathInfoFromRequestUriFix(object):
-
-    """On windows environment variables are limited to the system charset
-    which makes it impossible to store the `PATH_INFO` variable in the
-    environment without loss of information on some systems.
-
-    This is for example a problem for CGI scripts on a Windows Apache.
-
-    This fixer works by recreating the `PATH_INFO` from `REQUEST_URI`,
-    `REQUEST_URL`, or `UNENCODED_URL` (whatever is available).  Thus the
-    fix can only be applied if the webserver supports either of these
-    variables.
-
-    :param app: the WSGI application
-    """
-
-    def __init__(self, app):
-        self.app = app
-
-    def __call__(self, environ, start_response):
-        for key in 'REQUEST_URL', 'REQUEST_URI', 'UNENCODED_URL':
-            if key not in environ:
-                continue
-            request_uri = unquote(environ[key])
-            script_name = unquote(environ.get('SCRIPT_NAME', ''))
-            if request_uri.startswith(script_name):
-                environ['PATH_INFO'] = request_uri[len(script_name):] \
-                    .split('?', 1)[0]
-                break
-        return self.app(environ, start_response)
-
-
-class ProxyFix(object):
-
-    """This middleware can be applied to add HTTP proxy support to an
-    application that was not designed with HTTP proxies in mind.  It
-    sets `REMOTE_ADDR`, `HTTP_HOST` from `X-Forwarded` headers.  While
-    Werkzeug-based applications already can use
-    :py:func:`werkzeug.wsgi.get_host` to retrieve the current host even if
-    behind proxy setups, this middleware can be used for applications which
-    access the WSGI environment directly.
-
-    If you have more than one proxy server in front of your app, set
-    `num_proxies` accordingly.
-
-    Do not use this middleware in non-proxy setups for security reasons.
-
-    The original values of `REMOTE_ADDR` and `HTTP_HOST` are stored in
-    the WSGI environment as `werkzeug.proxy_fix.orig_remote_addr` and
-    `werkzeug.proxy_fix.orig_http_host`.
-
-    :param app: the WSGI application
-    :param num_proxies: the number of proxy servers in front of the app.
-    """
-
-    def __init__(self, app, num_proxies=1):
-        self.app = app
-        self.num_proxies = num_proxies
-
-    def get_remote_addr(self, forwarded_for):
-        """Selects the new remote addr from the given list of ips in
-        X-Forwarded-For.  By default it picks the one that the `num_proxies`
-        proxy server provides.  Before 0.9 it would always pick the first.
-
-        .. versionadded:: 0.8
-        """
-        if len(forwarded_for) >= self.num_proxies:
-            return forwarded_for[-self.num_proxies]
-
-    def __call__(self, environ, start_response):
-        getter = environ.get
-        forwarded_proto = getter('HTTP_X_FORWARDED_PROTO', '')
-        forwarded_for = getter('HTTP_X_FORWARDED_FOR', '').split(',')
-        forwarded_host = getter('HTTP_X_FORWARDED_HOST', '')
-        environ.update({
-            'werkzeug.proxy_fix.orig_wsgi_url_scheme':  getter('wsgi.url_scheme'),
-            'werkzeug.proxy_fix.orig_remote_addr':      getter('REMOTE_ADDR'),
-            'werkzeug.proxy_fix.orig_http_host':        getter('HTTP_HOST')
-        })
-        forwarded_for = [x for x in [x.strip() for x in forwarded_for] if x]
-        remote_addr = self.get_remote_addr(forwarded_for)
-        if remote_addr is not None:
-            environ['REMOTE_ADDR'] = remote_addr
-        if forwarded_host:
-            environ['HTTP_HOST'] = forwarded_host
-        if forwarded_proto:
-            environ['wsgi.url_scheme'] = forwarded_proto
-        return self.app(environ, start_response)
-
-
-class HeaderRewriterFix(object):
-
-    """This middleware can remove response headers and add others.  This
-    is for example useful to remove the `Date` header from responses if you
-    are using a server that adds that header, no matter if it's present or
-    not or to add `X-Powered-By` headers::
-
-        app = HeaderRewriterFix(app, remove_headers=['Date'],
-                                add_headers=[('X-Powered-By', 'WSGI')])
-
-    :param app: the WSGI application
-    :param remove_headers: a sequence of header keys that should be
-                           removed.
-    :param add_headers: a sequence of ``(key, value)`` tuples that should
-                        be added.
-    """
-
-    def __init__(self, app, remove_headers=None, add_headers=None):
-        self.app = app
-        self.remove_headers = set(x.lower() for x in (remove_headers or ()))
-        self.add_headers = list(add_headers or ())
-
-    def __call__(self, environ, start_response):
-        def rewriting_start_response(status, headers, exc_info=None):
-            new_headers = []
-            for key, value in headers:
-                if key.lower() not in self.remove_headers:
-                    new_headers.append((key, value))
-            new_headers += self.add_headers
-            return start_response(status, new_headers, exc_info)
-        return self.app(environ, rewriting_start_response)
-
-
-class InternetExplorerFix(object):
-
-    """This middleware fixes a couple of bugs with Microsoft Internet
-    Explorer.  Currently the following fixes are applied:
-
-    -   removing of `Vary` headers for unsupported mimetypes which
-        causes troubles with caching.  Can be disabled by passing
-        ``fix_vary=False`` to the constructor.
-        see: http://support.microsoft.com/kb/824847/en-us
-
-    -   removes offending headers to work around caching bugs in
-        Internet Explorer if `Content-Disposition` is set.  Can be
-        disabled by passing ``fix_attach=False`` to the constructor.
-
-    If it does not detect affected Internet Explorer versions it won't touch
-    the request / response.
-    """
-
-    # This code was inspired by Django fixers for the same bugs.  The
-    # fix_vary and fix_attach fixers were originally implemented in Django
-    # by Michael Axiak and is available as part of the Django project:
-    #     http://code.djangoproject.com/ticket/4148
-
-    def __init__(self, app, fix_vary=True, fix_attach=True):
-        self.app = app
-        self.fix_vary = fix_vary
-        self.fix_attach = fix_attach
-
-    def fix_headers(self, environ, headers, status=None):
-        if self.fix_vary:
-            header = headers.get('content-type', '')
-            mimetype, options = parse_options_header(header)
-            if mimetype not in ('text/html', 'text/plain', 'text/sgml'):
-                headers.pop('vary', None)
-
-        if self.fix_attach and 'content-disposition' in headers:
-            pragma = parse_set_header(headers.get('pragma', ''))
-            pragma.discard('no-cache')
-            header = pragma.to_header()
-            if not header:
-                headers.pop('pragma', '')
-            else:
-                headers['Pragma'] = header
-            header = headers.get('cache-control', '')
-            if header:
-                cc = parse_cache_control_header(header,
-                                                cls=ResponseCacheControl)
-                cc.no_cache = None
-                cc.no_store = False
-                header = cc.to_header()
-                if not header:
-                    headers.pop('cache-control', '')
-                else:
-                    headers['Cache-Control'] = header
-
-    def run_fixed(self, environ, start_response):
-        def fixing_start_response(status, headers, exc_info=None):
-            headers = Headers(headers)
-            self.fix_headers(environ, headers, status)
-            return start_response(status, headers.to_wsgi_list(), exc_info)
-        return self.app(environ, fixing_start_response)
-
-    def __call__(self, environ, start_response):
-        ua = UserAgent(environ)
-        if ua.browser != 'msie':
-            return self.app(environ, start_response)
-        return self.run_fixed(environ, start_response)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/iterio.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/iterio.py
deleted file mode 100644
index c0ced3700..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/iterio.py
+++ /dev/null
@@ -1,352 +0,0 @@
-# -*- coding: utf-8 -*-
-r"""
-    werkzeug.contrib.iterio
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module implements a :class:`IterIO` that converts an iterator into
-    a stream object and the other way round.  Converting streams into
-    iterators requires the `greenlet`_ module.
-
-    To convert an iterator into a stream all you have to do is to pass it
-    directly to the :class:`IterIO` constructor.  In this example we pass it
-    a newly created generator::
-
-        def foo():
-            yield "something\n"
-            yield "otherthings"
-        stream = IterIO(foo())
-        print stream.read()         # read the whole iterator
-
-    The other way round works a bit different because we have to ensure that
-    the code execution doesn't take place yet.  An :class:`IterIO` call with a
-    callable as first argument does two things.  The function itself is passed
-    an :class:`IterIO` stream it can feed.  The object returned by the
-    :class:`IterIO` constructor on the other hand is not an stream object but
-    an iterator::
-
-        def foo(stream):
-            stream.write("some")
-            stream.write("thing")
-            stream.flush()
-            stream.write("otherthing")
-        iterator = IterIO(foo)
-        print iterator.next()       # prints something
-        print iterator.next()       # prints otherthing
-        iterator.next()             # raises StopIteration
-
-    .. _greenlet: https://github.com/python-greenlet/greenlet
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-try:
-    import greenlet
-except ImportError:
-    greenlet = None
-
-from werkzeug._compat import implements_iterator
-
-
-def _mixed_join(iterable, sentinel):
-    """concatenate any string type in an intelligent way."""
-    iterator = iter(iterable)
-    first_item = next(iterator, sentinel)
-    if isinstance(first_item, bytes):
-        return first_item + b''.join(iterator)
-    return first_item + u''.join(iterator)
-
-
-def _newline(reference_string):
-    if isinstance(reference_string, bytes):
-        return b'\n'
-    return u'\n'
-
-
-@implements_iterator
-class IterIO(object):
-
-    """Instances of this object implement an interface compatible with the
-    standard Python :class:`file` object.  Streams are either read-only or
-    write-only depending on how the object is created.
-
-    If the first argument is an iterable a file like object is returned that
-    returns the contents of the iterable.  In case the iterable is empty
-    read operations will return the sentinel value.
-
-    If the first argument is a callable then the stream object will be
-    created and passed to that function.  The caller itself however will
-    not receive a stream but an iterable.  The function will be be executed
-    step by step as something iterates over the returned iterable.  Each
-    call to :meth:`flush` will create an item for the iterable.  If
-    :meth:`flush` is called without any writes in-between the sentinel
-    value will be yielded.
-
-    Note for Python 3: due to the incompatible interface of bytes and
-    streams you should set the sentinel value explicitly to an empty
-    bytestring (``b''``) if you are expecting to deal with bytes as
-    otherwise the end of the stream is marked with the wrong sentinel
-    value.
-
-    .. versionadded:: 0.9
-       `sentinel` parameter was added.
-    """
-
-    def __new__(cls, obj, sentinel=''):
-        try:
-            iterator = iter(obj)
-        except TypeError:
-            return IterI(obj, sentinel)
-        return IterO(iterator, sentinel)
-
-    def __iter__(self):
-        return self
-
-    def tell(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        return self.pos
-
-    def isatty(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        return False
-
-    def seek(self, pos, mode=0):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def truncate(self, size=None):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def write(self, s):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def writelines(self, list):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def read(self, n=-1):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def readlines(self, sizehint=0):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def readline(self, length=None):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def flush(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        raise IOError(9, 'Bad file descriptor')
-
-    def __next__(self):
-        if self.closed:
-            raise StopIteration()
-        line = self.readline()
-        if not line:
-            raise StopIteration()
-        return line
-
-
-class IterI(IterIO):
-
-    """Convert an stream into an iterator."""
-
-    def __new__(cls, func, sentinel=''):
-        if greenlet is None:
-            raise RuntimeError('IterI requires greenlet support')
-        stream = object.__new__(cls)
-        stream._parent = greenlet.getcurrent()
-        stream._buffer = []
-        stream.closed = False
-        stream.sentinel = sentinel
-        stream.pos = 0
-
-        def run():
-            func(stream)
-            stream.close()
-
-        g = greenlet.greenlet(run, stream._parent)
-        while 1:
-            rv = g.switch()
-            if not rv:
-                return
-            yield rv[0]
-
-    def close(self):
-        if not self.closed:
-            self.closed = True
-            self._flush_impl()
-
-    def write(self, s):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        if s:
-            self.pos += len(s)
-            self._buffer.append(s)
-
-    def writelines(self, list):
-        for item in list:
-            self.write(item)
-
-    def flush(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        self._flush_impl()
-
-    def _flush_impl(self):
-        data = _mixed_join(self._buffer, self.sentinel)
-        self._buffer = []
-        if not data and self.closed:
-            self._parent.switch()
-        else:
-            self._parent.switch((data,))
-
-
-class IterO(IterIO):
-
-    """Iter output.  Wrap an iterator and give it a stream like interface."""
-
-    def __new__(cls, gen, sentinel=''):
-        self = object.__new__(cls)
-        self._gen = gen
-        self._buf = None
-        self.sentinel = sentinel
-        self.closed = False
-        self.pos = 0
-        return self
-
-    def __iter__(self):
-        return self
-
-    def _buf_append(self, string):
-        '''Replace string directly without appending to an empty string,
-        avoiding type issues.'''
-        if not self._buf:
-            self._buf = string
-        else:
-            self._buf += string
-
-    def close(self):
-        if not self.closed:
-            self.closed = True
-            if hasattr(self._gen, 'close'):
-                self._gen.close()
-
-    def seek(self, pos, mode=0):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        if mode == 1:
-            pos += self.pos
-        elif mode == 2:
-            self.read()
-            self.pos = min(self.pos, self.pos + pos)
-            return
-        elif mode != 0:
-            raise IOError('Invalid argument')
-        buf = []
-        try:
-            tmp_end_pos = len(self._buf)
-            while pos > tmp_end_pos:
-                item = next(self._gen)
-                tmp_end_pos += len(item)
-                buf.append(item)
-        except StopIteration:
-            pass
-        if buf:
-            self._buf_append(_mixed_join(buf, self.sentinel))
-        self.pos = max(0, pos)
-
-    def read(self, n=-1):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        if n < 0:
-            self._buf_append(_mixed_join(self._gen, self.sentinel))
-            result = self._buf[self.pos:]
-            self.pos += len(result)
-            return result
-        new_pos = self.pos + n
-        buf = []
-        try:
-            tmp_end_pos = 0 if self._buf is None else len(self._buf)
-            while new_pos > tmp_end_pos or (self._buf is None and not buf):
-                item = next(self._gen)
-                tmp_end_pos += len(item)
-                buf.append(item)
-        except StopIteration:
-            pass
-        if buf:
-            self._buf_append(_mixed_join(buf, self.sentinel))
-
-        if self._buf is None:
-            return self.sentinel
-
-        new_pos = max(0, new_pos)
-        try:
-            return self._buf[self.pos:new_pos]
-        finally:
-            self.pos = min(new_pos, len(self._buf))
-
-    def readline(self, length=None):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-
-        nl_pos = -1
-        if self._buf:
-            nl_pos = self._buf.find(_newline(self._buf), self.pos)
-        buf = []
-        try:
-            if self._buf is None:
-                pos = self.pos
-            else:
-                pos = len(self._buf)
-            while nl_pos < 0:
-                item = next(self._gen)
-                local_pos = item.find(_newline(item))
-                buf.append(item)
-                if local_pos >= 0:
-                    nl_pos = pos + local_pos
-                    break
-                pos += len(item)
-        except StopIteration:
-            pass
-        if buf:
-            self._buf_append(_mixed_join(buf, self.sentinel))
-
-        if self._buf is None:
-            return self.sentinel
-
-        if nl_pos < 0:
-            new_pos = len(self._buf)
-        else:
-            new_pos = nl_pos + 1
-        if length is not None and self.pos + length < new_pos:
-            new_pos = self.pos + length
-        try:
-            return self._buf[self.pos:new_pos]
-        finally:
-            self.pos = min(new_pos, len(self._buf))
-
-    def readlines(self, sizehint=0):
-        total = 0
-        lines = []
-        line = self.readline()
-        while line:
-            lines.append(line)
-            total += len(line)
-            if 0 < sizehint <= total:
-                break
-            line = self.readline()
-        return lines
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/jsrouting.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/jsrouting.py
deleted file mode 100644
index d8158927e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/jsrouting.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.jsrouting
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Addon module that allows to create a JavaScript function from a map
-    that generates rules.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-try:
-    from simplejson import dumps
-except ImportError:
-    try:
-        from json import dumps
-    except ImportError:
-        def dumps(*args):
-            raise RuntimeError('simplejson required for jsrouting')
-
-from inspect import getmro
-from werkzeug.routing import NumberConverter
-from werkzeug._compat import iteritems
-
-
-def render_template(name_parts, rules, converters):
-    result = u''
-    if name_parts:
-        for idx in range(0, len(name_parts) - 1):
-            name = u'.'.join(name_parts[:idx + 1])
-            result += u"if (typeof %s === 'undefined') %s = {}\n" % (name, name)
-        result += '%s = ' % '.'.join(name_parts)
-    result += """(function (server_name, script_name, subdomain, url_scheme) {
-    var converters = [%(converters)s];
-    var rules = %(rules)s;
-    function in_array(array, value) {
-        if (array.indexOf != undefined) {
-            return array.indexOf(value) != -1;
-        }
-        for (var i = 0; i < array.length; i++) {
-            if (array[i] == value) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function array_diff(array1, array2) {
-        array1 = array1.slice();
-        for (var i = array1.length-1; i >= 0; i--) {
-            if (in_array(array2, array1[i])) {
-                array1.splice(i, 1);
-            }
-        }
-        return array1;
-    }
-    function split_obj(obj) {
-        var names = [];
-        var values = [];
-        for (var name in obj) {
-            if (typeof(obj[name]) != 'function') {
-                names.push(name);
-                values.push(obj[name]);
-            }
-        }
-        return {names: names, values: values, original: obj};
-    }
-    function suitable(rule, args) {
-        var default_args = split_obj(rule.defaults || {});
-        var diff_arg_names = array_diff(rule.arguments, default_args.names);
-
-        for (var i = 0; i < diff_arg_names.length; i++) {
-            if (!in_array(args.names, diff_arg_names[i])) {
-                return false;
-            }
-        }
-
-        if (array_diff(rule.arguments, args.names).length == 0) {
-            if (rule.defaults == null) {
-                return true;
-            }
-            for (var i = 0; i < default_args.names.length; i++) {
-                var key = default_args.names[i];
-                var value = default_args.values[i];
-                if (value != args.original[key]) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-    function build(rule, args) {
-        var tmp = [];
-        var processed = rule.arguments.slice();
-        for (var i = 0; i < rule.trace.length; i++) {
-            var part = rule.trace[i];
-            if (part.is_dynamic) {
-                var converter = converters[rule.converters[part.data]];
-                var data = converter(args.original[part.data]);
-                if (data == null) {
-                    return null;
-                }
-                tmp.push(data);
-                processed.push(part.name);
-            } else {
-                tmp.push(part.data);
-            }
-        }
-        tmp = tmp.join('');
-        var pipe = tmp.indexOf('|');
-        var subdomain = tmp.substring(0, pipe);
-        var url = tmp.substring(pipe+1);
-
-        var unprocessed = array_diff(args.names, processed);
-        var first_query_var = true;
-        for (var i = 0; i < unprocessed.length; i++) {
-            if (first_query_var) {
-                url += '?';
-            } else {
-                url += '&';
-            }
-            first_query_var = false;
-            url += encodeURIComponent(unprocessed[i]);
-            url += '=';
-            url += encodeURIComponent(args.original[unprocessed[i]]);
-        }
-        return {subdomain: subdomain, path: url};
-    }
-    function lstrip(s, c) {
-        while (s && s.substring(0, 1) == c) {
-            s = s.substring(1);
-        }
-        return s;
-    }
-    function rstrip(s, c) {
-        while (s && s.substring(s.length-1, s.length) == c) {
-            s = s.substring(0, s.length-1);
-        }
-        return s;
-    }
-    return function(endpoint, args, force_external) {
-        args = split_obj(args);
-        var rv = null;
-        for (var i = 0; i < rules.length; i++) {
-            var rule = rules[i];
-            if (rule.endpoint != endpoint) continue;
-            if (suitable(rule, args)) {
-                rv = build(rule, args);
-                if (rv != null) {
-                    break;
-                }
-            }
-        }
-        if (rv == null) {
-            return null;
-        }
-        if (!force_external && rv.subdomain == subdomain) {
-            return rstrip(script_name, '/') + '/' + lstrip(rv.path, '/');
-        } else {
-            return url_scheme + '://'
-                   + (rv.subdomain ? rv.subdomain + '.' : '')
-                   + server_name + rstrip(script_name, '/')
-                   + '/' + lstrip(rv.path, '/');
-        }
-    };
-})""" % {'converters': u', '.join(converters),
-         'rules': rules}
-
-    return result
-
-
-def generate_map(map, name='url_map'):
-    """
-    Generates a JavaScript function containing the rules defined in
-    this map, to be used with a MapAdapter's generate_javascript
-    method.  If you don't pass a name the returned JavaScript code is
-    an expression that returns a function.  Otherwise it's a standalone
-    script that assigns the function with that name.  Dotted names are
-    resolved (so you an use a name like 'obj.url_for')
-
-    In order to use JavaScript generation, simplejson must be installed.
-
-    Note that using this feature will expose the rules
-    defined in your map to users. If your rules contain sensitive
-    information, don't use JavaScript generation!
-    """
-    from warnings import warn
-    warn(DeprecationWarning('This module is deprecated'))
-    map.update()
-    rules = []
-    converters = []
-    for rule in map.iter_rules():
-        trace = [{
-            'is_dynamic':   is_dynamic,
-            'data':         data
-        } for is_dynamic, data in rule._trace]
-        rule_converters = {}
-        for key, converter in iteritems(rule._converters):
-            js_func = js_to_url_function(converter)
-            try:
-                index = converters.index(js_func)
-            except ValueError:
-                converters.append(js_func)
-                index = len(converters) - 1
-            rule_converters[key] = index
-        rules.append({
-            u'endpoint':    rule.endpoint,
-            u'arguments':   list(rule.arguments),
-            u'converters':  rule_converters,
-            u'trace':       trace,
-            u'defaults':    rule.defaults
-        })
-
-    return render_template(name_parts=name and name.split('.') or [],
-                           rules=dumps(rules),
-                           converters=converters)
-
-
-def generate_adapter(adapter, name='url_for', map_name='url_map'):
-    """Generates the url building function for a map."""
-    values = {
-        u'server_name':     dumps(adapter.server_name),
-        u'script_name':     dumps(adapter.script_name),
-        u'subdomain':       dumps(adapter.subdomain),
-        u'url_scheme':      dumps(adapter.url_scheme),
-        u'name':            name,
-        u'map_name':        map_name
-    }
-    return u'''\
-var %(name)s = %(map_name)s(
-    %(server_name)s,
-    %(script_name)s,
-    %(subdomain)s,
-    %(url_scheme)s
-);''' % values
-
-
-def js_to_url_function(converter):
-    """Get the JavaScript converter function from a rule."""
-    if hasattr(converter, 'js_to_url_function'):
-        data = converter.js_to_url_function()
-    else:
-        for cls in getmro(type(converter)):
-            if cls in js_to_url_functions:
-                data = js_to_url_functions[cls](converter)
-                break
-        else:
-            return 'encodeURIComponent'
-    return '(function(value) { %s })' % data
-
-
-def NumberConverter_js_to_url(conv):
-    if conv.fixed_digits:
-        return u'''\
-var result = value.toString();
-while (result.length < %s)
-    result = '0' + result;
-return result;''' % conv.fixed_digits
-    return u'return value.toString();'
-
-
-js_to_url_functions = {
-    NumberConverter:    NumberConverter_js_to_url
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/limiter.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/limiter.py
deleted file mode 100644
index 6bc9d3978..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/limiter.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.limiter
-    ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    A middleware that limits incoming data.  This works around problems with
-    Trac_ or Django_ because those directly stream into the memory.
-
-    .. _Trac: http://trac.edgewall.org/
-    .. _Django: http://www.djangoproject.com/
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from warnings import warn
-
-from werkzeug.wsgi import LimitedStream
-
-
-class StreamLimitMiddleware(object):
-
-    """Limits the input stream to a given number of bytes.  This is useful if
-    you have a WSGI application that reads form data into memory (django for
-    example) and you don't want users to harm the server by uploading tons of
-    data.
-
-    Default is 10MB
-
-    .. versionchanged:: 0.9
-       Deprecated middleware.
-    """
-
-    def __init__(self, app, maximum_size=1024 * 1024 * 10):
-        warn(DeprecationWarning('This middleware is deprecated'))
-        self.app = app
-        self.maximum_size = maximum_size
-
-    def __call__(self, environ, start_response):
-        limit = min(self.maximum_size, int(environ.get('CONTENT_LENGTH') or 0))
-        environ['wsgi.input'] = LimitedStream(environ['wsgi.input'], limit)
-        return self.app(environ, start_response)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/lint.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/lint.py
deleted file mode 100644
index 969c68741..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/lint.py
+++ /dev/null
@@ -1,343 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.lint
-    ~~~~~~~~~~~~~~~~~~~~~
-
-    .. versionadded:: 0.5
-
-    This module provides a middleware that performs sanity checks of the WSGI
-    application.  It checks that :pep:`333` is properly implemented and warns
-    on some common HTTP errors such as non-empty responses for 304 status
-    codes.
-
-    This module provides a middleware, the :class:`LintMiddleware`.  Wrap your
-    application with it and it will warn about common problems with WSGI and
-    HTTP while your application is running.
-
-    It's strongly recommended to use it during development.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-try:
-    from urllib.parse import urlparse
-except ImportError:
-    from urlparse import urlparse
-
-from warnings import warn
-
-from werkzeug.datastructures import Headers
-from werkzeug.http import is_entity_header
-from werkzeug.wsgi import FileWrapper
-from werkzeug._compat import string_types
-
-
-class WSGIWarning(Warning):
-
-    """Warning class for WSGI warnings."""
-
-
-class HTTPWarning(Warning):
-
-    """Warning class for HTTP warnings."""
-
-
-def check_string(context, obj, stacklevel=3):
-    if type(obj) is not str:
-        warn(WSGIWarning('%s requires bytestrings, got %s' %
-                         (context, obj.__class__.__name__)))
-
-
-class InputStream(object):
-
-    def __init__(self, stream):
-        self._stream = stream
-
-    def read(self, *args):
-        if len(args) == 0:
-            warn(WSGIWarning('wsgi does not guarantee an EOF marker on the '
-                             'input stream, thus making calls to '
-                             'wsgi.input.read() unsafe.  Conforming servers '
-                             'may never return from this call.'),
-                 stacklevel=2)
-        elif len(args) != 1:
-            warn(WSGIWarning('too many parameters passed to wsgi.input.read()'),
-                 stacklevel=2)
-        return self._stream.read(*args)
-
-    def readline(self, *args):
-        if len(args) == 0:
-            warn(WSGIWarning('Calls to wsgi.input.readline() without arguments'
-                             ' are unsafe.  Use wsgi.input.read() instead.'),
-                 stacklevel=2)
-        elif len(args) == 1:
-            warn(WSGIWarning('wsgi.input.readline() was called with a size hint. '
-                             'WSGI does not support this, although it\'s available '
-                             'on all major servers.'),
-                 stacklevel=2)
-        else:
-            raise TypeError('too many arguments passed to wsgi.input.readline()')
-        return self._stream.readline(*args)
-
-    def __iter__(self):
-        try:
-            return iter(self._stream)
-        except TypeError:
-            warn(WSGIWarning('wsgi.input is not iterable.'), stacklevel=2)
-            return iter(())
-
-    def close(self):
-        warn(WSGIWarning('application closed the input stream!'),
-             stacklevel=2)
-        self._stream.close()
-
-
-class ErrorStream(object):
-
-    def __init__(self, stream):
-        self._stream = stream
-
-    def write(self, s):
-        check_string('wsgi.error.write()', s)
-        self._stream.write(s)
-
-    def flush(self):
-        self._stream.flush()
-
-    def writelines(self, seq):
-        for line in seq:
-            self.write(seq)
-
-    def close(self):
-        warn(WSGIWarning('application closed the error stream!'),
-             stacklevel=2)
-        self._stream.close()
-
-
-class GuardedWrite(object):
-
-    def __init__(self, write, chunks):
-        self._write = write
-        self._chunks = chunks
-
-    def __call__(self, s):
-        check_string('write()', s)
-        self._write.write(s)
-        self._chunks.append(len(s))
-
-
-class GuardedIterator(object):
-
-    def __init__(self, iterator, headers_set, chunks):
-        self._iterator = iterator
-        self._next = iter(iterator).next
-        self.closed = False
-        self.headers_set = headers_set
-        self.chunks = chunks
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        if self.closed:
-            warn(WSGIWarning('iterated over closed app_iter'),
-                 stacklevel=2)
-        rv = self._next()
-        if not self.headers_set:
-            warn(WSGIWarning('Application returned before it '
-                             'started the response'), stacklevel=2)
-        check_string('application iterator items', rv)
-        self.chunks.append(len(rv))
-        return rv
-
-    def close(self):
-        self.closed = True
-        if hasattr(self._iterator, 'close'):
-            self._iterator.close()
-
-        if self.headers_set:
-            status_code, headers = self.headers_set
-            bytes_sent = sum(self.chunks)
-            content_length = headers.get('content-length', type=int)
-
-            if status_code == 304:
-                for key, value in headers:
-                    key = key.lower()
-                    if key not in ('expires', 'content-location') and \
-                       is_entity_header(key):
-                        warn(HTTPWarning('entity header %r found in 304 '
-                                         'response' % key))
-                if bytes_sent:
-                    warn(HTTPWarning('304 responses must not have a body'))
-            elif 100 <= status_code < 200 or status_code == 204:
-                if content_length != 0:
-                    warn(HTTPWarning('%r responses must have an empty '
-                                     'content length' % status_code))
-                if bytes_sent:
-                    warn(HTTPWarning('%r responses must not have a body' %
-                                     status_code))
-            elif content_length is not None and content_length != bytes_sent:
-                warn(WSGIWarning('Content-Length and the number of bytes '
-                                 'sent to the client do not match.'))
-
-    def __del__(self):
-        if not self.closed:
-            try:
-                warn(WSGIWarning('Iterator was garbage collected before '
-                                 'it was closed.'))
-            except Exception:
-                pass
-
-
-class LintMiddleware(object):
-
-    """This middleware wraps an application and warns on common errors.
-    Among other thing it currently checks for the following problems:
-
-    -   invalid status codes
-    -   non-bytestrings sent to the WSGI server
-    -   strings returned from the WSGI application
-    -   non-empty conditional responses
-    -   unquoted etags
-    -   relative URLs in the Location header
-    -   unsafe calls to wsgi.input
-    -   unclosed iterators
-
-    Detected errors are emitted using the standard Python :mod:`warnings`
-    system and usually end up on :data:`stderr`.
-
-    ::
-
-        from werkzeug.contrib.lint import LintMiddleware
-        app = LintMiddleware(app)
-
-    :param app: the application to wrap
-    """
-
-    def __init__(self, app):
-        self.app = app
-
-    def check_environ(self, environ):
-        if type(environ) is not dict:
-            warn(WSGIWarning('WSGI environment is not a standard python dict.'),
-                 stacklevel=4)
-        for key in ('REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT',
-                    'wsgi.version', 'wsgi.input', 'wsgi.errors',
-                    'wsgi.multithread', 'wsgi.multiprocess',
-                    'wsgi.run_once'):
-            if key not in environ:
-                warn(WSGIWarning('required environment key %r not found'
-                                 % key), stacklevel=3)
-        if environ['wsgi.version'] != (1, 0):
-            warn(WSGIWarning('environ is not a WSGI 1.0 environ'),
-                 stacklevel=3)
-
-        script_name = environ.get('SCRIPT_NAME', '')
-        if script_name and script_name[:1] != '/':
-            warn(WSGIWarning('SCRIPT_NAME does not start with a slash: %r'
-                             % script_name), stacklevel=3)
-        path_info = environ.get('PATH_INFO', '')
-        if path_info[:1] != '/':
-            warn(WSGIWarning('PATH_INFO does not start with a slash: %r'
-                             % path_info), stacklevel=3)
-
-    def check_start_response(self, status, headers, exc_info):
-        check_string('status', status)
-        status_code = status.split(None, 1)[0]
-        if len(status_code) != 3 or not status_code.isdigit():
-            warn(WSGIWarning('Status code must be three digits'), stacklevel=3)
-        if len(status) < 4 or status[3] != ' ':
-            warn(WSGIWarning('Invalid value for status %r.  Valid '
-                             'status strings are three digits, a space '
-                             'and a status explanation'), stacklevel=3)
-        status_code = int(status_code)
-        if status_code < 100:
-            warn(WSGIWarning('status code < 100 detected'), stacklevel=3)
-
-        if type(headers) is not list:
-            warn(WSGIWarning('header list is not a list'), stacklevel=3)
-        for item in headers:
-            if type(item) is not tuple or len(item) != 2:
-                warn(WSGIWarning('Headers must tuple 2-item tuples'),
-                     stacklevel=3)
-            name, value = item
-            if type(name) is not str or type(value) is not str:
-                warn(WSGIWarning('header items must be strings'),
-                     stacklevel=3)
-            if name.lower() == 'status':
-                warn(WSGIWarning('The status header is not supported due to '
-                                 'conflicts with the CGI spec.'),
-                     stacklevel=3)
-
-        if exc_info is not None and not isinstance(exc_info, tuple):
-            warn(WSGIWarning('invalid value for exc_info'), stacklevel=3)
-
-        headers = Headers(headers)
-        self.check_headers(headers)
-
-        return status_code, headers
-
-    def check_headers(self, headers):
-        etag = headers.get('etag')
-        if etag is not None:
-            if etag.startswith(('W/', 'w/')):
-                if etag.startswith('w/'):
-                    warn(HTTPWarning('weak etag indicator should be upcase.'),
-                         stacklevel=4)
-                etag = etag[2:]
-            if not (etag[:1] == etag[-1:] == '"'):
-                warn(HTTPWarning('unquoted etag emitted.'), stacklevel=4)
-
-        location = headers.get('location')
-        if location is not None:
-            if not urlparse(location).netloc:
-                warn(HTTPWarning('absolute URLs required for location header'),
-                     stacklevel=4)
-
-    def check_iterator(self, app_iter):
-        if isinstance(app_iter, string_types):
-            warn(WSGIWarning('application returned string.  Response will '
-                             'send character for character to the client '
-                             'which will kill the performance.  Return a '
-                             'list or iterable instead.'), stacklevel=3)
-
-    def __call__(self, *args, **kwargs):
-        if len(args) != 2:
-            warn(WSGIWarning('Two arguments to WSGI app required'), stacklevel=2)
-        if kwargs:
-            warn(WSGIWarning('No keyword arguments to WSGI app allowed'),
-                 stacklevel=2)
-        environ, start_response = args
-
-        self.check_environ(environ)
-        environ['wsgi.input'] = InputStream(environ['wsgi.input'])
-        environ['wsgi.errors'] = ErrorStream(environ['wsgi.errors'])
-
-        # hook our own file wrapper in so that applications will always
-        # iterate to the end and we can check the content length
-        environ['wsgi.file_wrapper'] = FileWrapper
-
-        headers_set = []
-        chunks = []
-
-        def checking_start_response(*args, **kwargs):
-            if len(args) not in (2, 3):
-                warn(WSGIWarning('Invalid number of arguments: %s, expected '
-                                 '2 or 3' % len(args), stacklevel=2))
-            if kwargs:
-                warn(WSGIWarning('no keyword arguments allowed.'))
-
-            status, headers = args[:2]
-            if len(args) == 3:
-                exc_info = args[2]
-            else:
-                exc_info = None
-
-            headers_set[:] = self.check_start_response(status, headers,
-                                                       exc_info)
-            return GuardedWrite(start_response(status, headers, exc_info),
-                                chunks)
-
-        app_iter = self.app(environ, checking_start_response)
-        self.check_iterator(app_iter)
-        return GuardedIterator(app_iter, headers_set, chunks)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/profiler.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/profiler.py
deleted file mode 100644
index be860afbc..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/profiler.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.profiler
-    ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module provides a simple WSGI profiler middleware for finding
-    bottlenecks in web application.  It uses the :mod:`profile` or
-    :mod:`cProfile` module to do the profiling and writes the stats to the
-    stream provided (defaults to stderr).
-
-    Example usage::
-
-        from werkzeug.contrib.profiler import ProfilerMiddleware
-        app = ProfilerMiddleware(app)
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-import time
-import os.path
-try:
-    try:
-        from cProfile import Profile
-    except ImportError:
-        from profile import Profile
-    from pstats import Stats
-    available = True
-except ImportError:
-    available = False
-
-
-class MergeStream(object):
-
-    """An object that redirects `write` calls to multiple streams.
-    Use this to log to both `sys.stdout` and a file::
-
-        f = open('profiler.log', 'w')
-        stream = MergeStream(sys.stdout, f)
-        profiler = ProfilerMiddleware(app, stream)
-    """
-
-    def __init__(self, *streams):
-        if not streams:
-            raise TypeError('at least one stream must be given')
-        self.streams = streams
-
-    def write(self, data):
-        for stream in self.streams:
-            stream.write(data)
-
-
-class ProfilerMiddleware(object):
-
-    """Simple profiler middleware.  Wraps a WSGI application and profiles
-    a request.  This intentionally buffers the response so that timings are
-    more exact.
-
-    By giving the `profile_dir` argument, pstat.Stats files are saved to that
-    directory, one file per request. Without it, a summary is printed to
-    `stream` instead.
-
-    For the exact meaning of `sort_by` and `restrictions` consult the
-    :mod:`profile` documentation.
-
-    .. versionadded:: 0.9
-       Added support for `restrictions` and `profile_dir`.
-
-    :param app: the WSGI application to profile.
-    :param stream: the stream for the profiled stats.  defaults to stderr.
-    :param sort_by: a tuple of columns to sort the result by.
-    :param restrictions: a tuple of profiling strictions, not used if dumping
-                         to `profile_dir`.
-    :param profile_dir: directory name to save pstat files
-    """
-
-    def __init__(self, app, stream=None,
-                 sort_by=('time', 'calls'), restrictions=(), profile_dir=None):
-        if not available:
-            raise RuntimeError('the profiler is not available because '
-                               'profile or pstat is not installed.')
-        self._app = app
-        self._stream = stream or sys.stdout
-        self._sort_by = sort_by
-        self._restrictions = restrictions
-        self._profile_dir = profile_dir
-
-    def __call__(self, environ, start_response):
-        response_body = []
-
-        def catching_start_response(status, headers, exc_info=None):
-            start_response(status, headers, exc_info)
-            return response_body.append
-
-        def runapp():
-            appiter = self._app(environ, catching_start_response)
-            response_body.extend(appiter)
-            if hasattr(appiter, 'close'):
-                appiter.close()
-
-        p = Profile()
-        start = time.time()
-        p.runcall(runapp)
-        body = b''.join(response_body)
-        elapsed = time.time() - start
-
-        if self._profile_dir is not None:
-            prof_filename = os.path.join(self._profile_dir,
-                                         '%s.%s.%06dms.%d.prof' % (
-                                             environ['REQUEST_METHOD'],
-                                             environ.get('PATH_INFO').strip(
-                                                 '/').replace('/', '.') or 'root',
-                                             elapsed * 1000.0,
-                                             time.time()
-                                         ))
-            p.dump_stats(prof_filename)
-
-        else:
-            stats = Stats(p, stream=self._stream)
-            stats.sort_stats(*self._sort_by)
-
-            self._stream.write('-' * 80)
-            self._stream.write('\nPATH: %r\n' % environ.get('PATH_INFO'))
-            stats.print_stats(*self._restrictions)
-            self._stream.write('-' * 80 + '\n\n')
-
-        return [body]
-
-
-def make_action(app_factory, hostname='localhost', port=5000,
-                threaded=False, processes=1, stream=None,
-                sort_by=('time', 'calls'), restrictions=()):
-    """Return a new callback for :mod:`werkzeug.script` that starts a local
-    server with the profiler enabled.
-
-    ::
-
-        from werkzeug.contrib import profiler
-        action_profile = profiler.make_action(make_app)
-    """
-    def action(hostname=('h', hostname), port=('p', port),
-               threaded=threaded, processes=processes):
-        """Start a new development server."""
-        from werkzeug.serving import run_simple
-        app = ProfilerMiddleware(app_factory(), stream, sort_by, restrictions)
-        run_simple(hostname, port, app, False, None, threaded, processes)
-    return action
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/securecookie.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/securecookie.py
deleted file mode 100644
index 5927e2b0b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/securecookie.py
+++ /dev/null
@@ -1,323 +0,0 @@
-# -*- coding: utf-8 -*-
-r"""
-    werkzeug.contrib.securecookie
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module implements a cookie that is not alterable from the client
-    because it adds a checksum the server checks for.  You can use it as
-    session replacement if all you have is a user id or something to mark
-    a logged in user.
-
-    Keep in mind that the data is still readable from the client as a
-    normal cookie is.  However you don't have to store and flush the
-    sessions you have at the server.
-
-    Example usage:
-
-    >>> from werkzeug.contrib.securecookie import SecureCookie
-    >>> x = SecureCookie({"foo": 42, "baz": (1, 2, 3)}, "deadbeef")
-
-    Dumping into a string so that one can store it in a cookie:
-
-    >>> value = x.serialize()
-
-    Loading from that string again:
-
-    >>> x = SecureCookie.unserialize(value, "deadbeef")
-    >>> x["baz"]
-    (1, 2, 3)
-
-    If someone modifies the cookie and the checksum is wrong the unserialize
-    method will fail silently and return a new empty `SecureCookie` object.
-
-    Keep in mind that the values will be visible in the cookie so do not
-    store data in a cookie you don't want the user to see.
-
-    Application Integration
-    =======================
-
-    If you are using the werkzeug request objects you could integrate the
-    secure cookie into your application like this::
-
-        from werkzeug.utils import cached_property
-        from werkzeug.wrappers import BaseRequest
-        from werkzeug.contrib.securecookie import SecureCookie
-
-        # don't use this key but a different one; you could just use
-        # os.urandom(20) to get something random
-        SECRET_KEY = '\xfa\xdd\xb8z\xae\xe0}4\x8b\xea'
-
-        class Request(BaseRequest):
-
-            @cached_property
-            def client_session(self):
-                data = self.cookies.get('session_data')
-                if not data:
-                    return SecureCookie(secret_key=SECRET_KEY)
-                return SecureCookie.unserialize(data, SECRET_KEY)
-
-        def application(environ, start_response):
-            request = Request(environ)
-
-            # get a response object here
-            response = ...
-
-            if request.client_session.should_save:
-                session_data = request.client_session.serialize()
-                response.set_cookie('session_data', session_data,
-                                    httponly=True)
-            return response(environ, start_response)
-
-    A less verbose integration can be achieved by using shorthand methods::
-
-        class Request(BaseRequest):
-
-            @cached_property
-            def client_session(self):
-                return SecureCookie.load_cookie(self, secret_key=COOKIE_SECRET)
-
-        def application(environ, start_response):
-            request = Request(environ)
-
-            # get a response object here
-            response = ...
-
-            request.client_session.save_cookie(response)
-            return response(environ, start_response)
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import pickle
-import base64
-from hmac import new as hmac
-from time import time
-from hashlib import sha1 as _default_hash
-
-from werkzeug._compat import iteritems, text_type, to_bytes
-from werkzeug.urls import url_quote_plus, url_unquote_plus
-from werkzeug._internal import _date_to_unix
-from werkzeug.contrib.sessions import ModificationTrackingDict
-from werkzeug.security import safe_str_cmp
-from werkzeug._compat import to_native
-
-
-class UnquoteError(Exception):
-
-    """Internal exception used to signal failures on quoting."""
-
-
-class SecureCookie(ModificationTrackingDict):
-
-    """Represents a secure cookie.  You can subclass this class and provide
-    an alternative mac method.  The import thing is that the mac method
-    is a function with a similar interface to the hashlib.  Required
-    methods are update() and digest().
-
-    Example usage:
-
-    >>> x = SecureCookie({"foo": 42, "baz": (1, 2, 3)}, "deadbeef")
-    >>> x["foo"]
-    42
-    >>> x["baz"]
-    (1, 2, 3)
-    >>> x["blafasel"] = 23
-    >>> x.should_save
-    True
-
-    :param data: the initial data.  Either a dict, list of tuples or `None`.
-    :param secret_key: the secret key.  If not set `None` or not specified
-                       it has to be set before :meth:`serialize` is called.
-    :param new: The initial value of the `new` flag.
-    """
-
-    #: The hash method to use.  This has to be a module with a new function
-    #: or a function that creates a hashlib object.  Such as `hashlib.md5`
-    #: Subclasses can override this attribute.  The default hash is sha1.
-    #: Make sure to wrap this in staticmethod() if you store an arbitrary
-    #: function there such as hashlib.sha1 which  might be implemented
-    #: as a function.
-    hash_method = staticmethod(_default_hash)
-
-    #: the module used for serialization.  Unless overriden by subclasses
-    #: the standard pickle module is used.
-    serialization_method = pickle
-
-    #: if the contents should be base64 quoted.  This can be disabled if the
-    #: serialization process returns cookie safe strings only.
-    quote_base64 = True
-
-    def __init__(self, data=None, secret_key=None, new=True):
-        ModificationTrackingDict.__init__(self, data or ())
-        # explicitly convert it into a bytestring because python 2.6
-        # no longer performs an implicit string conversion on hmac
-        if secret_key is not None:
-            secret_key = to_bytes(secret_key, 'utf-8')
-        self.secret_key = secret_key
-        self.new = new
-
-    def __repr__(self):
-        return '<%s %s%s>' % (
-            self.__class__.__name__,
-            dict.__repr__(self),
-            self.should_save and '*' or ''
-        )
-
-    @property
-    def should_save(self):
-        """True if the session should be saved.  By default this is only true
-        for :attr:`modified` cookies, not :attr:`new`.
-        """
-        return self.modified
-
-    @classmethod
-    def quote(cls, value):
-        """Quote the value for the cookie.  This can be any object supported
-        by :attr:`serialization_method`.
-
-        :param value: the value to quote.
-        """
-        if cls.serialization_method is not None:
-            value = cls.serialization_method.dumps(value)
-        if cls.quote_base64:
-            value = b''.join(base64.b64encode(value).splitlines()).strip()
-        return value
-
-    @classmethod
-    def unquote(cls, value):
-        """Unquote the value for the cookie.  If unquoting does not work a
-        :exc:`UnquoteError` is raised.
-
-        :param value: the value to unquote.
-        """
-        try:
-            if cls.quote_base64:
-                value = base64.b64decode(value)
-            if cls.serialization_method is not None:
-                value = cls.serialization_method.loads(value)
-            return value
-        except Exception:
-            # unfortunately pickle and other serialization modules can
-            # cause pretty every error here.  if we get one we catch it
-            # and convert it into an UnquoteError
-            raise UnquoteError()
-
-    def serialize(self, expires=None):
-        """Serialize the secure cookie into a string.
-
-        If expires is provided, the session will be automatically invalidated
-        after expiration when you unseralize it. This provides better
-        protection against session cookie theft.
-
-        :param expires: an optional expiration date for the cookie (a
-                        :class:`datetime.datetime` object)
-        """
-        if self.secret_key is None:
-            raise RuntimeError('no secret key defined')
-        if expires:
-            self['_expires'] = _date_to_unix(expires)
-        result = []
-        mac = hmac(self.secret_key, None, self.hash_method)
-        for key, value in sorted(self.items()):
-            result.append(('%s=%s' % (
-                url_quote_plus(key),
-                self.quote(value).decode('ascii')
-            )).encode('ascii'))
-            mac.update(b'|' + result[-1])
-        return b'?'.join([
-            base64.b64encode(mac.digest()).strip(),
-            b'&'.join(result)
-        ])
-
-    @classmethod
-    def unserialize(cls, string, secret_key):
-        """Load the secure cookie from a serialized string.
-
-        :param string: the cookie value to unserialize.
-        :param secret_key: the secret key used to serialize the cookie.
-        :return: a new :class:`SecureCookie`.
-        """
-        if isinstance(string, text_type):
-            string = string.encode('utf-8', 'replace')
-        if isinstance(secret_key, text_type):
-            secret_key = secret_key.encode('utf-8', 'replace')
-        try:
-            base64_hash, data = string.split(b'?', 1)
-        except (ValueError, IndexError):
-            items = ()
-        else:
-            items = {}
-            mac = hmac(secret_key, None, cls.hash_method)
-            for item in data.split(b'&'):
-                mac.update(b'|' + item)
-                if b'=' not in item:
-                    items = None
-                    break
-                key, value = item.split(b'=', 1)
-                # try to make the key a string
-                key = url_unquote_plus(key.decode('ascii'))
-                try:
-                    key = to_native(key)
-                except UnicodeError:
-                    pass
-                items[key] = value
-
-            # no parsing error and the mac looks okay, we can now
-            # sercurely unpickle our cookie.
-            try:
-                client_hash = base64.b64decode(base64_hash)
-            except TypeError:
-                items = client_hash = None
-            if items is not None and safe_str_cmp(client_hash, mac.digest()):
-                try:
-                    for key, value in iteritems(items):
-                        items[key] = cls.unquote(value)
-                except UnquoteError:
-                    items = ()
-                else:
-                    if '_expires' in items:
-                        if time() > items['_expires']:
-                            items = ()
-                        else:
-                            del items['_expires']
-            else:
-                items = ()
-        return cls(items, secret_key, False)
-
-    @classmethod
-    def load_cookie(cls, request, key='session', secret_key=None):
-        """Loads a :class:`SecureCookie` from a cookie in request.  If the
-        cookie is not set, a new :class:`SecureCookie` instanced is
-        returned.
-
-        :param request: a request object that has a `cookies` attribute
-                        which is a dict of all cookie values.
-        :param key: the name of the cookie.
-        :param secret_key: the secret key used to unquote the cookie.
-                           Always provide the value even though it has
-                           no default!
-        """
-        data = request.cookies.get(key)
-        if not data:
-            return cls(secret_key=secret_key)
-        return cls.unserialize(data, secret_key)
-
-    def save_cookie(self, response, key='session', expires=None,
-                    session_expires=None, max_age=None, path='/', domain=None,
-                    secure=None, httponly=False, force=False):
-        """Saves the SecureCookie in a cookie on response object.  All
-        parameters that are not described here are forwarded directly
-        to :meth:`~BaseResponse.set_cookie`.
-
-        :param response: a response object that has a
-                         :meth:`~BaseResponse.set_cookie` method.
-        :param key: the name of the cookie.
-        :param session_expires: the expiration date of the secure cookie
-                                stored information.  If this is not provided
-                                the cookie `expires` date is used instead.
-        """
-        if force or self.should_save:
-            data = self.serialize(session_expires or expires)
-            response.set_cookie(key, data, expires=expires, max_age=max_age,
-                                path=path, domain=domain, secure=secure,
-                                httponly=httponly)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/sessions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/sessions.py
deleted file mode 100644
index a9c3aa7ca..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/sessions.py
+++ /dev/null
@@ -1,352 +0,0 @@
-# -*- coding: utf-8 -*-
-r"""
-    werkzeug.contrib.sessions
-    ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module contains some helper classes that help one to add session
-    support to a python WSGI application.  For full client-side session
-    storage see :mod:`~werkzeug.contrib.securecookie` which implements a
-    secure, client-side session storage.
-
-
-    Application Integration
-    =======================
-
-    ::
-
-        from werkzeug.contrib.sessions import SessionMiddleware, \
-             FilesystemSessionStore
-
-        app = SessionMiddleware(app, FilesystemSessionStore())
-
-    The current session will then appear in the WSGI environment as
-    `werkzeug.session`.  However it's recommended to not use the middleware
-    but the stores directly in the application.  However for very simple
-    scripts a middleware for sessions could be sufficient.
-
-    This module does not implement methods or ways to check if a session is
-    expired.  That should be done by a cronjob and storage specific.  For
-    example to prune unused filesystem sessions one could check the modified
-    time of the files.  If sessions are stored in the database the new()
-    method should add an expiration timestamp for the session.
-
-    For better flexibility it's recommended to not use the middleware but the
-    store and session object directly in the application dispatching::
-
-        session_store = FilesystemSessionStore()
-
-        def application(environ, start_response):
-            request = Request(environ)
-            sid = request.cookies.get('cookie_name')
-            if sid is None:
-                request.session = session_store.new()
-            else:
-                request.session = session_store.get(sid)
-            response = get_the_response_object(request)
-            if request.session.should_save:
-                session_store.save(request.session)
-                response.set_cookie('cookie_name', request.session.sid)
-            return response(environ, start_response)
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import os
-import tempfile
-from os import path
-from time import time
-from random import random
-from hashlib import sha1
-from pickle import dump, load, HIGHEST_PROTOCOL
-
-from werkzeug.datastructures import CallbackDict
-from werkzeug.utils import dump_cookie, parse_cookie
-from werkzeug.wsgi import ClosingIterator
-from werkzeug.posixemulation import rename
-from werkzeug._compat import PY2, text_type
-from werkzeug.filesystem import get_filesystem_encoding
-
-
-_sha1_re = re.compile(r'^[a-f0-9]{40}$')
-
-
-def _urandom():
-    if hasattr(os, 'urandom'):
-        return os.urandom(30)
-    return text_type(random()).encode('ascii')
-
-
-def generate_key(salt=None):
-    if salt is None:
-        salt = repr(salt).encode('ascii')
-    return sha1(b''.join([
-        salt,
-        str(time()).encode('ascii'),
-        _urandom()
-    ])).hexdigest()
-
-
-class ModificationTrackingDict(CallbackDict):
-    __slots__ = ('modified',)
-
-    def __init__(self, *args, **kwargs):
-        def on_update(self):
-            self.modified = True
-        self.modified = False
-        CallbackDict.__init__(self, on_update=on_update)
-        dict.update(self, *args, **kwargs)
-
-    def copy(self):
-        """Create a flat copy of the dict."""
-        missing = object()
-        result = object.__new__(self.__class__)
-        for name in self.__slots__:
-            val = getattr(self, name, missing)
-            if val is not missing:
-                setattr(result, name, val)
-        return result
-
-    def __copy__(self):
-        return self.copy()
-
-
-class Session(ModificationTrackingDict):
-
-    """Subclass of a dict that keeps track of direct object changes.  Changes
-    in mutable structures are not tracked, for those you have to set
-    `modified` to `True` by hand.
-    """
-    __slots__ = ModificationTrackingDict.__slots__ + ('sid', 'new')
-
-    def __init__(self, data, sid, new=False):
-        ModificationTrackingDict.__init__(self, data)
-        self.sid = sid
-        self.new = new
-
-    def __repr__(self):
-        return '<%s %s%s>' % (
-            self.__class__.__name__,
-            dict.__repr__(self),
-            self.should_save and '*' or ''
-        )
-
-    @property
-    def should_save(self):
-        """True if the session should be saved.
-
-        .. versionchanged:: 0.6
-           By default the session is now only saved if the session is
-           modified, not if it is new like it was before.
-        """
-        return self.modified
-
-
-class SessionStore(object):
-
-    """Baseclass for all session stores.  The Werkzeug contrib module does not
-    implement any useful stores besides the filesystem store, application
-    developers are encouraged to create their own stores.
-
-    :param session_class: The session class to use.  Defaults to
-                          :class:`Session`.
-    """
-
-    def __init__(self, session_class=None):
-        if session_class is None:
-            session_class = Session
-        self.session_class = session_class
-
-    def is_valid_key(self, key):
-        """Check if a key has the correct format."""
-        return _sha1_re.match(key) is not None
-
-    def generate_key(self, salt=None):
-        """Simple function that generates a new session key."""
-        return generate_key(salt)
-
-    def new(self):
-        """Generate a new session."""
-        return self.session_class({}, self.generate_key(), True)
-
-    def save(self, session):
-        """Save a session."""
-
-    def save_if_modified(self, session):
-        """Save if a session class wants an update."""
-        if session.should_save:
-            self.save(session)
-
-    def delete(self, session):
-        """Delete a session."""
-
-    def get(self, sid):
-        """Get a session for this sid or a new session object.  This method
-        has to check if the session key is valid and create a new session if
-        that wasn't the case.
-        """
-        return self.session_class({}, sid, True)
-
-
-#: used for temporary files by the filesystem session store
-_fs_transaction_suffix = '.__wz_sess'
-
-
-class FilesystemSessionStore(SessionStore):
-
-    """Simple example session store that saves sessions on the filesystem.
-    This store works best on POSIX systems and Windows Vista / Windows
-    Server 2008 and newer.
-
-    .. versionchanged:: 0.6
-       `renew_missing` was added.  Previously this was considered `True`,
-       now the default changed to `False` and it can be explicitly
-       deactivated.
-
-    :param path: the path to the folder used for storing the sessions.
-                 If not provided the default temporary directory is used.
-    :param filename_template: a string template used to give the session
-                              a filename.  ``%s`` is replaced with the
-                              session id.
-    :param session_class: The session class to use.  Defaults to
-                          :class:`Session`.
-    :param renew_missing: set to `True` if you want the store to
-                          give the user a new sid if the session was
-                          not yet saved.
-    """
-
-    def __init__(self, path=None, filename_template='werkzeug_%s.sess',
-                 session_class=None, renew_missing=False, mode=0o644):
-        SessionStore.__init__(self, session_class)
-        if path is None:
-            path = tempfile.gettempdir()
-        self.path = path
-        if isinstance(filename_template, text_type) and PY2:
-            filename_template = filename_template.encode(
-                get_filesystem_encoding())
-        assert not filename_template.endswith(_fs_transaction_suffix), \
-            'filename templates may not end with %s' % _fs_transaction_suffix
-        self.filename_template = filename_template
-        self.renew_missing = renew_missing
-        self.mode = mode
-
-    def get_session_filename(self, sid):
-        # out of the box, this should be a strict ASCII subset but
-        # you might reconfigure the session object to have a more
-        # arbitrary string.
-        if isinstance(sid, text_type) and PY2:
-            sid = sid.encode(get_filesystem_encoding())
-        return path.join(self.path, self.filename_template % sid)
-
-    def save(self, session):
-        fn = self.get_session_filename(session.sid)
-        fd, tmp = tempfile.mkstemp(suffix=_fs_transaction_suffix,
-                                   dir=self.path)
-        f = os.fdopen(fd, 'wb')
-        try:
-            dump(dict(session), f, HIGHEST_PROTOCOL)
-        finally:
-            f.close()
-        try:
-            rename(tmp, fn)
-            os.chmod(fn, self.mode)
-        except (IOError, OSError):
-            pass
-
-    def delete(self, session):
-        fn = self.get_session_filename(session.sid)
-        try:
-            os.unlink(fn)
-        except OSError:
-            pass
-
-    def get(self, sid):
-        if not self.is_valid_key(sid):
-            return self.new()
-        try:
-            f = open(self.get_session_filename(sid), 'rb')
-        except IOError:
-            if self.renew_missing:
-                return self.new()
-            data = {}
-        else:
-            try:
-                try:
-                    data = load(f)
-                except Exception:
-                    data = {}
-            finally:
-                f.close()
-        return self.session_class(data, sid, False)
-
-    def list(self):
-        """Lists all sessions in the store.
-
-        .. versionadded:: 0.6
-        """
-        before, after = self.filename_template.split('%s', 1)
-        filename_re = re.compile(r'%s(.{5,})%s$' % (re.escape(before),
-                                                    re.escape(after)))
-        result = []
-        for filename in os.listdir(self.path):
-            #: this is a session that is still being saved.
-            if filename.endswith(_fs_transaction_suffix):
-                continue
-            match = filename_re.match(filename)
-            if match is not None:
-                result.append(match.group(1))
-        return result
-
-
-class SessionMiddleware(object):
-
-    """A simple middleware that puts the session object of a store provided
-    into the WSGI environ.  It automatically sets cookies and restores
-    sessions.
-
-    However a middleware is not the preferred solution because it won't be as
-    fast as sessions managed by the application itself and will put a key into
-    the WSGI environment only relevant for the application which is against
-    the concept of WSGI.
-
-    The cookie parameters are the same as for the :func:`~dump_cookie`
-    function just prefixed with ``cookie_``.  Additionally `max_age` is
-    called `cookie_age` and not `cookie_max_age` because of backwards
-    compatibility.
-    """
-
-    def __init__(self, app, store, cookie_name='session_id',
-                 cookie_age=None, cookie_expires=None, cookie_path='/',
-                 cookie_domain=None, cookie_secure=None,
-                 cookie_httponly=False, environ_key='werkzeug.session'):
-        self.app = app
-        self.store = store
-        self.cookie_name = cookie_name
-        self.cookie_age = cookie_age
-        self.cookie_expires = cookie_expires
-        self.cookie_path = cookie_path
-        self.cookie_domain = cookie_domain
-        self.cookie_secure = cookie_secure
-        self.cookie_httponly = cookie_httponly
-        self.environ_key = environ_key
-
-    def __call__(self, environ, start_response):
-        cookie = parse_cookie(environ.get('HTTP_COOKIE', ''))
-        sid = cookie.get(self.cookie_name, None)
-        if sid is None:
-            session = self.store.new()
-        else:
-            session = self.store.get(sid)
-        environ[self.environ_key] = session
-
-        def injecting_start_response(status, headers, exc_info=None):
-            if session.should_save:
-                self.store.save(session)
-                headers.append(('Set-Cookie', dump_cookie(self.cookie_name,
-                                                          session.sid, self.cookie_age,
-                                                          self.cookie_expires, self.cookie_path,
-                                                          self.cookie_domain, self.cookie_secure,
-                                                          self.cookie_httponly)))
-            return start_response(status, headers, exc_info)
-        return ClosingIterator(self.app(environ, injecting_start_response),
-                               lambda: self.store.save_if_modified(session))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/testtools.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/testtools.py
deleted file mode 100644
index 3dab6dbde..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/testtools.py
+++ /dev/null
@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.testtools
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module implements extended wrappers for simplified testing.
-
-    `TestResponse`
-        A response wrapper which adds various cached attributes for
-        simplified assertions on various content types.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from werkzeug.utils import cached_property, import_string
-from werkzeug.wrappers import Response
-
-from warnings import warn
-warn(DeprecationWarning('werkzeug.contrib.testtools is deprecated and '
-                        'will be removed with Werkzeug 1.0'))
-
-
-class ContentAccessors(object):
-
-    """
-    A mixin class for response objects that provides a couple of useful
-    accessors for unittesting.
-    """
-
-    def xml(self):
-        """Get an etree if possible."""
-        if 'xml' not in self.mimetype:
-            raise AttributeError(
-                'Not a XML response (Content-Type: %s)'
-                % self.mimetype)
-        for module in ['xml.etree.ElementTree', 'ElementTree',
-                       'elementtree.ElementTree']:
-            etree = import_string(module, silent=True)
-            if etree is not None:
-                return etree.XML(self.body)
-        raise RuntimeError('You must have ElementTree installed '
-                           'to use TestResponse.xml')
-    xml = cached_property(xml)
-
-    def lxml(self):
-        """Get an lxml etree if possible."""
-        if ('html' not in self.mimetype and 'xml' not in self.mimetype):
-            raise AttributeError('Not an HTML/XML response')
-        from lxml import etree
-        try:
-            from lxml.html import fromstring
-        except ImportError:
-            fromstring = etree.HTML
-        if self.mimetype == 'text/html':
-            return fromstring(self.data)
-        return etree.XML(self.data)
-    lxml = cached_property(lxml)
-
-    def json(self):
-        """Get the result of simplejson.loads if possible."""
-        if 'json' not in self.mimetype:
-            raise AttributeError('Not a JSON response')
-        try:
-            from simplejson import loads
-        except ImportError:
-            from json import loads
-        return loads(self.data)
-    json = cached_property(json)
-
-
-class TestResponse(Response, ContentAccessors):
-
-    """Pass this to `werkzeug.test.Client` for easier unittesting."""
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/wrappers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/wrappers.py
deleted file mode 100644
index 6c8645291..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/contrib/wrappers.py
+++ /dev/null
@@ -1,284 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.contrib.wrappers
-    ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Extra wrappers or mixins contributed by the community.  These wrappers can
-    be mixed in into request objects to add extra functionality.
-
-    Example::
-
-        from werkzeug.wrappers import Request as RequestBase
-        from werkzeug.contrib.wrappers import JSONRequestMixin
-
-        class Request(RequestBase, JSONRequestMixin):
-            pass
-
-    Afterwards this request object provides the extra functionality of the
-    :class:`JSONRequestMixin`.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import codecs
-try:
-    from simplejson import loads
-except ImportError:
-    from json import loads
-
-from werkzeug.exceptions import BadRequest
-from werkzeug.utils import cached_property
-from werkzeug.http import dump_options_header, parse_options_header
-from werkzeug._compat import wsgi_decoding_dance
-
-
-def is_known_charset(charset):
-    """Checks if the given charset is known to Python."""
-    try:
-        codecs.lookup(charset)
-    except LookupError:
-        return False
-    return True
-
-
-class JSONRequestMixin(object):
-
-    """Add json method to a request object.  This will parse the input data
-    through simplejson if possible.
-
-    :exc:`~werkzeug.exceptions.BadRequest` will be raised if the content-type
-    is not json or if the data itself cannot be parsed as json.
-    """
-
-    @cached_property
-    def json(self):
-        """Get the result of simplejson.loads if possible."""
-        if 'json' not in self.environ.get('CONTENT_TYPE', ''):
-            raise BadRequest('Not a JSON request')
-        try:
-            return loads(self.data.decode(self.charset, self.encoding_errors))
-        except Exception:
-            raise BadRequest('Unable to read JSON request')
-
-
-class ProtobufRequestMixin(object):
-
-    """Add protobuf parsing method to a request object.  This will parse the
-    input data through `protobuf`_ if possible.
-
-    :exc:`~werkzeug.exceptions.BadRequest` will be raised if the content-type
-    is not protobuf or if the data itself cannot be parsed property.
-
-    .. _protobuf: http://code.google.com/p/protobuf/
-    """
-
-    #: by default the :class:`ProtobufRequestMixin` will raise a
-    #: :exc:`~werkzeug.exceptions.BadRequest` if the object is not
-    #: initialized.  You can bypass that check by setting this
-    #: attribute to `False`.
-    protobuf_check_initialization = True
-
-    def parse_protobuf(self, proto_type):
-        """Parse the data into an instance of proto_type."""
-        if 'protobuf' not in self.environ.get('CONTENT_TYPE', ''):
-            raise BadRequest('Not a Protobuf request')
-
-        obj = proto_type()
-        try:
-            obj.ParseFromString(self.data)
-        except Exception:
-            raise BadRequest("Unable to parse Protobuf request")
-
-        # Fail if not all required fields are set
-        if self.protobuf_check_initialization and not obj.IsInitialized():
-            raise BadRequest("Partial Protobuf request")
-
-        return obj
-
-
-class RoutingArgsRequestMixin(object):
-
-    """This request mixin adds support for the wsgiorg routing args
-    `specification`_.
-
-    .. _specification: https://wsgi.readthedocs.io/en/latest/specifications/routing_args.html
-    """
-
-    def _get_routing_args(self):
-        return self.environ.get('wsgiorg.routing_args', (()))[0]
-
-    def _set_routing_args(self, value):
-        if self.shallow:
-            raise RuntimeError('A shallow request tried to modify the WSGI '
-                               'environment.  If you really want to do that, '
-                               'set `shallow` to False.')
-        self.environ['wsgiorg.routing_args'] = (value, self.routing_vars)
-
-    routing_args = property(_get_routing_args, _set_routing_args, doc='''
-        The positional URL arguments as `tuple`.''')
-    del _get_routing_args, _set_routing_args
-
-    def _get_routing_vars(self):
-        rv = self.environ.get('wsgiorg.routing_args')
-        if rv is not None:
-            return rv[1]
-        rv = {}
-        if not self.shallow:
-            self.routing_vars = rv
-        return rv
-
-    def _set_routing_vars(self, value):
-        if self.shallow:
-            raise RuntimeError('A shallow request tried to modify the WSGI '
-                               'environment.  If you really want to do that, '
-                               'set `shallow` to False.')
-        self.environ['wsgiorg.routing_args'] = (self.routing_args, value)
-
-    routing_vars = property(_get_routing_vars, _set_routing_vars, doc='''
-        The keyword URL arguments as `dict`.''')
-    del _get_routing_vars, _set_routing_vars
-
-
-class ReverseSlashBehaviorRequestMixin(object):
-
-    """This mixin reverses the trailing slash behavior of :attr:`script_root`
-    and :attr:`path`.  This makes it possible to use :func:`~urlparse.urljoin`
-    directly on the paths.
-
-    Because it changes the behavior or :class:`Request` this class has to be
-    mixed in *before* the actual request class::
-
-        class MyRequest(ReverseSlashBehaviorRequestMixin, Request):
-            pass
-
-    This example shows the differences (for an application mounted on
-    `/application` and the request going to `/application/foo/bar`):
-
-        +---------------+-------------------+---------------------+
-        |               | normal behavior   | reverse behavior    |
-        +===============+===================+=====================+
-        | `script_root` | ``/application``  | ``/application/``   |
-        +---------------+-------------------+---------------------+
-        | `path`        | ``/foo/bar``      | ``foo/bar``         |
-        +---------------+-------------------+---------------------+
-    """
-
-    @cached_property
-    def path(self):
-        """Requested path as unicode.  This works a bit like the regular path
-        info in the WSGI environment but will not include a leading slash.
-        """
-        path = wsgi_decoding_dance(self.environ.get('PATH_INFO') or '',
-                                   self.charset, self.encoding_errors)
-        return path.lstrip('/')
-
-    @cached_property
-    def script_root(self):
-        """The root path of the script includling a trailing slash."""
-        path = wsgi_decoding_dance(self.environ.get('SCRIPT_NAME') or '',
-                                   self.charset, self.encoding_errors)
-        return path.rstrip('/') + '/'
-
-
-class DynamicCharsetRequestMixin(object):
-
-    """"If this mixin is mixed into a request class it will provide
-    a dynamic `charset` attribute.  This means that if the charset is
-    transmitted in the content type headers it's used from there.
-
-    Because it changes the behavior or :class:`Request` this class has
-    to be mixed in *before* the actual request class::
-
-        class MyRequest(DynamicCharsetRequestMixin, Request):
-            pass
-
-    By default the request object assumes that the URL charset is the
-    same as the data charset.  If the charset varies on each request
-    based on the transmitted data it's not a good idea to let the URLs
-    change based on that.  Most browsers assume either utf-8 or latin1
-    for the URLs if they have troubles figuring out.  It's strongly
-    recommended to set the URL charset to utf-8::
-
-        class MyRequest(DynamicCharsetRequestMixin, Request):
-            url_charset = 'utf-8'
-
-    .. versionadded:: 0.6
-    """
-
-    #: the default charset that is assumed if the content type header
-    #: is missing or does not contain a charset parameter.  The default
-    #: is latin1 which is what HTTP specifies as default charset.
-    #: You may however want to set this to utf-8 to better support
-    #: browsers that do not transmit a charset for incoming data.
-    default_charset = 'latin1'
-
-    def unknown_charset(self, charset):
-        """Called if a charset was provided but is not supported by
-        the Python codecs module.  By default latin1 is assumed then
-        to not lose any information, you may override this method to
-        change the behavior.
-
-        :param charset: the charset that was not found.
-        :return: the replacement charset.
-        """
-        return 'latin1'
-
-    @cached_property
-    def charset(self):
-        """The charset from the content type."""
-        header = self.environ.get('CONTENT_TYPE')
-        if header:
-            ct, options = parse_options_header(header)
-            charset = options.get('charset')
-            if charset:
-                if is_known_charset(charset):
-                    return charset
-                return self.unknown_charset(charset)
-        return self.default_charset
-
-
-class DynamicCharsetResponseMixin(object):
-
-    """If this mixin is mixed into a response class it will provide
-    a dynamic `charset` attribute.  This means that if the charset is
-    looked up and stored in the `Content-Type` header and updates
-    itself automatically.  This also means a small performance hit but
-    can be useful if you're working with different charsets on
-    responses.
-
-    Because the charset attribute is no a property at class-level, the
-    default value is stored in `default_charset`.
-
-    Because it changes the behavior or :class:`Response` this class has
-    to be mixed in *before* the actual response class::
-
-        class MyResponse(DynamicCharsetResponseMixin, Response):
-            pass
-
-    .. versionadded:: 0.6
-    """
-
-    #: the default charset.
-    default_charset = 'utf-8'
-
-    def _get_charset(self):
-        header = self.headers.get('content-type')
-        if header:
-            charset = parse_options_header(header)[1].get('charset')
-            if charset:
-                return charset
-        return self.default_charset
-
-    def _set_charset(self, charset):
-        header = self.headers.get('content-type')
-        ct, options = parse_options_header(header)
-        if not ct:
-            raise TypeError('Cannot set charset if Content-Type '
-                            'header is missing.')
-        options['charset'] = charset
-        self.headers['Content-Type'] = dump_options_header(ct, options)
-
-    charset = property(_get_charset, _set_charset, doc="""
-        The charset for the response.  It's stored inside the
-        Content-Type header as a parameter.""")
-    del _get_charset, _set_charset
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/datastructures.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/datastructures.py
deleted file mode 100644
index 9624599da..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/datastructures.py
+++ /dev/null
@@ -1,2762 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.datastructures
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    This module provides mixins and classes with an immutable interface.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import codecs
-import mimetypes
-from copy import deepcopy
-from itertools import repeat
-from collections import Container, Iterable, MutableSet
-
-from werkzeug._internal import _missing, _empty_stream
-from werkzeug._compat import iterkeys, itervalues, iteritems, iterlists, \
-    PY2, text_type, integer_types, string_types, make_literal_wrapper, \
-    to_native
-from werkzeug.filesystem import get_filesystem_encoding
-
-
-_locale_delim_re = re.compile(r'[_-]')
-
-
-def is_immutable(self):
-    raise TypeError('%r objects are immutable' % self.__class__.__name__)
-
-
-def iter_multi_items(mapping):
-    """Iterates over the items of a mapping yielding keys and values
-    without dropping any from more complex structures.
-    """
-    if isinstance(mapping, MultiDict):
-        for item in iteritems(mapping, multi=True):
-            yield item
-    elif isinstance(mapping, dict):
-        for key, value in iteritems(mapping):
-            if isinstance(value, (tuple, list)):
-                for value in value:
-                    yield key, value
-            else:
-                yield key, value
-    else:
-        for item in mapping:
-            yield item
-
-
-def native_itermethods(names):
-    if not PY2:
-        return lambda x: x
-
-    def setviewmethod(cls, name):
-        viewmethod_name = 'view%s' % name
-        viewmethod = lambda self, *a, **kw: ViewItems(self, name, 'view_%s' % name, *a, **kw)
-        viewmethod.__doc__ = \
-            '"""`%s()` object providing a view on %s"""' % (viewmethod_name, name)
-        setattr(cls, viewmethod_name, viewmethod)
-
-    def setitermethod(cls, name):
-        itermethod = getattr(cls, name)
-        setattr(cls, 'iter%s' % name, itermethod)
-        listmethod = lambda self, *a, **kw: list(itermethod(self, *a, **kw))
-        listmethod.__doc__ = \
-            'Like :py:meth:`iter%s`, but returns a list.' % name
-        setattr(cls, name, listmethod)
-
-    def wrap(cls):
-        for name in names:
-            setitermethod(cls, name)
-            setviewmethod(cls, name)
-        return cls
-    return wrap
-
-
-class ImmutableListMixin(object):
-
-    """Makes a :class:`list` immutable.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-
-    _hash_cache = None
-
-    def __hash__(self):
-        if self._hash_cache is not None:
-            return self._hash_cache
-        rv = self._hash_cache = hash(tuple(self))
-        return rv
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (list(self),)
-
-    def __delitem__(self, key):
-        is_immutable(self)
-
-    def __iadd__(self, other):
-        is_immutable(self)
-    __imul__ = __iadd__
-
-    def __setitem__(self, key, value):
-        is_immutable(self)
-
-    def append(self, item):
-        is_immutable(self)
-    remove = append
-
-    def extend(self, iterable):
-        is_immutable(self)
-
-    def insert(self, pos, value):
-        is_immutable(self)
-
-    def pop(self, index=-1):
-        is_immutable(self)
-
-    def reverse(self):
-        is_immutable(self)
-
-    def sort(self, cmp=None, key=None, reverse=None):
-        is_immutable(self)
-
-
-class ImmutableList(ImmutableListMixin, list):
-
-    """An immutable :class:`list`.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-
-    def __repr__(self):
-        return '%s(%s)' % (
-            self.__class__.__name__,
-            list.__repr__(self),
-        )
-
-
-class ImmutableDictMixin(object):
-
-    """Makes a :class:`dict` immutable.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-    _hash_cache = None
-
-    @classmethod
-    def fromkeys(cls, keys, value=None):
-        instance = super(cls, cls).__new__(cls)
-        instance.__init__(zip(keys, repeat(value)))
-        return instance
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (dict(self),)
-
-    def _iter_hashitems(self):
-        return iteritems(self)
-
-    def __hash__(self):
-        if self._hash_cache is not None:
-            return self._hash_cache
-        rv = self._hash_cache = hash(frozenset(self._iter_hashitems()))
-        return rv
-
-    def setdefault(self, key, default=None):
-        is_immutable(self)
-
-    def update(self, *args, **kwargs):
-        is_immutable(self)
-
-    def pop(self, key, default=None):
-        is_immutable(self)
-
-    def popitem(self):
-        is_immutable(self)
-
-    def __setitem__(self, key, value):
-        is_immutable(self)
-
-    def __delitem__(self, key):
-        is_immutable(self)
-
-    def clear(self):
-        is_immutable(self)
-
-
-class ImmutableMultiDictMixin(ImmutableDictMixin):
-
-    """Makes a :class:`MultiDict` immutable.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (list(iteritems(self, multi=True)),)
-
-    def _iter_hashitems(self):
-        return iteritems(self, multi=True)
-
-    def add(self, key, value):
-        is_immutable(self)
-
-    def popitemlist(self):
-        is_immutable(self)
-
-    def poplist(self, key):
-        is_immutable(self)
-
-    def setlist(self, key, new_list):
-        is_immutable(self)
-
-    def setlistdefault(self, key, default_list=None):
-        is_immutable(self)
-
-
-class UpdateDictMixin(object):
-
-    """Makes dicts call `self.on_update` on modifications.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-
-    on_update = None
-
-    def calls_update(name):
-        def oncall(self, *args, **kw):
-            rv = getattr(super(UpdateDictMixin, self), name)(*args, **kw)
-            if self.on_update is not None:
-                self.on_update(self)
-            return rv
-        oncall.__name__ = name
-        return oncall
-
-    def setdefault(self, key, default=None):
-        modified = key not in self
-        rv = super(UpdateDictMixin, self).setdefault(key, default)
-        if modified and self.on_update is not None:
-            self.on_update(self)
-        return rv
-
-    def pop(self, key, default=_missing):
-        modified = key in self
-        if default is _missing:
-            rv = super(UpdateDictMixin, self).pop(key)
-        else:
-            rv = super(UpdateDictMixin, self).pop(key, default)
-        if modified and self.on_update is not None:
-            self.on_update(self)
-        return rv
-
-    __setitem__ = calls_update('__setitem__')
-    __delitem__ = calls_update('__delitem__')
-    clear = calls_update('clear')
-    popitem = calls_update('popitem')
-    update = calls_update('update')
-    del calls_update
-
-
-class TypeConversionDict(dict):
-
-    """Works like a regular dict but the :meth:`get` method can perform
-    type conversions.  :class:`MultiDict` and :class:`CombinedMultiDict`
-    are subclasses of this class and provide the same feature.
-
-    .. versionadded:: 0.5
-    """
-
-    def get(self, key, default=None, type=None):
-        """Return the default value if the requested data doesn't exist.
-        If `type` is provided and is a callable it should convert the value,
-        return it or raise a :exc:`ValueError` if that is not possible.  In
-        this case the function will return the default as if the value was not
-        found:
-
-        >>> d = TypeConversionDict(foo='42', bar='blub')
-        >>> d.get('foo', type=int)
-        42
-        >>> d.get('bar', -1, type=int)
-        -1
-
-        :param key: The key to be looked up.
-        :param default: The default value to be returned if the key can't
-                        be looked up.  If not further specified `None` is
-                        returned.
-        :param type: A callable that is used to cast the value in the
-                     :class:`MultiDict`.  If a :exc:`ValueError` is raised
-                     by this callable the default value is returned.
-        """
-        try:
-            rv = self[key]
-        except KeyError:
-            return default
-        if type is not None:
-            try:
-                rv = type(rv)
-            except ValueError:
-                rv = default
-        return rv
-
-
-class ImmutableTypeConversionDict(ImmutableDictMixin, TypeConversionDict):
-
-    """Works like a :class:`TypeConversionDict` but does not support
-    modifications.
-
-    .. versionadded:: 0.5
-    """
-
-    def copy(self):
-        """Return a shallow mutable copy of this object.  Keep in mind that
-        the standard library's :func:`copy` function is a no-op for this class
-        like for any other python immutable type (eg: :class:`tuple`).
-        """
-        return TypeConversionDict(self)
-
-    def __copy__(self):
-        return self
-
-
-class ViewItems(object):
-
-    def __init__(self, multi_dict, method, repr_name, *a, **kw):
-        self.__multi_dict = multi_dict
-        self.__method = method
-        self.__repr_name = repr_name
-        self.__a = a
-        self.__kw = kw
-
-    def __get_items(self):
-        return getattr(self.__multi_dict, self.__method)(*self.__a, **self.__kw)
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__repr_name, list(self.__get_items()))
-
-    def __iter__(self):
-        return iter(self.__get_items())
-
-
-@native_itermethods(['keys', 'values', 'items', 'lists', 'listvalues'])
-class MultiDict(TypeConversionDict):
-
-    """A :class:`MultiDict` is a dictionary subclass customized to deal with
-    multiple values for the same key which is for example used by the parsing
-    functions in the wrappers.  This is necessary because some HTML form
-    elements pass multiple values for the same key.
-
-    :class:`MultiDict` implements all standard dictionary methods.
-    Internally, it saves all values for a key as a list, but the standard dict
-    access methods will only return the first value for a key. If you want to
-    gain access to the other values, too, you have to use the `list` methods as
-    explained below.
-
-    Basic Usage:
-
-    >>> d = MultiDict([('a', 'b'), ('a', 'c')])
-    >>> d
-    MultiDict([('a', 'b'), ('a', 'c')])
-    >>> d['a']
-    'b'
-    >>> d.getlist('a')
-    ['b', 'c']
-    >>> 'a' in d
-    True
-
-    It behaves like a normal dict thus all dict functions will only return the
-    first value when multiple values for one key are found.
-
-    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a
-    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will
-    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP
-    exceptions.
-
-    A :class:`MultiDict` can be constructed from an iterable of
-    ``(key, value)`` tuples, a dict, a :class:`MultiDict` or from Werkzeug 0.2
-    onwards some keyword parameters.
-
-    :param mapping: the initial value for the :class:`MultiDict`.  Either a
-                    regular dict, an iterable of ``(key, value)`` tuples
-                    or `None`.
-    """
-
-    def __init__(self, mapping=None):
-        if isinstance(mapping, MultiDict):
-            dict.__init__(self, ((k, l[:]) for k, l in iterlists(mapping)))
-        elif isinstance(mapping, dict):
-            tmp = {}
-            for key, value in iteritems(mapping):
-                if isinstance(value, (tuple, list)):
-                    if len(value) == 0:
-                        continue
-                    value = list(value)
-                else:
-                    value = [value]
-                tmp[key] = value
-            dict.__init__(self, tmp)
-        else:
-            tmp = {}
-            for key, value in mapping or ():
-                tmp.setdefault(key, []).append(value)
-            dict.__init__(self, tmp)
-
-    def __getstate__(self):
-        return dict(self.lists())
-
-    def __setstate__(self, value):
-        dict.clear(self)
-        dict.update(self, value)
-
-    def __getitem__(self, key):
-        """Return the first data value for this key;
-        raises KeyError if not found.
-
-        :param key: The key to be looked up.
-        :raise KeyError: if the key does not exist.
-        """
-        if key in self:
-            lst = dict.__getitem__(self, key)
-            if len(lst) > 0:
-                return lst[0]
-        raise exceptions.BadRequestKeyError(key)
-
-    def __setitem__(self, key, value):
-        """Like :meth:`add` but removes an existing key first.
-
-        :param key: the key for the value.
-        :param value: the value to set.
-        """
-        dict.__setitem__(self, key, [value])
-
-    def add(self, key, value):
-        """Adds a new value for the key.
-
-        .. versionadded:: 0.6
-
-        :param key: the key for the value.
-        :param value: the value to add.
-        """
-        dict.setdefault(self, key, []).append(value)
-
-    def getlist(self, key, type=None):
-        """Return the list of items for a given key. If that key is not in the
-        `MultiDict`, the return value will be an empty list.  Just as `get`
-        `getlist` accepts a `type` parameter.  All items will be converted
-        with the callable defined there.
-
-        :param key: The key to be looked up.
-        :param type: A callable that is used to cast the value in the
-                     :class:`MultiDict`.  If a :exc:`ValueError` is raised
-                     by this callable the value will be removed from the list.
-        :return: a :class:`list` of all the values for the key.
-        """
-        try:
-            rv = dict.__getitem__(self, key)
-        except KeyError:
-            return []
-        if type is None:
-            return list(rv)
-        result = []
-        for item in rv:
-            try:
-                result.append(type(item))
-            except ValueError:
-                pass
-        return result
-
-    def setlist(self, key, new_list):
-        """Remove the old values for a key and add new ones.  Note that the list
-        you pass the values in will be shallow-copied before it is inserted in
-        the dictionary.
-
-        >>> d = MultiDict()
-        >>> d.setlist('foo', ['1', '2'])
-        >>> d['foo']
-        '1'
-        >>> d.getlist('foo')
-        ['1', '2']
-
-        :param key: The key for which the values are set.
-        :param new_list: An iterable with the new values for the key.  Old values
-                         are removed first.
-        """
-        dict.__setitem__(self, key, list(new_list))
-
-    def setdefault(self, key, default=None):
-        """Returns the value for the key if it is in the dict, otherwise it
-        returns `default` and sets that value for `key`.
-
-        :param key: The key to be looked up.
-        :param default: The default value to be returned if the key is not
-                        in the dict.  If not further specified it's `None`.
-        """
-        if key not in self:
-            self[key] = default
-        else:
-            default = self[key]
-        return default
-
-    def setlistdefault(self, key, default_list=None):
-        """Like `setdefault` but sets multiple values.  The list returned
-        is not a copy, but the list that is actually used internally.  This
-        means that you can put new values into the dict by appending items
-        to the list:
-
-        >>> d = MultiDict({"foo": 1})
-        >>> d.setlistdefault("foo").extend([2, 3])
-        >>> d.getlist("foo")
-        [1, 2, 3]
-
-        :param key: The key to be looked up.
-        :param default_list: An iterable of default values.  It is either copied
-                             (in case it was a list) or converted into a list
-                             before returned.
-        :return: a :class:`list`
-        """
-        if key not in self:
-            default_list = list(default_list or ())
-            dict.__setitem__(self, key, default_list)
-        else:
-            default_list = dict.__getitem__(self, key)
-        return default_list
-
-    def items(self, multi=False):
-        """Return an iterator of ``(key, value)`` pairs.
-
-        :param multi: If set to `True` the iterator returned will have a pair
-                      for each value of each key.  Otherwise it will only
-                      contain pairs for the first value of each key.
-        """
-
-        for key, values in iteritems(dict, self):
-            if multi:
-                for value in values:
-                    yield key, value
-            else:
-                yield key, values[0]
-
-    def lists(self):
-        """Return a list of ``(key, values)`` pairs, where values is the list
-        of all values associated with the key."""
-
-        for key, values in iteritems(dict, self):
-            yield key, list(values)
-
-    def keys(self):
-        return iterkeys(dict, self)
-
-    __iter__ = keys
-
-    def values(self):
-        """Returns an iterator of the first value on every key's value list."""
-        for values in itervalues(dict, self):
-            yield values[0]
-
-    def listvalues(self):
-        """Return an iterator of all values associated with a key.  Zipping
-        :meth:`keys` and this is the same as calling :meth:`lists`:
-
-        >>> d = MultiDict({"foo": [1, 2, 3]})
-        >>> zip(d.keys(), d.listvalues()) == d.lists()
-        True
-        """
-
-        return itervalues(dict, self)
-
-    def copy(self):
-        """Return a shallow copy of this object."""
-        return self.__class__(self)
-
-    def deepcopy(self, memo=None):
-        """Return a deep copy of this object."""
-        return self.__class__(deepcopy(self.to_dict(flat=False), memo))
-
-    def to_dict(self, flat=True):
-        """Return the contents as regular dict.  If `flat` is `True` the
-        returned dict will only have the first item present, if `flat` is
-        `False` all values will be returned as lists.
-
-        :param flat: If set to `False` the dict returned will have lists
-                     with all the values in it.  Otherwise it will only
-                     contain the first value for each key.
-        :return: a :class:`dict`
-        """
-        if flat:
-            return dict(iteritems(self))
-        return dict(self.lists())
-
-    def update(self, other_dict):
-        """update() extends rather than replaces existing key lists:
-
-        >>> a = MultiDict({'x': 1})
-        >>> b = MultiDict({'x': 2, 'y': 3})
-        >>> a.update(b)
-        >>> a
-        MultiDict([('y', 3), ('x', 1), ('x', 2)])
-
-        If the value list for a key in ``other_dict`` is empty, no new values
-        will be added to the dict and the key will not be created:
-
-        >>> x = {'empty_list': []}
-        >>> y = MultiDict()
-        >>> y.update(x)
-        >>> y
-        MultiDict([])
-        """
-        for key, value in iter_multi_items(other_dict):
-            MultiDict.add(self, key, value)
-
-    def pop(self, key, default=_missing):
-        """Pop the first item for a list on the dict.  Afterwards the
-        key is removed from the dict, so additional values are discarded:
-
-        >>> d = MultiDict({"foo": [1, 2, 3]})
-        >>> d.pop("foo")
-        1
-        >>> "foo" in d
-        False
-
-        :param key: the key to pop.
-        :param default: if provided the value to return if the key was
-                        not in the dictionary.
-        """
-        try:
-            lst = dict.pop(self, key)
-
-            if len(lst) == 0:
-                raise exceptions.BadRequestKeyError()
-
-            return lst[0]
-        except KeyError as e:
-            if default is not _missing:
-                return default
-            raise exceptions.BadRequestKeyError(str(e))
-
-    def popitem(self):
-        """Pop an item from the dict."""
-        try:
-            item = dict.popitem(self)
-
-            if len(item[1]) == 0:
-                raise exceptions.BadRequestKeyError()
-
-            return (item[0], item[1][0])
-        except KeyError as e:
-            raise exceptions.BadRequestKeyError(str(e))
-
-    def poplist(self, key):
-        """Pop the list for a key from the dict.  If the key is not in the dict
-        an empty list is returned.
-
-        .. versionchanged:: 0.5
-           If the key does no longer exist a list is returned instead of
-           raising an error.
-        """
-        return dict.pop(self, key, [])
-
-    def popitemlist(self):
-        """Pop a ``(key, list)`` tuple from the dict."""
-        try:
-            return dict.popitem(self)
-        except KeyError as e:
-            raise exceptions.BadRequestKeyError(str(e))
-
-    def __copy__(self):
-        return self.copy()
-
-    def __deepcopy__(self, memo):
-        return self.deepcopy(memo=memo)
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, list(iteritems(self, multi=True)))
-
-
-class _omd_bucket(object):
-
-    """Wraps values in the :class:`OrderedMultiDict`.  This makes it
-    possible to keep an order over multiple different keys.  It requires
-    a lot of extra memory and slows down access a lot, but makes it
-    possible to access elements in O(1) and iterate in O(n).
-    """
-    __slots__ = ('prev', 'key', 'value', 'next')
-
-    def __init__(self, omd, key, value):
-        self.prev = omd._last_bucket
-        self.key = key
-        self.value = value
-        self.next = None
-
-        if omd._first_bucket is None:
-            omd._first_bucket = self
-        if omd._last_bucket is not None:
-            omd._last_bucket.next = self
-        omd._last_bucket = self
-
-    def unlink(self, omd):
-        if self.prev:
-            self.prev.next = self.next
-        if self.next:
-            self.next.prev = self.prev
-        if omd._first_bucket is self:
-            omd._first_bucket = self.next
-        if omd._last_bucket is self:
-            omd._last_bucket = self.prev
-
-
-@native_itermethods(['keys', 'values', 'items', 'lists', 'listvalues'])
-class OrderedMultiDict(MultiDict):
-
-    """Works like a regular :class:`MultiDict` but preserves the
-    order of the fields.  To convert the ordered multi dict into a
-    list you can use the :meth:`items` method and pass it ``multi=True``.
-
-    In general an :class:`OrderedMultiDict` is an order of magnitude
-    slower than a :class:`MultiDict`.
-
-    .. admonition:: note
-
-       Due to a limitation in Python you cannot convert an ordered
-       multi dict into a regular dict by using ``dict(multidict)``.
-       Instead you have to use the :meth:`to_dict` method, otherwise
-       the internal bucket objects are exposed.
-    """
-
-    def __init__(self, mapping=None):
-        dict.__init__(self)
-        self._first_bucket = self._last_bucket = None
-        if mapping is not None:
-            OrderedMultiDict.update(self, mapping)
-
-    def __eq__(self, other):
-        if not isinstance(other, MultiDict):
-            return NotImplemented
-        if isinstance(other, OrderedMultiDict):
-            iter1 = iteritems(self, multi=True)
-            iter2 = iteritems(other, multi=True)
-            try:
-                for k1, v1 in iter1:
-                    k2, v2 = next(iter2)
-                    if k1 != k2 or v1 != v2:
-                        return False
-            except StopIteration:
-                return False
-            try:
-                next(iter2)
-            except StopIteration:
-                return True
-            return False
-        if len(self) != len(other):
-            return False
-        for key, values in iterlists(self):
-            if other.getlist(key) != values:
-                return False
-        return True
-
-    __hash__ = None
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (list(iteritems(self, multi=True)),)
-
-    def __getstate__(self):
-        return list(iteritems(self, multi=True))
-
-    def __setstate__(self, values):
-        dict.clear(self)
-        for key, value in values:
-            self.add(key, value)
-
-    def __getitem__(self, key):
-        if key in self:
-            return dict.__getitem__(self, key)[0].value
-        raise exceptions.BadRequestKeyError(key)
-
-    def __setitem__(self, key, value):
-        self.poplist(key)
-        self.add(key, value)
-
-    def __delitem__(self, key):
-        self.pop(key)
-
-    def keys(self):
-        return (key for key, value in iteritems(self))
-
-    __iter__ = keys
-
-    def values(self):
-        return (value for key, value in iteritems(self))
-
-    def items(self, multi=False):
-        ptr = self._first_bucket
-        if multi:
-            while ptr is not None:
-                yield ptr.key, ptr.value
-                ptr = ptr.next
-        else:
-            returned_keys = set()
-            while ptr is not None:
-                if ptr.key not in returned_keys:
-                    returned_keys.add(ptr.key)
-                    yield ptr.key, ptr.value
-                ptr = ptr.next
-
-    def lists(self):
-        returned_keys = set()
-        ptr = self._first_bucket
-        while ptr is not None:
-            if ptr.key not in returned_keys:
-                yield ptr.key, self.getlist(ptr.key)
-                returned_keys.add(ptr.key)
-            ptr = ptr.next
-
-    def listvalues(self):
-        for key, values in iterlists(self):
-            yield values
-
-    def add(self, key, value):
-        dict.setdefault(self, key, []).append(_omd_bucket(self, key, value))
-
-    def getlist(self, key, type=None):
-        try:
-            rv = dict.__getitem__(self, key)
-        except KeyError:
-            return []
-        if type is None:
-            return [x.value for x in rv]
-        result = []
-        for item in rv:
-            try:
-                result.append(type(item.value))
-            except ValueError:
-                pass
-        return result
-
-    def setlist(self, key, new_list):
-        self.poplist(key)
-        for value in new_list:
-            self.add(key, value)
-
-    def setlistdefault(self, key, default_list=None):
-        raise TypeError('setlistdefault is unsupported for '
-                        'ordered multi dicts')
-
-    def update(self, mapping):
-        for key, value in iter_multi_items(mapping):
-            OrderedMultiDict.add(self, key, value)
-
-    def poplist(self, key):
-        buckets = dict.pop(self, key, ())
-        for bucket in buckets:
-            bucket.unlink(self)
-        return [x.value for x in buckets]
-
-    def pop(self, key, default=_missing):
-        try:
-            buckets = dict.pop(self, key)
-        except KeyError as e:
-            if default is not _missing:
-                return default
-            raise exceptions.BadRequestKeyError(str(e))
-        for bucket in buckets:
-            bucket.unlink(self)
-        return buckets[0].value
-
-    def popitem(self):
-        try:
-            key, buckets = dict.popitem(self)
-        except KeyError as e:
-            raise exceptions.BadRequestKeyError(str(e))
-        for bucket in buckets:
-            bucket.unlink(self)
-        return key, buckets[0].value
-
-    def popitemlist(self):
-        try:
-            key, buckets = dict.popitem(self)
-        except KeyError as e:
-            raise exceptions.BadRequestKeyError(str(e))
-        for bucket in buckets:
-            bucket.unlink(self)
-        return key, [x.value for x in buckets]
-
-
-def _options_header_vkw(value, kw):
-    return dump_options_header(value, dict((k.replace('_', '-'), v)
-                                           for k, v in kw.items()))
-
-
-def _unicodify_header_value(value):
-    if isinstance(value, bytes):
-        value = value.decode('latin-1')
-    if not isinstance(value, text_type):
-        value = text_type(value)
-    return value
-
-
-@native_itermethods(['keys', 'values', 'items'])
-class Headers(object):
-
-    """An object that stores some headers.  It has a dict-like interface
-    but is ordered and can store the same keys multiple times.
-
-    This data structure is useful if you want a nicer way to handle WSGI
-    headers which are stored as tuples in a list.
-
-    From Werkzeug 0.3 onwards, the :exc:`KeyError` raised by this class is
-    also a subclass of the :class:`~exceptions.BadRequest` HTTP exception
-    and will render a page for a ``400 BAD REQUEST`` if caught in a
-    catch-all for HTTP exceptions.
-
-    Headers is mostly compatible with the Python :class:`wsgiref.headers.Headers`
-    class, with the exception of `__getitem__`.  :mod:`wsgiref` will return
-    `None` for ``headers['missing']``, whereas :class:`Headers` will raise
-    a :class:`KeyError`.
-
-    To create a new :class:`Headers` object pass it a list or dict of headers
-    which are used as default values.  This does not reuse the list passed
-    to the constructor for internal usage.
-
-    :param defaults: The list of default values for the :class:`Headers`.
-
-    .. versionchanged:: 0.9
-       This data structure now stores unicode values similar to how the
-       multi dicts do it.  The main difference is that bytes can be set as
-       well which will automatically be latin1 decoded.
-
-    .. versionchanged:: 0.9
-       The :meth:`linked` function was removed without replacement as it
-       was an API that does not support the changes to the encoding model.
-    """
-
-    def __init__(self, defaults=None):
-        self._list = []
-        if defaults is not None:
-            if isinstance(defaults, (list, Headers)):
-                self._list.extend(defaults)
-            else:
-                self.extend(defaults)
-
-    def __getitem__(self, key, _get_mode=False):
-        if not _get_mode:
-            if isinstance(key, integer_types):
-                return self._list[key]
-            elif isinstance(key, slice):
-                return self.__class__(self._list[key])
-        if not isinstance(key, string_types):
-            raise exceptions.BadRequestKeyError(key)
-        ikey = key.lower()
-        for k, v in self._list:
-            if k.lower() == ikey:
-                return v
-        # micro optimization: if we are in get mode we will catch that
-        # exception one stack level down so we can raise a standard
-        # key error instead of our special one.
-        if _get_mode:
-            raise KeyError()
-        raise exceptions.BadRequestKeyError(key)
-
-    def __eq__(self, other):
-        return other.__class__ is self.__class__ and \
-            set(other._list) == set(self._list)
-
-    __hash__ = None
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def get(self, key, default=None, type=None, as_bytes=False):
-        """Return the default value if the requested data doesn't exist.
-        If `type` is provided and is a callable it should convert the value,
-        return it or raise a :exc:`ValueError` if that is not possible.  In
-        this case the function will return the default as if the value was not
-        found:
-
-        >>> d = Headers([('Content-Length', '42')])
-        >>> d.get('Content-Length', type=int)
-        42
-
-        If a headers object is bound you must not add unicode strings
-        because no encoding takes place.
-
-        .. versionadded:: 0.9
-           Added support for `as_bytes`.
-
-        :param key: The key to be looked up.
-        :param default: The default value to be returned if the key can't
-                        be looked up.  If not further specified `None` is
-                        returned.
-        :param type: A callable that is used to cast the value in the
-                     :class:`Headers`.  If a :exc:`ValueError` is raised
-                     by this callable the default value is returned.
-        :param as_bytes: return bytes instead of unicode strings.
-        """
-        try:
-            rv = self.__getitem__(key, _get_mode=True)
-        except KeyError:
-            return default
-        if as_bytes:
-            rv = rv.encode('latin1')
-        if type is None:
-            return rv
-        try:
-            return type(rv)
-        except ValueError:
-            return default
-
-    def getlist(self, key, type=None, as_bytes=False):
-        """Return the list of items for a given key. If that key is not in the
-        :class:`Headers`, the return value will be an empty list.  Just as
-        :meth:`get` :meth:`getlist` accepts a `type` parameter.  All items will
-        be converted with the callable defined there.
-
-        .. versionadded:: 0.9
-           Added support for `as_bytes`.
-
-        :param key: The key to be looked up.
-        :param type: A callable that is used to cast the value in the
-                     :class:`Headers`.  If a :exc:`ValueError` is raised
-                     by this callable the value will be removed from the list.
-        :return: a :class:`list` of all the values for the key.
-        :param as_bytes: return bytes instead of unicode strings.
-        """
-        ikey = key.lower()
-        result = []
-        for k, v in self:
-            if k.lower() == ikey:
-                if as_bytes:
-                    v = v.encode('latin1')
-                if type is not None:
-                    try:
-                        v = type(v)
-                    except ValueError:
-                        continue
-                result.append(v)
-        return result
-
-    def get_all(self, name):
-        """Return a list of all the values for the named field.
-
-        This method is compatible with the :mod:`wsgiref`
-        :meth:`~wsgiref.headers.Headers.get_all` method.
-        """
-        return self.getlist(name)
-
-    def items(self, lower=False):
-        for key, value in self:
-            if lower:
-                key = key.lower()
-            yield key, value
-
-    def keys(self, lower=False):
-        for key, _ in iteritems(self, lower):
-            yield key
-
-    def values(self):
-        for _, value in iteritems(self):
-            yield value
-
-    def extend(self, iterable):
-        """Extend the headers with a dict or an iterable yielding keys and
-        values.
-        """
-        if isinstance(iterable, dict):
-            for key, value in iteritems(iterable):
-                if isinstance(value, (tuple, list)):
-                    for v in value:
-                        self.add(key, v)
-                else:
-                    self.add(key, value)
-        else:
-            for key, value in iterable:
-                self.add(key, value)
-
-    def __delitem__(self, key, _index_operation=True):
-        if _index_operation and isinstance(key, (integer_types, slice)):
-            del self._list[key]
-            return
-        key = key.lower()
-        new = []
-        for k, v in self._list:
-            if k.lower() != key:
-                new.append((k, v))
-        self._list[:] = new
-
-    def remove(self, key):
-        """Remove a key.
-
-        :param key: The key to be removed.
-        """
-        return self.__delitem__(key, _index_operation=False)
-
-    def pop(self, key=None, default=_missing):
-        """Removes and returns a key or index.
-
-        :param key: The key to be popped.  If this is an integer the item at
-                    that position is removed, if it's a string the value for
-                    that key is.  If the key is omitted or `None` the last
-                    item is removed.
-        :return: an item.
-        """
-        if key is None:
-            return self._list.pop()
-        if isinstance(key, integer_types):
-            return self._list.pop(key)
-        try:
-            rv = self[key]
-            self.remove(key)
-        except KeyError:
-            if default is not _missing:
-                return default
-            raise
-        return rv
-
-    def popitem(self):
-        """Removes a key or index and returns a (key, value) item."""
-        return self.pop()
-
-    def __contains__(self, key):
-        """Check if a key is present."""
-        try:
-            self.__getitem__(key, _get_mode=True)
-        except KeyError:
-            return False
-        return True
-
-    has_key = __contains__
-
-    def __iter__(self):
-        """Yield ``(key, value)`` tuples."""
-        return iter(self._list)
-
-    def __len__(self):
-        return len(self._list)
-
-    def add(self, _key, _value, **kw):
-        """Add a new header tuple to the list.
-
-        Keyword arguments can specify additional parameters for the header
-        value, with underscores converted to dashes::
-
-        >>> d = Headers()
-        >>> d.add('Content-Type', 'text/plain')
-        >>> d.add('Content-Disposition', 'attachment', filename='foo.png')
-
-        The keyword argument dumping uses :func:`dump_options_header`
-        behind the scenes.
-
-        .. versionadded:: 0.4.1
-            keyword arguments were added for :mod:`wsgiref` compatibility.
-        """
-        if kw:
-            _value = _options_header_vkw(_value, kw)
-        _value = _unicodify_header_value(_value)
-        self._validate_value(_value)
-        self._list.append((_key, _value))
-
-    def _validate_value(self, value):
-        if not isinstance(value, text_type):
-            raise TypeError('Value should be unicode.')
-        if u'\n' in value or u'\r' in value:
-            raise ValueError('Detected newline in header value.  This is '
-                             'a potential security problem')
-
-    def add_header(self, _key, _value, **_kw):
-        """Add a new header tuple to the list.
-
-        An alias for :meth:`add` for compatibility with the :mod:`wsgiref`
-        :meth:`~wsgiref.headers.Headers.add_header` method.
-        """
-        self.add(_key, _value, **_kw)
-
-    def clear(self):
-        """Clears all headers."""
-        del self._list[:]
-
-    def set(self, _key, _value, **kw):
-        """Remove all header tuples for `key` and add a new one.  The newly
-        added key either appears at the end of the list if there was no
-        entry or replaces the first one.
-
-        Keyword arguments can specify additional parameters for the header
-        value, with underscores converted to dashes.  See :meth:`add` for
-        more information.
-
-        .. versionchanged:: 0.6.1
-           :meth:`set` now accepts the same arguments as :meth:`add`.
-
-        :param key: The key to be inserted.
-        :param value: The value to be inserted.
-        """
-        if kw:
-            _value = _options_header_vkw(_value, kw)
-        _value = _unicodify_header_value(_value)
-        self._validate_value(_value)
-        if not self._list:
-            self._list.append((_key, _value))
-            return
-        listiter = iter(self._list)
-        ikey = _key.lower()
-        for idx, (old_key, old_value) in enumerate(listiter):
-            if old_key.lower() == ikey:
-                # replace first ocurrence
-                self._list[idx] = (_key, _value)
-                break
-        else:
-            self._list.append((_key, _value))
-            return
-        self._list[idx + 1:] = [t for t in listiter if t[0].lower() != ikey]
-
-    def setdefault(self, key, default):
-        """Returns the value for the key if it is in the dict, otherwise it
-        returns `default` and sets that value for `key`.
-
-        :param key: The key to be looked up.
-        :param default: The default value to be returned if the key is not
-                        in the dict.  If not further specified it's `None`.
-        """
-        if key in self:
-            return self[key]
-        self.set(key, default)
-        return default
-
-    def __setitem__(self, key, value):
-        """Like :meth:`set` but also supports index/slice based setting."""
-        if isinstance(key, (slice, integer_types)):
-            if isinstance(key, integer_types):
-                value = [value]
-            value = [(k, _unicodify_header_value(v)) for (k, v) in value]
-            [self._validate_value(v) for (k, v) in value]
-            if isinstance(key, integer_types):
-                self._list[key] = value[0]
-            else:
-                self._list[key] = value
-        else:
-            self.set(key, value)
-
-    def to_list(self, charset='iso-8859-1'):
-        """Convert the headers into a list suitable for WSGI."""
-        from warnings import warn
-        warn(DeprecationWarning('Method removed, use to_wsgi_list instead'),
-             stacklevel=2)
-        return self.to_wsgi_list()
-
-    def to_wsgi_list(self):
-        """Convert the headers into a list suitable for WSGI.
-
-        The values are byte strings in Python 2 converted to latin1 and unicode
-        strings in Python 3 for the WSGI server to encode.
-
-        :return: list
-        """
-        if PY2:
-            return [(to_native(k), v.encode('latin1')) for k, v in self]
-        return list(self)
-
-    def copy(self):
-        return self.__class__(self._list)
-
-    def __copy__(self):
-        return self.copy()
-
-    def __str__(self):
-        """Returns formatted headers suitable for HTTP transmission."""
-        strs = []
-        for key, value in self.to_wsgi_list():
-            strs.append('%s: %s' % (key, value))
-        strs.append('\r\n')
-        return '\r\n'.join(strs)
-
-    def __repr__(self):
-        return '%s(%r)' % (
-            self.__class__.__name__,
-            list(self)
-        )
-
-
-class ImmutableHeadersMixin(object):
-
-    """Makes a :class:`Headers` immutable.  We do not mark them as
-    hashable though since the only usecase for this datastructure
-    in Werkzeug is a view on a mutable structure.
-
-    .. versionadded:: 0.5
-
-    :private:
-    """
-
-    def __delitem__(self, key):
-        is_immutable(self)
-
-    def __setitem__(self, key, value):
-        is_immutable(self)
-    set = __setitem__
-
-    def add(self, item):
-        is_immutable(self)
-    remove = add_header = add
-
-    def extend(self, iterable):
-        is_immutable(self)
-
-    def insert(self, pos, value):
-        is_immutable(self)
-
-    def pop(self, index=-1):
-        is_immutable(self)
-
-    def popitem(self):
-        is_immutable(self)
-
-    def setdefault(self, key, default):
-        is_immutable(self)
-
-
-class EnvironHeaders(ImmutableHeadersMixin, Headers):
-
-    """Read only version of the headers from a WSGI environment.  This
-    provides the same interface as `Headers` and is constructed from
-    a WSGI environment.
-
-    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a
-    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will
-    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for
-    HTTP exceptions.
-    """
-
-    def __init__(self, environ):
-        self.environ = environ
-
-    def __eq__(self, other):
-        return self.environ is other.environ
-
-    __hash__ = None
-
-    def __getitem__(self, key, _get_mode=False):
-        # _get_mode is a no-op for this class as there is no index but
-        # used because get() calls it.
-        if not isinstance(key, string_types):
-            raise KeyError(key)
-        key = key.upper().replace('-', '_')
-        if key in ('CONTENT_TYPE', 'CONTENT_LENGTH'):
-            return _unicodify_header_value(self.environ[key])
-        return _unicodify_header_value(self.environ['HTTP_' + key])
-
-    def __len__(self):
-        # the iter is necessary because otherwise list calls our
-        # len which would call list again and so forth.
-        return len(list(iter(self)))
-
-    def __iter__(self):
-        for key, value in iteritems(self.environ):
-            if key.startswith('HTTP_') and key not in \
-               ('HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH'):
-                yield (key[5:].replace('_', '-').title(),
-                       _unicodify_header_value(value))
-            elif key in ('CONTENT_TYPE', 'CONTENT_LENGTH') and value:
-                yield (key.replace('_', '-').title(),
-                       _unicodify_header_value(value))
-
-    def copy(self):
-        raise TypeError('cannot create %r copies' % self.__class__.__name__)
-
-
-@native_itermethods(['keys', 'values', 'items', 'lists', 'listvalues'])
-class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict):
-
-    """A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict`
-    instances as sequence and it will combine the return values of all wrapped
-    dicts:
-
-    >>> from werkzeug.datastructures import CombinedMultiDict, MultiDict
-    >>> post = MultiDict([('foo', 'bar')])
-    >>> get = MultiDict([('blub', 'blah')])
-    >>> combined = CombinedMultiDict([get, post])
-    >>> combined['foo']
-    'bar'
-    >>> combined['blub']
-    'blah'
-
-    This works for all read operations and will raise a `TypeError` for
-    methods that usually change data which isn't possible.
-
-    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a
-    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will
-    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP
-    exceptions.
-    """
-
-    def __reduce_ex__(self, protocol):
-        return type(self), (self.dicts,)
-
-    def __init__(self, dicts=None):
-        self.dicts = dicts or []
-
-    @classmethod
-    def fromkeys(cls):
-        raise TypeError('cannot create %r instances by fromkeys' %
-                        cls.__name__)
-
-    def __getitem__(self, key):
-        for d in self.dicts:
-            if key in d:
-                return d[key]
-        raise exceptions.BadRequestKeyError(key)
-
-    def get(self, key, default=None, type=None):
-        for d in self.dicts:
-            if key in d:
-                if type is not None:
-                    try:
-                        return type(d[key])
-                    except ValueError:
-                        continue
-                return d[key]
-        return default
-
-    def getlist(self, key, type=None):
-        rv = []
-        for d in self.dicts:
-            rv.extend(d.getlist(key, type))
-        return rv
-
-    def _keys_impl(self):
-        """This function exists so __len__ can be implemented more efficiently,
-        saving one list creation from an iterator.
-
-        Using this for Python 2's ``dict.keys`` behavior would be useless since
-        `dict.keys` in Python 2 returns a list, while we have a set here.
-        """
-        rv = set()
-        for d in self.dicts:
-            rv.update(iterkeys(d))
-        return rv
-
-    def keys(self):
-        return iter(self._keys_impl())
-
-    __iter__ = keys
-
-    def items(self, multi=False):
-        found = set()
-        for d in self.dicts:
-            for key, value in iteritems(d, multi):
-                if multi:
-                    yield key, value
-                elif key not in found:
-                    found.add(key)
-                    yield key, value
-
-    def values(self):
-        for key, value in iteritems(self):
-            yield value
-
-    def lists(self):
-        rv = {}
-        for d in self.dicts:
-            for key, values in iterlists(d):
-                rv.setdefault(key, []).extend(values)
-        return iteritems(rv)
-
-    def listvalues(self):
-        return (x[1] for x in self.lists())
-
-    def copy(self):
-        """Return a shallow copy of this object."""
-        return self.__class__(self.dicts[:])
-
-    def to_dict(self, flat=True):
-        """Return the contents as regular dict.  If `flat` is `True` the
-        returned dict will only have the first item present, if `flat` is
-        `False` all values will be returned as lists.
-
-        :param flat: If set to `False` the dict returned will have lists
-                     with all the values in it.  Otherwise it will only
-                     contain the first item for each key.
-        :return: a :class:`dict`
-        """
-        rv = {}
-        for d in reversed(self.dicts):
-            rv.update(d.to_dict(flat))
-        return rv
-
-    def __len__(self):
-        return len(self._keys_impl())
-
-    def __contains__(self, key):
-        for d in self.dicts:
-            if key in d:
-                return True
-        return False
-
-    has_key = __contains__
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self.dicts)
-
-
-class FileMultiDict(MultiDict):
-
-    """A special :class:`MultiDict` that has convenience methods to add
-    files to it.  This is used for :class:`EnvironBuilder` and generally
-    useful for unittesting.
-
-    .. versionadded:: 0.5
-    """
-
-    def add_file(self, name, file, filename=None, content_type=None):
-        """Adds a new file to the dict.  `file` can be a file name or
-        a :class:`file`-like or a :class:`FileStorage` object.
-
-        :param name: the name of the field.
-        :param file: a filename or :class:`file`-like object
-        :param filename: an optional filename
-        :param content_type: an optional content type
-        """
-        if isinstance(file, FileStorage):
-            value = file
-        else:
-            if isinstance(file, string_types):
-                if filename is None:
-                    filename = file
-                file = open(file, 'rb')
-            if filename and content_type is None:
-                content_type = mimetypes.guess_type(filename)[0] or \
-                    'application/octet-stream'
-            value = FileStorage(file, filename, name, content_type)
-
-        self.add(name, value)
-
-
-class ImmutableDict(ImmutableDictMixin, dict):
-
-    """An immutable :class:`dict`.
-
-    .. versionadded:: 0.5
-    """
-
-    def __repr__(self):
-        return '%s(%s)' % (
-            self.__class__.__name__,
-            dict.__repr__(self),
-        )
-
-    def copy(self):
-        """Return a shallow mutable copy of this object.  Keep in mind that
-        the standard library's :func:`copy` function is a no-op for this class
-        like for any other python immutable type (eg: :class:`tuple`).
-        """
-        return dict(self)
-
-    def __copy__(self):
-        return self
-
-
-class ImmutableMultiDict(ImmutableMultiDictMixin, MultiDict):
-
-    """An immutable :class:`MultiDict`.
-
-    .. versionadded:: 0.5
-    """
-
-    def copy(self):
-        """Return a shallow mutable copy of this object.  Keep in mind that
-        the standard library's :func:`copy` function is a no-op for this class
-        like for any other python immutable type (eg: :class:`tuple`).
-        """
-        return MultiDict(self)
-
-    def __copy__(self):
-        return self
-
-
-class ImmutableOrderedMultiDict(ImmutableMultiDictMixin, OrderedMultiDict):
-
-    """An immutable :class:`OrderedMultiDict`.
-
-    .. versionadded:: 0.6
-    """
-
-    def _iter_hashitems(self):
-        return enumerate(iteritems(self, multi=True))
-
-    def copy(self):
-        """Return a shallow mutable copy of this object.  Keep in mind that
-        the standard library's :func:`copy` function is a no-op for this class
-        like for any other python immutable type (eg: :class:`tuple`).
-        """
-        return OrderedMultiDict(self)
-
-    def __copy__(self):
-        return self
-
-
-@native_itermethods(['values'])
-class Accept(ImmutableList):
-
-    """An :class:`Accept` object is just a list subclass for lists of
-    ``(value, quality)`` tuples.  It is automatically sorted by specificity
-    and quality.
-
-    All :class:`Accept` objects work similar to a list but provide extra
-    functionality for working with the data.  Containment checks are
-    normalized to the rules of that header:
-
-    >>> a = CharsetAccept([('ISO-8859-1', 1), ('utf-8', 0.7)])
-    >>> a.best
-    'ISO-8859-1'
-    >>> 'iso-8859-1' in a
-    True
-    >>> 'UTF8' in a
-    True
-    >>> 'utf7' in a
-    False
-
-    To get the quality for an item you can use normal item lookup:
-
-    >>> print a['utf-8']
-    0.7
-    >>> a['utf7']
-    0
-
-    .. versionchanged:: 0.5
-       :class:`Accept` objects are forced immutable now.
-    """
-
-    def __init__(self, values=()):
-        if values is None:
-            list.__init__(self)
-            self.provided = False
-        elif isinstance(values, Accept):
-            self.provided = values.provided
-            list.__init__(self, values)
-        else:
-            self.provided = True
-            values = sorted(values, key=lambda x: (self._specificity(x[0]), x[1], x[0]),
-                            reverse=True)
-            list.__init__(self, values)
-
-    def _specificity(self, value):
-        """Returns a tuple describing the value's specificity."""
-        return value != '*',
-
-    def _value_matches(self, value, item):
-        """Check if a value matches a given accept item."""
-        return item == '*' or item.lower() == value.lower()
-
-    def __getitem__(self, key):
-        """Besides index lookup (getting item n) you can also pass it a string
-        to get the quality for the item.  If the item is not in the list, the
-        returned quality is ``0``.
-        """
-        if isinstance(key, string_types):
-            return self.quality(key)
-        return list.__getitem__(self, key)
-
-    def quality(self, key):
-        """Returns the quality of the key.
-
-        .. versionadded:: 0.6
-           In previous versions you had to use the item-lookup syntax
-           (eg: ``obj[key]`` instead of ``obj.quality(key)``)
-        """
-        for item, quality in self:
-            if self._value_matches(key, item):
-                return quality
-        return 0
-
-    def __contains__(self, value):
-        for item, quality in self:
-            if self._value_matches(value, item):
-                return True
-        return False
-
-    def __repr__(self):
-        return '%s([%s])' % (
-            self.__class__.__name__,
-            ', '.join('(%r, %s)' % (x, y) for x, y in self)
-        )
-
-    def index(self, key):
-        """Get the position of an entry or raise :exc:`ValueError`.
-
-        :param key: The key to be looked up.
-
-        .. versionchanged:: 0.5
-           This used to raise :exc:`IndexError`, which was inconsistent
-           with the list API.
-        """
-        if isinstance(key, string_types):
-            for idx, (item, quality) in enumerate(self):
-                if self._value_matches(key, item):
-                    return idx
-            raise ValueError(key)
-        return list.index(self, key)
-
-    def find(self, key):
-        """Get the position of an entry or return -1.
-
-        :param key: The key to be looked up.
-        """
-        try:
-            return self.index(key)
-        except ValueError:
-            return -1
-
-    def values(self):
-        """Iterate over all values."""
-        for item in self:
-            yield item[0]
-
-    def to_header(self):
-        """Convert the header set into an HTTP header string."""
-        result = []
-        for value, quality in self:
-            if quality != 1:
-                value = '%s;q=%s' % (value, quality)
-            result.append(value)
-        return ','.join(result)
-
-    def __str__(self):
-        return self.to_header()
-
-    def _best_single_match(self, match):
-        for client_item, quality in self:
-            if self._value_matches(match, client_item):
-                # self is sorted by specificity descending, we can exit
-                return client_item, quality
-
-    def best_match(self, matches, default=None):
-        """Returns the best match from a list of possible matches based
-        on the specificity and quality of the client. If two items have the
-        same quality and specificity, the one is returned that comes first.
-
-        :param matches: a list of matches to check for
-        :param default: the value that is returned if none match
-        """
-        result = default
-        best_quality = -1
-        best_specificity = (-1,)
-        for server_item in matches:
-            match = self._best_single_match(server_item)
-            if not match:
-                continue
-            client_item, quality = match
-            specificity = self._specificity(client_item)
-            if quality <= 0 or quality < best_quality:
-                continue
-            # better quality or same quality but more specific => better match
-            if quality > best_quality or specificity > best_specificity:
-                result = server_item
-                best_quality = quality
-                best_specificity = specificity
-        return result
-
-    @property
-    def best(self):
-        """The best match as value."""
-        if self:
-            return self[0][0]
-
-
-class MIMEAccept(Accept):
-
-    """Like :class:`Accept` but with special methods and behavior for
-    mimetypes.
-    """
-
-    def _specificity(self, value):
-        return tuple(x != '*' for x in value.split('/', 1))
-
-    def _value_matches(self, value, item):
-        def _normalize(x):
-            x = x.lower()
-            return x == '*' and ('*', '*') or x.split('/', 1)
-
-        # this is from the application which is trusted.  to avoid developer
-        # frustration we actually check these for valid values
-        if '/' not in value:
-            raise ValueError('invalid mimetype %r' % value)
-        value_type, value_subtype = _normalize(value)
-        if value_type == '*' and value_subtype != '*':
-            raise ValueError('invalid mimetype %r' % value)
-
-        if '/' not in item:
-            return False
-        item_type, item_subtype = _normalize(item)
-        if item_type == '*' and item_subtype != '*':
-            return False
-        return (
-            (item_type == item_subtype == '*' or
-             value_type == value_subtype == '*') or
-            (item_type == value_type and (item_subtype == '*' or
-                                          value_subtype == '*' or
-                                          item_subtype == value_subtype))
-        )
-
-    @property
-    def accept_html(self):
-        """True if this object accepts HTML."""
-        return (
-            'text/html' in self or
-            'application/xhtml+xml' in self or
-            self.accept_xhtml
-        )
-
-    @property
-    def accept_xhtml(self):
-        """True if this object accepts XHTML."""
-        return (
-            'application/xhtml+xml' in self or
-            'application/xml' in self
-        )
-
-    @property
-    def accept_json(self):
-        """True if this object accepts JSON."""
-        return 'application/json' in self
-
-
-class LanguageAccept(Accept):
-
-    """Like :class:`Accept` but with normalization for languages."""
-
-    def _value_matches(self, value, item):
-        def _normalize(language):
-            return _locale_delim_re.split(language.lower())
-        return item == '*' or _normalize(value) == _normalize(item)
-
-
-class CharsetAccept(Accept):
-
-    """Like :class:`Accept` but with normalization for charsets."""
-
-    def _value_matches(self, value, item):
-        def _normalize(name):
-            try:
-                return codecs.lookup(name).name
-            except LookupError:
-                return name.lower()
-        return item == '*' or _normalize(value) == _normalize(item)
-
-
-def cache_property(key, empty, type):
-    """Return a new property object for a cache header.  Useful if you
-    want to add support for a cache extension in a subclass."""
-    return property(lambda x: x._get_cache_value(key, empty, type),
-                    lambda x, v: x._set_cache_value(key, v, type),
-                    lambda x: x._del_cache_value(key),
-                    'accessor for %r' % key)
-
-
-class _CacheControl(UpdateDictMixin, dict):
-
-    """Subclass of a dict that stores values for a Cache-Control header.  It
-    has accessors for all the cache-control directives specified in RFC 2616.
-    The class does not differentiate between request and response directives.
-
-    Because the cache-control directives in the HTTP header use dashes the
-    python descriptors use underscores for that.
-
-    To get a header of the :class:`CacheControl` object again you can convert
-    the object into a string or call the :meth:`to_header` method.  If you plan
-    to subclass it and add your own items have a look at the sourcecode for
-    that class.
-
-    .. versionchanged:: 0.4
-
-       Setting `no_cache` or `private` to boolean `True` will set the implicit
-       none-value which is ``*``:
-
-       >>> cc = ResponseCacheControl()
-       >>> cc.no_cache = True
-       >>> cc
-       <ResponseCacheControl 'no-cache'>
-       >>> cc.no_cache
-       '*'
-       >>> cc.no_cache = None
-       >>> cc
-       <ResponseCacheControl ''>
-
-       In versions before 0.5 the behavior documented here affected the now
-       no longer existing `CacheControl` class.
-    """
-
-    no_cache = cache_property('no-cache', '*', None)
-    no_store = cache_property('no-store', None, bool)
-    max_age = cache_property('max-age', -1, int)
-    no_transform = cache_property('no-transform', None, None)
-
-    def __init__(self, values=(), on_update=None):
-        dict.__init__(self, values or ())
-        self.on_update = on_update
-        self.provided = values is not None
-
-    def _get_cache_value(self, key, empty, type):
-        """Used internally by the accessor properties."""
-        if type is bool:
-            return key in self
-        if key in self:
-            value = self[key]
-            if value is None:
-                return empty
-            elif type is not None:
-                try:
-                    value = type(value)
-                except ValueError:
-                    pass
-            return value
-
-    def _set_cache_value(self, key, value, type):
-        """Used internally by the accessor properties."""
-        if type is bool:
-            if value:
-                self[key] = None
-            else:
-                self.pop(key, None)
-        else:
-            if value is None:
-                self.pop(key)
-            elif value is True:
-                self[key] = None
-            else:
-                self[key] = value
-
-    def _del_cache_value(self, key):
-        """Used internally by the accessor properties."""
-        if key in self:
-            del self[key]
-
-    def to_header(self):
-        """Convert the stored values into a cache control header."""
-        return dump_header(self)
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            self.__class__.__name__,
-            " ".join(
-                "%s=%r" % (k, v) for k, v in sorted(self.items())
-            ),
-        )
-
-
-class RequestCacheControl(ImmutableDictMixin, _CacheControl):
-
-    """A cache control for requests.  This is immutable and gives access
-    to all the request-relevant cache control headers.
-
-    To get a header of the :class:`RequestCacheControl` object again you can
-    convert the object into a string or call the :meth:`to_header` method.  If
-    you plan to subclass it and add your own items have a look at the sourcecode
-    for that class.
-
-    .. versionadded:: 0.5
-       In previous versions a `CacheControl` class existed that was used
-       both for request and response.
-    """
-
-    max_stale = cache_property('max-stale', '*', int)
-    min_fresh = cache_property('min-fresh', '*', int)
-    no_transform = cache_property('no-transform', None, None)
-    only_if_cached = cache_property('only-if-cached', None, bool)
-
-
-class ResponseCacheControl(_CacheControl):
-
-    """A cache control for responses.  Unlike :class:`RequestCacheControl`
-    this is mutable and gives access to response-relevant cache control
-    headers.
-
-    To get a header of the :class:`ResponseCacheControl` object again you can
-    convert the object into a string or call the :meth:`to_header` method.  If
-    you plan to subclass it and add your own items have a look at the sourcecode
-    for that class.
-
-    .. versionadded:: 0.5
-       In previous versions a `CacheControl` class existed that was used
-       both for request and response.
-    """
-
-    public = cache_property('public', None, bool)
-    private = cache_property('private', '*', None)
-    must_revalidate = cache_property('must-revalidate', None, bool)
-    proxy_revalidate = cache_property('proxy-revalidate', None, bool)
-    s_maxage = cache_property('s-maxage', None, None)
-
-
-# attach cache_property to the _CacheControl as staticmethod
-# so that others can reuse it.
-_CacheControl.cache_property = staticmethod(cache_property)
-
-
-class CallbackDict(UpdateDictMixin, dict):
-
-    """A dict that calls a function passed every time something is changed.
-    The function is passed the dict instance.
-    """
-
-    def __init__(self, initial=None, on_update=None):
-        dict.__init__(self, initial or ())
-        self.on_update = on_update
-
-    def __repr__(self):
-        return '<%s %s>' % (
-            self.__class__.__name__,
-            dict.__repr__(self)
-        )
-
-
-class HeaderSet(MutableSet):
-
-    """Similar to the :class:`ETags` class this implements a set-like structure.
-    Unlike :class:`ETags` this is case insensitive and used for vary, allow, and
-    content-language headers.
-
-    If not constructed using the :func:`parse_set_header` function the
-    instantiation works like this:
-
-    >>> hs = HeaderSet(['foo', 'bar', 'baz'])
-    >>> hs
-    HeaderSet(['foo', 'bar', 'baz'])
-    """
-
-    def __init__(self, headers=None, on_update=None):
-        self._headers = list(headers or ())
-        self._set = set([x.lower() for x in self._headers])
-        self.on_update = on_update
-
-    def add(self, header):
-        """Add a new header to the set."""
-        self.update((header,))
-
-    def remove(self, header):
-        """Remove a header from the set.  This raises an :exc:`KeyError` if the
-        header is not in the set.
-
-        .. versionchanged:: 0.5
-            In older versions a :exc:`IndexError` was raised instead of a
-            :exc:`KeyError` if the object was missing.
-
-        :param header: the header to be removed.
-        """
-        key = header.lower()
-        if key not in self._set:
-            raise KeyError(header)
-        self._set.remove(key)
-        for idx, key in enumerate(self._headers):
-            if key.lower() == header:
-                del self._headers[idx]
-                break
-        if self.on_update is not None:
-            self.on_update(self)
-
-    def update(self, iterable):
-        """Add all the headers from the iterable to the set.
-
-        :param iterable: updates the set with the items from the iterable.
-        """
-        inserted_any = False
-        for header in iterable:
-            key = header.lower()
-            if key not in self._set:
-                self._headers.append(header)
-                self._set.add(key)
-                inserted_any = True
-        if inserted_any and self.on_update is not None:
-            self.on_update(self)
-
-    def discard(self, header):
-        """Like :meth:`remove` but ignores errors.
-
-        :param header: the header to be discarded.
-        """
-        try:
-            return self.remove(header)
-        except KeyError:
-            pass
-
-    def find(self, header):
-        """Return the index of the header in the set or return -1 if not found.
-
-        :param header: the header to be looked up.
-        """
-        header = header.lower()
-        for idx, item in enumerate(self._headers):
-            if item.lower() == header:
-                return idx
-        return -1
-
-    def index(self, header):
-        """Return the index of the header in the set or raise an
-        :exc:`IndexError`.
-
-        :param header: the header to be looked up.
-        """
-        rv = self.find(header)
-        if rv < 0:
-            raise IndexError(header)
-        return rv
-
-    def clear(self):
-        """Clear the set."""
-        self._set.clear()
-        del self._headers[:]
-        if self.on_update is not None:
-            self.on_update(self)
-
-    def as_set(self, preserve_casing=False):
-        """Return the set as real python set type.  When calling this, all
-        the items are converted to lowercase and the ordering is lost.
-
-        :param preserve_casing: if set to `True` the items in the set returned
-                                will have the original case like in the
-                                :class:`HeaderSet`, otherwise they will
-                                be lowercase.
-        """
-        if preserve_casing:
-            return set(self._headers)
-        return set(self._set)
-
-    def to_header(self):
-        """Convert the header set into an HTTP header string."""
-        return ', '.join(map(quote_header_value, self._headers))
-
-    def __getitem__(self, idx):
-        return self._headers[idx]
-
-    def __delitem__(self, idx):
-        rv = self._headers.pop(idx)
-        self._set.remove(rv.lower())
-        if self.on_update is not None:
-            self.on_update(self)
-
-    def __setitem__(self, idx, value):
-        old = self._headers[idx]
-        self._set.remove(old.lower())
-        self._headers[idx] = value
-        self._set.add(value.lower())
-        if self.on_update is not None:
-            self.on_update(self)
-
-    def __contains__(self, header):
-        return header.lower() in self._set
-
-    def __len__(self):
-        return len(self._set)
-
-    def __iter__(self):
-        return iter(self._headers)
-
-    def __nonzero__(self):
-        return bool(self._set)
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '%s(%r)' % (
-            self.__class__.__name__,
-            self._headers
-        )
-
-
-class ETags(Container, Iterable):
-
-    """A set that can be used to check if one etag is present in a collection
-    of etags.
-    """
-
-    def __init__(self, strong_etags=None, weak_etags=None, star_tag=False):
-        self._strong = frozenset(not star_tag and strong_etags or ())
-        self._weak = frozenset(weak_etags or ())
-        self.star_tag = star_tag
-
-    def as_set(self, include_weak=False):
-        """Convert the `ETags` object into a python set.  Per default all the
-        weak etags are not part of this set."""
-        rv = set(self._strong)
-        if include_weak:
-            rv.update(self._weak)
-        return rv
-
-    def is_weak(self, etag):
-        """Check if an etag is weak."""
-        return etag in self._weak
-
-    def is_strong(self, etag):
-        """Check if an etag is strong."""
-        return etag in self._strong
-
-    def contains_weak(self, etag):
-        """Check if an etag is part of the set including weak and strong tags."""
-        return self.is_weak(etag) or self.contains(etag)
-
-    def contains(self, etag):
-        """Check if an etag is part of the set ignoring weak tags.
-        It is also possible to use the ``in`` operator.
-        """
-        if self.star_tag:
-            return True
-        return self.is_strong(etag)
-
-    def contains_raw(self, etag):
-        """When passed a quoted tag it will check if this tag is part of the
-        set.  If the tag is weak it is checked against weak and strong tags,
-        otherwise strong only."""
-        etag, weak = unquote_etag(etag)
-        if weak:
-            return self.contains_weak(etag)
-        return self.contains(etag)
-
-    def to_header(self):
-        """Convert the etags set into a HTTP header string."""
-        if self.star_tag:
-            return '*'
-        return ', '.join(
-            ['"%s"' % x for x in self._strong] +
-            ['W/"%s"' % x for x in self._weak]
-        )
-
-    def __call__(self, etag=None, data=None, include_weak=False):
-        if [etag, data].count(None) != 1:
-            raise TypeError('either tag or data required, but at least one')
-        if etag is None:
-            etag = generate_etag(data)
-        if include_weak:
-            if etag in self._weak:
-                return True
-        return etag in self._strong
-
-    def __bool__(self):
-        return bool(self.star_tag or self._strong or self._weak)
-
-    __nonzero__ = __bool__
-
-    def __str__(self):
-        return self.to_header()
-
-    def __iter__(self):
-        return iter(self._strong)
-
-    def __contains__(self, etag):
-        return self.contains(etag)
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, str(self))
-
-
-class IfRange(object):
-
-    """Very simple object that represents the `If-Range` header in parsed
-    form.  It will either have neither a etag or date or one of either but
-    never both.
-
-    .. versionadded:: 0.7
-    """
-
-    def __init__(self, etag=None, date=None):
-        #: The etag parsed and unquoted.  Ranges always operate on strong
-        #: etags so the weakness information is not necessary.
-        self.etag = etag
-        #: The date in parsed format or `None`.
-        self.date = date
-
-    def to_header(self):
-        """Converts the object back into an HTTP header."""
-        if self.date is not None:
-            return http_date(self.date)
-        if self.etag is not None:
-            return quote_etag(self.etag)
-        return ''
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, str(self))
-
-
-class Range(object):
-
-    """Represents a range header.  All the methods are only supporting bytes
-    as unit.  It does store multiple ranges but :meth:`range_for_length` will
-    only work if only one range is provided.
-
-    .. versionadded:: 0.7
-    """
-
-    def __init__(self, units, ranges):
-        #: The units of this range.  Usually "bytes".
-        self.units = units
-        #: A list of ``(begin, end)`` tuples for the range header provided.
-        #: The ranges are non-inclusive.
-        self.ranges = ranges
-
-    def range_for_length(self, length):
-        """If the range is for bytes, the length is not None and there is
-        exactly one range and it is satisfiable it returns a ``(start, stop)``
-        tuple, otherwise `None`.
-        """
-        if self.units != 'bytes' or length is None or len(self.ranges) != 1:
-            return None
-        start, end = self.ranges[0]
-        if end is None:
-            end = length
-            if start < 0:
-                start += length
-        if is_byte_range_valid(start, end, length):
-            return start, min(end, length)
-
-    def make_content_range(self, length):
-        """Creates a :class:`~werkzeug.datastructures.ContentRange` object
-        from the current range and given content length.
-        """
-        rng = self.range_for_length(length)
-        if rng is not None:
-            return ContentRange(self.units, rng[0], rng[1], length)
-
-    def to_header(self):
-        """Converts the object back into an HTTP header."""
-        ranges = []
-        for begin, end in self.ranges:
-            if end is None:
-                ranges.append(begin >= 0 and '%s-' % begin or str(begin))
-            else:
-                ranges.append('%s-%s' % (begin, end - 1))
-        return '%s=%s' % (self.units, ','.join(ranges))
-
-    def to_content_range_header(self, length):
-        """Converts the object into `Content-Range` HTTP header,
-        based on given length
-        """
-        range_for_length = self.range_for_length(length)
-        if range_for_length is not None:
-            return '%s %d-%d/%d' % (self.units,
-                                    range_for_length[0],
-                                    range_for_length[1] - 1, length)
-        return None
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, str(self))
-
-
-class ContentRange(object):
-
-    """Represents the content range header.
-
-    .. versionadded:: 0.7
-    """
-
-    def __init__(self, units, start, stop, length=None, on_update=None):
-        assert is_byte_range_valid(start, stop, length), \
-            'Bad range provided'
-        self.on_update = on_update
-        self.set(start, stop, length, units)
-
-    def _callback_property(name):
-        def fget(self):
-            return getattr(self, name)
-
-        def fset(self, value):
-            setattr(self, name, value)
-            if self.on_update is not None:
-                self.on_update(self)
-        return property(fget, fset)
-
-    #: The units to use, usually "bytes"
-    units = _callback_property('_units')
-    #: The start point of the range or `None`.
-    start = _callback_property('_start')
-    #: The stop point of the range (non-inclusive) or `None`.  Can only be
-    #: `None` if also start is `None`.
-    stop = _callback_property('_stop')
-    #: The length of the range or `None`.
-    length = _callback_property('_length')
-
-    def set(self, start, stop, length=None, units='bytes'):
-        """Simple method to update the ranges."""
-        assert is_byte_range_valid(start, stop, length), \
-            'Bad range provided'
-        self._units = units
-        self._start = start
-        self._stop = stop
-        self._length = length
-        if self.on_update is not None:
-            self.on_update(self)
-
-    def unset(self):
-        """Sets the units to `None` which indicates that the header should
-        no longer be used.
-        """
-        self.set(None, None, units=None)
-
-    def to_header(self):
-        if self.units is None:
-            return ''
-        if self.length is None:
-            length = '*'
-        else:
-            length = self.length
-        if self.start is None:
-            return '%s */%s' % (self.units, length)
-        return '%s %s-%s/%s' % (
-            self.units,
-            self.start,
-            self.stop - 1,
-            length
-        )
-
-    def __nonzero__(self):
-        return self.units is not None
-
-    __bool__ = __nonzero__
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, str(self))
-
-
-class Authorization(ImmutableDictMixin, dict):
-
-    """Represents an `Authorization` header sent by the client.  You should
-    not create this kind of object yourself but use it when it's returned by
-    the `parse_authorization_header` function.
-
-    This object is a dict subclass and can be altered by setting dict items
-    but it should be considered immutable as it's returned by the client and
-    not meant for modifications.
-
-    .. versionchanged:: 0.5
-       This object became immutable.
-    """
-
-    def __init__(self, auth_type, data=None):
-        dict.__init__(self, data or {})
-        self.type = auth_type
-
-    username = property(lambda x: x.get('username'), doc='''
-        The username transmitted.  This is set for both basic and digest
-        auth all the time.''')
-    password = property(lambda x: x.get('password'), doc='''
-        When the authentication type is basic this is the password
-        transmitted by the client, else `None`.''')
-    realm = property(lambda x: x.get('realm'), doc='''
-        This is the server realm sent back for HTTP digest auth.''')
-    nonce = property(lambda x: x.get('nonce'), doc='''
-        The nonce the server sent for digest auth, sent back by the client.
-        A nonce should be unique for every 401 response for HTTP digest
-        auth.''')
-    uri = property(lambda x: x.get('uri'), doc='''
-        The URI from Request-URI of the Request-Line; duplicated because
-        proxies are allowed to change the Request-Line in transit.  HTTP
-        digest auth only.''')
-    nc = property(lambda x: x.get('nc'), doc='''
-        The nonce count value transmitted by clients if a qop-header is
-        also transmitted.  HTTP digest auth only.''')
-    cnonce = property(lambda x: x.get('cnonce'), doc='''
-        If the server sent a qop-header in the ``WWW-Authenticate``
-        header, the client has to provide this value for HTTP digest auth.
-        See the RFC for more details.''')
-    response = property(lambda x: x.get('response'), doc='''
-        A string of 32 hex digits computed as defined in RFC 2617, which
-        proves that the user knows a password.  Digest auth only.''')
-    opaque = property(lambda x: x.get('opaque'), doc='''
-        The opaque header from the server returned unchanged by the client.
-        It is recommended that this string be base64 or hexadecimal data.
-        Digest auth only.''')
-    qop = property(lambda x: x.get('qop'), doc='''
-        Indicates what "quality of protection" the client has applied to
-        the message for HTTP digest auth. Note that this is a single token,
-        not a quoted list of alternatives as in WWW-Authenticate.''')
-
-
-class WWWAuthenticate(UpdateDictMixin, dict):
-
-    """Provides simple access to `WWW-Authenticate` headers."""
-
-    #: list of keys that require quoting in the generated header
-    _require_quoting = frozenset(['domain', 'nonce', 'opaque', 'realm', 'qop'])
-
-    def __init__(self, auth_type=None, values=None, on_update=None):
-        dict.__init__(self, values or ())
-        if auth_type:
-            self['__auth_type__'] = auth_type
-        self.on_update = on_update
-
-    def set_basic(self, realm='authentication required'):
-        """Clear the auth info and enable basic auth."""
-        dict.clear(self)
-        dict.update(self, {'__auth_type__': 'basic', 'realm': realm})
-        if self.on_update:
-            self.on_update(self)
-
-    def set_digest(self, realm, nonce, qop=('auth',), opaque=None,
-                   algorithm=None, stale=False):
-        """Clear the auth info and enable digest auth."""
-        d = {
-            '__auth_type__':    'digest',
-            'realm':            realm,
-            'nonce':            nonce,
-            'qop':              dump_header(qop)
-        }
-        if stale:
-            d['stale'] = 'TRUE'
-        if opaque is not None:
-            d['opaque'] = opaque
-        if algorithm is not None:
-            d['algorithm'] = algorithm
-        dict.clear(self)
-        dict.update(self, d)
-        if self.on_update:
-            self.on_update(self)
-
-    def to_header(self):
-        """Convert the stored values into a WWW-Authenticate header."""
-        d = dict(self)
-        auth_type = d.pop('__auth_type__', None) or 'basic'
-        return '%s %s' % (auth_type.title(), ', '.join([
-            '%s=%s' % (key, quote_header_value(value,
-                                               allow_token=key not in self._require_quoting))
-            for key, value in iteritems(d)
-        ]))
-
-    def __str__(self):
-        return self.to_header()
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self.to_header()
-        )
-
-    def auth_property(name, doc=None):
-        """A static helper function for subclasses to add extra authentication
-        system properties onto a class::
-
-            class FooAuthenticate(WWWAuthenticate):
-                special_realm = auth_property('special_realm')
-
-        For more information have a look at the sourcecode to see how the
-        regular properties (:attr:`realm` etc.) are implemented.
-        """
-
-        def _set_value(self, value):
-            if value is None:
-                self.pop(name, None)
-            else:
-                self[name] = str(value)
-        return property(lambda x: x.get(name), _set_value, doc=doc)
-
-    def _set_property(name, doc=None):
-        def fget(self):
-            def on_update(header_set):
-                if not header_set and name in self:
-                    del self[name]
-                elif header_set:
-                    self[name] = header_set.to_header()
-            return parse_set_header(self.get(name), on_update)
-        return property(fget, doc=doc)
-
-    type = auth_property('__auth_type__', doc='''
-        The type of the auth mechanism.  HTTP currently specifies
-        `Basic` and `Digest`.''')
-    realm = auth_property('realm', doc='''
-        A string to be displayed to users so they know which username and
-        password to use.  This string should contain at least the name of
-        the host performing the authentication and might additionally
-        indicate the collection of users who might have access.''')
-    domain = _set_property('domain', doc='''
-        A list of URIs that define the protection space.  If a URI is an
-        absolute path, it is relative to the canonical root URL of the
-        server being accessed.''')
-    nonce = auth_property('nonce', doc='''
-        A server-specified data string which should be uniquely generated
-        each time a 401 response is made.  It is recommended that this
-        string be base64 or hexadecimal data.''')
-    opaque = auth_property('opaque', doc='''
-        A string of data, specified by the server, which should be returned
-        by the client unchanged in the Authorization header of subsequent
-        requests with URIs in the same protection space.  It is recommended
-        that this string be base64 or hexadecimal data.''')
-    algorithm = auth_property('algorithm', doc='''
-        A string indicating a pair of algorithms used to produce the digest
-        and a checksum.  If this is not present it is assumed to be "MD5".
-        If the algorithm is not understood, the challenge should be ignored
-        (and a different one used, if there is more than one).''')
-    qop = _set_property('qop', doc='''
-        A set of quality-of-privacy directives such as auth and auth-int.''')
-
-    def _get_stale(self):
-        val = self.get('stale')
-        if val is not None:
-            return val.lower() == 'true'
-
-    def _set_stale(self, value):
-        if value is None:
-            self.pop('stale', None)
-        else:
-            self['stale'] = value and 'TRUE' or 'FALSE'
-    stale = property(_get_stale, _set_stale, doc='''
-        A flag, indicating that the previous request from the client was
-        rejected because the nonce value was stale.''')
-    del _get_stale, _set_stale
-
-    # make auth_property a staticmethod so that subclasses of
-    # `WWWAuthenticate` can use it for new properties.
-    auth_property = staticmethod(auth_property)
-    del _set_property
-
-
-class FileStorage(object):
-
-    """The :class:`FileStorage` class is a thin wrapper over incoming files.
-    It is used by the request object to represent uploaded files.  All the
-    attributes of the wrapper stream are proxied by the file storage so
-    it's possible to do ``storage.read()`` instead of the long form
-    ``storage.stream.read()``.
-    """
-
-    def __init__(self, stream=None, filename=None, name=None,
-                 content_type=None, content_length=None,
-                 headers=None):
-        self.name = name
-        self.stream = stream or _empty_stream
-
-        # if no filename is provided we can attempt to get the filename
-        # from the stream object passed.  There we have to be careful to
-        # skip things like <fdopen>, <stderr> etc.  Python marks these
-        # special filenames with angular brackets.
-        if filename is None:
-            filename = getattr(stream, 'name', None)
-            s = make_literal_wrapper(filename)
-            if filename and filename[0] == s('<') and filename[-1] == s('>'):
-                filename = None
-
-            # On Python 3 we want to make sure the filename is always unicode.
-            # This might not be if the name attribute is bytes due to the
-            # file being opened from the bytes API.
-            if not PY2 and isinstance(filename, bytes):
-                filename = filename.decode(get_filesystem_encoding(),
-                                           'replace')
-
-        self.filename = filename
-        if headers is None:
-            headers = Headers()
-        self.headers = headers
-        if content_type is not None:
-            headers['Content-Type'] = content_type
-        if content_length is not None:
-            headers['Content-Length'] = str(content_length)
-
-    def _parse_content_type(self):
-        if not hasattr(self, '_parsed_content_type'):
-            self._parsed_content_type = \
-                parse_options_header(self.content_type)
-
-    @property
-    def content_type(self):
-        """The content-type sent in the header.  Usually not available"""
-        return self.headers.get('content-type')
-
-    @property
-    def content_length(self):
-        """The content-length sent in the header.  Usually not available"""
-        return int(self.headers.get('content-length') or 0)
-
-    @property
-    def mimetype(self):
-        """Like :attr:`content_type`, but without parameters (eg, without
-        charset, type etc.) and always lowercase.  For example if the content
-        type is ``text/HTML; charset=utf-8`` the mimetype would be
-        ``'text/html'``.
-
-        .. versionadded:: 0.7
-        """
-        self._parse_content_type()
-        return self._parsed_content_type[0].lower()
-
-    @property
-    def mimetype_params(self):
-        """The mimetype parameters as dict.  For example if the content
-        type is ``text/html; charset=utf-8`` the params would be
-        ``{'charset': 'utf-8'}``.
-
-        .. versionadded:: 0.7
-        """
-        self._parse_content_type()
-        return self._parsed_content_type[1]
-
-    def save(self, dst, buffer_size=16384):
-        """Save the file to a destination path or file object.  If the
-        destination is a file object you have to close it yourself after the
-        call.  The buffer size is the number of bytes held in memory during
-        the copy process.  It defaults to 16KB.
-
-        For secure file saving also have a look at :func:`secure_filename`.
-
-        :param dst: a filename or open file object the uploaded file
-                    is saved to.
-        :param buffer_size: the size of the buffer.  This works the same as
-                            the `length` parameter of
-                            :func:`shutil.copyfileobj`.
-        """
-        from shutil import copyfileobj
-        close_dst = False
-        if isinstance(dst, string_types):
-            dst = open(dst, 'wb')
-            close_dst = True
-        try:
-            copyfileobj(self.stream, dst, buffer_size)
-        finally:
-            if close_dst:
-                dst.close()
-
-    def close(self):
-        """Close the underlying file if possible."""
-        try:
-            self.stream.close()
-        except Exception:
-            pass
-
-    def __nonzero__(self):
-        return bool(self.filename)
-    __bool__ = __nonzero__
-
-    def __getattr__(self, name):
-        return getattr(self.stream, name)
-
-    def __iter__(self):
-        return iter(self.stream)
-
-    def __repr__(self):
-        return '<%s: %r (%r)>' % (
-            self.__class__.__name__,
-            self.filename,
-            self.content_type
-        )
-
-
-# circular dependencies
-from werkzeug.http import dump_options_header, dump_header, generate_etag, \
-    quote_header_value, parse_set_header, unquote_etag, quote_etag, \
-    parse_options_header, http_date, is_byte_range_valid
-from werkzeug import exceptions
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__init__.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__init__.py
deleted file mode 100644
index 14fe19352..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__init__.py
+++ /dev/null
@@ -1,470 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.debug
-    ~~~~~~~~~~~~~~
-
-    WSGI application traceback debugger.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import re
-import sys
-import uuid
-import json
-import time
-import getpass
-import hashlib
-import mimetypes
-from itertools import chain
-from os.path import join, dirname, basename, isfile
-from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
-from werkzeug.http import parse_cookie
-from werkzeug.debug.tbtools import get_current_traceback, render_console_html
-from werkzeug.debug.console import Console
-from werkzeug.security import gen_salt
-from werkzeug._internal import _log
-from werkzeug._compat import text_type
-
-
-# DEPRECATED
-#: import this here because it once was documented as being available
-#: from this module.  In case there are users left ...
-from werkzeug.debug.repr import debug_repr  # noqa
-
-
-# A week
-PIN_TIME = 60 * 60 * 24 * 7
-
-
-def hash_pin(pin):
-    if isinstance(pin, text_type):
-        pin = pin.encode('utf-8', 'replace')
-    return hashlib.md5(pin + b'shittysalt').hexdigest()[:12]
-
-
-_machine_id = None
-
-
-def get_machine_id():
-    global _machine_id
-    rv = _machine_id
-    if rv is not None:
-        return rv
-
-    def _generate():
-        # Potential sources of secret information on linux.  The machine-id
-        # is stable across boots, the boot id is not
-        for filename in '/etc/machine-id', '/proc/sys/kernel/random/boot_id':
-            try:
-                with open(filename, 'rb') as f:
-                    return f.readline().strip()
-            except IOError:
-                continue
-
-        # On OS X we can use the computer's serial number assuming that
-        # ioreg exists and can spit out that information.
-        try:
-            # Also catch import errors: subprocess may not be available, e.g.
-            # Google App Engine
-            # See https://github.com/pallets/werkzeug/issues/925
-            from subprocess import Popen, PIPE
-            dump = Popen(['ioreg', '-c', 'IOPlatformExpertDevice', '-d', '2'],
-                         stdout=PIPE).communicate()[0]
-            match = re.search(b'"serial-number" = <([^>]+)', dump)
-            if match is not None:
-                return match.group(1)
-        except (OSError, ImportError):
-            pass
-
-        # On Windows we can use winreg to get the machine guid
-        wr = None
-        try:
-            import winreg as wr
-        except ImportError:
-            try:
-                import _winreg as wr
-            except ImportError:
-                pass
-        if wr is not None:
-            try:
-                with wr.OpenKey(wr.HKEY_LOCAL_MACHINE,
-                                'SOFTWARE\\Microsoft\\Cryptography', 0,
-                                wr.KEY_READ | wr.KEY_WOW64_64KEY) as rk:
-                    machineGuid, wrType = wr.QueryValueEx(rk, 'MachineGuid')
-                    if (wrType == wr.REG_SZ):
-                        return machineGuid.encode('utf-8')
-                    else:
-                        return machineGuid
-            except WindowsError:
-                pass
-
-    _machine_id = rv = _generate()
-    return rv
-
-
-class _ConsoleFrame(object):
-
-    """Helper class so that we can reuse the frame console code for the
-    standalone console.
-    """
-
-    def __init__(self, namespace):
-        self.console = Console(namespace)
-        self.id = 0
-
-
-def get_pin_and_cookie_name(app):
-    """Given an application object this returns a semi-stable 9 digit pin
-    code and a random key.  The hope is that this is stable between
-    restarts to not make debugging particularly frustrating.  If the pin
-    was forcefully disabled this returns `None`.
-
-    Second item in the resulting tuple is the cookie name for remembering.
-    """
-    pin = os.environ.get('WERKZEUG_DEBUG_PIN')
-    rv = None
-    num = None
-
-    # Pin was explicitly disabled
-    if pin == 'off':
-        return None, None
-
-    # Pin was provided explicitly
-    if pin is not None and pin.replace('-', '').isdigit():
-        # If there are separators in the pin, return it directly
-        if '-' in pin:
-            rv = pin
-        else:
-            num = pin
-
-    modname = getattr(app, '__module__',
-                      getattr(app.__class__, '__module__'))
-
-    try:
-        # `getpass.getuser()` imports the `pwd` module,
-        # which does not exist in the Google App Engine sandbox.
-        username = getpass.getuser()
-    except ImportError:
-        username = None
-
-    mod = sys.modules.get(modname)
-
-    # This information only exists to make the cookie unique on the
-    # computer, not as a security feature.
-    probably_public_bits = [
-        username,
-        modname,
-        getattr(app, '__name__', getattr(app.__class__, '__name__')),
-        getattr(mod, '__file__', None),
-    ]
-
-    # This information is here to make it harder for an attacker to
-    # guess the cookie name.  They are unlikely to be contained anywhere
-    # within the unauthenticated debug page.
-    private_bits = [
-        str(uuid.getnode()),
-        get_machine_id(),
-    ]
-
-    h = hashlib.md5()
-    for bit in chain(probably_public_bits, private_bits):
-        if not bit:
-            continue
-        if isinstance(bit, text_type):
-            bit = bit.encode('utf-8')
-        h.update(bit)
-    h.update(b'cookiesalt')
-
-    cookie_name = '__wzd' + h.hexdigest()[:20]
-
-    # If we need to generate a pin we salt it a bit more so that we don't
-    # end up with the same value and generate out 9 digits
-    if num is None:
-        h.update(b'pinsalt')
-        num = ('%09d' % int(h.hexdigest(), 16))[:9]
-
-    # Format the pincode in groups of digits for easier remembering if
-    # we don't have a result yet.
-    if rv is None:
-        for group_size in 5, 4, 3:
-            if len(num) % group_size == 0:
-                rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
-                              for x in range(0, len(num), group_size))
-                break
-        else:
-            rv = num
-
-    return rv, cookie_name
-
-
-class DebuggedApplication(object):
-    """Enables debugging support for a given application::
-
-        from werkzeug.debug import DebuggedApplication
-        from myapp import app
-        app = DebuggedApplication(app, evalex=True)
-
-    The `evalex` keyword argument allows evaluating expressions in a
-    traceback's frame context.
-
-    .. versionadded:: 0.9
-       The `lodgeit_url` parameter was deprecated.
-
-    :param app: the WSGI application to run debugged.
-    :param evalex: enable exception evaluation feature (interactive
-                   debugging).  This requires a non-forking server.
-    :param request_key: The key that points to the request object in ths
-                        environment.  This parameter is ignored in current
-                        versions.
-    :param console_path: the URL for a general purpose console.
-    :param console_init_func: the function that is executed before starting
-                              the general purpose console.  The return value
-                              is used as initial namespace.
-    :param show_hidden_frames: by default hidden traceback frames are skipped.
-                               You can show them by setting this parameter
-                               to `True`.
-    :param pin_security: can be used to disable the pin based security system.
-    :param pin_logging: enables the logging of the pin system.
-    """
-
-    def __init__(self, app, evalex=False, request_key='werkzeug.request',
-                 console_path='/console', console_init_func=None,
-                 show_hidden_frames=False, lodgeit_url=None,
-                 pin_security=True, pin_logging=True):
-        if lodgeit_url is not None:
-            from warnings import warn
-            warn(DeprecationWarning('Werkzeug now pastes into gists.'))
-        if not console_init_func:
-            console_init_func = None
-        self.app = app
-        self.evalex = evalex
-        self.frames = {}
-        self.tracebacks = {}
-        self.request_key = request_key
-        self.console_path = console_path
-        self.console_init_func = console_init_func
-        self.show_hidden_frames = show_hidden_frames
-        self.secret = gen_salt(20)
-        self._failed_pin_auth = 0
-
-        self.pin_logging = pin_logging
-        if pin_security:
-            # Print out the pin for the debugger on standard out.
-            if os.environ.get('WERKZEUG_RUN_MAIN') == 'true' and \
-               pin_logging:
-                _log('warning', ' * Debugger is active!')
-                if self.pin is None:
-                    _log('warning', ' * Debugger PIN disabled.  '
-                         'DEBUGGER UNSECURED!')
-                else:
-                    _log('info', ' * Debugger PIN: %s' % self.pin)
-        else:
-            self.pin = None
-
-    def _get_pin(self):
-        if not hasattr(self, '_pin'):
-            self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
-        return self._pin
-
-    def _set_pin(self, value):
-        self._pin = value
-
-    pin = property(_get_pin, _set_pin)
-    del _get_pin, _set_pin
-
-    @property
-    def pin_cookie_name(self):
-        """The name of the pin cookie."""
-        if not hasattr(self, '_pin_cookie'):
-            self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
-        return self._pin_cookie
-
-    def debug_application(self, environ, start_response):
-        """Run the application and conserve the traceback frames."""
-        app_iter = None
-        try:
-            app_iter = self.app(environ, start_response)
-            for item in app_iter:
-                yield item
-            if hasattr(app_iter, 'close'):
-                app_iter.close()
-        except Exception:
-            if hasattr(app_iter, 'close'):
-                app_iter.close()
-            traceback = get_current_traceback(
-                skip=1, show_hidden_frames=self.show_hidden_frames,
-                ignore_system_exceptions=True)
-            for frame in traceback.frames:
-                self.frames[frame.id] = frame
-            self.tracebacks[traceback.id] = traceback
-
-            try:
-                start_response('500 INTERNAL SERVER ERROR', [
-                    ('Content-Type', 'text/html; charset=utf-8'),
-                    # Disable Chrome's XSS protection, the debug
-                    # output can cause false-positives.
-                    ('X-XSS-Protection', '0'),
-                ])
-            except Exception:
-                # if we end up here there has been output but an error
-                # occurred.  in that situation we can do nothing fancy any
-                # more, better log something into the error log and fall
-                # back gracefully.
-                environ['wsgi.errors'].write(
-                    'Debugging middleware caught exception in streamed '
-                    'response at a point where response headers were already '
-                    'sent.\n')
-            else:
-                is_trusted = bool(self.check_pin_trust(environ))
-                yield traceback.render_full(evalex=self.evalex,
-                                            evalex_trusted=is_trusted,
-                                            secret=self.secret) \
-                    .encode('utf-8', 'replace')
-
-            traceback.log(environ['wsgi.errors'])
-
-    def execute_command(self, request, command, frame):
-        """Execute a command in a console."""
-        return Response(frame.console.eval(command), mimetype='text/html')
-
-    def display_console(self, request):
-        """Display a standalone shell."""
-        if 0 not in self.frames:
-            if self.console_init_func is None:
-                ns = {}
-            else:
-                ns = dict(self.console_init_func())
-            ns.setdefault('app', self.app)
-            self.frames[0] = _ConsoleFrame(ns)
-        is_trusted = bool(self.check_pin_trust(request.environ))
-        return Response(render_console_html(secret=self.secret,
-                                            evalex_trusted=is_trusted),
-                        mimetype='text/html')
-
-    def paste_traceback(self, request, traceback):
-        """Paste the traceback and return a JSON response."""
-        rv = traceback.paste()
-        return Response(json.dumps(rv), mimetype='application/json')
-
-    def get_resource(self, request, filename):
-        """Return a static resource from the shared folder."""
-        filename = join(dirname(__file__), 'shared', basename(filename))
-        if isfile(filename):
-            mimetype = mimetypes.guess_type(filename)[0] \
-                or 'application/octet-stream'
-            f = open(filename, 'rb')
-            try:
-                return Response(f.read(), mimetype=mimetype)
-            finally:
-                f.close()
-        return Response('Not Found', status=404)
-
-    def check_pin_trust(self, environ):
-        """Checks if the request passed the pin test.  This returns `True` if the
-        request is trusted on a pin/cookie basis and returns `False` if not.
-        Additionally if the cookie's stored pin hash is wrong it will return
-        `None` so that appropriate action can be taken.
-        """
-        if self.pin is None:
-            return True
-        val = parse_cookie(environ).get(self.pin_cookie_name)
-        if not val or '|' not in val:
-            return False
-        ts, pin_hash = val.split('|', 1)
-        if not ts.isdigit():
-            return False
-        if pin_hash != hash_pin(self.pin):
-            return None
-        return (time.time() - PIN_TIME) < int(ts)
-
-    def _fail_pin_auth(self):
-        time.sleep(self._failed_pin_auth > 5 and 5.0 or 0.5)
-        self._failed_pin_auth += 1
-
-    def pin_auth(self, request):
-        """Authenticates with the pin."""
-        exhausted = False
-        auth = False
-        trust = self.check_pin_trust(request.environ)
-
-        # If the trust return value is `None` it means that the cookie is
-        # set but the stored pin hash value is bad.  This means that the
-        # pin was changed.  In this case we count a bad auth and unset the
-        # cookie.  This way it becomes harder to guess the cookie name
-        # instead of the pin as we still count up failures.
-        bad_cookie = False
-        if trust is None:
-            self._fail_pin_auth()
-            bad_cookie = True
-
-        # If we're trusted, we're authenticated.
-        elif trust:
-            auth = True
-
-        # If we failed too many times, then we're locked out.
-        elif self._failed_pin_auth > 10:
-            exhausted = True
-
-        # Otherwise go through pin based authentication
-        else:
-            entered_pin = request.args.get('pin')
-            if entered_pin.strip().replace('-', '') == \
-               self.pin.replace('-', ''):
-                self._failed_pin_auth = 0
-                auth = True
-            else:
-                self._fail_pin_auth()
-
-        rv = Response(json.dumps({
-            'auth': auth,
-            'exhausted': exhausted,
-        }), mimetype='application/json')
-        if auth:
-            rv.set_cookie(self.pin_cookie_name, '%s|%s' % (
-                int(time.time()),
-                hash_pin(self.pin)
-            ), httponly=True)
-        elif bad_cookie:
-            rv.delete_cookie(self.pin_cookie_name)
-        return rv
-
-    def log_pin_request(self):
-        """Log the pin if needed."""
-        if self.pin_logging and self.pin is not None:
-            _log('info', ' * To enable the debugger you need to '
-                 'enter the security pin:')
-            _log('info', ' * Debugger pin code: %s' % self.pin)
-        return Response('')
-
-    def __call__(self, environ, start_response):
-        """Dispatch the requests."""
-        # important: don't ever access a function here that reads the incoming
-        # form data!  Otherwise the application won't have access to that data
-        # any more!
-        request = Request(environ)
-        response = self.debug_application
-        if request.args.get('__debugger__') == 'yes':
-            cmd = request.args.get('cmd')
-            arg = request.args.get('f')
-            secret = request.args.get('s')
-            traceback = self.tracebacks.get(request.args.get('tb', type=int))
-            frame = self.frames.get(request.args.get('frm', type=int))
-            if cmd == 'resource' and arg:
-                response = self.get_resource(request, arg)
-            elif cmd == 'paste' and traceback is not None and \
-                    secret == self.secret:
-                response = self.paste_traceback(request, traceback)
-            elif cmd == 'pinauth' and secret == self.secret:
-                response = self.pin_auth(request)
-            elif cmd == 'printpin' and secret == self.secret:
-                response = self.log_pin_request()
-            elif self.evalex and cmd is not None and frame is not None \
-                    and self.secret == secret and \
-                    self.check_pin_trust(environ):
-                response = self.execute_command(request, cmd, frame)
-        elif self.evalex and self.console_path is not None and \
-                request.path == self.console_path:
-            response = self.display_console(request)
-        return response(environ, start_response)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/__init__.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 6b98f4018..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/__init__.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/console.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/console.cpython-35.pyc
deleted file mode 100644
index 91c6c2279..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/console.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/repr.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/repr.cpython-35.pyc
deleted file mode 100644
index ebe2b64ec..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/repr.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/tbtools.cpython-35.pyc b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/tbtools.cpython-35.pyc
deleted file mode 100644
index 7091d6a69..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/__pycache__/tbtools.cpython-35.pyc and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/console.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/console.py
deleted file mode 100644
index 30e89063f..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/console.py
+++ /dev/null
@@ -1,215 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.debug.console
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    Interactive console support.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD.
-"""
-import sys
-import code
-from types import CodeType
-
-from werkzeug.utils import escape
-from werkzeug.local import Local
-from werkzeug.debug.repr import debug_repr, dump, helper
-
-
-_local = Local()
-
-
-class HTMLStringO(object):
-
-    """A StringO version that HTML escapes on write."""
-
-    def __init__(self):
-        self._buffer = []
-
-    def isatty(self):
-        return False
-
-    def close(self):
-        pass
-
-    def flush(self):
-        pass
-
-    def seek(self, n, mode=0):
-        pass
-
-    def readline(self):
-        if len(self._buffer) == 0:
-            return ''
-        ret = self._buffer[0]
-        del self._buffer[0]
-        return ret
-
-    def reset(self):
-        val = ''.join(self._buffer)
-        del self._buffer[:]
-        return val
-
-    def _write(self, x):
-        if isinstance(x, bytes):
-            x = x.decode('utf-8', 'replace')
-        self._buffer.append(x)
-
-    def write(self, x):
-        self._write(escape(x))
-
-    def writelines(self, x):
-        self._write(escape(''.join(x)))
-
-
-class ThreadedStream(object):
-
-    """Thread-local wrapper for sys.stdout for the interactive console."""
-
-    def push():
-        if not isinstance(sys.stdout, ThreadedStream):
-            sys.stdout = ThreadedStream()
-        _local.stream = HTMLStringO()
-    push = staticmethod(push)
-
-    def fetch():
-        try:
-            stream = _local.stream
-        except AttributeError:
-            return ''
-        return stream.reset()
-    fetch = staticmethod(fetch)
-
-    def displayhook(obj):
-        try:
-            stream = _local.stream
-        except AttributeError:
-            return _displayhook(obj)
-        # stream._write bypasses escaping as debug_repr is
-        # already generating HTML for us.
-        if obj is not None:
-            _local._current_ipy.locals['_'] = obj
-            stream._write(debug_repr(obj))
-    displayhook = staticmethod(displayhook)
-
-    def __setattr__(self, name, value):
-        raise AttributeError('read only attribute %s' % name)
-
-    def __dir__(self):
-        return dir(sys.__stdout__)
-
-    def __getattribute__(self, name):
-        if name == '__members__':
-            return dir(sys.__stdout__)
-        try:
-            stream = _local.stream
-        except AttributeError:
-            stream = sys.__stdout__
-        return getattr(stream, name)
-
-    def __repr__(self):
-        return repr(sys.__stdout__)
-
-
-# add the threaded stream as display hook
-_displayhook = sys.displayhook
-sys.displayhook = ThreadedStream.displayhook
-
-
-class _ConsoleLoader(object):
-
-    def __init__(self):
-        self._storage = {}
-
-    def register(self, code, source):
-        self._storage[id(code)] = source
-        # register code objects of wrapped functions too.
-        for var in code.co_consts:
-            if isinstance(var, CodeType):
-                self._storage[id(var)] = source
-
-    def get_source_by_code(self, code):
-        try:
-            return self._storage[id(code)]
-        except KeyError:
-            pass
-
-
-def _wrap_compiler(console):
-    compile = console.compile
-
-    def func(source, filename, symbol):
-        code = compile(source, filename, symbol)
-        console.loader.register(code, source)
-        return code
-    console.compile = func
-
-
-class _InteractiveConsole(code.InteractiveInterpreter):
-
-    def __init__(self, globals, locals):
-        code.InteractiveInterpreter.__init__(self, locals)
-        self.globals = dict(globals)
-        self.globals['dump'] = dump
-        self.globals['help'] = helper
-        self.globals['__loader__'] = self.loader = _ConsoleLoader()
-        self.more = False
-        self.buffer = []
-        _wrap_compiler(self)
-
-    def runsource(self, source):
-        source = source.rstrip() + '\n'
-        ThreadedStream.push()
-        prompt = self.more and '... ' or '>>> '
-        try:
-            source_to_eval = ''.join(self.buffer + [source])
-            if code.InteractiveInterpreter.runsource(self,
-                                                     source_to_eval, '<debugger>', 'single'):
-                self.more = True
-                self.buffer.append(source)
-            else:
-                self.more = False
-                del self.buffer[:]
-        finally:
-            output = ThreadedStream.fetch()
-        return prompt + escape(source) + output
-
-    def runcode(self, code):
-        try:
-            eval(code, self.globals, self.locals)
-        except Exception:
-            self.showtraceback()
-
-    def showtraceback(self):
-        from werkzeug.debug.tbtools import get_current_traceback
-        tb = get_current_traceback(skip=1)
-        sys.stdout._write(tb.render_summary())
-
-    def showsyntaxerror(self, filename=None):
-        from werkzeug.debug.tbtools import get_current_traceback
-        tb = get_current_traceback(skip=4)
-        sys.stdout._write(tb.render_summary())
-
-    def write(self, data):
-        sys.stdout.write(data)
-
-
-class Console(object):
-
-    """An interactive console."""
-
-    def __init__(self, globals=None, locals=None):
-        if locals is None:
-            locals = {}
-        if globals is None:
-            globals = {}
-        self._ipy = _InteractiveConsole(globals, locals)
-
-    def eval(self, code):
-        _local._current_ipy = self._ipy
-        old_sys_stdout = sys.stdout
-        try:
-            return self._ipy.runsource(code)
-        finally:
-            sys.stdout = old_sys_stdout
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/repr.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/repr.py
deleted file mode 100644
index 0a024576e..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/repr.py
+++ /dev/null
@@ -1,280 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.debug.repr
-    ~~~~~~~~~~~~~~~~~~~
-
-    This module implements object representations for debugging purposes.
-    Unlike the default repr these reprs expose a lot more information and
-    produce HTML instead of ASCII.
-
-    Together with the CSS and JavaScript files of the debugger this gives
-    a colorful and more compact output.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD.
-"""
-import sys
-import re
-import codecs
-from traceback import format_exception_only
-try:
-    from collections import deque
-except ImportError:  # pragma: no cover
-    deque = None
-from werkzeug.utils import escape
-from werkzeug._compat import iteritems, PY2, text_type, integer_types, \
-    string_types
-
-
-missing = object()
-_paragraph_re = re.compile(r'(?:\r\n|\r|\n){2,}')
-RegexType = type(_paragraph_re)
-
-
-HELP_HTML = '''\
-<div class=box>
-  <h3>%(title)s</h3>
-  <pre class=help>%(text)s</pre>
-</div>\
-'''
-OBJECT_DUMP_HTML = '''\
-<div class=box>
-  <h3>%(title)s</h3>
-  %(repr)s
-  <table>%(items)s</table>
-</div>\
-'''
-
-
-def debug_repr(obj):
-    """Creates a debug repr of an object as HTML unicode string."""
-    return DebugReprGenerator().repr(obj)
-
-
-def dump(obj=missing):
-    """Print the object details to stdout._write (for the interactive
-    console of the web debugger.
-    """
-    gen = DebugReprGenerator()
-    if obj is missing:
-        rv = gen.dump_locals(sys._getframe(1).f_locals)
-    else:
-        rv = gen.dump_object(obj)
-    sys.stdout._write(rv)
-
-
-class _Helper(object):
-
-    """Displays an HTML version of the normal help, for the interactive
-    debugger only because it requires a patched sys.stdout.
-    """
-
-    def __repr__(self):
-        return 'Type help(object) for help about object.'
-
-    def __call__(self, topic=None):
-        if topic is None:
-            sys.stdout._write('<span class=help>%s</span>' % repr(self))
-            return
-        import pydoc
-        pydoc.help(topic)
-        rv = sys.stdout.reset()
-        if isinstance(rv, bytes):
-            rv = rv.decode('utf-8', 'ignore')
-        paragraphs = _paragraph_re.split(rv)
-        if len(paragraphs) > 1:
-            title = paragraphs[0]
-            text = '\n\n'.join(paragraphs[1:])
-        else:  # pragma: no cover
-            title = 'Help'
-            text = paragraphs[0]
-        sys.stdout._write(HELP_HTML % {'title': title, 'text': text})
-
-
-helper = _Helper()
-
-
-def _add_subclass_info(inner, obj, base):
-    if isinstance(base, tuple):
-        for base in base:
-            if type(obj) is base:
-                return inner
-    elif type(obj) is base:
-        return inner
-    module = ''
-    if obj.__class__.__module__ not in ('__builtin__', 'exceptions'):
-        module = '<span class="module">%s.</span>' % obj.__class__.__module__
-    return '%s%s(%s)' % (module, obj.__class__.__name__, inner)
-
-
-class DebugReprGenerator(object):
-
-    def __init__(self):
-        self._stack = []
-
-    def _sequence_repr_maker(left, right, base=object(), limit=8):
-        def proxy(self, obj, recursive):
-            if recursive:
-                return _add_subclass_info(left + '...' + right, obj, base)
-            buf = [left]
-            have_extended_section = False
-            for idx, item in enumerate(obj):
-                if idx:
-                    buf.append(', ')
-                if idx == limit:
-                    buf.append('<span class="extended">')
-                    have_extended_section = True
-                buf.append(self.repr(item))
-            if have_extended_section:
-                buf.append('</span>')
-            buf.append(right)
-            return _add_subclass_info(u''.join(buf), obj, base)
-        return proxy
-
-    list_repr = _sequence_repr_maker('[', ']', list)
-    tuple_repr = _sequence_repr_maker('(', ')', tuple)
-    set_repr = _sequence_repr_maker('set([', '])', set)
-    frozenset_repr = _sequence_repr_maker('frozenset([', '])', frozenset)
-    if deque is not None:
-        deque_repr = _sequence_repr_maker('<span class="module">collections.'
-                                          '</span>deque([', '])', deque)
-    del _sequence_repr_maker
-
-    def regex_repr(self, obj):
-        pattern = repr(obj.pattern)
-        if PY2:
-            pattern = pattern.decode('string-escape', 'ignore')
-        else:
-            pattern = codecs.decode(pattern, 'unicode-escape', 'ignore')
-        if pattern[:1] == 'u':
-            pattern = 'ur' + pattern[1:]
-        else:
-            pattern = 'r' + pattern
-        return u're.compile(<span class="string regex">%s</span>)' % pattern
-
-    def string_repr(self, obj, limit=70):
-        buf = ['<span class="string">']
-        a = repr(obj[:limit])
-        b = repr(obj[limit:])
-        if isinstance(obj, text_type) and PY2:
-            buf.append('u')
-            a = a[1:]
-            b = b[1:]
-        if b != "''":
-            buf.extend((escape(a[:-1]), '<span class="extended">', escape(b[1:]), '</span>'))
-        else:
-            buf.append(escape(a))
-        buf.append('</span>')
-        return _add_subclass_info(u''.join(buf), obj, (bytes, text_type))
-
-    def dict_repr(self, d, recursive, limit=5):
-        if recursive:
-            return _add_subclass_info(u'{...}', d, dict)
-        buf = ['{']
-        have_extended_section = False
-        for idx, (key, value) in enumerate(iteritems(d)):
-            if idx:
-                buf.append(', ')
-            if idx == limit - 1:
-                buf.append('<span class="extended">')
-                have_extended_section = True
-            buf.append('<span class="pair"><span class="key">%s</span>: '
-                       '<span class="value">%s</span></span>' %
-                       (self.repr(key), self.repr(value)))
-        if have_extended_section:
-            buf.append('</span>')
-        buf.append('}')
-        return _add_subclass_info(u''.join(buf), d, dict)
-
-    def object_repr(self, obj):
-        r = repr(obj)
-        if PY2:
-            r = r.decode('utf-8', 'replace')
-        return u'<span class="object">%s</span>' % escape(r)
-
-    def dispatch_repr(self, obj, recursive):
-        if obj is helper:
-            return u'<span class="help">%r</span>' % helper
-        if isinstance(obj, (integer_types, float, complex)):
-            return u'<span class="number">%r</span>' % obj
-        if isinstance(obj, string_types):
-            return self.string_repr(obj)
-        if isinstance(obj, RegexType):
-            return self.regex_repr(obj)
-        if isinstance(obj, list):
-            return self.list_repr(obj, recursive)
-        if isinstance(obj, tuple):
-            return self.tuple_repr(obj, recursive)
-        if isinstance(obj, set):
-            return self.set_repr(obj, recursive)
-        if isinstance(obj, frozenset):
-            return self.frozenset_repr(obj, recursive)
-        if isinstance(obj, dict):
-            return self.dict_repr(obj, recursive)
-        if deque is not None and isinstance(obj, deque):
-            return self.deque_repr(obj, recursive)
-        return self.object_repr(obj)
-
-    def fallback_repr(self):
-        try:
-            info = ''.join(format_exception_only(*sys.exc_info()[:2]))
-        except Exception:  # pragma: no cover
-            info = '?'
-        if PY2:
-            info = info.decode('utf-8', 'ignore')
-        return u'<span class="brokenrepr">&lt;broken repr (%s)&gt;' \
-               u'</span>' % escape(info.strip())
-
-    def repr(self, obj):
-        recursive = False
-        for item in self._stack:
-            if item is obj:
-                recursive = True
-                break
-        self._stack.append(obj)
-        try:
-            try:
-                return self.dispatch_repr(obj, recursive)
-            except Exception:
-                return self.fallback_repr()
-        finally:
-            self._stack.pop()
-
-    def dump_object(self, obj):
-        repr = items = None
-        if isinstance(obj, dict):
-            title = 'Contents of'
-            items = []
-            for key, value in iteritems(obj):
-                if not isinstance(key, string_types):
-                    items = None
-                    break
-                items.append((key, self.repr(value)))
-        if items is None:
-            items = []
-            repr = self.repr(obj)
-            for key in dir(obj):
-                try:
-                    items.append((key, self.repr(getattr(obj, key))))
-                except Exception:
-                    pass
-            title = 'Details for'
-        title += ' ' + object.__repr__(obj)[1:-1]
-        return self.render_object_dump(items, title, repr)
-
-    def dump_locals(self, d):
-        items = [(key, self.repr(value)) for key, value in d.items()]
-        return self.render_object_dump(items, 'Local variables in frame')
-
-    def render_object_dump(self, items, title, repr=None):
-        html_items = []
-        for key, value in items:
-            html_items.append('<tr><th>%s<td><pre class=repr>%s</pre>' %
-                              (escape(key), value))
-        if not html_items:
-            html_items.append('<tr><td><em>Nothing</em>')
-        return OBJECT_DUMP_HTML % {
-            'title':    escape(title),
-            'repr':     repr and '<pre class=repr>%s</pre>' % repr or '',
-            'items':    '\n'.join(html_items)
-        }
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/FONT_LICENSE b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/FONT_LICENSE
deleted file mode 100644
index ae78a8f94..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/FONT_LICENSE
+++ /dev/null
@@ -1,96 +0,0 @@
--------------------------------
-UBUNTU FONT LICENCE Version 1.0
--------------------------------
-
-PREAMBLE
-This licence allows the licensed fonts to be used, studied, modified and
-redistributed freely. The fonts, including any derivative works, can be
-bundled, embedded, and redistributed provided the terms of this licence
-are met. The fonts and derivatives, however, cannot be released under
-any other licence. The requirement for fonts to remain under this
-licence does not require any document created using the fonts or their
-derivatives to be published under this licence, as long as the primary
-purpose of the document is not to be a vehicle for the distribution of
-the fonts.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this licence and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Original Version" refers to the collection of Font Software components
-as received under this licence.
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to
-a new environment.
-
-"Copyright Holder(s)" refers to all individuals and companies who have a
-copyright ownership of the Font Software.
-
-"Substantially Changed" refers to Modified Versions which can be easily
-identified as dissimilar to the Font Software by users of the Font
-Software comparing the Original Version with the Modified Version.
-
-To "Propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification and with or without charging
-a redistribution fee), making available to the public, and in some
-countries other activities as well.
-
-PERMISSION & CONDITIONS
-This licence does not grant any rights under trademark law and all such
-rights are reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of the Font Software, to propagate the Font Software, subject to
-the below conditions:
-
-1) Each copy of the Font Software must contain the above copyright
-notice and this licence. These can be included either as stand-alone
-text files, human-readable headers or in the appropriate machine-
-readable metadata fields within text or binary files as long as those
-fields can be easily viewed by the user.
-
-2) The font name complies with the following:
-(a) The Original Version must retain its name, unmodified.
-(b) Modified Versions which are Substantially Changed must be renamed to
-avoid use of the name of the Original Version or similar names entirely.
-(c) Modified Versions which are not Substantially Changed must be
-renamed to both (i) retain the name of the Original Version and (ii) add
-additional naming elements to distinguish the Modified Version from the
-Original Version. The name of such Modified Versions must be the name of
-the Original Version, with "derivative X" where X represents the name of
-the new work, appended to that name.
-
-3) The name(s) of the Copyright Holder(s) and any contributor to the
-Font Software shall not be used to promote, endorse or advertise any
-Modified Version, except (i) as required by this licence, (ii) to
-acknowledge the contribution(s) of the Copyright Holder(s) or (iii) with
-their explicit written permission.
-
-4) The Font Software, modified or unmodified, in part or in whole, must
-be distributed entirely under this licence, and must not be distributed
-under any other licence. The requirement for fonts to remain under this
-licence does not affect any document created using the Font Software,
-except any version of the Font Software extracted from a document
-created using the Font Software may only be distributed under this
-licence.
-
-TERMINATION
-This licence becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
-COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
-DEALINGS IN THE FONT SOFTWARE.
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/console.png b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/console.png
deleted file mode 100644
index c28dd6381..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/console.png and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/debugger.js b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/debugger.js
deleted file mode 100644
index 534019dc4..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/debugger.js
+++ /dev/null
@@ -1,205 +0,0 @@
-$(function() {
-  if (!EVALEX_TRUSTED) {
-    initPinBox();
-  }
-
-  /**
-   * if we are in console mode, show the console.
-   */
-  if (CONSOLE_MODE && EVALEX) {
-    openShell(null, $('div.console div.inner').empty(), 0);
-  }
-
-  $('div.traceback div.frame').each(function() {
-    var
-      target = $('pre', this),
-      consoleNode = null,
-      frameID = this.id.substring(6);
-
-    target.click(function() {
-      $(this).parent().toggleClass('expanded');
-    });
-
-    /**
-     * Add an interactive console to the frames
-     */
-    if (EVALEX && target.is('.current')) {
-      $('<img src="?__debugger__=yes&cmd=resource&f=console.png">')
-        .attr('title', 'Open an interactive python shell in this frame')
-        .click(function() {
-          consoleNode = openShell(consoleNode, target, frameID);
-          return false;
-        })
-        .prependTo(target);
-    }
-  });
-
-  /**
-   * toggle traceback types on click.
-   */
-  $('h2.traceback').click(function() {
-    $(this).next().slideToggle('fast');
-    $('div.plain').slideToggle('fast');
-  }).css('cursor', 'pointer');
-  $('div.plain').hide();
-
-  /**
-   * Add extra info (this is here so that only users with JavaScript
-   * enabled see it.)
-   */
-  $('span.nojavascript')
-    .removeClass('nojavascript')
-    .html('<p>To switch between the interactive traceback and the plaintext ' +
-          'one, you can click on the "Traceback" headline.  From the text ' +
-          'traceback you can also create a paste of it. ' + (!EVALEX ? '' :
-          'For code execution mouse-over the frame you want to debug and ' +
-          'click on the console icon on the right side.' +
-          '<p>You can execute arbitrary Python code in the stack frames and ' +
-          'there are some extra helpers available for introspection:' +
-          '<ul><li><code>dump()</code> shows all variables in the frame' +
-          '<li><code>dump(obj)</code> dumps all that\'s known about the object</ul>'));
-
-  /**
-   * Add the pastebin feature
-   */
-  $('div.plain form')
-    .submit(function() {
-      var label = $('input[type="submit"]', this);
-      var old_val = label.val();
-      label.val('submitting...');
-      $.ajax({
-        dataType:     'json',
-        url:          document.location.pathname,
-        data:         {__debugger__: 'yes', tb: TRACEBACK, cmd: 'paste',
-                       s: SECRET},
-        success:      function(data) {
-          $('div.plain span.pastemessage')
-            .removeClass('pastemessage')
-            .text('Paste created: ')
-            .append($('<a>#' + data.id + '</a>').attr('href', data.url));
-        },
-        error:        function() {
-          alert('Error: Could not submit paste.  No network connection?');
-          label.val(old_val);
-        }
-      });
-      return false;
-    });
-
-  // if we have javascript we submit by ajax anyways, so no need for the
-  // not scaling textarea.
-  var plainTraceback = $('div.plain textarea');
-  plainTraceback.replaceWith($('<pre>').text(plainTraceback.text()));
-});
-
-function initPinBox() {
-  $('.pin-prompt form').submit(function(evt) {
-    evt.preventDefault();
-    var pin = this.pin.value;
-    var btn = this.btn;
-    btn.disabled = true;
-    $.ajax({
-      dataType: 'json',
-      url: document.location.pathname,
-      data: {__debugger__: 'yes', cmd: 'pinauth', pin: pin,
-             s: SECRET},
-      success: function(data) {
-        btn.disabled = false;
-        if (data.auth) {
-          EVALEX_TRUSTED = true;
-          $('.pin-prompt').fadeOut();
-        } else {
-          if (data.exhausted) {
-            alert('Error: too many attempts.  Restart server to retry.');
-          } else {
-            alert('Error: incorrect pin');
-          }
-        }
-        console.log(data);
-      },
-      error: function() {
-        btn.disabled = false;
-        alert('Error: Could not verify PIN.  Network error?');
-      }
-    });
-  });
-}
-
-function promptForPin() {
-  if (!EVALEX_TRUSTED) {
-    $.ajax({
-      url: document.location.pathname,
-      data: {__debugger__: 'yes', cmd: 'printpin', s: SECRET}
-    });
-    $('.pin-prompt').fadeIn(function() {
-      $('.pin-prompt input[name="pin"]').focus();
-    });
-  }
-}
-
-
-/**
- * Helper function for shell initialization
- */
-function openShell(consoleNode, target, frameID) {
-  promptForPin();
-  if (consoleNode)
-    return consoleNode.slideToggle('fast');
-  consoleNode = $('<pre class="console">')
-    .appendTo(target.parent())
-    .hide()
-  var historyPos = 0, history = [''];
-  var output = $('<div class="output">[console ready]</div>')
-    .appendTo(consoleNode);
-  var form = $('<form>&gt;&gt;&gt; </form>')
-    .submit(function() {
-      var cmd = command.val();
-      $.get('', {
-          __debugger__: 'yes', cmd: cmd, frm: frameID, s: SECRET}, function(data) {
-        var tmp = $('<div>').html(data);
-        $('span.extended', tmp).each(function() {
-          var hidden = $(this).wrap('<span>').hide();
-          hidden
-            .parent()
-            .append($('<a href="#" class="toggle">&nbsp;&nbsp;</a>')
-              .click(function() {
-                hidden.toggle();
-                $(this).toggleClass('open')
-                return false;
-              }));
-        });
-        output.append(tmp);
-        command.focus();
-        consoleNode.scrollTop(consoleNode.get(0).scrollHeight);
-        var old = history.pop();
-        history.push(cmd);
-        if (typeof old != 'undefined')
-          history.push(old);
-        historyPos = history.length - 1;
-      });
-      command.val('');
-      return false;
-    }).
-    appendTo(consoleNode);
-
-  var command = $('<input type="text" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false">')
-    .appendTo(form)
-    .keydown(function(e) {
-      if (e.charCode == 100 && e.ctrlKey) {
-        output.text('--- screen cleared ---');
-        return false;
-      }
-      else if (e.charCode == 0 && (e.keyCode == 38 || e.keyCode == 40)) {
-        if (e.keyCode == 38 && historyPos > 0)
-          historyPos--;
-        else if (e.keyCode == 40 && historyPos < history.length)
-          historyPos++;
-        command.val(history[historyPos]);
-        return false;
-      }
-    });
-
-  return consoleNode.slideDown('fast', function() {
-    command.focus();
-  });
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/jquery.js b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/jquery.js
deleted file mode 100644
index 0f60b7bd0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/jquery.js
+++ /dev/null
@@ -1,5 +0,0 @@
-/*! jQuery v1.11.3 | (c) 2005, 2015 jQuery Foundation, Inc. | jquery.org/license */
-!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k={},l="1.11.3",m=function(a,b){return new m.fn.init(a,b)},n=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,o=/^-ms-/,p=/-([\da-z])/gi,q=function(a,b){return b.toUpperCase()};m.fn=m.prototype={jquery:l,constructor:m,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=m.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return m.each(this,a,b)},map:function(a){return this.pushStack(m.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},m.extend=m.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||m.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(m.isPlainObject(c)||(b=m.isArray(c)))?(b?(b=!1,f=a&&m.isArray(a)?a:[]):f=a&&m.isPlainObject(a)?a:{},g[d]=m.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},m.extend({expando:"jQuery"+(l+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===m.type(a)},isArray:Array.isArray||function(a){return"array"===m.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){return!m.isArray(a)&&a-parseFloat(a)+1>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==m.type(a)||a.nodeType||m.isWindow(a))return!1;try{if(a.constructor&&!j.call(a,"constructor")&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(k.ownLast)for(b in a)return j.call(a,b);for(b in a);return void 0===b||j.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(b){b&&m.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(o,"ms-").replace(p,q)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=r(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(n,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(r(Object(a))?m.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(g)return g.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=r(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(f=a[b],b=a,a=f),m.isFunction(a)?(c=d.call(arguments,2),e=function(){return a.apply(b||this,c.concat(d.call(arguments)))},e.guid=a.guid=a.guid||m.guid++,e):void 0},now:function(){return+new Date},support:k}),m.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function r(a){var b="length"in a&&a.length,c=m.type(a);return"function"===c||m.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var s=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C=1<<31,D={}.hasOwnProperty,E=[],F=E.pop,G=E.push,H=E.push,I=E.slice,J=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},K="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",L="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",N=M.replace("w","w#"),O="\\["+L+"*("+M+")(?:"+L+"*([*^$|!~]?=)"+L+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+N+"))|)"+L+"*\\]",P=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+O+")*)|.*)\\)|)",Q=new RegExp(L+"+","g"),R=new RegExp("^"+L+"+|((?:^|[^\\\\])(?:\\\\.)*)"+L+"+$","g"),S=new RegExp("^"+L+"*,"+L+"*"),T=new RegExp("^"+L+"*([>+~]|"+L+")"+L+"*"),U=new RegExp("="+L+"*([^\\]'\"]*?)"+L+"*\\]","g"),V=new RegExp(P),W=new RegExp("^"+N+"$"),X={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M.replace("w","w*")+")"),ATTR:new RegExp("^"+O),PSEUDO:new RegExp("^"+P),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+L+"*(even|odd|(([+-]|)(\\d*)n|)"+L+"*(?:([+-]|)"+L+"*(\\d+)|))"+L+"*\\)|)","i"),bool:new RegExp("^(?:"+K+")$","i"),needsContext:new RegExp("^"+L+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+L+"*((?:-\\d)?\\d*)"+L+"*\\)|)(?=[^-]|$)","i")},Y=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,$=/^[^{]+\{\s*\[native \w/,_=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,aa=/[+~]/,ba=/'|\\/g,ca=new RegExp("\\\\([\\da-f]{1,6}"+L+"?|("+L+")|.)","ig"),da=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ea=function(){m()};try{H.apply(E=I.call(v.childNodes),v.childNodes),E[v.childNodes.length].nodeType}catch(fa){H={apply:E.length?function(a,b){G.apply(a,I.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s,w,x;if((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,d=d||[],k=b.nodeType,"string"!=typeof a||!a||1!==k&&9!==k&&11!==k)return d;if(!e&&p){if(11!==k&&(f=_.exec(a)))if(j=f[1]){if(9===k){if(h=b.getElementById(j),!h||!h.parentNode)return d;if(h.id===j)return d.push(h),d}else if(b.ownerDocument&&(h=b.ownerDocument.getElementById(j))&&t(b,h)&&h.id===j)return d.push(h),d}else{if(f[2])return H.apply(d,b.getElementsByTagName(a)),d;if((j=f[3])&&c.getElementsByClassName)return H.apply(d,b.getElementsByClassName(j)),d}if(c.qsa&&(!q||!q.test(a))){if(s=r=u,w=b,x=1!==k&&a,1===k&&"object"!==b.nodeName.toLowerCase()){o=g(a),(r=b.getAttribute("id"))?s=r.replace(ba,"\\$&"):b.setAttribute("id",s),s="[id='"+s+"'] ",l=o.length;while(l--)o[l]=s+ra(o[l]);w=aa.test(a)&&pa(b.parentNode)||b,x=o.join(",")}if(x)try{return H.apply(d,w.querySelectorAll(x)),d}catch(y){}finally{r||b.removeAttribute("id")}}}return i(a.replace(R,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||C)-(~a.sourceIndex||C);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function pa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=g.documentElement,e=g.defaultView,e&&e!==e.top&&(e.addEventListener?e.addEventListener("unload",ea,!1):e.attachEvent&&e.attachEvent("onunload",ea)),p=!f(g),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(g.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=$.test(g.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!g.getElementsByName||!g.getElementsByName(u).length}),c.getById?(d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ca,da);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return p?b.getElementsByClassName(a):void 0},r=[],q=[],(c.qsa=$.test(g.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\f]' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+L+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+L+"*(?:value|"+K+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){var b=g.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+L+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=$.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"div"),s.call(a,"[s!='']:x"),r.push("!=",P)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=$.test(o.compareDocumentPosition),t=b||$.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===g||a.ownerDocument===v&&t(v,a)?-1:b===g||b.ownerDocument===v&&t(v,b)?1:k?J(k,a)-J(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,h=[a],i=[b];if(!e||!f)return a===g?-1:b===g?1:e?-1:f?1:k?J(k,a)-J(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)i.unshift(c);while(h[d]===i[d])d++;return d?la(h[d],i[d]):h[d]===v?-1:i[d]===v?1:0},g):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(U,"='$1']"),!(!c.matchesSelector||!p||r&&r.test(b)||q&&q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&D.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:X,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ca,da),a[3]=(a[3]||a[4]||a[5]||"").replace(ca,da),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return X.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&V.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ca,da).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+L+")"+a+"("+L+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(Q," ")+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){k=q[u]||(q[u]={}),j=k[a]||[],n=j[0]===w&&j[1],m=j[0]===w&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[w,n,m];break}}else if(s&&(j=(b[u]||(b[u]={}))[a])&&j[0]===w)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(s&&((l[u]||(l[u]={}))[a]=[w,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=J(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(R,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(ca,da),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return W.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(ca,da).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return Z.test(a.nodeName)},input:function(a){return Y.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:oa(function(){return[0]}),last:oa(function(a,b){return[b-1]}),eq:oa(function(a,b,c){return[0>c?c+b:c]}),even:oa(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:oa(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:oa(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:oa(function(a,b,c){for(var d=0>c?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function qa(){}qa.prototype=d.filters=d.pseudos,d.setFilters=new qa,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){(!c||(e=S.exec(h)))&&(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=T.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(R," ")}),h=h.slice(c.length));for(g in d.filter)!(e=X[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function ra(a){for(var b=0,c=a.length,d="";c>b;b++)d+=a[b].value;return d}function sa(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=x++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[w,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[u]||(b[u]={}),(h=i[d])&&h[0]===w&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function ta(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function ua(a,b,c){for(var d=0,e=b.length;e>d;d++)ga(a,b[d],c);return c}function va(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function wa(a,b,c,d,e,f){return d&&!d[u]&&(d=wa(d)),e&&!e[u]&&(e=wa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||ua(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:va(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=va(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?J(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=va(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):H.apply(g,r)})}function xa(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=sa(function(a){return a===b},h,!0),l=sa(function(a){return J(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];f>i;i++)if(c=d.relative[a[i].type])m=[sa(ta(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return wa(i>1&&ta(m),i>1&&ra(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(R,"$1"),c,e>i&&xa(a.slice(i,e)),f>e&&xa(a=a.slice(e)),f>e&&ra(a))}m.push(c)}return ta(m)}function ya(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,m,o,p=0,q="0",r=f&&[],s=[],t=j,u=f||e&&d.find.TAG("*",k),v=w+=null==t?1:Math.random()||.1,x=u.length;for(k&&(j=g!==n&&g);q!==x&&null!=(l=u[q]);q++){if(e&&l){m=0;while(o=a[m++])if(o(l,g,h)){i.push(l);break}k&&(w=v)}c&&((l=!o&&l)&&p--,f&&r.push(l))}if(p+=q,c&&q!==p){m=0;while(o=b[m++])o(r,s,g,h);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=F.call(i));s=va(s)}H.apply(i,s),k&&!f&&s.length>0&&p+b.length>1&&ga.uniqueSort(i)}return k&&(w=v,j=t),r};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=xa(b[c]),f[u]?d.push(f):e.push(f);f=A(a,ya(e,d)),f.selector=a}return f},i=ga.select=function(a,b,e,f){var i,j,k,l,m,n="function"==typeof a&&a,o=!f&&g(a=n.selector||a);if(e=e||[],1===o.length){if(j=o[0]=o[0].slice(0),j.length>2&&"ID"===(k=j[0]).type&&c.getById&&9===b.nodeType&&p&&d.relative[j[1].type]){if(b=(d.find.ID(k.matches[0].replace(ca,da),b)||[])[0],!b)return e;n&&(b=b.parentNode),a=a.slice(j.shift().value.length)}i=X.needsContext.test(a)?0:j.length;while(i--){if(k=j[i],d.relative[l=k.type])break;if((m=d.find[l])&&(f=m(k.matches[0].replace(ca,da),aa.test(j[0].type)&&pa(b.parentNode)||b))){if(j.splice(i,1),a=f.length&&ra(j),!a)return H.apply(e,f),e;break}}}return(n||h(a,o))(f,b,!p,e,aa.test(a)&&pa(b.parentNode)||b),e},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("div"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(K,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);m.find=s,m.expr=s.selectors,m.expr[":"]=m.expr.pseudos,m.unique=s.uniqueSort,m.text=s.getText,m.isXMLDoc=s.isXML,m.contains=s.contains;var t=m.expr.match.needsContext,u=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,v=/^.[^:#\[\.,]*$/;function w(a,b,c){if(m.isFunction(b))return m.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return m.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(v.test(b))return m.filter(b,a,c);b=m.filter(b,a)}return m.grep(a,function(a){return m.inArray(a,b)>=0!==c})}m.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?m.find.matchesSelector(d,a)?[d]:[]:m.find.matches(a,m.grep(b,function(a){return 1===a.nodeType}))},m.fn.extend({find:function(a){var b,c=[],d=this,e=d.length;if("string"!=typeof a)return this.pushStack(m(a).filter(function(){for(b=0;e>b;b++)if(m.contains(d[b],this))return!0}));for(b=0;e>b;b++)m.find(a,d[b],c);return c=this.pushStack(e>1?m.unique(c):c),c.selector=this.selector?this.selector+" "+a:a,c},filter:function(a){return this.pushStack(w(this,a||[],!1))},not:function(a){return this.pushStack(w(this,a||[],!0))},is:function(a){return!!w(this,"string"==typeof a&&t.test(a)?m(a):a||[],!1).length}});var x,y=a.document,z=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,A=m.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a.charAt(0)&&">"===a.charAt(a.length-1)&&a.length>=3?[null,a,null]:z.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||x).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof m?b[0]:b,m.merge(this,m.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:y,!0)),u.test(c[1])&&m.isPlainObject(b))for(c in b)m.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}if(d=y.getElementById(c[2]),d&&d.parentNode){if(d.id!==c[2])return x.find(a);this.length=1,this[0]=d}return this.context=y,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):m.isFunction(a)?"undefined"!=typeof x.ready?x.ready(a):a(m):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),m.makeArray(a,this))};A.prototype=m.fn,x=m(y);var B=/^(?:parents|prev(?:Until|All))/,C={children:!0,contents:!0,next:!0,prev:!0};m.extend({dir:function(a,b,c){var d=[],e=a[b];while(e&&9!==e.nodeType&&(void 0===c||1!==e.nodeType||!m(e).is(c)))1===e.nodeType&&d.push(e),e=e[b];return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),m.fn.extend({has:function(a){var b,c=m(a,this),d=c.length;return this.filter(function(){for(b=0;d>b;b++)if(m.contains(this,c[b]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=t.test(a)||"string"!=typeof a?m(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&m.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?m.unique(f):f)},index:function(a){return a?"string"==typeof a?m.inArray(this[0],m(a)):m.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(m.unique(m.merge(this.get(),m(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function D(a,b){do a=a[b];while(a&&1!==a.nodeType);return a}m.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return m.dir(a,"parentNode")},parentsUntil:function(a,b,c){return m.dir(a,"parentNode",c)},next:function(a){return D(a,"nextSibling")},prev:function(a){return D(a,"previousSibling")},nextAll:function(a){return m.dir(a,"nextSibling")},prevAll:function(a){return m.dir(a,"previousSibling")},nextUntil:function(a,b,c){return m.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return m.dir(a,"previousSibling",c)},siblings:function(a){return m.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return m.sibling(a.firstChild)},contents:function(a){return m.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:m.merge([],a.childNodes)}},function(a,b){m.fn[a]=function(c,d){var e=m.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=m.filter(d,e)),this.length>1&&(C[a]||(e=m.unique(e)),B.test(a)&&(e=e.reverse())),this.pushStack(e)}});var E=/\S+/g,F={};function G(a){var b=F[a]={};return m.each(a.match(E)||[],function(a,c){b[c]=!0}),b}m.Callbacks=function(a){a="string"==typeof a?F[a]||G(a):m.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(c=a.memory&&l,d=!0,f=g||0,g=0,e=h.length,b=!0;h&&e>f;f++)if(h[f].apply(l[0],l[1])===!1&&a.stopOnFalse){c=!1;break}b=!1,h&&(i?i.length&&j(i.shift()):c?h=[]:k.disable())},k={add:function(){if(h){var d=h.length;!function f(b){m.each(b,function(b,c){var d=m.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&f(c)})}(arguments),b?e=h.length:c&&(g=d,j(c))}return this},remove:function(){return h&&m.each(arguments,function(a,c){var d;while((d=m.inArray(c,h,d))>-1)h.splice(d,1),b&&(e>=d&&e--,f>=d&&f--)}),this},has:function(a){return a?m.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],e=0,this},disable:function(){return h=i=c=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,c||k.disable(),this},locked:function(){return!i},fireWith:function(a,c){return!h||d&&!i||(c=c||[],c=[a,c.slice?c.slice():c],b?i.push(c):j(c)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!d}};return k},m.extend({Deferred:function(a){var b=[["resolve","done",m.Callbacks("once memory"),"resolved"],["reject","fail",m.Callbacks("once memory"),"rejected"],["notify","progress",m.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return m.Deferred(function(c){m.each(b,function(b,f){var g=m.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&m.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?m.extend(a,d):d}},e={};return d.pipe=d.then,m.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&m.isFunction(a.promise)?e:0,g=1===f?a:m.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&m.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var H;m.fn.ready=function(a){return m.ready.promise().done(a),this},m.extend({isReady:!1,readyWait:1,holdReady:function(a){a?m.readyWait++:m.ready(!0)},ready:function(a){if(a===!0?!--m.readyWait:!m.isReady){if(!y.body)return setTimeout(m.ready);m.isReady=!0,a!==!0&&--m.readyWait>0||(H.resolveWith(y,[m]),m.fn.triggerHandler&&(m(y).triggerHandler("ready"),m(y).off("ready")))}}});function I(){y.addEventListener?(y.removeEventListener("DOMContentLoaded",J,!1),a.removeEventListener("load",J,!1)):(y.detachEvent("onreadystatechange",J),a.detachEvent("onload",J))}function J(){(y.addEventListener||"load"===event.type||"complete"===y.readyState)&&(I(),m.ready())}m.ready.promise=function(b){if(!H)if(H=m.Deferred(),"complete"===y.readyState)setTimeout(m.ready);else if(y.addEventListener)y.addEventListener("DOMContentLoaded",J,!1),a.addEventListener("load",J,!1);else{y.attachEvent("onreadystatechange",J),a.attachEvent("onload",J);var c=!1;try{c=null==a.frameElement&&y.documentElement}catch(d){}c&&c.doScroll&&!function e(){if(!m.isReady){try{c.doScroll("left")}catch(a){return setTimeout(e,50)}I(),m.ready()}}()}return H.promise(b)};var K="undefined",L;for(L in m(k))break;k.ownLast="0"!==L,k.inlineBlockNeedsLayout=!1,m(function(){var a,b,c,d;c=y.getElementsByTagName("body")[0],c&&c.style&&(b=y.createElement("div"),d=y.createElement("div"),d.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(d).appendChild(b),typeof b.style.zoom!==K&&(b.style.cssText="display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1",k.inlineBlockNeedsLayout=a=3===b.offsetWidth,a&&(c.style.zoom=1)),c.removeChild(d))}),function(){var a=y.createElement("div");if(null==k.deleteExpando){k.deleteExpando=!0;try{delete a.test}catch(b){k.deleteExpando=!1}}a=null}(),m.acceptData=function(a){var b=m.noData[(a.nodeName+" ").toLowerCase()],c=+a.nodeType||1;return 1!==c&&9!==c?!1:!b||b!==!0&&a.getAttribute("classid")===b};var M=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,N=/([A-Z])/g;function O(a,b,c){if(void 0===c&&1===a.nodeType){var d="data-"+b.replace(N,"-$1").toLowerCase();if(c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:M.test(c)?m.parseJSON(c):c}catch(e){}m.data(a,b,c)}else c=void 0}return c}function P(a){var b;for(b in a)if(("data"!==b||!m.isEmptyObject(a[b]))&&"toJSON"!==b)return!1;
-
-return!0}function Q(a,b,d,e){if(m.acceptData(a)){var f,g,h=m.expando,i=a.nodeType,j=i?m.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||m.guid++:h),j[k]||(j[k]=i?{}:{toJSON:m.noop}),("object"==typeof b||"function"==typeof b)&&(e?j[k]=m.extend(j[k],b):j[k].data=m.extend(j[k].data,b)),g=j[k],e||(g.data||(g.data={}),g=g.data),void 0!==d&&(g[m.camelCase(b)]=d),"string"==typeof b?(f=g[b],null==f&&(f=g[m.camelCase(b)])):f=g,f}}function R(a,b,c){if(m.acceptData(a)){var d,e,f=a.nodeType,g=f?m.cache:a,h=f?a[m.expando]:m.expando;if(g[h]){if(b&&(d=c?g[h]:g[h].data)){m.isArray(b)?b=b.concat(m.map(b,m.camelCase)):b in d?b=[b]:(b=m.camelCase(b),b=b in d?[b]:b.split(" ")),e=b.length;while(e--)delete d[b[e]];if(c?!P(d):!m.isEmptyObject(d))return}(c||(delete g[h].data,P(g[h])))&&(f?m.cleanData([a],!0):k.deleteExpando||g!=g.window?delete g[h]:g[h]=null)}}}m.extend({cache:{},noData:{"applet ":!0,"embed ":!0,"object ":"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"},hasData:function(a){return a=a.nodeType?m.cache[a[m.expando]]:a[m.expando],!!a&&!P(a)},data:function(a,b,c){return Q(a,b,c)},removeData:function(a,b){return R(a,b)},_data:function(a,b,c){return Q(a,b,c,!0)},_removeData:function(a,b){return R(a,b,!0)}}),m.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=m.data(f),1===f.nodeType&&!m._data(f,"parsedAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=m.camelCase(d.slice(5)),O(f,d,e[d])));m._data(f,"parsedAttrs",!0)}return e}return"object"==typeof a?this.each(function(){m.data(this,a)}):arguments.length>1?this.each(function(){m.data(this,a,b)}):f?O(f,a,m.data(f,a)):void 0},removeData:function(a){return this.each(function(){m.removeData(this,a)})}}),m.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=m._data(a,b),c&&(!d||m.isArray(c)?d=m._data(a,b,m.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=m.queue(a,b),d=c.length,e=c.shift(),f=m._queueHooks(a,b),g=function(){m.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return m._data(a,c)||m._data(a,c,{empty:m.Callbacks("once memory").add(function(){m._removeData(a,b+"queue"),m._removeData(a,c)})})}}),m.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?m.queue(this[0],a):void 0===b?this:this.each(function(){var c=m.queue(this,a,b);m._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&m.dequeue(this,a)})},dequeue:function(a){return this.each(function(){m.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=m.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=m._data(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var S=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,T=["Top","Right","Bottom","Left"],U=function(a,b){return a=b||a,"none"===m.css(a,"display")||!m.contains(a.ownerDocument,a)},V=m.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===m.type(c)){e=!0;for(h in c)m.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,m.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(m(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},W=/^(?:checkbox|radio)$/i;!function(){var a=y.createElement("input"),b=y.createElement("div"),c=y.createDocumentFragment();if(b.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",k.leadingWhitespace=3===b.firstChild.nodeType,k.tbody=!b.getElementsByTagName("tbody").length,k.htmlSerialize=!!b.getElementsByTagName("link").length,k.html5Clone="<:nav></:nav>"!==y.createElement("nav").cloneNode(!0).outerHTML,a.type="checkbox",a.checked=!0,c.appendChild(a),k.appendChecked=a.checked,b.innerHTML="<textarea>x</textarea>",k.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue,c.appendChild(b),b.innerHTML="<input type='radio' checked='checked' name='t'/>",k.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,k.noCloneEvent=!0,b.attachEvent&&(b.attachEvent("onclick",function(){k.noCloneEvent=!1}),b.cloneNode(!0).click()),null==k.deleteExpando){k.deleteExpando=!0;try{delete b.test}catch(d){k.deleteExpando=!1}}}(),function(){var b,c,d=y.createElement("div");for(b in{submit:!0,change:!0,focusin:!0})c="on"+b,(k[b+"Bubbles"]=c in a)||(d.setAttribute(c,"t"),k[b+"Bubbles"]=d.attributes[c].expando===!1);d=null}();var X=/^(?:input|select|textarea)$/i,Y=/^key/,Z=/^(?:mouse|pointer|contextmenu)|click/,$=/^(?:focusinfocus|focusoutblur)$/,_=/^([^.]*)(?:\.(.+)|)$/;function aa(){return!0}function ba(){return!1}function ca(){try{return y.activeElement}catch(a){}}m.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,n,o,p,q,r=m._data(a);if(r){c.handler&&(i=c,c=i.handler,e=i.selector),c.guid||(c.guid=m.guid++),(g=r.events)||(g=r.events={}),(k=r.handle)||(k=r.handle=function(a){return typeof m===K||a&&m.event.triggered===a.type?void 0:m.event.dispatch.apply(k.elem,arguments)},k.elem=a),b=(b||"").match(E)||[""],h=b.length;while(h--)f=_.exec(b[h])||[],o=q=f[1],p=(f[2]||"").split(".").sort(),o&&(j=m.event.special[o]||{},o=(e?j.delegateType:j.bindType)||o,j=m.event.special[o]||{},l=m.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&m.expr.match.needsContext.test(e),namespace:p.join(".")},i),(n=g[o])||(n=g[o]=[],n.delegateCount=0,j.setup&&j.setup.call(a,d,p,k)!==!1||(a.addEventListener?a.addEventListener(o,k,!1):a.attachEvent&&a.attachEvent("on"+o,k))),j.add&&(j.add.call(a,l),l.handler.guid||(l.handler.guid=c.guid)),e?n.splice(n.delegateCount++,0,l):n.push(l),m.event.global[o]=!0);a=null}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,n,o,p,q,r=m.hasData(a)&&m._data(a);if(r&&(k=r.events)){b=(b||"").match(E)||[""],j=b.length;while(j--)if(h=_.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=m.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,n=k[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),i=f=n.length;while(f--)g=n[f],!e&&q!==g.origType||c&&c.guid!==g.guid||h&&!h.test(g.namespace)||d&&d!==g.selector&&("**"!==d||!g.selector)||(n.splice(f,1),g.selector&&n.delegateCount--,l.remove&&l.remove.call(a,g));i&&!n.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||m.removeEvent(a,o,r.handle),delete k[o])}else for(o in k)m.event.remove(a,o+b[j],c,d,!0);m.isEmptyObject(k)&&(delete r.handle,m._removeData(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,l,n,o=[d||y],p=j.call(b,"type")?b.type:b,q=j.call(b,"namespace")?b.namespace.split("."):[];if(h=l=d=d||y,3!==d.nodeType&&8!==d.nodeType&&!$.test(p+m.event.triggered)&&(p.indexOf(".")>=0&&(q=p.split("."),p=q.shift(),q.sort()),g=p.indexOf(":")<0&&"on"+p,b=b[m.expando]?b:new m.Event(p,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=q.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:m.makeArray(c,[b]),k=m.event.special[p]||{},e||!k.trigger||k.trigger.apply(d,c)!==!1)){if(!e&&!k.noBubble&&!m.isWindow(d)){for(i=k.delegateType||p,$.test(i+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),l=h;l===(d.ownerDocument||y)&&o.push(l.defaultView||l.parentWindow||a)}n=0;while((h=o[n++])&&!b.isPropagationStopped())b.type=n>1?i:k.bindType||p,f=(m._data(h,"events")||{})[b.type]&&m._data(h,"handle"),f&&f.apply(h,c),f=g&&h[g],f&&f.apply&&m.acceptData(h)&&(b.result=f.apply(h,c),b.result===!1&&b.preventDefault());if(b.type=p,!e&&!b.isDefaultPrevented()&&(!k._default||k._default.apply(o.pop(),c)===!1)&&m.acceptData(d)&&g&&d[p]&&!m.isWindow(d)){l=d[g],l&&(d[g]=null),m.event.triggered=p;try{d[p]()}catch(r){}m.event.triggered=void 0,l&&(d[g]=l)}return b.result}},dispatch:function(a){a=m.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(m._data(this,"events")||{})[a.type]||[],k=m.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=m.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,g=0;while((e=f.handlers[g++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(e.namespace))&&(a.handleObj=e,a.data=e.data,c=((m.event.special[e.origType]||{}).handle||e.handler).apply(f.elem,i),void 0!==c&&(a.result=c)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!=this;i=i.parentNode||this)if(1===i.nodeType&&(i.disabled!==!0||"click"!==a.type)){for(e=[],f=0;h>f;f++)d=b[f],c=d.selector+" ",void 0===e[c]&&(e[c]=d.needsContext?m(c,this).index(i)>=0:m.find(c,this,null,[i]).length),e[c]&&e.push(d);e.length&&g.push({elem:i,handlers:e})}return h<b.length&&g.push({elem:this,handlers:b.slice(h)}),g},fix:function(a){if(a[m.expando])return a;var b,c,d,e=a.type,f=a,g=this.fixHooks[e];g||(this.fixHooks[e]=g=Z.test(e)?this.mouseHooks:Y.test(e)?this.keyHooks:{}),d=g.props?this.props.concat(g.props):this.props,a=new m.Event(f),b=d.length;while(b--)c=d[b],a[c]=f[c];return a.target||(a.target=f.srcElement||y),3===a.target.nodeType&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,g.filter?g.filter(a,f):a},props:"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return null==a.which&&(a.which=null!=b.charCode?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,b){var c,d,e,f=b.button,g=b.fromElement;return null==a.pageX&&null!=b.clientX&&(d=a.target.ownerDocument||y,e=d.documentElement,c=d.body,a.pageX=b.clientX+(e&&e.scrollLeft||c&&c.scrollLeft||0)-(e&&e.clientLeft||c&&c.clientLeft||0),a.pageY=b.clientY+(e&&e.scrollTop||c&&c.scrollTop||0)-(e&&e.clientTop||c&&c.clientTop||0)),!a.relatedTarget&&g&&(a.relatedTarget=g===a.target?b.toElement:g),a.which||void 0===f||(a.which=1&f?1:2&f?3:4&f?2:0),a}},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==ca()&&this.focus)try{return this.focus(),!1}catch(a){}},delegateType:"focusin"},blur:{trigger:function(){return this===ca()&&this.blur?(this.blur(),!1):void 0},delegateType:"focusout"},click:{trigger:function(){return m.nodeName(this,"input")&&"checkbox"===this.type&&this.click?(this.click(),!1):void 0},_default:function(a){return m.nodeName(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}},simulate:function(a,b,c,d){var e=m.extend(new m.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?m.event.trigger(e,null,b):m.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},m.removeEvent=y.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]===K&&(a[d]=null),a.detachEvent(d,c))},m.Event=function(a,b){return this instanceof m.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?aa:ba):this.type=a,b&&m.extend(this,b),this.timeStamp=a&&a.timeStamp||m.now(),void(this[m.expando]=!0)):new m.Event(a,b)},m.Event.prototype={isDefaultPrevented:ba,isPropagationStopped:ba,isImmediatePropagationStopped:ba,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=aa,a&&(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=aa,a&&(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=aa,a&&a.stopImmediatePropagation&&a.stopImmediatePropagation(),this.stopPropagation()}},m.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){m.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return(!e||e!==d&&!m.contains(d,e))&&(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),k.submitBubbles||(m.event.special.submit={setup:function(){return m.nodeName(this,"form")?!1:void m.event.add(this,"click._submit keypress._submit",function(a){var b=a.target,c=m.nodeName(b,"input")||m.nodeName(b,"button")?b.form:void 0;c&&!m._data(c,"submitBubbles")&&(m.event.add(c,"submit._submit",function(a){a._submit_bubble=!0}),m._data(c,"submitBubbles",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&m.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){return m.nodeName(this,"form")?!1:void m.event.remove(this,"._submit")}}),k.changeBubbles||(m.event.special.change={setup:function(){return X.test(this.nodeName)?(("checkbox"===this.type||"radio"===this.type)&&(m.event.add(this,"propertychange._change",function(a){"checked"===a.originalEvent.propertyName&&(this._just_changed=!0)}),m.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),m.event.simulate("change",this,a,!0)})),!1):void m.event.add(this,"beforeactivate._change",function(a){var b=a.target;X.test(b.nodeName)&&!m._data(b,"changeBubbles")&&(m.event.add(b,"change._change",function(a){!this.parentNode||a.isSimulated||a.isTrigger||m.event.simulate("change",this.parentNode,a,!0)}),m._data(b,"changeBubbles",!0))})},handle:function(a){var b=a.target;return this!==b||a.isSimulated||a.isTrigger||"radio"!==b.type&&"checkbox"!==b.type?a.handleObj.handler.apply(this,arguments):void 0},teardown:function(){return m.event.remove(this,"._change"),!X.test(this.nodeName)}}),k.focusinBubbles||m.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){m.event.simulate(b,a.target,m.event.fix(a),!0)};m.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=m._data(d,b);e||d.addEventListener(a,c,!0),m._data(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=m._data(d,b)-1;e?m._data(d,b,e):(d.removeEventListener(a,c,!0),m._removeData(d,b))}}}),m.fn.extend({on:function(a,b,c,d,e){var f,g;if("object"==typeof a){"string"!=typeof b&&(c=c||b,b=void 0);for(f in a)this.on(f,b,c,a[f],e);return this}if(null==c&&null==d?(d=b,c=b=void 0):null==d&&("string"==typeof b?(d=c,c=void 0):(d=c,c=b,b=void 0)),d===!1)d=ba;else if(!d)return this;return 1===e&&(g=d,d=function(a){return m().off(a),g.apply(this,arguments)},d.guid=g.guid||(g.guid=m.guid++)),this.each(function(){m.event.add(this,a,d,c,b)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,m(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return(b===!1||"function"==typeof b)&&(c=b,b=void 0),c===!1&&(c=ba),this.each(function(){m.event.remove(this,a,c,b)})},trigger:function(a,b){return this.each(function(){m.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];return c?m.event.trigger(a,b,c,!0):void 0}});function da(a){var b=ea.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}var ea="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",fa=/ jQuery\d+="(?:null|\d+)"/g,ga=new RegExp("<(?:"+ea+")[\\s/>]","i"),ha=/^\s+/,ia=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,ja=/<([\w:]+)/,ka=/<tbody/i,la=/<|&#?\w+;/,ma=/<(?:script|style|link)/i,na=/checked\s*(?:[^=]|=\s*.checked.)/i,oa=/^$|\/(?:java|ecma)script/i,pa=/^true\/(.*)/,qa=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,ra={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],area:[1,"<map>","</map>"],param:[1,"<object>","</object>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:k.htmlSerialize?[0,"",""]:[1,"X<div>","</div>"]},sa=da(y),ta=sa.appendChild(y.createElement("div"));ra.optgroup=ra.option,ra.tbody=ra.tfoot=ra.colgroup=ra.caption=ra.thead,ra.th=ra.td;function ua(a,b){var c,d,e=0,f=typeof a.getElementsByTagName!==K?a.getElementsByTagName(b||"*"):typeof a.querySelectorAll!==K?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||m.nodeName(d,b)?f.push(d):m.merge(f,ua(d,b));return void 0===b||b&&m.nodeName(a,b)?m.merge([a],f):f}function va(a){W.test(a.type)&&(a.defaultChecked=a.checked)}function wa(a,b){return m.nodeName(a,"table")&&m.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function xa(a){return a.type=(null!==m.find.attr(a,"type"))+"/"+a.type,a}function ya(a){var b=pa.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function za(a,b){for(var c,d=0;null!=(c=a[d]);d++)m._data(c,"globalEval",!b||m._data(b[d],"globalEval"))}function Aa(a,b){if(1===b.nodeType&&m.hasData(a)){var c,d,e,f=m._data(a),g=m._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)m.event.add(b,c,h[c][d])}g.data&&(g.data=m.extend({},g.data))}}function Ba(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!k.noCloneEvent&&b[m.expando]){e=m._data(b);for(d in e.events)m.removeEvent(b,d,e.handle);b.removeAttribute(m.expando)}"script"===c&&b.text!==a.text?(xa(b).text=a.text,ya(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),k.html5Clone&&a.innerHTML&&!m.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&W.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}}m.extend({clone:function(a,b,c){var d,e,f,g,h,i=m.contains(a.ownerDocument,a);if(k.html5Clone||m.isXMLDoc(a)||!ga.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(ta.innerHTML=a.outerHTML,ta.removeChild(f=ta.firstChild)),!(k.noCloneEvent&&k.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||m.isXMLDoc(a)))for(d=ua(f),h=ua(a),g=0;null!=(e=h[g]);++g)d[g]&&Ba(e,d[g]);if(b)if(c)for(h=h||ua(a),d=d||ua(f),g=0;null!=(e=h[g]);g++)Aa(e,d[g]);else Aa(a,f);return d=ua(f,"script"),d.length>0&&za(d,!i&&ua(a,"script")),d=h=e=null,f},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,l,n=a.length,o=da(b),p=[],q=0;n>q;q++)if(f=a[q],f||0===f)if("object"===m.type(f))m.merge(p,f.nodeType?[f]:f);else if(la.test(f)){h=h||o.appendChild(b.createElement("div")),i=(ja.exec(f)||["",""])[1].toLowerCase(),l=ra[i]||ra._default,h.innerHTML=l[1]+f.replace(ia,"<$1></$2>")+l[2],e=l[0];while(e--)h=h.lastChild;if(!k.leadingWhitespace&&ha.test(f)&&p.push(b.createTextNode(ha.exec(f)[0])),!k.tbody){f="table"!==i||ka.test(f)?"<table>"!==l[1]||ka.test(f)?0:h:h.firstChild,e=f&&f.childNodes.length;while(e--)m.nodeName(j=f.childNodes[e],"tbody")&&!j.childNodes.length&&f.removeChild(j)}m.merge(p,h.childNodes),h.textContent="";while(h.firstChild)h.removeChild(h.firstChild);h=o.lastChild}else p.push(b.createTextNode(f));h&&o.removeChild(h),k.appendChecked||m.grep(ua(p,"input"),va),q=0;while(f=p[q++])if((!d||-1===m.inArray(f,d))&&(g=m.contains(f.ownerDocument,f),h=ua(o.appendChild(f),"script"),g&&za(h),c)){e=0;while(f=h[e++])oa.test(f.type||"")&&c.push(f)}return h=null,o},cleanData:function(a,b){for(var d,e,f,g,h=0,i=m.expando,j=m.cache,l=k.deleteExpando,n=m.event.special;null!=(d=a[h]);h++)if((b||m.acceptData(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)n[e]?m.event.remove(d,e):m.removeEvent(d,e,g.handle);j[f]&&(delete j[f],l?delete d[i]:typeof d.removeAttribute!==K?d.removeAttribute(i):d[i]=null,c.push(f))}}}),m.fn.extend({text:function(a){return V(this,function(a){return void 0===a?m.text(this):this.empty().append((this[0]&&this[0].ownerDocument||y).createTextNode(a))},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=wa(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=wa(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?m.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||m.cleanData(ua(c)),c.parentNode&&(b&&m.contains(c.ownerDocument,c)&&za(ua(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&m.cleanData(ua(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&m.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return m.clone(this,a,b)})},html:function(a){return V(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(fa,""):void 0;if(!("string"!=typeof a||ma.test(a)||!k.htmlSerialize&&ga.test(a)||!k.leadingWhitespace&&ha.test(a)||ra[(ja.exec(a)||["",""])[1].toLowerCase()])){a=a.replace(ia,"<$1></$2>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(m.cleanData(ua(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,m.cleanData(ua(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,l=this.length,n=this,o=l-1,p=a[0],q=m.isFunction(p);if(q||l>1&&"string"==typeof p&&!k.checkClone&&na.test(p))return this.each(function(c){var d=n.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(l&&(i=m.buildFragment(a,this[0].ownerDocument,!1,this),c=i.firstChild,1===i.childNodes.length&&(i=c),c)){for(g=m.map(ua(i,"script"),xa),f=g.length;l>j;j++)d=i,j!==o&&(d=m.clone(d,!0,!0),f&&m.merge(g,ua(d,"script"))),b.call(this[j],d,j);if(f)for(h=g[g.length-1].ownerDocument,m.map(g,ya),j=0;f>j;j++)d=g[j],oa.test(d.type||"")&&!m._data(d,"globalEval")&&m.contains(h,d)&&(d.src?m._evalUrl&&m._evalUrl(d.src):m.globalEval((d.text||d.textContent||d.innerHTML||"").replace(qa,"")));i=c=null}return this}}),m.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){m.fn[a]=function(a){for(var c,d=0,e=[],g=m(a),h=g.length-1;h>=d;d++)c=d===h?this:this.clone(!0),m(g[d])[b](c),f.apply(e,c.get());return this.pushStack(e)}});var Ca,Da={};function Ea(b,c){var d,e=m(c.createElement(b)).appendTo(c.body),f=a.getDefaultComputedStyle&&(d=a.getDefaultComputedStyle(e[0]))?d.display:m.css(e[0],"display");return e.detach(),f}function Fa(a){var b=y,c=Da[a];return c||(c=Ea(a,b),"none"!==c&&c||(Ca=(Ca||m("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement),b=(Ca[0].contentWindow||Ca[0].contentDocument).document,b.write(),b.close(),c=Ea(a,b),Ca.detach()),Da[a]=c),c}!function(){var a;k.shrinkWrapBlocks=function(){if(null!=a)return a;a=!1;var b,c,d;return c=y.getElementsByTagName("body")[0],c&&c.style?(b=y.createElement("div"),d=y.createElement("div"),d.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(d).appendChild(b),typeof b.style.zoom!==K&&(b.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:1px;width:1px;zoom:1",b.appendChild(y.createElement("div")).style.width="5px",a=3!==b.offsetWidth),c.removeChild(d),a):void 0}}();var Ga=/^margin/,Ha=new RegExp("^("+S+")(?!px)[a-z%]+$","i"),Ia,Ja,Ka=/^(top|right|bottom|left)$/;a.getComputedStyle?(Ia=function(b){return b.ownerDocument.defaultView.opener?b.ownerDocument.defaultView.getComputedStyle(b,null):a.getComputedStyle(b,null)},Ja=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ia(a),g=c?c.getPropertyValue(b)||c[b]:void 0,c&&(""!==g||m.contains(a.ownerDocument,a)||(g=m.style(a,b)),Ha.test(g)&&Ga.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0===g?g:g+""}):y.documentElement.currentStyle&&(Ia=function(a){return a.currentStyle},Ja=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Ia(a),g=c?c[b]:void 0,null==g&&h&&h[b]&&(g=h[b]),Ha.test(g)&&!Ka.test(b)&&(d=h.left,e=a.runtimeStyle,f=e&&e.left,f&&(e.left=a.currentStyle.left),h.left="fontSize"===b?"1em":g,g=h.pixelLeft+"px",h.left=d,f&&(e.left=f)),void 0===g?g:g+""||"auto"});function La(a,b){return{get:function(){var c=a();if(null!=c)return c?void delete this.get:(this.get=b).apply(this,arguments)}}}!function(){var b,c,d,e,f,g,h;if(b=y.createElement("div"),b.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",d=b.getElementsByTagName("a")[0],c=d&&d.style){c.cssText="float:left;opacity:.5",k.opacity="0.5"===c.opacity,k.cssFloat=!!c.cssFloat,b.style.backgroundClip="content-box",b.cloneNode(!0).style.backgroundClip="",k.clearCloneStyle="content-box"===b.style.backgroundClip,k.boxSizing=""===c.boxSizing||""===c.MozBoxSizing||""===c.WebkitBoxSizing,m.extend(k,{reliableHiddenOffsets:function(){return null==g&&i(),g},boxSizingReliable:function(){return null==f&&i(),f},pixelPosition:function(){return null==e&&i(),e},reliableMarginRight:function(){return null==h&&i(),h}});function i(){var b,c,d,i;c=y.getElementsByTagName("body")[0],c&&c.style&&(b=y.createElement("div"),d=y.createElement("div"),d.style.cssText="position:absolute;border:0;width:0;height:0;top:0;left:-9999px",c.appendChild(d).appendChild(b),b.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;margin-top:1%;top:1%;border:1px;padding:1px;width:4px;position:absolute",e=f=!1,h=!0,a.getComputedStyle&&(e="1%"!==(a.getComputedStyle(b,null)||{}).top,f="4px"===(a.getComputedStyle(b,null)||{width:"4px"}).width,i=b.appendChild(y.createElement("div")),i.style.cssText=b.style.cssText="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0",i.style.marginRight=i.style.width="0",b.style.width="1px",h=!parseFloat((a.getComputedStyle(i,null)||{}).marginRight),b.removeChild(i)),b.innerHTML="<table><tr><td></td><td>t</td></tr></table>",i=b.getElementsByTagName("td"),i[0].style.cssText="margin:0;border:0;padding:0;display:none",g=0===i[0].offsetHeight,g&&(i[0].style.display="",i[1].style.display="none",g=0===i[0].offsetHeight),c.removeChild(d))}}}(),m.swap=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};var Ma=/alpha\([^)]*\)/i,Na=/opacity\s*=\s*([^)]*)/,Oa=/^(none|table(?!-c[ea]).+)/,Pa=new RegExp("^("+S+")(.*)$","i"),Qa=new RegExp("^([+-])=("+S+")","i"),Ra={position:"absolute",visibility:"hidden",display:"block"},Sa={letterSpacing:"0",fontWeight:"400"},Ta=["Webkit","O","Moz","ms"];function Ua(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=Ta.length;while(e--)if(b=Ta[e]+c,b in a)return b;return d}function Va(a,b){for(var c,d,e,f=[],g=0,h=a.length;h>g;g++)d=a[g],d.style&&(f[g]=m._data(d,"olddisplay"),c=d.style.display,b?(f[g]||"none"!==c||(d.style.display=""),""===d.style.display&&U(d)&&(f[g]=m._data(d,"olddisplay",Fa(d.nodeName)))):(e=U(d),(c&&"none"!==c||!e)&&m._data(d,"olddisplay",e?c:m.css(d,"display"))));for(g=0;h>g;g++)d=a[g],d.style&&(b&&"none"!==d.style.display&&""!==d.style.display||(d.style.display=b?f[g]||"":"none"));return a}function Wa(a,b,c){var d=Pa.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function Xa(a,b,c,d,e){for(var f=c===(d?"border":"content")?4:"width"===b?1:0,g=0;4>f;f+=2)"margin"===c&&(g+=m.css(a,c+T[f],!0,e)),d?("content"===c&&(g-=m.css(a,"padding"+T[f],!0,e)),"margin"!==c&&(g-=m.css(a,"border"+T[f]+"Width",!0,e))):(g+=m.css(a,"padding"+T[f],!0,e),"padding"!==c&&(g+=m.css(a,"border"+T[f]+"Width",!0,e)));return g}function Ya(a,b,c){var d=!0,e="width"===b?a.offsetWidth:a.offsetHeight,f=Ia(a),g=k.boxSizing&&"border-box"===m.css(a,"boxSizing",!1,f);if(0>=e||null==e){if(e=Ja(a,b,f),(0>e||null==e)&&(e=a.style[b]),Ha.test(e))return e;d=g&&(k.boxSizingReliable()||e===a.style[b]),e=parseFloat(e)||0}return e+Xa(a,b,c||(g?"border":"content"),d,f)+"px"}m.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Ja(a,"opacity");return""===c?"1":c}}}},cssNumber:{columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":k.cssFloat?"cssFloat":"styleFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=m.camelCase(b),i=a.style;if(b=m.cssProps[h]||(m.cssProps[h]=Ua(i,h)),g=m.cssHooks[b]||m.cssHooks[h],void 0===c)return g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:i[b];if(f=typeof c,"string"===f&&(e=Qa.exec(c))&&(c=(e[1]+1)*e[2]+parseFloat(m.css(a,b)),f="number"),null!=c&&c===c&&("number"!==f||m.cssNumber[h]||(c+="px"),k.clearCloneStyle||""!==c||0!==b.indexOf("background")||(i[b]="inherit"),!(g&&"set"in g&&void 0===(c=g.set(a,c,d)))))try{i[b]=c}catch(j){}}},css:function(a,b,c,d){var e,f,g,h=m.camelCase(b);return b=m.cssProps[h]||(m.cssProps[h]=Ua(a.style,h)),g=m.cssHooks[b]||m.cssHooks[h],g&&"get"in g&&(f=g.get(a,!0,c)),void 0===f&&(f=Ja(a,b,d)),"normal"===f&&b in Sa&&(f=Sa[b]),""===c||c?(e=parseFloat(f),c===!0||m.isNumeric(e)?e||0:f):f}}),m.each(["height","width"],function(a,b){m.cssHooks[b]={get:function(a,c,d){return c?Oa.test(m.css(a,"display"))&&0===a.offsetWidth?m.swap(a,Ra,function(){return Ya(a,b,d)}):Ya(a,b,d):void 0},set:function(a,c,d){var e=d&&Ia(a);return Wa(a,c,d?Xa(a,b,d,k.boxSizing&&"border-box"===m.css(a,"boxSizing",!1,e),e):0)}}}),k.opacity||(m.cssHooks.opacity={get:function(a,b){return Na.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=m.isNumeric(b)?"alpha(opacity="+100*b+")":"",f=d&&d.filter||c.filter||"";c.zoom=1,(b>=1||""===b)&&""===m.trim(f.replace(Ma,""))&&c.removeAttribute&&(c.removeAttribute("filter"),""===b||d&&!d.filter)||(c.filter=Ma.test(f)?f.replace(Ma,e):f+" "+e)}}),m.cssHooks.marginRight=La(k.reliableMarginRight,function(a,b){return b?m.swap(a,{display:"inline-block"},Ja,[a,"marginRight"]):void 0}),m.each({margin:"",padding:"",border:"Width"},function(a,b){m.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];4>d;d++)e[a+T[d]+b]=f[d]||f[d-2]||f[0];return e}},Ga.test(a)||(m.cssHooks[a+b].set=Wa)}),m.fn.extend({css:function(a,b){return V(this,function(a,b,c){var d,e,f={},g=0;if(m.isArray(b)){for(d=Ia(a),e=b.length;e>g;g++)f[b[g]]=m.css(a,b[g],!1,d);return f}return void 0!==c?m.style(a,b,c):m.css(a,b)},a,b,arguments.length>1)},show:function(){return Va(this,!0)},hide:function(){return Va(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){U(this)?m(this).show():m(this).hide()})}});function Za(a,b,c,d,e){
-return new Za.prototype.init(a,b,c,d,e)}m.Tween=Za,Za.prototype={constructor:Za,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(m.cssNumber[c]?"":"px")},cur:function(){var a=Za.propHooks[this.prop];return a&&a.get?a.get(this):Za.propHooks._default.get(this)},run:function(a){var b,c=Za.propHooks[this.prop];return this.options.duration?this.pos=b=m.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):Za.propHooks._default.set(this),this}},Za.prototype.init.prototype=Za.prototype,Za.propHooks={_default:{get:function(a){var b;return null==a.elem[a.prop]||a.elem.style&&null!=a.elem.style[a.prop]?(b=m.css(a.elem,a.prop,""),b&&"auto"!==b?b:0):a.elem[a.prop]},set:function(a){m.fx.step[a.prop]?m.fx.step[a.prop](a):a.elem.style&&(null!=a.elem.style[m.cssProps[a.prop]]||m.cssHooks[a.prop])?m.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},Za.propHooks.scrollTop=Za.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},m.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},m.fx=Za.prototype.init,m.fx.step={};var $a,_a,ab=/^(?:toggle|show|hide)$/,bb=new RegExp("^(?:([+-])=|)("+S+")([a-z%]*)$","i"),cb=/queueHooks$/,db=[ib],eb={"*":[function(a,b){var c=this.createTween(a,b),d=c.cur(),e=bb.exec(b),f=e&&e[3]||(m.cssNumber[a]?"":"px"),g=(m.cssNumber[a]||"px"!==f&&+d)&&bb.exec(m.css(c.elem,a)),h=1,i=20;if(g&&g[3]!==f){f=f||g[3],e=e||[],g=+d||1;do h=h||".5",g/=h,m.style(c.elem,a,g+f);while(h!==(h=c.cur()/d)&&1!==h&&--i)}return e&&(g=c.start=+g||+d||0,c.unit=f,c.end=e[1]?g+(e[1]+1)*e[2]:+e[2]),c}]};function fb(){return setTimeout(function(){$a=void 0}),$a=m.now()}function gb(a,b){var c,d={height:a},e=0;for(b=b?1:0;4>e;e+=2-b)c=T[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function hb(a,b,c){for(var d,e=(eb[b]||[]).concat(eb["*"]),f=0,g=e.length;g>f;f++)if(d=e[f].call(c,b,a))return d}function ib(a,b,c){var d,e,f,g,h,i,j,l,n=this,o={},p=a.style,q=a.nodeType&&U(a),r=m._data(a,"fxshow");c.queue||(h=m._queueHooks(a,"fx"),null==h.unqueued&&(h.unqueued=0,i=h.empty.fire,h.empty.fire=function(){h.unqueued||i()}),h.unqueued++,n.always(function(){n.always(function(){h.unqueued--,m.queue(a,"fx").length||h.empty.fire()})})),1===a.nodeType&&("height"in b||"width"in b)&&(c.overflow=[p.overflow,p.overflowX,p.overflowY],j=m.css(a,"display"),l="none"===j?m._data(a,"olddisplay")||Fa(a.nodeName):j,"inline"===l&&"none"===m.css(a,"float")&&(k.inlineBlockNeedsLayout&&"inline"!==Fa(a.nodeName)?p.zoom=1:p.display="inline-block")),c.overflow&&(p.overflow="hidden",k.shrinkWrapBlocks()||n.always(function(){p.overflow=c.overflow[0],p.overflowX=c.overflow[1],p.overflowY=c.overflow[2]}));for(d in b)if(e=b[d],ab.exec(e)){if(delete b[d],f=f||"toggle"===e,e===(q?"hide":"show")){if("show"!==e||!r||void 0===r[d])continue;q=!0}o[d]=r&&r[d]||m.style(a,d)}else j=void 0;if(m.isEmptyObject(o))"inline"===("none"===j?Fa(a.nodeName):j)&&(p.display=j);else{r?"hidden"in r&&(q=r.hidden):r=m._data(a,"fxshow",{}),f&&(r.hidden=!q),q?m(a).show():n.done(function(){m(a).hide()}),n.done(function(){var b;m._removeData(a,"fxshow");for(b in o)m.style(a,b,o[b])});for(d in o)g=hb(q?r[d]:0,d,n),d in r||(r[d]=g.start,q&&(g.end=g.start,g.start="width"===d||"height"===d?1:0))}}function jb(a,b){var c,d,e,f,g;for(c in a)if(d=m.camelCase(c),e=b[d],f=a[c],m.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=m.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function kb(a,b,c){var d,e,f=0,g=db.length,h=m.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=$a||fb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;i>g;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),1>f&&i?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:m.extend({},b),opts:m.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:$a||fb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=m.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;d>c;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;for(jb(k,j.opts.specialEasing);g>f;f++)if(d=db[f].call(j,a,k,j.opts))return d;return m.map(k,hb,j),m.isFunction(j.opts.start)&&j.opts.start.call(a,j),m.fx.timer(m.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}m.Animation=m.extend(kb,{tweener:function(a,b){m.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");for(var c,d=0,e=a.length;e>d;d++)c=a[d],eb[c]=eb[c]||[],eb[c].unshift(b)},prefilter:function(a,b){b?db.unshift(a):db.push(a)}}),m.speed=function(a,b,c){var d=a&&"object"==typeof a?m.extend({},a):{complete:c||!c&&b||m.isFunction(a)&&a,duration:a,easing:c&&b||b&&!m.isFunction(b)&&b};return d.duration=m.fx.off?0:"number"==typeof d.duration?d.duration:d.duration in m.fx.speeds?m.fx.speeds[d.duration]:m.fx.speeds._default,(null==d.queue||d.queue===!0)&&(d.queue="fx"),d.old=d.complete,d.complete=function(){m.isFunction(d.old)&&d.old.call(this),d.queue&&m.dequeue(this,d.queue)},d},m.fn.extend({fadeTo:function(a,b,c,d){return this.filter(U).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=m.isEmptyObject(a),f=m.speed(b,c,d),g=function(){var b=kb(this,m.extend({},a),f);(e||m._data(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=m.timers,g=m._data(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&cb.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));(b||!c)&&m.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=m._data(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=m.timers,g=d?d.length:0;for(c.finish=!0,m.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;g>b;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),m.each(["toggle","show","hide"],function(a,b){var c=m.fn[b];m.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(gb(b,!0),a,d,e)}}),m.each({slideDown:gb("show"),slideUp:gb("hide"),slideToggle:gb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){m.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),m.timers=[],m.fx.tick=function(){var a,b=m.timers,c=0;for($a=m.now();c<b.length;c++)a=b[c],a()||b[c]!==a||b.splice(c--,1);b.length||m.fx.stop(),$a=void 0},m.fx.timer=function(a){m.timers.push(a),a()?m.fx.start():m.timers.pop()},m.fx.interval=13,m.fx.start=function(){_a||(_a=setInterval(m.fx.tick,m.fx.interval))},m.fx.stop=function(){clearInterval(_a),_a=null},m.fx.speeds={slow:600,fast:200,_default:400},m.fn.delay=function(a,b){return a=m.fx?m.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},function(){var a,b,c,d,e;b=y.createElement("div"),b.setAttribute("className","t"),b.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",d=b.getElementsByTagName("a")[0],c=y.createElement("select"),e=c.appendChild(y.createElement("option")),a=b.getElementsByTagName("input")[0],d.style.cssText="top:1px",k.getSetAttribute="t"!==b.className,k.style=/top/.test(d.getAttribute("style")),k.hrefNormalized="/a"===d.getAttribute("href"),k.checkOn=!!a.value,k.optSelected=e.selected,k.enctype=!!y.createElement("form").enctype,c.disabled=!0,k.optDisabled=!e.disabled,a=y.createElement("input"),a.setAttribute("value",""),k.input=""===a.getAttribute("value"),a.value="t",a.setAttribute("type","radio"),k.radioValue="t"===a.value}();var lb=/\r/g;m.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=m.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,m(this).val()):a,null==e?e="":"number"==typeof e?e+="":m.isArray(e)&&(e=m.map(e,function(a){return null==a?"":a+""})),b=m.valHooks[this.type]||m.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=m.valHooks[e.type]||m.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(lb,""):null==c?"":c)}}}),m.extend({valHooks:{option:{get:function(a){var b=m.find.attr(a,"value");return null!=b?b:m.trim(m.text(a))}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type||0>e,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],!(!c.selected&&i!==e||(k.optDisabled?c.disabled:null!==c.getAttribute("disabled"))||c.parentNode.disabled&&m.nodeName(c.parentNode,"optgroup"))){if(b=m(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=m.makeArray(b),g=e.length;while(g--)if(d=e[g],m.inArray(m.valHooks.option.get(d),f)>=0)try{d.selected=c=!0}catch(h){d.scrollHeight}else d.selected=!1;return c||(a.selectedIndex=-1),e}}}}),m.each(["radio","checkbox"],function(){m.valHooks[this]={set:function(a,b){return m.isArray(b)?a.checked=m.inArray(m(a).val(),b)>=0:void 0}},k.checkOn||(m.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var mb,nb,ob=m.expr.attrHandle,pb=/^(?:checked|selected)$/i,qb=k.getSetAttribute,rb=k.input;m.fn.extend({attr:function(a,b){return V(this,m.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){m.removeAttr(this,a)})}}),m.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(a&&3!==f&&8!==f&&2!==f)return typeof a.getAttribute===K?m.prop(a,b,c):(1===f&&m.isXMLDoc(a)||(b=b.toLowerCase(),d=m.attrHooks[b]||(m.expr.match.bool.test(b)?nb:mb)),void 0===c?d&&"get"in d&&null!==(e=d.get(a,b))?e:(e=m.find.attr(a,b),null==e?void 0:e):null!==c?d&&"set"in d&&void 0!==(e=d.set(a,c,b))?e:(a.setAttribute(b,c+""),c):void m.removeAttr(a,b))},removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(E);if(f&&1===a.nodeType)while(c=f[e++])d=m.propFix[c]||c,m.expr.match.bool.test(c)?rb&&qb||!pb.test(c)?a[d]=!1:a[m.camelCase("default-"+c)]=a[d]=!1:m.attr(a,c,""),a.removeAttribute(qb?c:d)},attrHooks:{type:{set:function(a,b){if(!k.radioValue&&"radio"===b&&m.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}}}),nb={set:function(a,b,c){return b===!1?m.removeAttr(a,c):rb&&qb||!pb.test(c)?a.setAttribute(!qb&&m.propFix[c]||c,c):a[m.camelCase("default-"+c)]=a[c]=!0,c}},m.each(m.expr.match.bool.source.match(/\w+/g),function(a,b){var c=ob[b]||m.find.attr;ob[b]=rb&&qb||!pb.test(b)?function(a,b,d){var e,f;return d||(f=ob[b],ob[b]=e,e=null!=c(a,b,d)?b.toLowerCase():null,ob[b]=f),e}:function(a,b,c){return c?void 0:a[m.camelCase("default-"+b)]?b.toLowerCase():null}}),rb&&qb||(m.attrHooks.value={set:function(a,b,c){return m.nodeName(a,"input")?void(a.defaultValue=b):mb&&mb.set(a,b,c)}}),qb||(mb={set:function(a,b,c){var d=a.getAttributeNode(c);return d||a.setAttributeNode(d=a.ownerDocument.createAttribute(c)),d.value=b+="","value"===c||b===a.getAttribute(c)?b:void 0}},ob.id=ob.name=ob.coords=function(a,b,c){var d;return c?void 0:(d=a.getAttributeNode(b))&&""!==d.value?d.value:null},m.valHooks.button={get:function(a,b){var c=a.getAttributeNode(b);return c&&c.specified?c.value:void 0},set:mb.set},m.attrHooks.contenteditable={set:function(a,b,c){mb.set(a,""===b?!1:b,c)}},m.each(["width","height"],function(a,b){m.attrHooks[b]={set:function(a,c){return""===c?(a.setAttribute(b,"auto"),c):void 0}}})),k.style||(m.attrHooks.style={get:function(a){return a.style.cssText||void 0},set:function(a,b){return a.style.cssText=b+""}});var sb=/^(?:input|select|textarea|button|object)$/i,tb=/^(?:a|area)$/i;m.fn.extend({prop:function(a,b){return V(this,m.prop,a,b,arguments.length>1)},removeProp:function(a){return a=m.propFix[a]||a,this.each(function(){try{this[a]=void 0,delete this[a]}catch(b){}})}}),m.extend({propFix:{"for":"htmlFor","class":"className"},prop:function(a,b,c){var d,e,f,g=a.nodeType;if(a&&3!==g&&8!==g&&2!==g)return f=1!==g||!m.isXMLDoc(a),f&&(b=m.propFix[b]||b,e=m.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=m.find.attr(a,"tabindex");return b?parseInt(b,10):sb.test(a.nodeName)||tb.test(a.nodeName)&&a.href?0:-1}}}}),k.hrefNormalized||m.each(["href","src"],function(a,b){m.propHooks[b]={get:function(a){return a.getAttribute(b,4)}}}),k.optSelected||(m.propHooks.selected={get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}}),m.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){m.propFix[this.toLowerCase()]=this}),k.enctype||(m.propFix.enctype="encoding");var ub=/[\t\r\n\f]/g;m.fn.extend({addClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j="string"==typeof a&&a;if(m.isFunction(a))return this.each(function(b){m(this).addClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(E)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(ub," "):" ")){f=0;while(e=b[f++])d.indexOf(" "+e+" ")<0&&(d+=e+" ");g=m.trim(d),c.className!==g&&(c.className=g)}return this},removeClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j=0===arguments.length||"string"==typeof a&&a;if(m.isFunction(a))return this.each(function(b){m(this).removeClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(E)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(ub," "):"")){f=0;while(e=b[f++])while(d.indexOf(" "+e+" ")>=0)d=d.replace(" "+e+" "," ");g=a?m.trim(d):"",c.className!==g&&(c.className=g)}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):this.each(m.isFunction(a)?function(c){m(this).toggleClass(a.call(this,c,this.className,b),b)}:function(){if("string"===c){var b,d=0,e=m(this),f=a.match(E)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else(c===K||"boolean"===c)&&(this.className&&m._data(this,"__className__",this.className),this.className=this.className||a===!1?"":m._data(this,"__className__")||"")})},hasClass:function(a){for(var b=" "+a+" ",c=0,d=this.length;d>c;c++)if(1===this[c].nodeType&&(" "+this[c].className+" ").replace(ub," ").indexOf(b)>=0)return!0;return!1}}),m.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){m.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),m.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}});var vb=m.now(),wb=/\?/,xb=/(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;m.parseJSON=function(b){if(a.JSON&&a.JSON.parse)return a.JSON.parse(b+"");var c,d=null,e=m.trim(b+"");return e&&!m.trim(e.replace(xb,function(a,b,e,f){return c&&b&&(d=0),0===d?a:(c=e||b,d+=!f-!e,"")}))?Function("return "+e)():m.error("Invalid JSON: "+b)},m.parseXML=function(b){var c,d;if(!b||"string"!=typeof b)return null;try{a.DOMParser?(d=new DOMParser,c=d.parseFromString(b,"text/xml")):(c=new ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b))}catch(e){c=void 0}return c&&c.documentElement&&!c.getElementsByTagName("parsererror").length||m.error("Invalid XML: "+b),c};var yb,zb,Ab=/#.*$/,Bb=/([?&])_=[^&]*/,Cb=/^(.*?):[ \t]*([^\r\n]*)\r?$/gm,Db=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Eb=/^(?:GET|HEAD)$/,Fb=/^\/\//,Gb=/^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,Hb={},Ib={},Jb="*/".concat("*");try{zb=location.href}catch(Kb){zb=y.createElement("a"),zb.href="",zb=zb.href}yb=Gb.exec(zb.toLowerCase())||[];function Lb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(E)||[];if(m.isFunction(c))while(d=f[e++])"+"===d.charAt(0)?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Mb(a,b,c,d){var e={},f=a===Ib;function g(h){var i;return e[h]=!0,m.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Nb(a,b){var c,d,e=m.ajaxSettings.flatOptions||{};for(d in b)void 0!==b[d]&&((e[d]?a:c||(c={}))[d]=b[d]);return c&&m.extend(!0,a,c),a}function Ob(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===e&&(e=a.mimeType||b.getResponseHeader("Content-Type"));if(e)for(g in h)if(h[g]&&h[g].test(e)){i.unshift(g);break}if(i[0]in c)f=i[0];else{for(g in c){if(!i[0]||a.converters[g+" "+i[0]]){f=g;break}d||(d=g)}f=f||d}return f?(f!==i[0]&&i.unshift(f),c[f]):void 0}function Pb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}m.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:zb,type:"GET",isLocal:Db.test(yb[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Jb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":m.parseJSON,"text xml":m.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Nb(Nb(a,m.ajaxSettings),b):Nb(m.ajaxSettings,a)},ajaxPrefilter:Lb(Hb),ajaxTransport:Lb(Ib),ajax:function(a,b){"object"==typeof a&&(b=a,a=void 0),b=b||{};var c,d,e,f,g,h,i,j,k=m.ajaxSetup({},b),l=k.context||k,n=k.context&&(l.nodeType||l.jquery)?m(l):m.event,o=m.Deferred(),p=m.Callbacks("once memory"),q=k.statusCode||{},r={},s={},t=0,u="canceled",v={readyState:0,getResponseHeader:function(a){var b;if(2===t){if(!j){j={};while(b=Cb.exec(f))j[b[1].toLowerCase()]=b[2]}b=j[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return 2===t?f:null},setRequestHeader:function(a,b){var c=a.toLowerCase();return t||(a=s[c]=s[c]||a,r[a]=b),this},overrideMimeType:function(a){return t||(k.mimeType=a),this},statusCode:function(a){var b;if(a)if(2>t)for(b in a)q[b]=[q[b],a[b]];else v.always(a[v.status]);return this},abort:function(a){var b=a||u;return i&&i.abort(b),x(0,b),this}};if(o.promise(v).complete=p.add,v.success=v.done,v.error=v.fail,k.url=((a||k.url||zb)+"").replace(Ab,"").replace(Fb,yb[1]+"//"),k.type=b.method||b.type||k.method||k.type,k.dataTypes=m.trim(k.dataType||"*").toLowerCase().match(E)||[""],null==k.crossDomain&&(c=Gb.exec(k.url.toLowerCase()),k.crossDomain=!(!c||c[1]===yb[1]&&c[2]===yb[2]&&(c[3]||("http:"===c[1]?"80":"443"))===(yb[3]||("http:"===yb[1]?"80":"443")))),k.data&&k.processData&&"string"!=typeof k.data&&(k.data=m.param(k.data,k.traditional)),Mb(Hb,k,b,v),2===t)return v;h=m.event&&k.global,h&&0===m.active++&&m.event.trigger("ajaxStart"),k.type=k.type.toUpperCase(),k.hasContent=!Eb.test(k.type),e=k.url,k.hasContent||(k.data&&(e=k.url+=(wb.test(e)?"&":"?")+k.data,delete k.data),k.cache===!1&&(k.url=Bb.test(e)?e.replace(Bb,"$1_="+vb++):e+(wb.test(e)?"&":"?")+"_="+vb++)),k.ifModified&&(m.lastModified[e]&&v.setRequestHeader("If-Modified-Since",m.lastModified[e]),m.etag[e]&&v.setRequestHeader("If-None-Match",m.etag[e])),(k.data&&k.hasContent&&k.contentType!==!1||b.contentType)&&v.setRequestHeader("Content-Type",k.contentType),v.setRequestHeader("Accept",k.dataTypes[0]&&k.accepts[k.dataTypes[0]]?k.accepts[k.dataTypes[0]]+("*"!==k.dataTypes[0]?", "+Jb+"; q=0.01":""):k.accepts["*"]);for(d in k.headers)v.setRequestHeader(d,k.headers[d]);if(k.beforeSend&&(k.beforeSend.call(l,v,k)===!1||2===t))return v.abort();u="abort";for(d in{success:1,error:1,complete:1})v[d](k[d]);if(i=Mb(Ib,k,b,v)){v.readyState=1,h&&n.trigger("ajaxSend",[v,k]),k.async&&k.timeout>0&&(g=setTimeout(function(){v.abort("timeout")},k.timeout));try{t=1,i.send(r,x)}catch(w){if(!(2>t))throw w;x(-1,w)}}else x(-1,"No Transport");function x(a,b,c,d){var j,r,s,u,w,x=b;2!==t&&(t=2,g&&clearTimeout(g),i=void 0,f=d||"",v.readyState=a>0?4:0,j=a>=200&&300>a||304===a,c&&(u=Ob(k,v,c)),u=Pb(k,u,v,j),j?(k.ifModified&&(w=v.getResponseHeader("Last-Modified"),w&&(m.lastModified[e]=w),w=v.getResponseHeader("etag"),w&&(m.etag[e]=w)),204===a||"HEAD"===k.type?x="nocontent":304===a?x="notmodified":(x=u.state,r=u.data,s=u.error,j=!s)):(s=x,(a||!x)&&(x="error",0>a&&(a=0))),v.status=a,v.statusText=(b||x)+"",j?o.resolveWith(l,[r,x,v]):o.rejectWith(l,[v,x,s]),v.statusCode(q),q=void 0,h&&n.trigger(j?"ajaxSuccess":"ajaxError",[v,k,j?r:s]),p.fireWith(l,[v,x]),h&&(n.trigger("ajaxComplete",[v,k]),--m.active||m.event.trigger("ajaxStop")))}return v},getJSON:function(a,b,c){return m.get(a,b,c,"json")},getScript:function(a,b){return m.get(a,void 0,b,"script")}}),m.each(["get","post"],function(a,b){m[b]=function(a,c,d,e){return m.isFunction(c)&&(e=e||d,d=c,c=void 0),m.ajax({url:a,type:b,dataType:e,data:c,success:d})}}),m._evalUrl=function(a){return m.ajax({url:a,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0})},m.fn.extend({wrapAll:function(a){if(m.isFunction(a))return this.each(function(b){m(this).wrapAll(a.call(this,b))});if(this[0]){var b=m(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&1===a.firstChild.nodeType)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return this.each(m.isFunction(a)?function(b){m(this).wrapInner(a.call(this,b))}:function(){var b=m(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=m.isFunction(a);return this.each(function(c){m(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){m.nodeName(this,"body")||m(this).replaceWith(this.childNodes)}).end()}}),m.expr.filters.hidden=function(a){return a.offsetWidth<=0&&a.offsetHeight<=0||!k.reliableHiddenOffsets()&&"none"===(a.style&&a.style.display||m.css(a,"display"))},m.expr.filters.visible=function(a){return!m.expr.filters.hidden(a)};var Qb=/%20/g,Rb=/\[\]$/,Sb=/\r?\n/g,Tb=/^(?:submit|button|image|reset|file)$/i,Ub=/^(?:input|select|textarea|keygen)/i;function Vb(a,b,c,d){var e;if(m.isArray(b))m.each(b,function(b,e){c||Rb.test(a)?d(a,e):Vb(a+"["+("object"==typeof e?b:"")+"]",e,c,d)});else if(c||"object"!==m.type(b))d(a,b);else for(e in b)Vb(a+"["+e+"]",b[e],c,d)}m.param=function(a,b){var c,d=[],e=function(a,b){b=m.isFunction(b)?b():null==b?"":b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};if(void 0===b&&(b=m.ajaxSettings&&m.ajaxSettings.traditional),m.isArray(a)||a.jquery&&!m.isPlainObject(a))m.each(a,function(){e(this.name,this.value)});else for(c in a)Vb(c,a[c],b,e);return d.join("&").replace(Qb,"+")},m.fn.extend({serialize:function(){return m.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=m.prop(this,"elements");return a?m.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!m(this).is(":disabled")&&Ub.test(this.nodeName)&&!Tb.test(a)&&(this.checked||!W.test(a))}).map(function(a,b){var c=m(this).val();return null==c?null:m.isArray(c)?m.map(c,function(a){return{name:b.name,value:a.replace(Sb,"\r\n")}}):{name:b.name,value:c.replace(Sb,"\r\n")}}).get()}}),m.ajaxSettings.xhr=void 0!==a.ActiveXObject?function(){return!this.isLocal&&/^(get|post|head|put|delete|options)$/i.test(this.type)&&Zb()||$b()}:Zb;var Wb=0,Xb={},Yb=m.ajaxSettings.xhr();a.attachEvent&&a.attachEvent("onunload",function(){for(var a in Xb)Xb[a](void 0,!0)}),k.cors=!!Yb&&"withCredentials"in Yb,Yb=k.ajax=!!Yb,Yb&&m.ajaxTransport(function(a){if(!a.crossDomain||k.cors){var b;return{send:function(c,d){var e,f=a.xhr(),g=++Wb;if(f.open(a.type,a.url,a.async,a.username,a.password),a.xhrFields)for(e in a.xhrFields)f[e]=a.xhrFields[e];a.mimeType&&f.overrideMimeType&&f.overrideMimeType(a.mimeType),a.crossDomain||c["X-Requested-With"]||(c["X-Requested-With"]="XMLHttpRequest");for(e in c)void 0!==c[e]&&f.setRequestHeader(e,c[e]+"");f.send(a.hasContent&&a.data||null),b=function(c,e){var h,i,j;if(b&&(e||4===f.readyState))if(delete Xb[g],b=void 0,f.onreadystatechange=m.noop,e)4!==f.readyState&&f.abort();else{j={},h=f.status,"string"==typeof f.responseText&&(j.text=f.responseText);try{i=f.statusText}catch(k){i=""}h||!a.isLocal||a.crossDomain?1223===h&&(h=204):h=j.text?200:404}j&&d(h,i,j,f.getAllResponseHeaders())},a.async?4===f.readyState?setTimeout(b):f.onreadystatechange=Xb[g]=b:b()},abort:function(){b&&b(void 0,!0)}}}});function Zb(){try{return new a.XMLHttpRequest}catch(b){}}function $b(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}m.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(a){return m.globalEval(a),a}}}),m.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),m.ajaxTransport("script",function(a){if(a.crossDomain){var b,c=y.head||m("head")[0]||y.documentElement;return{send:function(d,e){b=y.createElement("script"),b.async=!0,a.scriptCharset&&(b.charset=a.scriptCharset),b.src=a.url,b.onload=b.onreadystatechange=function(a,c){(c||!b.readyState||/loaded|complete/.test(b.readyState))&&(b.onload=b.onreadystatechange=null,b.parentNode&&b.parentNode.removeChild(b),b=null,c||e(200,"success"))},c.insertBefore(b,c.firstChild)},abort:function(){b&&b.onload(void 0,!0)}}}});var _b=[],ac=/(=)\?(?=&|$)|\?\?/;m.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=_b.pop()||m.expando+"_"+vb++;return this[a]=!0,a}}),m.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(ac.test(b.url)?"url":"string"==typeof b.data&&!(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&ac.test(b.data)&&"data");return h||"jsonp"===b.dataTypes[0]?(e=b.jsonpCallback=m.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(ac,"$1"+e):b.jsonp!==!1&&(b.url+=(wb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||m.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,_b.push(e)),g&&m.isFunction(f)&&f(g[0]),g=f=void 0}),"script"):void 0}),m.parseHTML=function(a,b,c){if(!a||"string"!=typeof a)return null;"boolean"==typeof b&&(c=b,b=!1),b=b||y;var d=u.exec(a),e=!c&&[];return d?[b.createElement(d[1])]:(d=m.buildFragment([a],b,e),e&&e.length&&m(e).remove(),m.merge([],d.childNodes))};var bc=m.fn.load;m.fn.load=function(a,b,c){if("string"!=typeof a&&bc)return bc.apply(this,arguments);var d,e,f,g=this,h=a.indexOf(" ");return h>=0&&(d=m.trim(a.slice(h,a.length)),a=a.slice(0,h)),m.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(f="POST"),g.length>0&&m.ajax({url:a,type:f,dataType:"html",data:b}).done(function(a){e=arguments,g.html(d?m("<div>").append(m.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},m.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){m.fn[b]=function(a){return this.on(b,a)}}),m.expr.filters.animated=function(a){return m.grep(m.timers,function(b){return a===b.elem}).length};var cc=a.document.documentElement;function dc(a){return m.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}m.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=m.css(a,"position"),l=m(a),n={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=m.css(a,"top"),i=m.css(a,"left"),j=("absolute"===k||"fixed"===k)&&m.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),m.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(n.top=b.top-h.top+g),null!=b.left&&(n.left=b.left-h.left+e),"using"in b?b.using.call(a,n):l.css(n)}},m.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){m.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,m.contains(b,e)?(typeof e.getBoundingClientRect!==K&&(d=e.getBoundingClientRect()),c=dc(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===m.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),m.nodeName(a[0],"html")||(c=a.offset()),c.top+=m.css(a[0],"borderTopWidth",!0),c.left+=m.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-m.css(d,"marginTop",!0),left:b.left-c.left-m.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||cc;while(a&&!m.nodeName(a,"html")&&"static"===m.css(a,"position"))a=a.offsetParent;return a||cc})}}),m.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);m.fn[a]=function(d){return V(this,function(a,d,e){var f=dc(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?m(f).scrollLeft():e,c?e:m(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),m.each(["top","left"],function(a,b){m.cssHooks[b]=La(k.pixelPosition,function(a,c){return c?(c=Ja(a,b),Ha.test(c)?m(a).position()[b]+"px":c):void 0})}),m.each({Height:"height",Width:"width"},function(a,b){m.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){m.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return V(this,function(b,c,d){var e;return m.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?m.css(b,c,g):m.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),m.fn.size=function(){return this.length},m.fn.andSelf=m.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return m});var ec=a.jQuery,fc=a.$;return m.noConflict=function(b){return a.$===m&&(a.$=fc),b&&a.jQuery===m&&(a.jQuery=ec),m},typeof b===K&&(a.jQuery=a.$=m),m});
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/less.png b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/less.png
deleted file mode 100644
index 5efefd62b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/less.png and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/more.png b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/more.png
deleted file mode 100644
index 804fa226f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/more.png and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/source.png b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/source.png
deleted file mode 100644
index f7ea90419..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/source.png and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/style.css b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/style.css
deleted file mode 100644
index 2f4c5beab..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/style.css
+++ /dev/null
@@ -1,143 +0,0 @@
-@font-face {
-  font-family: 'Ubuntu';
-  font-style: normal;
-  font-weight: normal;
-  src: local('Ubuntu'), local('Ubuntu-Regular'),
-    url('?__debugger__=yes&cmd=resource&f=ubuntu.ttf') format('truetype');
-}
-
-body, input  { font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
-               'Verdana', sans-serif; color: #000; text-align: center;
-               margin: 1em; padding: 0; font-size: 15px; }
-h1, h2, h3   { font-family: 'Ubuntu', 'Lucida Grande', 'Lucida Sans Unicode',
-               'Geneva', 'Verdana', sans-serif; font-weight: normal; }
-
-input        { background-color: #fff; margin: 0; text-align: left;
-               outline: none !important; }
-input[type="submit"] { padding: 3px 6px; }
-a            { color: #11557C; }
-a:hover      { color: #177199; }
-pre, code,
-textarea     { font-family: 'Consolas', 'Monaco', 'Bitstream Vera Sans Mono',
-               monospace; font-size: 14px; }
-
-div.debugger { text-align: left; padding: 12px; margin: auto;
-               background-color: white; }
-h1           { font-size: 36px; margin: 0 0 0.3em 0; }
-div.detail p { margin: 0 0 8px 13px; font-size: 14px; white-space: pre-wrap;
-               font-family: monospace; }
-div.explanation { margin: 20px 13px; font-size: 15px; color: #555; }
-div.footer   { font-size: 13px; text-align: right; margin: 30px 0;
-               color: #86989B; }
-
-h2           { font-size: 16px; margin: 1.3em 0 0.0 0; padding: 9px;
-               background-color: #11557C; color: white; }
-h2 em, h3 em { font-style: normal; color: #A5D6D9; font-weight: normal; }
-
-div.traceback, div.plain { border: 1px solid #ddd; margin: 0 0 1em 0; padding: 10px; }
-div.plain p      { margin: 0; }
-div.plain textarea,
-div.plain pre { margin: 10px 0 0 0; padding: 4px;
-                background-color: #E8EFF0; border: 1px solid #D3E7E9; }
-div.plain textarea { width: 99%; height: 300px; }
-div.traceback h3 { font-size: 1em; margin: 0 0 0.8em 0; }
-div.traceback ul { list-style: none; margin: 0; padding: 0 0 0 1em; }
-div.traceback h4 { font-size: 13px; font-weight: normal; margin: 0.7em 0 0.1em 0; }
-div.traceback pre { margin: 0; padding: 5px 0 3px 15px;
-                    background-color: #E8EFF0; border: 1px solid #D3E7E9; }
-div.traceback pre:hover { background-color: #DDECEE; color: black; cursor: pointer; }
-div.traceback div.source.expanded pre + pre { border-top: none; }
-
-div.traceback span.ws { display: none; }
-div.traceback pre.before, div.traceback pre.after { display: none; background: white; }
-div.traceback div.source.expanded pre.before,
-div.traceback div.source.expanded pre.after {
-    display: block;
-}
-
-div.traceback div.source.expanded span.ws {
-    display: inline;
-}
-
-div.traceback blockquote { margin: 1em 0 0 0; padding: 0; }
-div.traceback img { float: right; padding: 2px; margin: -3px 2px 0 0; display: none; }
-div.traceback img:hover { background-color: #ddd; cursor: pointer;
-                          border-color: #BFDDE0; }
-div.traceback pre:hover img { display: block; }
-div.traceback cite.filename { font-style: normal; color: #3B666B; }
-
-pre.console { border: 1px solid #ccc; background: white!important;
-              color: black; padding: 5px!important;
-              margin: 3px 0 0 0!important; cursor: default!important;
-              max-height: 400px; overflow: auto; }
-pre.console form { color: #555; }
-pre.console input { background-color: transparent; color: #555;
-                    width: 90%; font-family: 'Consolas', 'Deja Vu Sans Mono',
-                    'Bitstream Vera Sans Mono', monospace; font-size: 14px;
-                     border: none!important; }
-
-span.string { color: #30799B; }
-span.number { color: #9C1A1C; }
-span.help   { color: #3A7734; }
-span.object { color: #485F6E; }
-span.extended { opacity: 0.5; }
-span.extended:hover { opacity: 1; }
-a.toggle { text-decoration: none; background-repeat: no-repeat;
-           background-position: center center;
-           background-image: url(?__debugger__=yes&cmd=resource&f=more.png); }
-a.toggle:hover { background-color: #444; }
-a.open { background-image: url(?__debugger__=yes&cmd=resource&f=less.png); }
-
-pre.console div.traceback,
-pre.console div.box { margin: 5px 10px; white-space: normal;
-                      border: 1px solid #11557C; padding: 10px;
-                      font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
-                      'Verdana', sans-serif;  }
-pre.console div.box h3,
-pre.console div.traceback h3 { margin: -10px -10px 10px -10px; padding: 5px;
-                               background: #11557C; color: white; }
-
-pre.console div.traceback pre:hover { cursor: default; background: #E8EFF0; }
-pre.console div.traceback pre.syntaxerror { background: inherit; border: none;
-                                            margin: 20px -10px -10px -10px;
-                                            padding: 10px; border-top: 1px solid #BFDDE0;
-                                            background: #E8EFF0; }
-pre.console div.noframe-traceback pre.syntaxerror { margin-top: -10px; border: none; }
-
-pre.console div.box pre.repr { padding: 0; margin: 0; background-color: white; border: none; }
-pre.console div.box table { margin-top: 6px; }
-pre.console div.box pre { border: none; }
-pre.console div.box pre.help { background-color: white; }
-pre.console div.box pre.help:hover { cursor: default; }
-pre.console table tr { vertical-align: top; }
-div.console { border: 1px solid #ccc; padding: 4px; background-color: #fafafa; }
-
-div.traceback pre, div.console pre {
-    white-space: pre-wrap;       /* css-3 should we be so lucky... */
-    white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
-    white-space: -pre-wrap;      /* Opera 4-6 ?? */
-    white-space: -o-pre-wrap;    /* Opera 7 ?? */
-    word-wrap: break-word;       /* Internet Explorer 5.5+ */
-    _white-space: pre;           /* IE only hack to re-specify in
-                                 addition to word-wrap  */
-}
-
-
-div.pin-prompt {
-    position: absolute;
-    display: none;
-    top: 0;
-    bottom: 0;
-    left: 0;
-    right: 0;
-    background: rgba(255, 255, 255, 0.8);
-}
-
-div.pin-prompt .inner {
-    background: #eee;
-    padding: 10px 50px;
-    width: 350px;
-    margin: 10% auto 0 auto;
-    border: 1px solid #ccc;
-    border-radius: 2px;
-}
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/ubuntu.ttf b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/ubuntu.ttf
deleted file mode 100644
index 8079f938c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/shared/ubuntu.ttf and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/tbtools.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/tbtools.py
deleted file mode 100644
index 27a31bc5b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/debug/tbtools.py
+++ /dev/null
@@ -1,556 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.debug.tbtools
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    This module provides various traceback related utility functions.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD.
-"""
-import re
-
-import os
-import sys
-import json
-import inspect
-import traceback
-import codecs
-from tokenize import TokenError
-
-from werkzeug.utils import cached_property, escape
-from werkzeug.debug.console import Console
-from werkzeug._compat import range_type, PY2, text_type, string_types, \
-    to_native, to_unicode
-from werkzeug.filesystem import get_filesystem_encoding
-
-
-_coding_re = re.compile(br'coding[:=]\s*([-\w.]+)')
-_line_re = re.compile(br'^(.*?)$', re.MULTILINE)
-_funcdef_re = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
-UTF8_COOKIE = b'\xef\xbb\xbf'
-
-system_exceptions = (SystemExit, KeyboardInterrupt)
-try:
-    system_exceptions += (GeneratorExit,)
-except NameError:
-    pass
-
-
-HEADER = u'''\
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-  <head>
-    <title>%(title)s // Werkzeug Debugger</title>
-    <link rel="stylesheet" href="?__debugger__=yes&amp;cmd=resource&amp;f=style.css"
-        type="text/css">
-    <!-- We need to make sure this has a favicon so that the debugger does
-         not by accident trigger a request to /favicon.ico which might
-         change the application state. -->
-    <link rel="shortcut icon"
-        href="?__debugger__=yes&amp;cmd=resource&amp;f=console.png">
-    <script src="?__debugger__=yes&amp;cmd=resource&amp;f=jquery.js"></script>
-    <script src="?__debugger__=yes&amp;cmd=resource&amp;f=debugger.js"></script>
-    <script type="text/javascript">
-      var TRACEBACK = %(traceback_id)d,
-          CONSOLE_MODE = %(console)s,
-          EVALEX = %(evalex)s,
-          EVALEX_TRUSTED = %(evalex_trusted)s,
-          SECRET = "%(secret)s";
-    </script>
-  </head>
-  <body style="background-color: #fff">
-    <div class="debugger">
-'''
-FOOTER = u'''\
-      <div class="footer">
-        Brought to you by <strong class="arthur">DON'T PANIC</strong>, your
-        friendly Werkzeug powered traceback interpreter.
-      </div>
-    </div>
-
-    <div class="pin-prompt">
-      <div class="inner">
-        <h3>Console Locked</h3>
-        <p>
-          The console is locked and needs to be unlocked by entering the PIN.
-          You can find the PIN printed out on the standard output of your
-          shell that runs the server.
-        <form>
-          <p>PIN:
-            <input type=text name=pin size=14>
-            <input type=submit name=btn value="Confirm Pin">
-        </form>
-      </div>
-    </div>
-  </body>
-</html>
-'''
-
-PAGE_HTML = HEADER + u'''\
-<h1>%(exception_type)s</h1>
-<div class="detail">
-  <p class="errormsg">%(exception)s</p>
-</div>
-<h2 class="traceback">Traceback <em>(most recent call last)</em></h2>
-%(summary)s
-<div class="plain">
-  <form action="/?__debugger__=yes&amp;cmd=paste" method="post">
-    <p>
-      <input type="hidden" name="language" value="pytb">
-      This is the Copy/Paste friendly version of the traceback.  <span
-      class="pastemessage">You can also paste this traceback into
-      a <a href="https://gist.github.com/">gist</a>:
-      <input type="submit" value="create paste"></span>
-    </p>
-    <textarea cols="50" rows="10" name="code" readonly>%(plaintext)s</textarea>
-  </form>
-</div>
-<div class="explanation">
-  The debugger caught an exception in your WSGI application.  You can now
-  look at the traceback which led to the error.  <span class="nojavascript">
-  If you enable JavaScript you can also use additional features such as code
-  execution (if the evalex feature is enabled), automatic pasting of the
-  exceptions and much more.</span>
-</div>
-''' + FOOTER + '''
-<!--
-
-%(plaintext_cs)s
-
--->
-'''
-
-CONSOLE_HTML = HEADER + u'''\
-<h1>Interactive Console</h1>
-<div class="explanation">
-In this console you can execute Python expressions in the context of the
-application.  The initial namespace was created by the debugger automatically.
-</div>
-<div class="console"><div class="inner">The Console requires JavaScript.</div></div>
-''' + FOOTER
-
-SUMMARY_HTML = u'''\
-<div class="%(classes)s">
-  %(title)s
-  <ul>%(frames)s</ul>
-  %(description)s
-</div>
-'''
-
-FRAME_HTML = u'''\
-<div class="frame" id="frame-%(id)d">
-  <h4>File <cite class="filename">"%(filename)s"</cite>,
-      line <em class="line">%(lineno)s</em>,
-      in <code class="function">%(function_name)s</code></h4>
-  <div class="source">%(lines)s</div>
-</div>
-'''
-
-SOURCE_LINE_HTML = u'''\
-<tr class="%(classes)s">
-  <td class=lineno>%(lineno)s</td>
-  <td>%(code)s</td>
-</tr>
-'''
-
-
-def render_console_html(secret, evalex_trusted=True):
-    return CONSOLE_HTML % {
-        'evalex':           'true',
-        'evalex_trusted':   evalex_trusted and 'true' or 'false',
-        'console':          'true',
-        'title':            'Console',
-        'secret':           secret,
-        'traceback_id': -1
-    }
-
-
-def get_current_traceback(ignore_system_exceptions=False,
-                          show_hidden_frames=False, skip=0):
-    """Get the current exception info as `Traceback` object.  Per default
-    calling this method will reraise system exceptions such as generator exit,
-    system exit or others.  This behavior can be disabled by passing `False`
-    to the function as first parameter.
-    """
-    exc_type, exc_value, tb = sys.exc_info()
-    if ignore_system_exceptions and exc_type in system_exceptions:
-        raise
-    for x in range_type(skip):
-        if tb.tb_next is None:
-            break
-        tb = tb.tb_next
-    tb = Traceback(exc_type, exc_value, tb)
-    if not show_hidden_frames:
-        tb.filter_hidden_frames()
-    return tb
-
-
-class Line(object):
-    """Helper for the source renderer."""
-    __slots__ = ('lineno', 'code', 'in_frame', 'current')
-
-    def __init__(self, lineno, code):
-        self.lineno = lineno
-        self.code = code
-        self.in_frame = False
-        self.current = False
-
-    def classes(self):
-        rv = ['line']
-        if self.in_frame:
-            rv.append('in-frame')
-        if self.current:
-            rv.append('current')
-        return rv
-    classes = property(classes)
-
-    def render(self):
-        return SOURCE_LINE_HTML % {
-            'classes':      u' '.join(self.classes),
-            'lineno':       self.lineno,
-            'code':         escape(self.code)
-        }
-
-
-class Traceback(object):
-    """Wraps a traceback."""
-
-    def __init__(self, exc_type, exc_value, tb):
-        self.exc_type = exc_type
-        self.exc_value = exc_value
-        if not isinstance(exc_type, str):
-            exception_type = exc_type.__name__
-            if exc_type.__module__ not in ('__builtin__', 'exceptions'):
-                exception_type = exc_type.__module__ + '.' + exception_type
-        else:
-            exception_type = exc_type
-        self.exception_type = exception_type
-
-        # we only add frames to the list that are not hidden.  This follows
-        # the the magic variables as defined by paste.exceptions.collector
-        self.frames = []
-        while tb:
-            self.frames.append(Frame(exc_type, exc_value, tb))
-            tb = tb.tb_next
-
-    def filter_hidden_frames(self):
-        """Remove the frames according to the paste spec."""
-        if not self.frames:
-            return
-
-        new_frames = []
-        hidden = False
-        for frame in self.frames:
-            hide = frame.hide
-            if hide in ('before', 'before_and_this'):
-                new_frames = []
-                hidden = False
-                if hide == 'before_and_this':
-                    continue
-            elif hide in ('reset', 'reset_and_this'):
-                hidden = False
-                if hide == 'reset_and_this':
-                    continue
-            elif hide in ('after', 'after_and_this'):
-                hidden = True
-                if hide == 'after_and_this':
-                    continue
-            elif hide or hidden:
-                continue
-            new_frames.append(frame)
-
-        # if we only have one frame and that frame is from the codeop
-        # module, remove it.
-        if len(new_frames) == 1 and self.frames[0].module == 'codeop':
-            del self.frames[:]
-
-        # if the last frame is missing something went terrible wrong :(
-        elif self.frames[-1] in new_frames:
-            self.frames[:] = new_frames
-
-    def is_syntax_error(self):
-        """Is it a syntax error?"""
-        return isinstance(self.exc_value, SyntaxError)
-    is_syntax_error = property(is_syntax_error)
-
-    def exception(self):
-        """String representation of the exception."""
-        buf = traceback.format_exception_only(self.exc_type, self.exc_value)
-        rv = ''.join(buf).strip()
-        return rv.decode('utf-8', 'replace') if PY2 else rv
-    exception = property(exception)
-
-    def log(self, logfile=None):
-        """Log the ASCII traceback into a file object."""
-        if logfile is None:
-            logfile = sys.stderr
-        tb = self.plaintext.rstrip() + u'\n'
-        if PY2:
-            tb = tb.encode('utf-8', 'replace')
-        logfile.write(tb)
-
-    def paste(self):
-        """Create a paste and return the paste id."""
-        data = json.dumps({
-            'description': 'Werkzeug Internal Server Error',
-            'public': False,
-            'files': {
-                'traceback.txt': {
-                    'content': self.plaintext
-                }
-            }
-        }).encode('utf-8')
-        try:
-            from urllib2 import urlopen
-        except ImportError:
-            from urllib.request import urlopen
-        rv = urlopen('https://api.github.com/gists', data=data)
-        resp = json.loads(rv.read().decode('utf-8'))
-        rv.close()
-        return {
-            'url': resp['html_url'],
-            'id': resp['id']
-        }
-
-    def render_summary(self, include_title=True):
-        """Render the traceback for the interactive console."""
-        title = ''
-        frames = []
-        classes = ['traceback']
-        if not self.frames:
-            classes.append('noframe-traceback')
-
-        if include_title:
-            if self.is_syntax_error:
-                title = u'Syntax Error'
-            else:
-                title = u'Traceback <em>(most recent call last)</em>:'
-
-        for frame in self.frames:
-            frames.append(u'<li%s>%s' % (
-                frame.info and u' title="%s"' % escape(frame.info) or u'',
-                frame.render()
-            ))
-
-        if self.is_syntax_error:
-            description_wrapper = u'<pre class=syntaxerror>%s</pre>'
-        else:
-            description_wrapper = u'<blockquote>%s</blockquote>'
-
-        return SUMMARY_HTML % {
-            'classes':      u' '.join(classes),
-            'title':        title and u'<h3>%s</h3>' % title or u'',
-            'frames':       u'\n'.join(frames),
-            'description':  description_wrapper % escape(self.exception)
-        }
-
-    def render_full(self, evalex=False, secret=None,
-                    evalex_trusted=True):
-        """Render the Full HTML page with the traceback info."""
-        exc = escape(self.exception)
-        return PAGE_HTML % {
-            'evalex':           evalex and 'true' or 'false',
-            'evalex_trusted':   evalex_trusted and 'true' or 'false',
-            'console':          'false',
-            'title':            exc,
-            'exception':        exc,
-            'exception_type':   escape(self.exception_type),
-            'summary':          self.render_summary(include_title=False),
-            'plaintext':        escape(self.plaintext),
-            'plaintext_cs':     re.sub('-{2,}', '-', self.plaintext),
-            'traceback_id':     self.id,
-            'secret':           secret
-        }
-
-    def generate_plaintext_traceback(self):
-        """Like the plaintext attribute but returns a generator"""
-        yield u'Traceback (most recent call last):'
-        for frame in self.frames:
-            yield u'  File "%s", line %s, in %s' % (
-                frame.filename,
-                frame.lineno,
-                frame.function_name
-            )
-            yield u'    ' + frame.current_line.strip()
-        yield self.exception
-
-    def plaintext(self):
-        return u'\n'.join(self.generate_plaintext_traceback())
-    plaintext = cached_property(plaintext)
-
-    id = property(lambda x: id(x))
-
-
-class Frame(object):
-
-    """A single frame in a traceback."""
-
-    def __init__(self, exc_type, exc_value, tb):
-        self.lineno = tb.tb_lineno
-        self.function_name = tb.tb_frame.f_code.co_name
-        self.locals = tb.tb_frame.f_locals
-        self.globals = tb.tb_frame.f_globals
-
-        fn = inspect.getsourcefile(tb) or inspect.getfile(tb)
-        if fn[-4:] in ('.pyo', '.pyc'):
-            fn = fn[:-1]
-        # if it's a file on the file system resolve the real filename.
-        if os.path.isfile(fn):
-            fn = os.path.realpath(fn)
-        self.filename = to_unicode(fn, get_filesystem_encoding())
-        self.module = self.globals.get('__name__')
-        self.loader = self.globals.get('__loader__')
-        self.code = tb.tb_frame.f_code
-
-        # support for paste's traceback extensions
-        self.hide = self.locals.get('__traceback_hide__', False)
-        info = self.locals.get('__traceback_info__')
-        if info is not None:
-            try:
-                info = text_type(info)
-            except UnicodeError:
-                info = str(info).decode('utf-8', 'replace')
-        self.info = info
-
-    def render(self):
-        """Render a single frame in a traceback."""
-        return FRAME_HTML % {
-            'id':               self.id,
-            'filename':         escape(self.filename),
-            'lineno':           self.lineno,
-            'function_name':    escape(self.function_name),
-            'lines':            self.render_line_context(),
-        }
-
-    def render_line_context(self):
-        before, current, after = self.get_context_lines()
-        rv = []
-
-        def render_line(line, cls):
-            line = line.expandtabs().rstrip()
-            stripped_line = line.strip()
-            prefix = len(line) - len(stripped_line)
-            rv.append(
-                '<pre class="line %s"><span class="ws">%s</span>%s</pre>' % (
-                    cls, ' ' * prefix, escape(stripped_line) or ' '))
-
-        for line in before:
-            render_line(line, 'before')
-        render_line(current, 'current')
-        for line in after:
-            render_line(line, 'after')
-
-        return '\n'.join(rv)
-
-    def get_annotated_lines(self):
-        """Helper function that returns lines with extra information."""
-        lines = [Line(idx + 1, x) for idx, x in enumerate(self.sourcelines)]
-
-        # find function definition and mark lines
-        if hasattr(self.code, 'co_firstlineno'):
-            lineno = self.code.co_firstlineno - 1
-            while lineno > 0:
-                if _funcdef_re.match(lines[lineno].code):
-                    break
-                lineno -= 1
-            try:
-                offset = len(inspect.getblock([x.code + '\n' for x
-                                               in lines[lineno:]]))
-            except TokenError:
-                offset = 0
-            for line in lines[lineno:lineno + offset]:
-                line.in_frame = True
-
-        # mark current line
-        try:
-            lines[self.lineno - 1].current = True
-        except IndexError:
-            pass
-
-        return lines
-
-    def eval(self, code, mode='single'):
-        """Evaluate code in the context of the frame."""
-        if isinstance(code, string_types):
-            if PY2 and isinstance(code, unicode):  # noqa
-                code = UTF8_COOKIE + code.encode('utf-8')
-            code = compile(code, '<interactive>', mode)
-        return eval(code, self.globals, self.locals)
-
-    @cached_property
-    def sourcelines(self):
-        """The sourcecode of the file as list of unicode strings."""
-        # get sourcecode from loader or file
-        source = None
-        if self.loader is not None:
-            try:
-                if hasattr(self.loader, 'get_source'):
-                    source = self.loader.get_source(self.module)
-                elif hasattr(self.loader, 'get_source_by_code'):
-                    source = self.loader.get_source_by_code(self.code)
-            except Exception:
-                # we munch the exception so that we don't cause troubles
-                # if the loader is broken.
-                pass
-
-        if source is None:
-            try:
-                f = open(to_native(self.filename, get_filesystem_encoding()),
-                         mode='rb')
-            except IOError:
-                return []
-            try:
-                source = f.read()
-            finally:
-                f.close()
-
-        # already unicode?  return right away
-        if isinstance(source, text_type):
-            return source.splitlines()
-
-        # yes. it should be ascii, but we don't want to reject too many
-        # characters in the debugger if something breaks
-        charset = 'utf-8'
-        if source.startswith(UTF8_COOKIE):
-            source = source[3:]
-        else:
-            for idx, match in enumerate(_line_re.finditer(source)):
-                match = _coding_re.search(match.group())
-                if match is not None:
-                    charset = match.group(1)
-                    break
-                if idx > 1:
-                    break
-
-        # on broken cookies we fall back to utf-8 too
-        charset = to_native(charset)
-        try:
-            codecs.lookup(charset)
-        except LookupError:
-            charset = 'utf-8'
-
-        return source.decode(charset, 'replace').splitlines()
-
-    def get_context_lines(self, context=5):
-        before = self.sourcelines[self.lineno - context - 1:self.lineno - 1]
-        past = self.sourcelines[self.lineno:self.lineno + context]
-        return (
-            before,
-            self.current_line,
-            past,
-        )
-
-    @property
-    def current_line(self):
-        try:
-            return self.sourcelines[self.lineno - 1]
-        except IndexError:
-            return u''
-
-    @cached_property
-    def console(self):
-        return Console(self.globals, self.locals)
-
-    id = property(lambda x: id(x))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/exceptions.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/exceptions.py
deleted file mode 100644
index 1d68185a9..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/exceptions.py
+++ /dev/null
@@ -1,719 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.exceptions
-    ~~~~~~~~~~~~~~~~~~~
-
-    This module implements a number of Python exceptions you can raise from
-    within your views to trigger a standard non-200 response.
-
-
-    Usage Example
-    -------------
-
-    ::
-
-        from werkzeug.wrappers import BaseRequest
-        from werkzeug.wsgi import responder
-        from werkzeug.exceptions import HTTPException, NotFound
-
-        def view(request):
-            raise NotFound()
-
-        @responder
-        def application(environ, start_response):
-            request = BaseRequest(environ)
-            try:
-                return view(request)
-            except HTTPException as e:
-                return e
-
-
-    As you can see from this example those exceptions are callable WSGI
-    applications.  Because of Python 2.4 compatibility those do not extend
-    from the response objects but only from the python exception class.
-
-    As a matter of fact they are not Werkzeug response objects.  However you
-    can get a response object by calling ``get_response()`` on a HTTP
-    exception.
-
-    Keep in mind that you have to pass an environment to ``get_response()``
-    because some errors fetch additional information from the WSGI
-    environment.
-
-    If you want to hook in a different exception page to say, a 404 status
-    code, you can add a second except for a specific subclass of an error::
-
-        @responder
-        def application(environ, start_response):
-            request = BaseRequest(environ)
-            try:
-                return view(request)
-            except NotFound, e:
-                return not_found(request)
-            except HTTPException, e:
-                return e
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-
-# Because of bootstrapping reasons we need to manually patch ourselves
-# onto our parent module.
-import werkzeug
-werkzeug.exceptions = sys.modules[__name__]
-
-from werkzeug._internal import _get_environ
-from werkzeug._compat import iteritems, integer_types, text_type, \
-    implements_to_string
-
-from werkzeug.wrappers import Response
-
-
-@implements_to_string
-class HTTPException(Exception):
-
-    """
-    Baseclass for all HTTP exceptions.  This exception can be called as WSGI
-    application to render a default error page or you can catch the subclasses
-    of it independently and render nicer error messages.
-    """
-
-    code = None
-    description = None
-
-    def __init__(self, description=None, response=None):
-        Exception.__init__(self)
-        if description is not None:
-            self.description = description
-        self.response = response
-
-    @classmethod
-    def wrap(cls, exception, name=None):
-        """This method returns a new subclass of the exception provided that
-        also is a subclass of `BadRequest`.
-        """
-        class newcls(cls, exception):
-
-            def __init__(self, arg=None, *args, **kwargs):
-                cls.__init__(self, *args, **kwargs)
-                exception.__init__(self, arg)
-        newcls.__module__ = sys._getframe(1).f_globals.get('__name__')
-        newcls.__name__ = name or cls.__name__ + exception.__name__
-        return newcls
-
-    @property
-    def name(self):
-        """The status name."""
-        return HTTP_STATUS_CODES.get(self.code, 'Unknown Error')
-
-    def get_description(self, environ=None):
-        """Get the description."""
-        return u'<p>%s</p>' % escape(self.description)
-
-    def get_body(self, environ=None):
-        """Get the HTML body."""
-        return text_type((
-            u'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">\n'
-            u'<title>%(code)s %(name)s</title>\n'
-            u'<h1>%(name)s</h1>\n'
-            u'%(description)s\n'
-        ) % {
-            'code':         self.code,
-            'name':         escape(self.name),
-            'description':  self.get_description(environ)
-        })
-
-    def get_headers(self, environ=None):
-        """Get a list of headers."""
-        return [('Content-Type', 'text/html')]
-
-    def get_response(self, environ=None):
-        """Get a response object.  If one was passed to the exception
-        it's returned directly.
-
-        :param environ: the optional environ for the request.  This
-                        can be used to modify the response depending
-                        on how the request looked like.
-        :return: a :class:`Response` object or a subclass thereof.
-        """
-        if self.response is not None:
-            return self.response
-        if environ is not None:
-            environ = _get_environ(environ)
-        headers = self.get_headers(environ)
-        return Response(self.get_body(environ), self.code, headers)
-
-    def __call__(self, environ, start_response):
-        """Call the exception as WSGI application.
-
-        :param environ: the WSGI environment.
-        :param start_response: the response callable provided by the WSGI
-                               server.
-        """
-        response = self.get_response(environ)
-        return response(environ, start_response)
-
-    def __str__(self):
-        code = self.code if self.code is not None else '???'
-        return '%s %s: %s' % (code, self.name, self.description)
-
-    def __repr__(self):
-        code = self.code if self.code is not None else '???'
-        return "<%s '%s: %s'>" % (self.__class__.__name__, code, self.name)
-
-
-class BadRequest(HTTPException):
-
-    """*400* `Bad Request`
-
-    Raise if the browser sends something to the application the application
-    or server cannot handle.
-    """
-    code = 400
-    description = (
-        'The browser (or proxy) sent a request that this server could '
-        'not understand.'
-    )
-
-
-class ClientDisconnected(BadRequest):
-
-    """Internal exception that is raised if Werkzeug detects a disconnected
-    client.  Since the client is already gone at that point attempting to
-    send the error message to the client might not work and might ultimately
-    result in another exception in the server.  Mainly this is here so that
-    it is silenced by default as far as Werkzeug is concerned.
-
-    Since disconnections cannot be reliably detected and are unspecified
-    by WSGI to a large extent this might or might not be raised if a client
-    is gone.
-
-    .. versionadded:: 0.8
-    """
-
-
-class SecurityError(BadRequest):
-
-    """Raised if something triggers a security error.  This is otherwise
-    exactly like a bad request error.
-
-    .. versionadded:: 0.9
-    """
-
-
-class BadHost(BadRequest):
-
-    """Raised if the submitted host is badly formatted.
-
-    .. versionadded:: 0.11.2
-    """
-
-
-class Unauthorized(HTTPException):
-
-    """*401* `Unauthorized`
-
-    Raise if the user is not authorized.  Also used if you want to use HTTP
-    basic auth.
-    """
-    code = 401
-    description = (
-        'The server could not verify that you are authorized to access '
-        'the URL requested.  You either supplied the wrong credentials (e.g. '
-        'a bad password), or your browser doesn\'t understand how to supply '
-        'the credentials required.'
-    )
-
-
-class Forbidden(HTTPException):
-
-    """*403* `Forbidden`
-
-    Raise if the user doesn't have the permission for the requested resource
-    but was authenticated.
-    """
-    code = 403
-    description = (
-        'You don\'t have the permission to access the requested resource. '
-        'It is either read-protected or not readable by the server.'
-    )
-
-
-class NotFound(HTTPException):
-
-    """*404* `Not Found`
-
-    Raise if a resource does not exist and never existed.
-    """
-    code = 404
-    description = (
-        'The requested URL was not found on the server.  '
-        'If you entered the URL manually please check your spelling and '
-        'try again.'
-    )
-
-
-class MethodNotAllowed(HTTPException):
-
-    """*405* `Method Not Allowed`
-
-    Raise if the server used a method the resource does not handle.  For
-    example `POST` if the resource is view only.  Especially useful for REST.
-
-    The first argument for this exception should be a list of allowed methods.
-    Strictly speaking the response would be invalid if you don't provide valid
-    methods in the header which you can do with that list.
-    """
-    code = 405
-    description = 'The method is not allowed for the requested URL.'
-
-    def __init__(self, valid_methods=None, description=None):
-        """Takes an optional list of valid http methods
-        starting with werkzeug 0.3 the list will be mandatory."""
-        HTTPException.__init__(self, description)
-        self.valid_methods = valid_methods
-
-    def get_headers(self, environ):
-        headers = HTTPException.get_headers(self, environ)
-        if self.valid_methods:
-            headers.append(('Allow', ', '.join(self.valid_methods)))
-        return headers
-
-
-class NotAcceptable(HTTPException):
-
-    """*406* `Not Acceptable`
-
-    Raise if the server can't return any content conforming to the
-    `Accept` headers of the client.
-    """
-    code = 406
-
-    description = (
-        'The resource identified by the request is only capable of '
-        'generating response entities which have content characteristics '
-        'not acceptable according to the accept headers sent in the '
-        'request.'
-    )
-
-
-class RequestTimeout(HTTPException):
-
-    """*408* `Request Timeout`
-
-    Raise to signalize a timeout.
-    """
-    code = 408
-    description = (
-        'The server closed the network connection because the browser '
-        'didn\'t finish the request within the specified time.'
-    )
-
-
-class Conflict(HTTPException):
-
-    """*409* `Conflict`
-
-    Raise to signal that a request cannot be completed because it conflicts
-    with the current state on the server.
-
-    .. versionadded:: 0.7
-    """
-    code = 409
-    description = (
-        'A conflict happened while processing the request.  The resource '
-        'might have been modified while the request was being processed.'
-    )
-
-
-class Gone(HTTPException):
-
-    """*410* `Gone`
-
-    Raise if a resource existed previously and went away without new location.
-    """
-    code = 410
-    description = (
-        'The requested URL is no longer available on this server and there '
-        'is no forwarding address. If you followed a link from a foreign '
-        'page, please contact the author of this page.'
-    )
-
-
-class LengthRequired(HTTPException):
-
-    """*411* `Length Required`
-
-    Raise if the browser submitted data but no ``Content-Length`` header which
-    is required for the kind of processing the server does.
-    """
-    code = 411
-    description = (
-        'A request with this method requires a valid <code>Content-'
-        'Length</code> header.'
-    )
-
-
-class PreconditionFailed(HTTPException):
-
-    """*412* `Precondition Failed`
-
-    Status code used in combination with ``If-Match``, ``If-None-Match``, or
-    ``If-Unmodified-Since``.
-    """
-    code = 412
-    description = (
-        'The precondition on the request for the URL failed positive '
-        'evaluation.'
-    )
-
-
-class RequestEntityTooLarge(HTTPException):
-
-    """*413* `Request Entity Too Large`
-
-    The status code one should return if the data submitted exceeded a given
-    limit.
-    """
-    code = 413
-    description = (
-        'The data value transmitted exceeds the capacity limit.'
-    )
-
-
-class RequestURITooLarge(HTTPException):
-
-    """*414* `Request URI Too Large`
-
-    Like *413* but for too long URLs.
-    """
-    code = 414
-    description = (
-        'The length of the requested URL exceeds the capacity limit '
-        'for this server.  The request cannot be processed.'
-    )
-
-
-class UnsupportedMediaType(HTTPException):
-
-    """*415* `Unsupported Media Type`
-
-    The status code returned if the server is unable to handle the media type
-    the client transmitted.
-    """
-    code = 415
-    description = (
-        'The server does not support the media type transmitted in '
-        'the request.'
-    )
-
-
-class RequestedRangeNotSatisfiable(HTTPException):
-
-    """*416* `Requested Range Not Satisfiable`
-
-    The client asked for an invalid part of the file.
-
-    .. versionadded:: 0.7
-    """
-    code = 416
-    description = (
-        'The server cannot provide the requested range.'
-    )
-
-    def __init__(self, length=None, units="bytes", description=None):
-        """Takes an optional `Content-Range` header value based on ``length``
-        parameter.
-        """
-        HTTPException.__init__(self, description)
-        self.length = length
-        self.units = units
-
-    def get_headers(self, environ):
-        headers = HTTPException.get_headers(self, environ)
-        if self.length is not None:
-            headers.append(
-                ('Content-Range', '%s */%d' % (self.units, self.length)))
-        return headers
-
-
-class ExpectationFailed(HTTPException):
-
-    """*417* `Expectation Failed`
-
-    The server cannot meet the requirements of the Expect request-header.
-
-    .. versionadded:: 0.7
-    """
-    code = 417
-    description = (
-        'The server could not meet the requirements of the Expect header'
-    )
-
-
-class ImATeapot(HTTPException):
-
-    """*418* `I'm a teapot`
-
-    The server should return this if it is a teapot and someone attempted
-    to brew coffee with it.
-
-    .. versionadded:: 0.7
-    """
-    code = 418
-    description = (
-        'This server is a teapot, not a coffee machine'
-    )
-
-
-class UnprocessableEntity(HTTPException):
-
-    """*422* `Unprocessable Entity`
-
-    Used if the request is well formed, but the instructions are otherwise
-    incorrect.
-    """
-    code = 422
-    description = (
-        'The request was well-formed but was unable to be followed '
-        'due to semantic errors.'
-    )
-
-
-class Locked(HTTPException):
-
-    """*423* `Locked`
-
-    Used if the resource that is being accessed is locked.
-    """
-    code = 423
-    description = (
-        'The resource that is being accessed is locked.'
-    )
-
-
-class PreconditionRequired(HTTPException):
-
-    """*428* `Precondition Required`
-
-    The server requires this request to be conditional, typically to prevent
-    the lost update problem, which is a race condition between two or more
-    clients attempting to update a resource through PUT or DELETE. By requiring
-    each client to include a conditional header ("If-Match" or "If-Unmodified-
-    Since") with the proper value retained from a recent GET request, the
-    server ensures that each client has at least seen the previous revision of
-    the resource.
-    """
-    code = 428
-    description = (
-        'This request is required to be conditional; try using "If-Match" '
-        'or "If-Unmodified-Since".'
-    )
-
-
-class TooManyRequests(HTTPException):
-
-    """*429* `Too Many Requests`
-
-    The server is limiting the rate at which this user receives responses, and
-    this request exceeds that rate. (The server may use any convenient method
-    to identify users and their request rates). The server may include a
-    "Retry-After" header to indicate how long the user should wait before
-    retrying.
-    """
-    code = 429
-    description = (
-        'This user has exceeded an allotted request count. Try again later.'
-    )
-
-
-class RequestHeaderFieldsTooLarge(HTTPException):
-
-    """*431* `Request Header Fields Too Large`
-
-    The server refuses to process the request because the header fields are too
-    large. One or more individual fields may be too large, or the set of all
-    headers is too large.
-    """
-    code = 431
-    description = (
-        'One or more header fields exceeds the maximum size.'
-    )
-
-
-class UnavailableForLegalReasons(HTTPException):
-
-    """*451* `Unavailable For Legal Reasons`
-
-    This status code indicates that the server is denying access to the
-    resource as a consequence of a legal demand.
-    """
-    code = 451
-    description = (
-        'Unavailable for legal reasons.'
-    )
-
-
-class InternalServerError(HTTPException):
-
-    """*500* `Internal Server Error`
-
-    Raise if an internal server error occurred.  This is a good fallback if an
-    unknown error occurred in the dispatcher.
-    """
-    code = 500
-    description = (
-        'The server encountered an internal error and was unable to '
-        'complete your request.  Either the server is overloaded or there '
-        'is an error in the application.'
-    )
-
-
-class NotImplemented(HTTPException):
-
-    """*501* `Not Implemented`
-
-    Raise if the application does not support the action requested by the
-    browser.
-    """
-    code = 501
-    description = (
-        'The server does not support the action requested by the '
-        'browser.'
-    )
-
-
-class BadGateway(HTTPException):
-
-    """*502* `Bad Gateway`
-
-    If you do proxying in your application you should return this status code
-    if you received an invalid response from the upstream server it accessed
-    in attempting to fulfill the request.
-    """
-    code = 502
-    description = (
-        'The proxy server received an invalid response from an upstream '
-        'server.'
-    )
-
-
-class ServiceUnavailable(HTTPException):
-
-    """*503* `Service Unavailable`
-
-    Status code you should return if a service is temporarily unavailable.
-    """
-    code = 503
-    description = (
-        'The server is temporarily unable to service your request due to '
-        'maintenance downtime or capacity problems.  Please try again '
-        'later.'
-    )
-
-
-class GatewayTimeout(HTTPException):
-
-    """*504* `Gateway Timeout`
-
-    Status code you should return if a connection to an upstream server
-    times out.
-    """
-    code = 504
-    description = (
-        'The connection to an upstream server timed out.'
-    )
-
-
-class HTTPVersionNotSupported(HTTPException):
-
-    """*505* `HTTP Version Not Supported`
-
-    The server does not support the HTTP protocol version used in the request.
-    """
-    code = 505
-    description = (
-        'The server does not support the HTTP protocol version used in the '
-        'request.'
-    )
-
-
-default_exceptions = {}
-__all__ = ['HTTPException']
-
-
-def _find_exceptions():
-    for name, obj in iteritems(globals()):
-        try:
-            is_http_exception = issubclass(obj, HTTPException)
-        except TypeError:
-            is_http_exception = False
-        if not is_http_exception or obj.code is None:
-            continue
-        __all__.append(obj.__name__)
-        old_obj = default_exceptions.get(obj.code, None)
-        if old_obj is not None and issubclass(obj, old_obj):
-            continue
-        default_exceptions[obj.code] = obj
-_find_exceptions()
-del _find_exceptions
-
-
-class Aborter(object):
-
-    """
-    When passed a dict of code -> exception items it can be used as
-    callable that raises exceptions.  If the first argument to the
-    callable is an integer it will be looked up in the mapping, if it's
-    a WSGI application it will be raised in a proxy exception.
-
-    The rest of the arguments are forwarded to the exception constructor.
-    """
-
-    def __init__(self, mapping=None, extra=None):
-        if mapping is None:
-            mapping = default_exceptions
-        self.mapping = dict(mapping)
-        if extra is not None:
-            self.mapping.update(extra)
-
-    def __call__(self, code, *args, **kwargs):
-        if not args and not kwargs and not isinstance(code, integer_types):
-            raise HTTPException(response=code)
-        if code not in self.mapping:
-            raise LookupError('no exception for %r' % code)
-        raise self.mapping[code](*args, **kwargs)
-
-
-def abort(status, *args, **kwargs):
-    '''
-    Raises an :py:exc:`HTTPException` for the given status code or WSGI
-    application::
-
-        abort(404)  # 404 Not Found
-        abort(Response('Hello World'))
-
-    Can be passed a WSGI application or a status code.  If a status code is
-    given it's looked up in the list of exceptions and will raise that
-    exception, if passed a WSGI application it will wrap it in a proxy WSGI
-    exception and raise that::
-
-       abort(404)
-       abort(Response('Hello World'))
-
-    '''
-    return _aborter(status, *args, **kwargs)
-
-_aborter = Aborter()
-
-
-#: an exception that is used internally to signal both a key error and a
-#: bad request.  Used by a lot of the datastructures.
-BadRequestKeyError = BadRequest.wrap(KeyError)
-
-
-# imported here because of circular dependencies of werkzeug.utils
-from werkzeug.utils import escape
-from werkzeug.http import HTTP_STATUS_CODES
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/filesystem.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/filesystem.py
deleted file mode 100644
index 624674655..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/filesystem.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.filesystem
-    ~~~~~~~~~~~~~~~~~~~
-
-    Various utilities for the local filesystem.
-
-    :copyright: (c) 2015 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import codecs
-import sys
-import warnings
-
-# We do not trust traditional unixes.
-has_likely_buggy_unicode_filesystem = \
-    sys.platform.startswith('linux') or 'bsd' in sys.platform
-
-
-def _is_ascii_encoding(encoding):
-    """
-    Given an encoding this figures out if the encoding is actually ASCII (which
-    is something we don't actually want in most cases). This is necessary
-    because ASCII comes under many names such as ANSI_X3.4-1968.
-    """
-    if encoding is None:
-        return False
-    try:
-        return codecs.lookup(encoding).name == 'ascii'
-    except LookupError:
-        return False
-
-
-class BrokenFilesystemWarning(RuntimeWarning, UnicodeWarning):
-    '''The warning used by Werkzeug to signal a broken filesystem. Will only be
-    used once per runtime.'''
-
-
-_warned_about_filesystem_encoding = False
-
-
-def get_filesystem_encoding():
-    """
-    Returns the filesystem encoding that should be used. Note that this is
-    different from the Python understanding of the filesystem encoding which
-    might be deeply flawed. Do not use this value against Python's unicode APIs
-    because it might be different. See :ref:`filesystem-encoding` for the exact
-    behavior.
-
-    The concept of a filesystem encoding in generally is not something you
-    should rely on. As such if you ever need to use this function except for
-    writing wrapper code reconsider.
-    """
-    global _warned_about_filesystem_encoding
-    rv = sys.getfilesystemencoding()
-    if has_likely_buggy_unicode_filesystem and not rv \
-       or _is_ascii_encoding(rv):
-        if not _warned_about_filesystem_encoding:
-            warnings.warn(
-                'Detected a misconfigured UNIX filesystem: Will use UTF-8 as '
-                'filesystem encoding instead of {0!r}'.format(rv),
-                BrokenFilesystemWarning)
-            _warned_about_filesystem_encoding = True
-        return 'utf-8'
-    return rv
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/formparser.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/formparser.py
deleted file mode 100644
index c56859e90..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/formparser.py
+++ /dev/null
@@ -1,534 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.formparser
-    ~~~~~~~~~~~~~~~~~~~
-
-    This module implements the form parsing.  It supports url-encoded forms
-    as well as non-nested multipart uploads.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import codecs
-
-# there are some platforms where SpooledTemporaryFile is not available.
-# In that case we need to provide a fallback.
-try:
-    from tempfile import SpooledTemporaryFile
-except ImportError:
-    from tempfile import TemporaryFile
-    SpooledTemporaryFile = None
-
-from itertools import chain, repeat, tee
-from functools import update_wrapper
-
-from werkzeug._compat import to_native, text_type, BytesIO
-from werkzeug.urls import url_decode_stream
-from werkzeug.wsgi import make_line_iter, \
-    get_input_stream, get_content_length
-from werkzeug.datastructures import Headers, FileStorage, MultiDict
-from werkzeug.http import parse_options_header
-
-
-#: an iterator that yields empty strings
-_empty_string_iter = repeat('')
-
-#: a regular expression for multipart boundaries
-_multipart_boundary_re = re.compile('^[ -~]{0,200}[!-~]$')
-
-#: supported http encodings that are also available in python we support
-#: for multipart messages.
-_supported_multipart_encodings = frozenset(['base64', 'quoted-printable'])
-
-
-def default_stream_factory(total_content_length, filename, content_type,
-                           content_length=None):
-    """The stream factory that is used per default."""
-    max_size = 1024 * 500
-    if SpooledTemporaryFile is not None:
-        return SpooledTemporaryFile(max_size=max_size, mode='wb+')
-    if total_content_length is None or total_content_length > max_size:
-        return TemporaryFile('wb+')
-    return BytesIO()
-
-
-def parse_form_data(environ, stream_factory=None, charset='utf-8',
-                    errors='replace', max_form_memory_size=None,
-                    max_content_length=None, cls=None,
-                    silent=True):
-    """Parse the form data in the environ and return it as tuple in the form
-    ``(stream, form, files)``.  You should only call this method if the
-    transport method is `POST`, `PUT`, or `PATCH`.
-
-    If the mimetype of the data transmitted is `multipart/form-data` the
-    files multidict will be filled with `FileStorage` objects.  If the
-    mimetype is unknown the input stream is wrapped and returned as first
-    argument, else the stream is empty.
-
-    This is a shortcut for the common usage of :class:`FormDataParser`.
-
-    Have a look at :ref:`dealing-with-request-data` for more details.
-
-    .. versionadded:: 0.5
-       The `max_form_memory_size`, `max_content_length` and
-       `cls` parameters were added.
-
-    .. versionadded:: 0.5.1
-       The optional `silent` flag was added.
-
-    :param environ: the WSGI environment to be used for parsing.
-    :param stream_factory: An optional callable that returns a new read and
-                           writeable file descriptor.  This callable works
-                           the same as :meth:`~BaseResponse._get_file_stream`.
-    :param charset: The character set for URL and url encoded form data.
-    :param errors: The encoding error behavior.
-    :param max_form_memory_size: the maximum number of bytes to be accepted for
-                           in-memory stored form data.  If the data
-                           exceeds the value specified an
-                           :exc:`~exceptions.RequestEntityTooLarge`
-                           exception is raised.
-    :param max_content_length: If this is provided and the transmitted data
-                               is longer than this value an
-                               :exc:`~exceptions.RequestEntityTooLarge`
-                               exception is raised.
-    :param cls: an optional dict class to use.  If this is not specified
-                       or `None` the default :class:`MultiDict` is used.
-    :param silent: If set to False parsing errors will not be caught.
-    :return: A tuple in the form ``(stream, form, files)``.
-    """
-    return FormDataParser(stream_factory, charset, errors,
-                          max_form_memory_size, max_content_length,
-                          cls, silent).parse_from_environ(environ)
-
-
-def exhaust_stream(f):
-    """Helper decorator for methods that exhausts the stream on return."""
-
-    def wrapper(self, stream, *args, **kwargs):
-        try:
-            return f(self, stream, *args, **kwargs)
-        finally:
-            exhaust = getattr(stream, 'exhaust', None)
-            if exhaust is not None:
-                exhaust()
-            else:
-                while 1:
-                    chunk = stream.read(1024 * 64)
-                    if not chunk:
-                        break
-    return update_wrapper(wrapper, f)
-
-
-class FormDataParser(object):
-
-    """This class implements parsing of form data for Werkzeug.  By itself
-    it can parse multipart and url encoded form data.  It can be subclassed
-    and extended but for most mimetypes it is a better idea to use the
-    untouched stream and expose it as separate attributes on a request
-    object.
-
-    .. versionadded:: 0.8
-
-    :param stream_factory: An optional callable that returns a new read and
-                           writeable file descriptor.  This callable works
-                           the same as :meth:`~BaseResponse._get_file_stream`.
-    :param charset: The character set for URL and url encoded form data.
-    :param errors: The encoding error behavior.
-    :param max_form_memory_size: the maximum number of bytes to be accepted for
-                           in-memory stored form data.  If the data
-                           exceeds the value specified an
-                           :exc:`~exceptions.RequestEntityTooLarge`
-                           exception is raised.
-    :param max_content_length: If this is provided and the transmitted data
-                               is longer than this value an
-                               :exc:`~exceptions.RequestEntityTooLarge`
-                               exception is raised.
-    :param cls: an optional dict class to use.  If this is not specified
-                       or `None` the default :class:`MultiDict` is used.
-    :param silent: If set to False parsing errors will not be caught.
-    """
-
-    def __init__(self, stream_factory=None, charset='utf-8',
-                 errors='replace', max_form_memory_size=None,
-                 max_content_length=None, cls=None,
-                 silent=True):
-        if stream_factory is None:
-            stream_factory = default_stream_factory
-        self.stream_factory = stream_factory
-        self.charset = charset
-        self.errors = errors
-        self.max_form_memory_size = max_form_memory_size
-        self.max_content_length = max_content_length
-        if cls is None:
-            cls = MultiDict
-        self.cls = cls
-        self.silent = silent
-
-    def get_parse_func(self, mimetype, options):
-        return self.parse_functions.get(mimetype)
-
-    def parse_from_environ(self, environ):
-        """Parses the information from the environment as form data.
-
-        :param environ: the WSGI environment to be used for parsing.
-        :return: A tuple in the form ``(stream, form, files)``.
-        """
-        content_type = environ.get('CONTENT_TYPE', '')
-        content_length = get_content_length(environ)
-        mimetype, options = parse_options_header(content_type)
-        return self.parse(get_input_stream(environ), mimetype,
-                          content_length, options)
-
-    def parse(self, stream, mimetype, content_length, options=None):
-        """Parses the information from the given stream, mimetype,
-        content length and mimetype parameters.
-
-        :param stream: an input stream
-        :param mimetype: the mimetype of the data
-        :param content_length: the content length of the incoming data
-        :param options: optional mimetype parameters (used for
-                        the multipart boundary for instance)
-        :return: A tuple in the form ``(stream, form, files)``.
-        """
-        if self.max_content_length is not None and \
-           content_length is not None and \
-           content_length > self.max_content_length:
-            raise exceptions.RequestEntityTooLarge()
-        if options is None:
-            options = {}
-
-        parse_func = self.get_parse_func(mimetype, options)
-        if parse_func is not None:
-            try:
-                return parse_func(self, stream, mimetype,
-                                  content_length, options)
-            except ValueError:
-                if not self.silent:
-                    raise
-
-        return stream, self.cls(), self.cls()
-
-    @exhaust_stream
-    def _parse_multipart(self, stream, mimetype, content_length, options):
-        parser = MultiPartParser(self.stream_factory, self.charset, self.errors,
-                                 max_form_memory_size=self.max_form_memory_size,
-                                 cls=self.cls)
-        boundary = options.get('boundary')
-        if boundary is None:
-            raise ValueError('Missing boundary')
-        if isinstance(boundary, text_type):
-            boundary = boundary.encode('ascii')
-        form, files = parser.parse(stream, boundary, content_length)
-        return stream, form, files
-
-    @exhaust_stream
-    def _parse_urlencoded(self, stream, mimetype, content_length, options):
-        if self.max_form_memory_size is not None and \
-           content_length is not None and \
-           content_length > self.max_form_memory_size:
-            raise exceptions.RequestEntityTooLarge()
-        form = url_decode_stream(stream, self.charset,
-                                 errors=self.errors, cls=self.cls)
-        return stream, form, self.cls()
-
-    #: mapping of mimetypes to parsing functions
-    parse_functions = {
-        'multipart/form-data':                  _parse_multipart,
-        'application/x-www-form-urlencoded':    _parse_urlencoded,
-        'application/x-url-encoded':            _parse_urlencoded
-    }
-
-
-def is_valid_multipart_boundary(boundary):
-    """Checks if the string given is a valid multipart boundary."""
-    return _multipart_boundary_re.match(boundary) is not None
-
-
-def _line_parse(line):
-    """Removes line ending characters and returns a tuple (`stripped_line`,
-    `is_terminated`).
-    """
-    if line[-2:] in ['\r\n', b'\r\n']:
-        return line[:-2], True
-    elif line[-1:] in ['\r', '\n', b'\r', b'\n']:
-        return line[:-1], True
-    return line, False
-
-
-def parse_multipart_headers(iterable):
-    """Parses multipart headers from an iterable that yields lines (including
-    the trailing newline symbol).  The iterable has to be newline terminated.
-
-    The iterable will stop at the line where the headers ended so it can be
-    further consumed.
-
-    :param iterable: iterable of strings that are newline terminated
-    """
-    result = []
-    for line in iterable:
-        line = to_native(line)
-        line, line_terminated = _line_parse(line)
-        if not line_terminated:
-            raise ValueError('unexpected end of line in multipart header')
-        if not line:
-            break
-        elif line[0] in ' \t' and result:
-            key, value = result[-1]
-            result[-1] = (key, value + '\n ' + line[1:])
-        else:
-            parts = line.split(':', 1)
-            if len(parts) == 2:
-                result.append((parts[0].strip(), parts[1].strip()))
-
-    # we link the list to the headers, no need to create a copy, the
-    # list was not shared anyways.
-    return Headers(result)
-
-
-_begin_form = 'begin_form'
-_begin_file = 'begin_file'
-_cont = 'cont'
-_end = 'end'
-
-
-class MultiPartParser(object):
-
-    def __init__(self, stream_factory=None, charset='utf-8', errors='replace',
-                 max_form_memory_size=None, cls=None, buffer_size=64 * 1024):
-        self.charset = charset
-        self.errors = errors
-        self.max_form_memory_size = max_form_memory_size
-        self.stream_factory = default_stream_factory if stream_factory is None else stream_factory
-        self.cls = MultiDict if cls is None else cls
-
-        # make sure the buffer size is divisible by four so that we can base64
-        # decode chunk by chunk
-        assert buffer_size % 4 == 0, 'buffer size has to be divisible by 4'
-        # also the buffer size has to be at least 1024 bytes long or long headers
-        # will freak out the system
-        assert buffer_size >= 1024, 'buffer size has to be at least 1KB'
-
-        self.buffer_size = buffer_size
-
-    def _fix_ie_filename(self, filename):
-        """Internet Explorer 6 transmits the full file name if a file is
-        uploaded.  This function strips the full path if it thinks the
-        filename is Windows-like absolute.
-        """
-        if filename[1:3] == ':\\' or filename[:2] == '\\\\':
-            return filename.split('\\')[-1]
-        return filename
-
-    def _find_terminator(self, iterator):
-        """The terminator might have some additional newlines before it.
-        There is at least one application that sends additional newlines
-        before headers (the python setuptools package).
-        """
-        for line in iterator:
-            if not line:
-                break
-            line = line.strip()
-            if line:
-                return line
-        return b''
-
-    def fail(self, message):
-        raise ValueError(message)
-
-    def get_part_encoding(self, headers):
-        transfer_encoding = headers.get('content-transfer-encoding')
-        if transfer_encoding is not None and \
-           transfer_encoding in _supported_multipart_encodings:
-            return transfer_encoding
-
-    def get_part_charset(self, headers):
-        # Figure out input charset for current part
-        content_type = headers.get('content-type')
-        if content_type:
-            mimetype, ct_params = parse_options_header(content_type)
-            return ct_params.get('charset', self.charset)
-        return self.charset
-
-    def start_file_streaming(self, filename, headers, total_content_length):
-        if isinstance(filename, bytes):
-            filename = filename.decode(self.charset, self.errors)
-        filename = self._fix_ie_filename(filename)
-        content_type = headers.get('content-type')
-        try:
-            content_length = int(headers['content-length'])
-        except (KeyError, ValueError):
-            content_length = 0
-        container = self.stream_factory(total_content_length, content_type,
-                                        filename, content_length)
-        return filename, container
-
-    def in_memory_threshold_reached(self, bytes):
-        raise exceptions.RequestEntityTooLarge()
-
-    def validate_boundary(self, boundary):
-        if not boundary:
-            self.fail('Missing boundary')
-        if not is_valid_multipart_boundary(boundary):
-            self.fail('Invalid boundary: %s' % boundary)
-        if len(boundary) > self.buffer_size:  # pragma: no cover
-            # this should never happen because we check for a minimum size
-            # of 1024 and boundaries may not be longer than 200.  The only
-            # situation when this happens is for non debug builds where
-            # the assert is skipped.
-            self.fail('Boundary longer than buffer size')
-
-    def parse_lines(self, file, boundary, content_length, cap_at_buffer=True):
-        """Generate parts of
-        ``('begin_form', (headers, name))``
-        ``('begin_file', (headers, name, filename))``
-        ``('cont', bytestring)``
-        ``('end', None)``
-
-        Always obeys the grammar
-        parts = ( begin_form cont* end |
-                  begin_file cont* end )*
-        """
-        next_part = b'--' + boundary
-        last_part = next_part + b'--'
-
-        iterator = chain(make_line_iter(file, limit=content_length,
-                                        buffer_size=self.buffer_size,
-                                        cap_at_buffer=cap_at_buffer),
-                         _empty_string_iter)
-
-        terminator = self._find_terminator(iterator)
-
-        if terminator == last_part:
-            return
-        elif terminator != next_part:
-            self.fail('Expected boundary at start of multipart data')
-
-        while terminator != last_part:
-            headers = parse_multipart_headers(iterator)
-
-            disposition = headers.get('content-disposition')
-            if disposition is None:
-                self.fail('Missing Content-Disposition header')
-            disposition, extra = parse_options_header(disposition)
-            transfer_encoding = self.get_part_encoding(headers)
-            name = extra.get('name')
-
-            # Accept filename* to support non-ascii filenames as per rfc2231
-            filename = extra.get('filename') or extra.get('filename*')
-
-            # if no content type is given we stream into memory.  A list is
-            # used as a temporary container.
-            if filename is None:
-                yield _begin_form, (headers, name)
-
-            # otherwise we parse the rest of the headers and ask the stream
-            # factory for something we can write in.
-            else:
-                yield _begin_file, (headers, name, filename)
-
-            buf = b''
-            for line in iterator:
-                if not line:
-                    self.fail('unexpected end of stream')
-
-                if line[:2] == b'--':
-                    terminator = line.rstrip()
-                    if terminator in (next_part, last_part):
-                        break
-
-                if transfer_encoding is not None:
-                    if transfer_encoding == 'base64':
-                        transfer_encoding = 'base64_codec'
-                    try:
-                        line = codecs.decode(line, transfer_encoding)
-                    except Exception:
-                        self.fail('could not decode transfer encoded chunk')
-
-                # we have something in the buffer from the last iteration.
-                # this is usually a newline delimiter.
-                if buf:
-                    yield _cont, buf
-                    buf = b''
-
-                # If the line ends with windows CRLF we write everything except
-                # the last two bytes.  In all other cases however we write
-                # everything except the last byte.  If it was a newline, that's
-                # fine, otherwise it does not matter because we will write it
-                # the next iteration.  this ensures we do not write the
-                # final newline into the stream.  That way we do not have to
-                # truncate the stream.  However we do have to make sure that
-                # if something else than a newline is in there we write it
-                # out.
-                if line[-2:] == b'\r\n':
-                    buf = b'\r\n'
-                    cutoff = -2
-                else:
-                    buf = line[-1:]
-                    cutoff = -1
-                yield _cont, line[:cutoff]
-
-            else:  # pragma: no cover
-                raise ValueError('unexpected end of part')
-
-            # if we have a leftover in the buffer that is not a newline
-            # character we have to flush it, otherwise we will chop of
-            # certain values.
-            if buf not in (b'', b'\r', b'\n', b'\r\n'):
-                yield _cont, buf
-
-            yield _end, None
-
-    def parse_parts(self, file, boundary, content_length):
-        """Generate ``('file', (name, val))`` and
-        ``('form', (name, val))`` parts.
-        """
-        in_memory = 0
-
-        for ellt, ell in self.parse_lines(file, boundary, content_length):
-            if ellt == _begin_file:
-                headers, name, filename = ell
-                is_file = True
-                guard_memory = False
-                filename, container = self.start_file_streaming(
-                    filename, headers, content_length)
-                _write = container.write
-
-            elif ellt == _begin_form:
-                headers, name = ell
-                is_file = False
-                container = []
-                _write = container.append
-                guard_memory = self.max_form_memory_size is not None
-
-            elif ellt == _cont:
-                _write(ell)
-                # if we write into memory and there is a memory size limit we
-                # count the number of bytes in memory and raise an exception if
-                # there is too much data in memory.
-                if guard_memory:
-                    in_memory += len(ell)
-                    if in_memory > self.max_form_memory_size:
-                        self.in_memory_threshold_reached(in_memory)
-
-            elif ellt == _end:
-                if is_file:
-                    container.seek(0)
-                    yield ('file',
-                           (name, FileStorage(container, filename, name,
-                                              headers=headers)))
-                else:
-                    part_charset = self.get_part_charset(headers)
-                    yield ('form',
-                           (name, b''.join(container).decode(
-                               part_charset, self.errors)))
-
-    def parse(self, file, boundary, content_length):
-        formstream, filestream = tee(
-            self.parse_parts(file, boundary, content_length), 2)
-        form = (p[1] for p in formstream if p[0] == 'form')
-        files = (p[1] for p in filestream if p[0] == 'file')
-        return self.cls(form), self.cls(files)
-
-
-from werkzeug import exceptions
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/http.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/http.py
deleted file mode 100644
index 22197221c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/http.py
+++ /dev/null
@@ -1,1158 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.http
-    ~~~~~~~~~~~~~
-
-    Werkzeug comes with a bunch of utilities that help Werkzeug to deal with
-    HTTP data.  Most of the classes and functions provided by this module are
-    used by the wrappers, but they are useful on their own, too, especially if
-    the response and request objects are not used.
-
-    This covers some of the more HTTP centric features of WSGI, some other
-    utilities such as cookie handling are documented in the `werkzeug.utils`
-    module.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import warnings
-from time import time, gmtime
-try:
-    from email.utils import parsedate_tz
-except ImportError:  # pragma: no cover
-    from email.Utils import parsedate_tz
-try:
-    from urllib.request import parse_http_list as _parse_list_header
-    from urllib.parse import unquote_to_bytes as _unquote
-except ImportError:  # pragma: no cover
-    from urllib2 import parse_http_list as _parse_list_header, \
-        unquote as _unquote
-from datetime import datetime, timedelta
-from hashlib import md5
-import base64
-
-from werkzeug._internal import _cookie_quote, _make_cookie_domain, \
-    _cookie_parse_impl
-from werkzeug._compat import to_unicode, iteritems, text_type, \
-    string_types, try_coerce_native, to_bytes, PY2, \
-    integer_types
-
-
-_cookie_charset = 'latin1'
-# for explanation of "media-range", etc. see Sections 5.3.{1,2} of RFC 7231
-_accept_re = re.compile(
-    r'''(                       # media-range capturing-parenthesis
-              [^\s;,]+              # type/subtype
-              (?:[ \t]*;[ \t]*      # ";"
-                (?:                 # parameter non-capturing-parenthesis
-                  [^\s;,q][^\s;,]*  # token that doesn't start with "q"
-                |                   # or
-                  q[^\s;,=][^\s;,]* # token that is more than just "q"
-                )
-              )*                    # zero or more parameters
-            )                       # end of media-range
-            (?:[ \t]*;[ \t]*q=      # weight is a "q" parameter
-              (\d*(?:\.\d+)?)       # qvalue capturing-parentheses
-              [^,]*                 # "extension" accept params: who cares?
-            )?                      # accept params are optional
-        ''', re.VERBOSE)
-_token_chars = frozenset("!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                         '^_`abcdefghijklmnopqrstuvwxyz|~')
-_etag_re = re.compile(r'([Ww]/)?(?:"(.*?)"|(.*?))(?:\s*,\s*|$)')
-_unsafe_header_chars = set('()<>@,;:\"/[]?={} \t')
-_option_header_piece_re = re.compile(r'''
-    ;\s*
-    (?P<key>
-        "[^"\\]*(?:\\.[^"\\]*)*"  # quoted string
-    |
-        [^\s;,=*]+  # token
-    )
-    \s*
-    (?:  # optionally followed by =value
-        (?:  # equals sign, possibly with encoding
-            \*\s*=\s*  # * indicates extended notation
-            (?P<encoding>[^\s]+?)
-            '(?P<language>[^\s]*?)'
-        |
-            =\s*  # basic notation
-        )
-        (?P<value>
-            "[^"\\]*(?:\\.[^"\\]*)*"  # quoted string
-        |
-            [^;,]+  # token
-        )?
-    )?
-    \s*
-''', flags=re.VERBOSE)
-_option_header_start_mime_type = re.compile(r',\s*([^;,\s]+)([;,]\s*.+)?')
-
-_entity_headers = frozenset([
-    'allow', 'content-encoding', 'content-language', 'content-length',
-    'content-location', 'content-md5', 'content-range', 'content-type',
-    'expires', 'last-modified'
-])
-_hop_by_hop_headers = frozenset([
-    'connection', 'keep-alive', 'proxy-authenticate',
-    'proxy-authorization', 'te', 'trailer', 'transfer-encoding',
-    'upgrade'
-])
-
-
-HTTP_STATUS_CODES = {
-    100:    'Continue',
-    101:    'Switching Protocols',
-    102:    'Processing',
-    200:    'OK',
-    201:    'Created',
-    202:    'Accepted',
-    203:    'Non Authoritative Information',
-    204:    'No Content',
-    205:    'Reset Content',
-    206:    'Partial Content',
-    207:    'Multi Status',
-    226:    'IM Used',              # see RFC 3229
-    300:    'Multiple Choices',
-    301:    'Moved Permanently',
-    302:    'Found',
-    303:    'See Other',
-    304:    'Not Modified',
-    305:    'Use Proxy',
-    307:    'Temporary Redirect',
-    400:    'Bad Request',
-    401:    'Unauthorized',
-    402:    'Payment Required',     # unused
-    403:    'Forbidden',
-    404:    'Not Found',
-    405:    'Method Not Allowed',
-    406:    'Not Acceptable',
-    407:    'Proxy Authentication Required',
-    408:    'Request Timeout',
-    409:    'Conflict',
-    410:    'Gone',
-    411:    'Length Required',
-    412:    'Precondition Failed',
-    413:    'Request Entity Too Large',
-    414:    'Request URI Too Long',
-    415:    'Unsupported Media Type',
-    416:    'Requested Range Not Satisfiable',
-    417:    'Expectation Failed',
-    418:    'I\'m a teapot',  # see RFC 2324
-    422:    'Unprocessable Entity',
-    423:    'Locked',
-    424:    'Failed Dependency',
-    426:    'Upgrade Required',
-    428:    'Precondition Required',  # see RFC 6585
-    429:    'Too Many Requests',
-    431:    'Request Header Fields Too Large',
-    449:    'Retry With',  # proprietary MS extension
-    451:    'Unavailable For Legal Reasons',
-    500:    'Internal Server Error',
-    501:    'Not Implemented',
-    502:    'Bad Gateway',
-    503:    'Service Unavailable',
-    504:    'Gateway Timeout',
-    505:    'HTTP Version Not Supported',
-    507:    'Insufficient Storage',
-    510:    'Not Extended'
-}
-
-
-def wsgi_to_bytes(data):
-    """coerce wsgi unicode represented bytes to real ones
-
-    """
-    if isinstance(data, bytes):
-        return data
-    return data.encode('latin1')  # XXX: utf8 fallback?
-
-
-def bytes_to_wsgi(data):
-    assert isinstance(data, bytes), 'data must be bytes'
-    if isinstance(data, str):
-        return data
-    else:
-        return data.decode('latin1')
-
-
-def quote_header_value(value, extra_chars='', allow_token=True):
-    """Quote a header value if necessary.
-
-    .. versionadded:: 0.5
-
-    :param value: the value to quote.
-    :param extra_chars: a list of extra characters to skip quoting.
-    :param allow_token: if this is enabled token values are returned
-                        unchanged.
-    """
-    if isinstance(value, bytes):
-        value = bytes_to_wsgi(value)
-    value = str(value)
-    if allow_token:
-        token_chars = _token_chars | set(extra_chars)
-        if set(value).issubset(token_chars):
-            return value
-    return '"%s"' % value.replace('\\', '\\\\').replace('"', '\\"')
-
-
-def unquote_header_value(value, is_filename=False):
-    r"""Unquotes a header value.  (Reversal of :func:`quote_header_value`).
-    This does not use the real unquoting but what browsers are actually
-    using for quoting.
-
-    .. versionadded:: 0.5
-
-    :param value: the header value to unquote.
-    """
-    if value and value[0] == value[-1] == '"':
-        # this is not the real unquoting, but fixing this so that the
-        # RFC is met will result in bugs with internet explorer and
-        # probably some other browsers as well.  IE for example is
-        # uploading files with "C:\foo\bar.txt" as filename
-        value = value[1:-1]
-
-        # if this is a filename and the starting characters look like
-        # a UNC path, then just return the value without quotes.  Using the
-        # replace sequence below on a UNC path has the effect of turning
-        # the leading double slash into a single slash and then
-        # _fix_ie_filename() doesn't work correctly.  See #458.
-        if not is_filename or value[:2] != '\\\\':
-            return value.replace('\\\\', '\\').replace('\\"', '"')
-    return value
-
-
-def dump_options_header(header, options):
-    """The reverse function to :func:`parse_options_header`.
-
-    :param header: the header to dump
-    :param options: a dict of options to append.
-    """
-    segments = []
-    if header is not None:
-        segments.append(header)
-    for key, value in iteritems(options):
-        if value is None:
-            segments.append(key)
-        else:
-            segments.append('%s=%s' % (key, quote_header_value(value)))
-    return '; '.join(segments)
-
-
-def dump_header(iterable, allow_token=True):
-    """Dump an HTTP header again.  This is the reversal of
-    :func:`parse_list_header`, :func:`parse_set_header` and
-    :func:`parse_dict_header`.  This also quotes strings that include an
-    equals sign unless you pass it as dict of key, value pairs.
-
-    >>> dump_header({'foo': 'bar baz'})
-    'foo="bar baz"'
-    >>> dump_header(('foo', 'bar baz'))
-    'foo, "bar baz"'
-
-    :param iterable: the iterable or dict of values to quote.
-    :param allow_token: if set to `False` tokens as values are disallowed.
-                        See :func:`quote_header_value` for more details.
-    """
-    if isinstance(iterable, dict):
-        items = []
-        for key, value in iteritems(iterable):
-            if value is None:
-                items.append(key)
-            else:
-                items.append('%s=%s' % (
-                    key,
-                    quote_header_value(value, allow_token=allow_token)
-                ))
-    else:
-        items = [quote_header_value(x, allow_token=allow_token)
-                 for x in iterable]
-    return ', '.join(items)
-
-
-def parse_list_header(value):
-    """Parse lists as described by RFC 2068 Section 2.
-
-    In particular, parse comma-separated lists where the elements of
-    the list may include quoted-strings.  A quoted-string could
-    contain a comma.  A non-quoted string could have quotes in the
-    middle.  Quotes are removed automatically after parsing.
-
-    It basically works like :func:`parse_set_header` just that items
-    may appear multiple times and case sensitivity is preserved.
-
-    The return value is a standard :class:`list`:
-
-    >>> parse_list_header('token, "quoted value"')
-    ['token', 'quoted value']
-
-    To create a header from the :class:`list` again, use the
-    :func:`dump_header` function.
-
-    :param value: a string with a list header.
-    :return: :class:`list`
-    """
-    result = []
-    for item in _parse_list_header(value):
-        if item[:1] == item[-1:] == '"':
-            item = unquote_header_value(item[1:-1])
-        result.append(item)
-    return result
-
-
-def parse_dict_header(value, cls=dict):
-    """Parse lists of key, value pairs as described by RFC 2068 Section 2 and
-    convert them into a python dict (or any other mapping object created from
-    the type with a dict like interface provided by the `cls` argument):
-
-    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
-    >>> type(d) is dict
-    True
-    >>> sorted(d.items())
-    [('bar', 'as well'), ('foo', 'is a fish')]
-
-    If there is no value for a key it will be `None`:
-
-    >>> parse_dict_header('key_without_value')
-    {'key_without_value': None}
-
-    To create a header from the :class:`dict` again, use the
-    :func:`dump_header` function.
-
-    .. versionchanged:: 0.9
-       Added support for `cls` argument.
-
-    :param value: a string with a dict header.
-    :param cls: callable to use for storage of parsed results.
-    :return: an instance of `cls`
-    """
-    result = cls()
-    if not isinstance(value, text_type):
-        # XXX: validate
-        value = bytes_to_wsgi(value)
-    for item in _parse_list_header(value):
-        if '=' not in item:
-            result[item] = None
-            continue
-        name, value = item.split('=', 1)
-        if value[:1] == value[-1:] == '"':
-            value = unquote_header_value(value[1:-1])
-        result[name] = value
-    return result
-
-
-def parse_options_header(value, multiple=False):
-    """Parse a ``Content-Type`` like header into a tuple with the content
-    type and the options:
-
-    >>> parse_options_header('text/html; charset=utf8')
-    ('text/html', {'charset': 'utf8'})
-
-    This should not be used to parse ``Cache-Control`` like headers that use
-    a slightly different format.  For these headers use the
-    :func:`parse_dict_header` function.
-
-    .. versionadded:: 0.5
-
-    :param value: the header to parse.
-    :param multiple: Whether try to parse and return multiple MIME types
-    :return: (mimetype, options) or (mimetype, options, mimetype, options, …)
-             if multiple=True
-    """
-    if not value:
-        return '', {}
-
-    result = []
-
-    value = "," + value.replace("\n", ",")
-    while value:
-        match = _option_header_start_mime_type.match(value)
-        if not match:
-            break
-        result.append(match.group(1))  # mimetype
-        options = {}
-        # Parse options
-        rest = match.group(2)
-        while rest:
-            optmatch = _option_header_piece_re.match(rest)
-            if not optmatch:
-                break
-            option, encoding, _, option_value = optmatch.groups()
-            option = unquote_header_value(option)
-            if option_value is not None:
-                option_value = unquote_header_value(
-                    option_value,
-                    option == 'filename')
-                if encoding is not None:
-                    option_value = _unquote(option_value).decode(encoding)
-            options[option] = option_value
-            rest = rest[optmatch.end():]
-        result.append(options)
-        if multiple is False:
-            return tuple(result)
-        value = rest
-
-    return tuple(result) if result else ('', {})
-
-
-def parse_accept_header(value, cls=None):
-    """Parses an HTTP Accept-* header.  This does not implement a complete
-    valid algorithm but one that supports at least value and quality
-    extraction.
-
-    Returns a new :class:`Accept` object (basically a list of ``(value, quality)``
-    tuples sorted by the quality with some additional accessor methods).
-
-    The second parameter can be a subclass of :class:`Accept` that is created
-    with the parsed values and returned.
-
-    :param value: the accept header string to be parsed.
-    :param cls: the wrapper class for the return value (can be
-                         :class:`Accept` or a subclass thereof)
-    :return: an instance of `cls`.
-    """
-    if cls is None:
-        cls = Accept
-
-    if not value:
-        return cls(None)
-
-    result = []
-    for match in _accept_re.finditer(value):
-        quality = match.group(2)
-        if not quality:
-            quality = 1
-        else:
-            quality = max(min(float(quality), 1), 0)
-        result.append((match.group(1), quality))
-    return cls(result)
-
-
-def parse_cache_control_header(value, on_update=None, cls=None):
-    """Parse a cache control header.  The RFC differs between response and
-    request cache control, this method does not.  It's your responsibility
-    to not use the wrong control statements.
-
-    .. versionadded:: 0.5
-       The `cls` was added.  If not specified an immutable
-       :class:`~werkzeug.datastructures.RequestCacheControl` is returned.
-
-    :param value: a cache control header to be parsed.
-    :param on_update: an optional callable that is called every time a value
-                      on the :class:`~werkzeug.datastructures.CacheControl`
-                      object is changed.
-    :param cls: the class for the returned object.  By default
-                :class:`~werkzeug.datastructures.RequestCacheControl` is used.
-    :return: a `cls` object.
-    """
-    if cls is None:
-        cls = RequestCacheControl
-    if not value:
-        return cls(None, on_update)
-    return cls(parse_dict_header(value), on_update)
-
-
-def parse_set_header(value, on_update=None):
-    """Parse a set-like header and return a
-    :class:`~werkzeug.datastructures.HeaderSet` object:
-
-    >>> hs = parse_set_header('token, "quoted value"')
-
-    The return value is an object that treats the items case-insensitively
-    and keeps the order of the items:
-
-    >>> 'TOKEN' in hs
-    True
-    >>> hs.index('quoted value')
-    1
-    >>> hs
-    HeaderSet(['token', 'quoted value'])
-
-    To create a header from the :class:`HeaderSet` again, use the
-    :func:`dump_header` function.
-
-    :param value: a set header to be parsed.
-    :param on_update: an optional callable that is called every time a
-                      value on the :class:`~werkzeug.datastructures.HeaderSet`
-                      object is changed.
-    :return: a :class:`~werkzeug.datastructures.HeaderSet`
-    """
-    if not value:
-        return HeaderSet(None, on_update)
-    return HeaderSet(parse_list_header(value), on_update)
-
-
-def parse_authorization_header(value):
-    """Parse an HTTP basic/digest authorization header transmitted by the web
-    browser.  The return value is either `None` if the header was invalid or
-    not given, otherwise an :class:`~werkzeug.datastructures.Authorization`
-    object.
-
-    :param value: the authorization header to parse.
-    :return: a :class:`~werkzeug.datastructures.Authorization` object or `None`.
-    """
-    if not value:
-        return
-    value = wsgi_to_bytes(value)
-    try:
-        auth_type, auth_info = value.split(None, 1)
-        auth_type = auth_type.lower()
-    except ValueError:
-        return
-    if auth_type == b'basic':
-        try:
-            username, password = base64.b64decode(auth_info).split(b':', 1)
-        except Exception:
-            return
-        return Authorization('basic', {'username':  bytes_to_wsgi(username),
-                                       'password': bytes_to_wsgi(password)})
-    elif auth_type == b'digest':
-        auth_map = parse_dict_header(auth_info)
-        for key in 'username', 'realm', 'nonce', 'uri', 'response':
-            if key not in auth_map:
-                return
-        if 'qop' in auth_map:
-            if not auth_map.get('nc') or not auth_map.get('cnonce'):
-                return
-        return Authorization('digest', auth_map)
-
-
-def parse_www_authenticate_header(value, on_update=None):
-    """Parse an HTTP WWW-Authenticate header into a
-    :class:`~werkzeug.datastructures.WWWAuthenticate` object.
-
-    :param value: a WWW-Authenticate header to parse.
-    :param on_update: an optional callable that is called every time a value
-                      on the :class:`~werkzeug.datastructures.WWWAuthenticate`
-                      object is changed.
-    :return: a :class:`~werkzeug.datastructures.WWWAuthenticate` object.
-    """
-    if not value:
-        return WWWAuthenticate(on_update=on_update)
-    try:
-        auth_type, auth_info = value.split(None, 1)
-        auth_type = auth_type.lower()
-    except (ValueError, AttributeError):
-        return WWWAuthenticate(value.strip().lower(), on_update=on_update)
-    return WWWAuthenticate(auth_type, parse_dict_header(auth_info),
-                           on_update)
-
-
-def parse_if_range_header(value):
-    """Parses an if-range header which can be an etag or a date.  Returns
-    a :class:`~werkzeug.datastructures.IfRange` object.
-
-    .. versionadded:: 0.7
-    """
-    if not value:
-        return IfRange()
-    date = parse_date(value)
-    if date is not None:
-        return IfRange(date=date)
-    # drop weakness information
-    return IfRange(unquote_etag(value)[0])
-
-
-def parse_range_header(value, make_inclusive=True):
-    """Parses a range header into a :class:`~werkzeug.datastructures.Range`
-    object.  If the header is missing or malformed `None` is returned.
-    `ranges` is a list of ``(start, stop)`` tuples where the ranges are
-    non-inclusive.
-
-    .. versionadded:: 0.7
-    """
-    if not value or '=' not in value:
-        return None
-
-    ranges = []
-    last_end = 0
-    units, rng = value.split('=', 1)
-    units = units.strip().lower()
-
-    for item in rng.split(','):
-        item = item.strip()
-        if '-' not in item:
-            return None
-        if item.startswith('-'):
-            if last_end < 0:
-                return None
-            try:
-                begin = int(item)
-            except ValueError:
-                return None
-            end = None
-            last_end = -1
-        elif '-' in item:
-            begin, end = item.split('-', 1)
-            begin = begin.strip()
-            end = end.strip()
-            if not begin.isdigit():
-                return None
-            begin = int(begin)
-            if begin < last_end or last_end < 0:
-                return None
-            if end:
-                if not end.isdigit():
-                    return None
-                end = int(end) + 1
-                if begin >= end:
-                    return None
-            else:
-                end = None
-            last_end = end
-        ranges.append((begin, end))
-
-    return Range(units, ranges)
-
-
-def parse_content_range_header(value, on_update=None):
-    """Parses a range header into a
-    :class:`~werkzeug.datastructures.ContentRange` object or `None` if
-    parsing is not possible.
-
-    .. versionadded:: 0.7
-
-    :param value: a content range header to be parsed.
-    :param on_update: an optional callable that is called every time a value
-                      on the :class:`~werkzeug.datastructures.ContentRange`
-                      object is changed.
-    """
-    if value is None:
-        return None
-    try:
-        units, rangedef = (value or '').strip().split(None, 1)
-    except ValueError:
-        return None
-
-    if '/' not in rangedef:
-        return None
-    rng, length = rangedef.split('/', 1)
-    if length == '*':
-        length = None
-    elif length.isdigit():
-        length = int(length)
-    else:
-        return None
-
-    if rng == '*':
-        return ContentRange(units, None, None, length, on_update=on_update)
-    elif '-' not in rng:
-        return None
-
-    start, stop = rng.split('-', 1)
-    try:
-        start = int(start)
-        stop = int(stop) + 1
-    except ValueError:
-        return None
-
-    if is_byte_range_valid(start, stop, length):
-        return ContentRange(units, start, stop, length, on_update=on_update)
-
-
-def quote_etag(etag, weak=False):
-    """Quote an etag.
-
-    :param etag: the etag to quote.
-    :param weak: set to `True` to tag it "weak".
-    """
-    if '"' in etag:
-        raise ValueError('invalid etag')
-    etag = '"%s"' % etag
-    if weak:
-        etag = 'W/' + etag
-    return etag
-
-
-def unquote_etag(etag):
-    """Unquote a single etag:
-
-    >>> unquote_etag('W/"bar"')
-    ('bar', True)
-    >>> unquote_etag('"bar"')
-    ('bar', False)
-
-    :param etag: the etag identifier to unquote.
-    :return: a ``(etag, weak)`` tuple.
-    """
-    if not etag:
-        return None, None
-    etag = etag.strip()
-    weak = False
-    if etag.startswith(('W/', 'w/')):
-        weak = True
-        etag = etag[2:]
-    if etag[:1] == etag[-1:] == '"':
-        etag = etag[1:-1]
-    return etag, weak
-
-
-def parse_etags(value):
-    """Parse an etag header.
-
-    :param value: the tag header to parse
-    :return: an :class:`~werkzeug.datastructures.ETags` object.
-    """
-    if not value:
-        return ETags()
-    strong = []
-    weak = []
-    end = len(value)
-    pos = 0
-    while pos < end:
-        match = _etag_re.match(value, pos)
-        if match is None:
-            break
-        is_weak, quoted, raw = match.groups()
-        if raw == '*':
-            return ETags(star_tag=True)
-        elif quoted:
-            raw = quoted
-        if is_weak:
-            weak.append(raw)
-        else:
-            strong.append(raw)
-        pos = match.end()
-    return ETags(strong, weak)
-
-
-def generate_etag(data):
-    """Generate an etag for some data."""
-    return md5(data).hexdigest()
-
-
-def parse_date(value):
-    """Parse one of the following date formats into a datetime object:
-
-    .. sourcecode:: text
-
-        Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
-        Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
-        Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
-
-    If parsing fails the return value is `None`.
-
-    :param value: a string with a supported date format.
-    :return: a :class:`datetime.datetime` object.
-    """
-    if value:
-        t = parsedate_tz(value.strip())
-        if t is not None:
-            try:
-                year = t[0]
-                # unfortunately that function does not tell us if two digit
-                # years were part of the string, or if they were prefixed
-                # with two zeroes.  So what we do is to assume that 69-99
-                # refer to 1900, and everything below to 2000
-                if year >= 0 and year <= 68:
-                    year += 2000
-                elif year >= 69 and year <= 99:
-                    year += 1900
-                return datetime(*((year,) + t[1:7])) - \
-                    timedelta(seconds=t[-1] or 0)
-            except (ValueError, OverflowError):
-                return None
-
-
-def _dump_date(d, delim):
-    """Used for `http_date` and `cookie_date`."""
-    if d is None:
-        d = gmtime()
-    elif isinstance(d, datetime):
-        d = d.utctimetuple()
-    elif isinstance(d, (integer_types, float)):
-        d = gmtime(d)
-    return '%s, %02d%s%s%s%s %02d:%02d:%02d GMT' % (
-        ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')[d.tm_wday],
-        d.tm_mday, delim,
-        ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
-         'Oct', 'Nov', 'Dec')[d.tm_mon - 1],
-        delim, str(d.tm_year), d.tm_hour, d.tm_min, d.tm_sec
-    )
-
-
-def cookie_date(expires=None):
-    """Formats the time to ensure compatibility with Netscape's cookie
-    standard.
-
-    Accepts a floating point number expressed in seconds since the epoch in, a
-    datetime object or a timetuple.  All times in UTC.  The :func:`parse_date`
-    function can be used to parse such a date.
-
-    Outputs a string in the format ``Wdy, DD-Mon-YYYY HH:MM:SS GMT``.
-
-    :param expires: If provided that date is used, otherwise the current.
-    """
-    return _dump_date(expires, '-')
-
-
-def http_date(timestamp=None):
-    """Formats the time to match the RFC1123 date format.
-
-    Accepts a floating point number expressed in seconds since the epoch in, a
-    datetime object or a timetuple.  All times in UTC.  The :func:`parse_date`
-    function can be used to parse such a date.
-
-    Outputs a string in the format ``Wdy, DD Mon YYYY HH:MM:SS GMT``.
-
-    :param timestamp: If provided that date is used, otherwise the current.
-    """
-    return _dump_date(timestamp, ' ')
-
-
-def parse_age(value=None):
-    """Parses a base-10 integer count of seconds into a timedelta.
-
-    If parsing fails, the return value is `None`.
-
-    :param value: a string consisting of an integer represented in base-10
-    :return: a :class:`datetime.timedelta` object or `None`.
-    """
-    if not value:
-        return None
-    try:
-        seconds = int(value)
-    except ValueError:
-        return None
-    if seconds < 0:
-        return None
-    try:
-        return timedelta(seconds=seconds)
-    except OverflowError:
-        return None
-
-
-def dump_age(age=None):
-    """Formats the duration as a base-10 integer.
-
-    :param age: should be an integer number of seconds,
-                a :class:`datetime.timedelta` object, or,
-                if the age is unknown, `None` (default).
-    """
-    if age is None:
-        return
-    if isinstance(age, timedelta):
-        # do the equivalent of Python 2.7's timedelta.total_seconds(),
-        # but disregarding fractional seconds
-        age = age.seconds + (age.days * 24 * 3600)
-
-    age = int(age)
-    if age < 0:
-        raise ValueError('age cannot be negative')
-
-    return str(age)
-
-
-def is_resource_modified(environ, etag=None, data=None, last_modified=None,
-                         ignore_if_range=True):
-    """Convenience method for conditional requests.
-
-    :param environ: the WSGI environment of the request to be checked.
-    :param etag: the etag for the response for comparison.
-    :param data: or alternatively the data of the response to automatically
-                 generate an etag using :func:`generate_etag`.
-    :param last_modified: an optional date of the last modification.
-    :param ignore_if_range: If `False`, `If-Range` header will be taken into
-                            account.
-    :return: `True` if the resource was modified, otherwise `False`.
-    """
-    if etag is None and data is not None:
-        etag = generate_etag(data)
-    elif data is not None:
-        raise TypeError('both data and etag given')
-    if environ['REQUEST_METHOD'] not in ('GET', 'HEAD'):
-        return False
-
-    unmodified = False
-    if isinstance(last_modified, string_types):
-        last_modified = parse_date(last_modified)
-
-    # ensure that microsecond is zero because the HTTP spec does not transmit
-    # that either and we might have some false positives.  See issue #39
-    if last_modified is not None:
-        last_modified = last_modified.replace(microsecond=0)
-
-    if_range = None
-    if not ignore_if_range and 'HTTP_RANGE' in environ:
-        # http://tools.ietf.org/html/rfc7233#section-3.2
-        # A server MUST ignore an If-Range header field received in a request
-        # that does not contain a Range header field.
-        if_range = parse_if_range_header(environ.get('HTTP_IF_RANGE'))
-
-    if if_range is not None and if_range.date is not None:
-        modified_since = if_range.date
-    else:
-        modified_since = parse_date(environ.get('HTTP_IF_MODIFIED_SINCE'))
-
-    if modified_since and last_modified and last_modified <= modified_since:
-        unmodified = True
-
-    if etag:
-        etag, _ = unquote_etag(etag)
-        if if_range is not None and if_range.etag is not None:
-            unmodified = parse_etags(if_range.etag).contains(etag)
-        else:
-            if_none_match = parse_etags(environ.get('HTTP_IF_NONE_MATCH'))
-            if if_none_match:
-                # http://tools.ietf.org/html/rfc7232#section-3.2
-                # "A recipient MUST use the weak comparison function when comparing
-                # entity-tags for If-None-Match"
-                unmodified = if_none_match.contains_weak(etag)
-
-            # https://tools.ietf.org/html/rfc7232#section-3.1
-            # "Origin server MUST use the strong comparison function when
-            # comparing entity-tags for If-Match"
-            if_match = parse_etags(environ.get('HTTP_IF_MATCH'))
-            if if_match:
-                unmodified = not if_match.is_strong(etag)
-
-    return not unmodified
-
-
-def remove_entity_headers(headers, allowed=('expires', 'content-location')):
-    """Remove all entity headers from a list or :class:`Headers` object.  This
-    operation works in-place.  `Expires` and `Content-Location` headers are
-    by default not removed.  The reason for this is :rfc:`2616` section
-    10.3.5 which specifies some entity headers that should be sent.
-
-    .. versionchanged:: 0.5
-       added `allowed` parameter.
-
-    :param headers: a list or :class:`Headers` object.
-    :param allowed: a list of headers that should still be allowed even though
-                    they are entity headers.
-    """
-    allowed = set(x.lower() for x in allowed)
-    headers[:] = [(key, value) for key, value in headers if
-                  not is_entity_header(key) or key.lower() in allowed]
-
-
-def remove_hop_by_hop_headers(headers):
-    """Remove all HTTP/1.1 "Hop-by-Hop" headers from a list or
-    :class:`Headers` object.  This operation works in-place.
-
-    .. versionadded:: 0.5
-
-    :param headers: a list or :class:`Headers` object.
-    """
-    headers[:] = [(key, value) for key, value in headers if
-                  not is_hop_by_hop_header(key)]
-
-
-def is_entity_header(header):
-    """Check if a header is an entity header.
-
-    .. versionadded:: 0.5
-
-    :param header: the header to test.
-    :return: `True` if it's an entity header, `False` otherwise.
-    """
-    return header.lower() in _entity_headers
-
-
-def is_hop_by_hop_header(header):
-    """Check if a header is an HTTP/1.1 "Hop-by-Hop" header.
-
-    .. versionadded:: 0.5
-
-    :param header: the header to test.
-    :return: `True` if it's an HTTP/1.1 "Hop-by-Hop" header, `False` otherwise.
-    """
-    return header.lower() in _hop_by_hop_headers
-
-
-def parse_cookie(header, charset='utf-8', errors='replace', cls=None):
-    """Parse a cookie.  Either from a string or WSGI environ.
-
-    Per default encoding errors are ignored.  If you want a different behavior
-    you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
-    :exc:`HTTPUnicodeError` is raised.
-
-    .. versionchanged:: 0.5
-       This function now returns a :class:`TypeConversionDict` instead of a
-       regular dict.  The `cls` parameter was added.
-
-    :param header: the header to be used to parse the cookie.  Alternatively
-                   this can be a WSGI environment.
-    :param charset: the charset for the cookie values.
-    :param errors: the error behavior for the charset decoding.
-    :param cls: an optional dict class to use.  If this is not specified
-                       or `None` the default :class:`TypeConversionDict` is
-                       used.
-    """
-    if isinstance(header, dict):
-        header = header.get('HTTP_COOKIE', '')
-    elif header is None:
-        header = ''
-
-    # If the value is an unicode string it's mangled through latin1.  This
-    # is done because on PEP 3333 on Python 3 all headers are assumed latin1
-    # which however is incorrect for cookies, which are sent in page encoding.
-    # As a result we
-    if isinstance(header, text_type):
-        header = header.encode('latin1', 'replace')
-
-    if cls is None:
-        cls = TypeConversionDict
-
-    def _parse_pairs():
-        for key, val in _cookie_parse_impl(header):
-            key = to_unicode(key, charset, errors, allow_none_charset=True)
-            val = to_unicode(val, charset, errors, allow_none_charset=True)
-            yield try_coerce_native(key), val
-
-    return cls(_parse_pairs())
-
-
-def dump_cookie(key, value='', max_age=None, expires=None, path='/',
-                domain=None, secure=False, httponly=False,
-                charset='utf-8', sync_expires=True, max_size=4093,
-                samesite=None):
-    """Creates a new Set-Cookie header without the ``Set-Cookie`` prefix
-    The parameters are the same as in the cookie Morsel object in the
-    Python standard library but it accepts unicode data, too.
-
-    On Python 3 the return value of this function will be a unicode
-    string, on Python 2 it will be a native string.  In both cases the
-    return value is usually restricted to ascii as the vast majority of
-    values are properly escaped, but that is no guarantee.  If a unicode
-    string is returned it's tunneled through latin1 as required by
-    PEP 3333.
-
-    The return value is not ASCII safe if the key contains unicode
-    characters.  This is technically against the specification but
-    happens in the wild.  It's strongly recommended to not use
-    non-ASCII values for the keys.
-
-    :param max_age: should be a number of seconds, or `None` (default) if
-                    the cookie should last only as long as the client's
-                    browser session.  Additionally `timedelta` objects
-                    are accepted, too.
-    :param expires: should be a `datetime` object or unix timestamp.
-    :param path: limits the cookie to a given path, per default it will
-                 span the whole domain.
-    :param domain: Use this if you want to set a cross-domain cookie. For
-                   example, ``domain=".example.com"`` will set a cookie
-                   that is readable by the domain ``www.example.com``,
-                   ``foo.example.com`` etc. Otherwise, a cookie will only
-                   be readable by the domain that set it.
-    :param secure: The cookie will only be available via HTTPS
-    :param httponly: disallow JavaScript to access the cookie.  This is an
-                     extension to the cookie standard and probably not
-                     supported by all browsers.
-    :param charset: the encoding for unicode values.
-    :param sync_expires: automatically set expires if max_age is defined
-                         but expires not.
-    :param max_size: Warn if the final header value exceeds this size. The
-        default, 4093, should be safely `supported by most browsers
-        <cookie_>`_. Set to 0 to disable this check.
-    :param samesite: Limits the scope of the cookie such that it will only
-                     be attached to requests if those requests are "same-site".
-
-    .. _`cookie`: http://browsercookielimits.squawky.net/
-    """
-    key = to_bytes(key, charset)
-    value = to_bytes(value, charset)
-
-    if path is not None:
-        path = iri_to_uri(path, charset)
-    domain = _make_cookie_domain(domain)
-    if isinstance(max_age, timedelta):
-        max_age = (max_age.days * 60 * 60 * 24) + max_age.seconds
-    if expires is not None:
-        if not isinstance(expires, string_types):
-            expires = cookie_date(expires)
-    elif max_age is not None and sync_expires:
-        expires = to_bytes(cookie_date(time() + max_age))
-
-    samesite = samesite.title() if samesite else None
-    if samesite not in ('Strict', 'Lax', None):
-        raise ValueError("invalid SameSite value; must be 'Strict', 'Lax' or None")
-
-    buf = [key + b'=' + _cookie_quote(value)]
-
-    # XXX: In theory all of these parameters that are not marked with `None`
-    # should be quoted.  Because stdlib did not quote it before I did not
-    # want to introduce quoting there now.
-    for k, v, q in ((b'Domain', domain, True),
-                    (b'Expires', expires, False,),
-                    (b'Max-Age', max_age, False),
-                    (b'Secure', secure, None),
-                    (b'HttpOnly', httponly, None),
-                    (b'Path', path, False),
-                    (b'SameSite', samesite, False)):
-        if q is None:
-            if v:
-                buf.append(k)
-            continue
-
-        if v is None:
-            continue
-
-        tmp = bytearray(k)
-        if not isinstance(v, (bytes, bytearray)):
-            v = to_bytes(text_type(v), charset)
-        if q:
-            v = _cookie_quote(v)
-        tmp += b'=' + v
-        buf.append(bytes(tmp))
-
-    # The return value will be an incorrectly encoded latin1 header on
-    # Python 3 for consistency with the headers object and a bytestring
-    # on Python 2 because that's how the API makes more sense.
-    rv = b'; '.join(buf)
-    if not PY2:
-        rv = rv.decode('latin1')
-
-    # Warn if the final value of the cookie is less than the limit. If the
-    # cookie is too large, then it may be silently ignored, which can be quite
-    # hard to debug.
-    cookie_size = len(rv)
-
-    if max_size and cookie_size > max_size:
-        value_size = len(value)
-        warnings.warn(
-            'The "{key}" cookie is too large: the value was {value_size} bytes'
-            ' but the header required {extra_size} extra bytes. The final size'
-            ' was {cookie_size} bytes but the limit is {max_size} bytes.'
-            ' Browsers may silently ignore cookies larger than this.'.format(
-                key=key,
-                value_size=value_size,
-                extra_size=cookie_size - value_size,
-                cookie_size=cookie_size,
-                max_size=max_size
-            ),
-            stacklevel=2
-        )
-
-    return rv
-
-
-def is_byte_range_valid(start, stop, length):
-    """Checks if a given byte content range is valid for the given length.
-
-    .. versionadded:: 0.7
-    """
-    if (start is None) != (stop is None):
-        return False
-    elif start is None:
-        return length is None or length >= 0
-    elif length is None:
-        return 0 <= start < stop
-    elif start >= stop:
-        return False
-    return 0 <= start < length
-
-
-# circular dependency fun
-from werkzeug.datastructures import Accept, HeaderSet, ETags, Authorization, \
-    WWWAuthenticate, TypeConversionDict, IfRange, Range, ContentRange, \
-    RequestCacheControl
-
-
-# DEPRECATED
-# backwards compatible imports
-from werkzeug.datastructures import (  # noqa
-    MIMEAccept, CharsetAccept, LanguageAccept, Headers
-)
-from werkzeug.urls import iri_to_uri
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/local.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/local.py
deleted file mode 100644
index e6d7478a0..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/local.py
+++ /dev/null
@@ -1,420 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.local
-    ~~~~~~~~~~~~~~
-
-    This module implements context-local objects.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import copy
-from functools import update_wrapper
-from werkzeug.wsgi import ClosingIterator
-from werkzeug._compat import PY2, implements_bool
-
-# since each thread has its own greenlet we can just use those as identifiers
-# for the context.  If greenlets are not available we fall back to the
-# current thread ident depending on where it is.
-try:
-    from greenlet import getcurrent as get_ident
-except ImportError:
-    try:
-        from thread import get_ident
-    except ImportError:
-        from _thread import get_ident
-
-
-def release_local(local):
-    """Releases the contents of the local for the current context.
-    This makes it possible to use locals without a manager.
-
-    Example::
-
-        >>> loc = Local()
-        >>> loc.foo = 42
-        >>> release_local(loc)
-        >>> hasattr(loc, 'foo')
-        False
-
-    With this function one can release :class:`Local` objects as well
-    as :class:`LocalStack` objects.  However it is not possible to
-    release data held by proxies that way, one always has to retain
-    a reference to the underlying local object in order to be able
-    to release it.
-
-    .. versionadded:: 0.6.1
-    """
-    local.__release_local__()
-
-
-class Local(object):
-    __slots__ = ('__storage__', '__ident_func__')
-
-    def __init__(self):
-        object.__setattr__(self, '__storage__', {})
-        object.__setattr__(self, '__ident_func__', get_ident)
-
-    def __iter__(self):
-        return iter(self.__storage__.items())
-
-    def __call__(self, proxy):
-        """Create a proxy for a name."""
-        return LocalProxy(self, proxy)
-
-    def __release_local__(self):
-        self.__storage__.pop(self.__ident_func__(), None)
-
-    def __getattr__(self, name):
-        try:
-            return self.__storage__[self.__ident_func__()][name]
-        except KeyError:
-            raise AttributeError(name)
-
-    def __setattr__(self, name, value):
-        ident = self.__ident_func__()
-        storage = self.__storage__
-        try:
-            storage[ident][name] = value
-        except KeyError:
-            storage[ident] = {name: value}
-
-    def __delattr__(self, name):
-        try:
-            del self.__storage__[self.__ident_func__()][name]
-        except KeyError:
-            raise AttributeError(name)
-
-
-class LocalStack(object):
-
-    """This class works similar to a :class:`Local` but keeps a stack
-    of objects instead.  This is best explained with an example::
-
-        >>> ls = LocalStack()
-        >>> ls.push(42)
-        >>> ls.top
-        42
-        >>> ls.push(23)
-        >>> ls.top
-        23
-        >>> ls.pop()
-        23
-        >>> ls.top
-        42
-
-    They can be force released by using a :class:`LocalManager` or with
-    the :func:`release_local` function but the correct way is to pop the
-    item from the stack after using.  When the stack is empty it will
-    no longer be bound to the current context (and as such released).
-
-    By calling the stack without arguments it returns a proxy that resolves to
-    the topmost item on the stack.
-
-    .. versionadded:: 0.6.1
-    """
-
-    def __init__(self):
-        self._local = Local()
-
-    def __release_local__(self):
-        self._local.__release_local__()
-
-    def _get__ident_func__(self):
-        return self._local.__ident_func__
-
-    def _set__ident_func__(self, value):
-        object.__setattr__(self._local, '__ident_func__', value)
-    __ident_func__ = property(_get__ident_func__, _set__ident_func__)
-    del _get__ident_func__, _set__ident_func__
-
-    def __call__(self):
-        def _lookup():
-            rv = self.top
-            if rv is None:
-                raise RuntimeError('object unbound')
-            return rv
-        return LocalProxy(_lookup)
-
-    def push(self, obj):
-        """Pushes a new item to the stack"""
-        rv = getattr(self._local, 'stack', None)
-        if rv is None:
-            self._local.stack = rv = []
-        rv.append(obj)
-        return rv
-
-    def pop(self):
-        """Removes the topmost item from the stack, will return the
-        old value or `None` if the stack was already empty.
-        """
-        stack = getattr(self._local, 'stack', None)
-        if stack is None:
-            return None
-        elif len(stack) == 1:
-            release_local(self._local)
-            return stack[-1]
-        else:
-            return stack.pop()
-
-    @property
-    def top(self):
-        """The topmost item on the stack.  If the stack is empty,
-        `None` is returned.
-        """
-        try:
-            return self._local.stack[-1]
-        except (AttributeError, IndexError):
-            return None
-
-
-class LocalManager(object):
-
-    """Local objects cannot manage themselves. For that you need a local
-    manager.  You can pass a local manager multiple locals or add them later
-    by appending them to `manager.locals`.  Every time the manager cleans up,
-    it will clean up all the data left in the locals for this context.
-
-    The `ident_func` parameter can be added to override the default ident
-    function for the wrapped locals.
-
-    .. versionchanged:: 0.6.1
-       Instead of a manager the :func:`release_local` function can be used
-       as well.
-
-    .. versionchanged:: 0.7
-       `ident_func` was added.
-    """
-
-    def __init__(self, locals=None, ident_func=None):
-        if locals is None:
-            self.locals = []
-        elif isinstance(locals, Local):
-            self.locals = [locals]
-        else:
-            self.locals = list(locals)
-        if ident_func is not None:
-            self.ident_func = ident_func
-            for local in self.locals:
-                object.__setattr__(local, '__ident_func__', ident_func)
-        else:
-            self.ident_func = get_ident
-
-    def get_ident(self):
-        """Return the context identifier the local objects use internally for
-        this context.  You cannot override this method to change the behavior
-        but use it to link other context local objects (such as SQLAlchemy's
-        scoped sessions) to the Werkzeug locals.
-
-        .. versionchanged:: 0.7
-           You can pass a different ident function to the local manager that
-           will then be propagated to all the locals passed to the
-           constructor.
-        """
-        return self.ident_func()
-
-    def cleanup(self):
-        """Manually clean up the data in the locals for this context.  Call
-        this at the end of the request or use `make_middleware()`.
-        """
-        for local in self.locals:
-            release_local(local)
-
-    def make_middleware(self, app):
-        """Wrap a WSGI application so that cleaning up happens after
-        request end.
-        """
-        def application(environ, start_response):
-            return ClosingIterator(app(environ, start_response), self.cleanup)
-        return application
-
-    def middleware(self, func):
-        """Like `make_middleware` but for decorating functions.
-
-        Example usage::
-
-            @manager.middleware
-            def application(environ, start_response):
-                ...
-
-        The difference to `make_middleware` is that the function passed
-        will have all the arguments copied from the inner application
-        (name, docstring, module).
-        """
-        return update_wrapper(self.make_middleware(func), func)
-
-    def __repr__(self):
-        return '<%s storages: %d>' % (
-            self.__class__.__name__,
-            len(self.locals)
-        )
-
-
-@implements_bool
-class LocalProxy(object):
-
-    """Acts as a proxy for a werkzeug local.  Forwards all operations to
-    a proxied object.  The only operations not supported for forwarding
-    are right handed operands and any kind of assignment.
-
-    Example usage::
-
-        from werkzeug.local import Local
-        l = Local()
-
-        # these are proxies
-        request = l('request')
-        user = l('user')
-
-
-        from werkzeug.local import LocalStack
-        _response_local = LocalStack()
-
-        # this is a proxy
-        response = _response_local()
-
-    Whenever something is bound to l.user / l.request the proxy objects
-    will forward all operations.  If no object is bound a :exc:`RuntimeError`
-    will be raised.
-
-    To create proxies to :class:`Local` or :class:`LocalStack` objects,
-    call the object as shown above.  If you want to have a proxy to an
-    object looked up by a function, you can (as of Werkzeug 0.6.1) pass
-    a function to the :class:`LocalProxy` constructor::
-
-        session = LocalProxy(lambda: get_current_request().session)
-
-    .. versionchanged:: 0.6.1
-       The class can be instantiated with a callable as well now.
-    """
-    __slots__ = ('__local', '__dict__', '__name__', '__wrapped__')
-
-    def __init__(self, local, name=None):
-        object.__setattr__(self, '_LocalProxy__local', local)
-        object.__setattr__(self, '__name__', name)
-        if callable(local) and not hasattr(local, '__release_local__'):
-            # "local" is a callable that is not an instance of Local or
-            # LocalManager: mark it as a wrapped function.
-            object.__setattr__(self, '__wrapped__', local)
-
-    def _get_current_object(self):
-        """Return the current object.  This is useful if you want the real
-        object behind the proxy at a time for performance reasons or because
-        you want to pass the object into a different context.
-        """
-        if not hasattr(self.__local, '__release_local__'):
-            return self.__local()
-        try:
-            return getattr(self.__local, self.__name__)
-        except AttributeError:
-            raise RuntimeError('no object bound to %s' % self.__name__)
-
-    @property
-    def __dict__(self):
-        try:
-            return self._get_current_object().__dict__
-        except RuntimeError:
-            raise AttributeError('__dict__')
-
-    def __repr__(self):
-        try:
-            obj = self._get_current_object()
-        except RuntimeError:
-            return '<%s unbound>' % self.__class__.__name__
-        return repr(obj)
-
-    def __bool__(self):
-        try:
-            return bool(self._get_current_object())
-        except RuntimeError:
-            return False
-
-    def __unicode__(self):
-        try:
-            return unicode(self._get_current_object())  # noqa
-        except RuntimeError:
-            return repr(self)
-
-    def __dir__(self):
-        try:
-            return dir(self._get_current_object())
-        except RuntimeError:
-            return []
-
-    def __getattr__(self, name):
-        if name == '__members__':
-            return dir(self._get_current_object())
-        return getattr(self._get_current_object(), name)
-
-    def __setitem__(self, key, value):
-        self._get_current_object()[key] = value
-
-    def __delitem__(self, key):
-        del self._get_current_object()[key]
-
-    if PY2:
-        __getslice__ = lambda x, i, j: x._get_current_object()[i:j]
-
-        def __setslice__(self, i, j, seq):
-            self._get_current_object()[i:j] = seq
-
-        def __delslice__(self, i, j):
-            del self._get_current_object()[i:j]
-
-    __setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
-    __delattr__ = lambda x, n: delattr(x._get_current_object(), n)
-    __str__ = lambda x: str(x._get_current_object())
-    __lt__ = lambda x, o: x._get_current_object() < o
-    __le__ = lambda x, o: x._get_current_object() <= o
-    __eq__ = lambda x, o: x._get_current_object() == o
-    __ne__ = lambda x, o: x._get_current_object() != o
-    __gt__ = lambda x, o: x._get_current_object() > o
-    __ge__ = lambda x, o: x._get_current_object() >= o
-    __cmp__ = lambda x, o: cmp(x._get_current_object(), o)  # noqa
-    __hash__ = lambda x: hash(x._get_current_object())
-    __call__ = lambda x, *a, **kw: x._get_current_object()(*a, **kw)
-    __len__ = lambda x: len(x._get_current_object())
-    __getitem__ = lambda x, i: x._get_current_object()[i]
-    __iter__ = lambda x: iter(x._get_current_object())
-    __contains__ = lambda x, i: i in x._get_current_object()
-    __add__ = lambda x, o: x._get_current_object() + o
-    __sub__ = lambda x, o: x._get_current_object() - o
-    __mul__ = lambda x, o: x._get_current_object() * o
-    __floordiv__ = lambda x, o: x._get_current_object() // o
-    __mod__ = lambda x, o: x._get_current_object() % o
-    __divmod__ = lambda x, o: x._get_current_object().__divmod__(o)
-    __pow__ = lambda x, o: x._get_current_object() ** o
-    __lshift__ = lambda x, o: x._get_current_object() << o
-    __rshift__ = lambda x, o: x._get_current_object() >> o
-    __and__ = lambda x, o: x._get_current_object() & o
-    __xor__ = lambda x, o: x._get_current_object() ^ o
-    __or__ = lambda x, o: x._get_current_object() | o
-    __div__ = lambda x, o: x._get_current_object().__div__(o)
-    __truediv__ = lambda x, o: x._get_current_object().__truediv__(o)
-    __neg__ = lambda x: -(x._get_current_object())
-    __pos__ = lambda x: +(x._get_current_object())
-    __abs__ = lambda x: abs(x._get_current_object())
-    __invert__ = lambda x: ~(x._get_current_object())
-    __complex__ = lambda x: complex(x._get_current_object())
-    __int__ = lambda x: int(x._get_current_object())
-    __long__ = lambda x: long(x._get_current_object())  # noqa
-    __float__ = lambda x: float(x._get_current_object())
-    __oct__ = lambda x: oct(x._get_current_object())
-    __hex__ = lambda x: hex(x._get_current_object())
-    __index__ = lambda x: x._get_current_object().__index__()
-    __coerce__ = lambda x, o: x._get_current_object().__coerce__(x, o)
-    __enter__ = lambda x: x._get_current_object().__enter__()
-    __exit__ = lambda x, *a, **kw: x._get_current_object().__exit__(*a, **kw)
-    __radd__ = lambda x, o: o + x._get_current_object()
-    __rsub__ = lambda x, o: o - x._get_current_object()
-    __rmul__ = lambda x, o: o * x._get_current_object()
-    __rdiv__ = lambda x, o: o / x._get_current_object()
-    if PY2:
-        __rtruediv__ = lambda x, o: x._get_current_object().__rtruediv__(o)
-    else:
-        __rtruediv__ = __rdiv__
-    __rfloordiv__ = lambda x, o: o // x._get_current_object()
-    __rmod__ = lambda x, o: o % x._get_current_object()
-    __rdivmod__ = lambda x, o: x._get_current_object().__rdivmod__(o)
-    __copy__ = lambda x: copy.copy(x._get_current_object())
-    __deepcopy__ = lambda x, memo: copy.deepcopy(x._get_current_object(), memo)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/posixemulation.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/posixemulation.py
deleted file mode 100644
index 8fd6314f2..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/posixemulation.py
+++ /dev/null
@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-r"""
-    werkzeug.posixemulation
-    ~~~~~~~~~~~~~~~~~~~~~~~
-
-    Provides a POSIX emulation for some features that are relevant to
-    web applications.  The main purpose is to simplify support for
-    systems such as Windows NT that are not 100% POSIX compatible.
-
-    Currently this only implements a :func:`rename` function that
-    follows POSIX semantics.  Eg: if the target file already exists it
-    will be replaced without asking.
-
-    This module was introduced in 0.6.1 and is not a public interface.
-    It might become one in later versions of Werkzeug.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-import os
-import errno
-import time
-import random
-
-from ._compat import to_unicode
-from .filesystem import get_filesystem_encoding
-
-
-can_rename_open_file = False
-if os.name == 'nt':  # pragma: no cover
-    _rename = lambda src, dst: False
-    _rename_atomic = lambda src, dst: False
-
-    try:
-        import ctypes
-
-        _MOVEFILE_REPLACE_EXISTING = 0x1
-        _MOVEFILE_WRITE_THROUGH = 0x8
-        _MoveFileEx = ctypes.windll.kernel32.MoveFileExW
-
-        def _rename(src, dst):
-            src = to_unicode(src, get_filesystem_encoding())
-            dst = to_unicode(dst, get_filesystem_encoding())
-            if _rename_atomic(src, dst):
-                return True
-            retry = 0
-            rv = False
-            while not rv and retry < 100:
-                rv = _MoveFileEx(src, dst, _MOVEFILE_REPLACE_EXISTING |
-                                 _MOVEFILE_WRITE_THROUGH)
-                if not rv:
-                    time.sleep(0.001)
-                    retry += 1
-            return rv
-
-        # new in Vista and Windows Server 2008
-        _CreateTransaction = ctypes.windll.ktmw32.CreateTransaction
-        _CommitTransaction = ctypes.windll.ktmw32.CommitTransaction
-        _MoveFileTransacted = ctypes.windll.kernel32.MoveFileTransactedW
-        _CloseHandle = ctypes.windll.kernel32.CloseHandle
-        can_rename_open_file = True
-
-        def _rename_atomic(src, dst):
-            ta = _CreateTransaction(None, 0, 0, 0, 0, 1000, 'Werkzeug rename')
-            if ta == -1:
-                return False
-            try:
-                retry = 0
-                rv = False
-                while not rv and retry < 100:
-                    rv = _MoveFileTransacted(src, dst, None, None,
-                                             _MOVEFILE_REPLACE_EXISTING |
-                                             _MOVEFILE_WRITE_THROUGH, ta)
-                    if rv:
-                        rv = _CommitTransaction(ta)
-                        break
-                    else:
-                        time.sleep(0.001)
-                        retry += 1
-                return rv
-            finally:
-                _CloseHandle(ta)
-    except Exception:
-        pass
-
-    def rename(src, dst):
-        # Try atomic or pseudo-atomic rename
-        if _rename(src, dst):
-            return
-        # Fall back to "move away and replace"
-        try:
-            os.rename(src, dst)
-        except OSError as e:
-            if e.errno != errno.EEXIST:
-                raise
-            old = "%s-%08x" % (dst, random.randint(0, sys.maxint))
-            os.rename(dst, old)
-            os.rename(src, dst)
-            try:
-                os.unlink(old)
-            except Exception:
-                pass
-else:
-    rename = os.rename
-    can_rename_open_file = True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/routing.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/routing.py
deleted file mode 100644
index 2e4e2f42c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/routing.py
+++ /dev/null
@@ -1,1792 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.routing
-    ~~~~~~~~~~~~~~~~
-
-    When it comes to combining multiple controller or view functions (however
-    you want to call them) you need a dispatcher.  A simple way would be
-    applying regular expression tests on the ``PATH_INFO`` and calling
-    registered callback functions that return the value then.
-
-    This module implements a much more powerful system than simple regular
-    expression matching because it can also convert values in the URLs and
-    build URLs.
-
-    Here a simple example that creates an URL map for an application with
-    two subdomains (www and kb) and some URL rules:
-
-    >>> m = Map([
-    ...     # Static URLs
-    ...     Rule('/', endpoint='static/index'),
-    ...     Rule('/about', endpoint='static/about'),
-    ...     Rule('/help', endpoint='static/help'),
-    ...     # Knowledge Base
-    ...     Subdomain('kb', [
-    ...         Rule('/', endpoint='kb/index'),
-    ...         Rule('/browse/', endpoint='kb/browse'),
-    ...         Rule('/browse/<int:id>/', endpoint='kb/browse'),
-    ...         Rule('/browse/<int:id>/<int:page>', endpoint='kb/browse')
-    ...     ])
-    ... ], default_subdomain='www')
-
-    If the application doesn't use subdomains it's perfectly fine to not set
-    the default subdomain and not use the `Subdomain` rule factory.  The endpoint
-    in the rules can be anything, for example import paths or unique
-    identifiers.  The WSGI application can use those endpoints to get the
-    handler for that URL.  It doesn't have to be a string at all but it's
-    recommended.
-
-    Now it's possible to create a URL adapter for one of the subdomains and
-    build URLs:
-
-    >>> c = m.bind('example.com')
-    >>> c.build("kb/browse", dict(id=42))
-    'http://kb.example.com/browse/42/'
-    >>> c.build("kb/browse", dict())
-    'http://kb.example.com/browse/'
-    >>> c.build("kb/browse", dict(id=42, page=3))
-    'http://kb.example.com/browse/42/3'
-    >>> c.build("static/about")
-    '/about'
-    >>> c.build("static/index", force_external=True)
-    'http://www.example.com/'
-
-    >>> c = m.bind('example.com', subdomain='kb')
-    >>> c.build("static/about")
-    'http://www.example.com/about'
-
-    The first argument to bind is the server name *without* the subdomain.
-    Per default it will assume that the script is mounted on the root, but
-    often that's not the case so you can provide the real mount point as
-    second argument:
-
-    >>> c = m.bind('example.com', '/applications/example')
-
-    The third argument can be the subdomain, if not given the default
-    subdomain is used.  For more details about binding have a look at the
-    documentation of the `MapAdapter`.
-
-    And here is how you can match URLs:
-
-    >>> c = m.bind('example.com')
-    >>> c.match("/")
-    ('static/index', {})
-    >>> c.match("/about")
-    ('static/about', {})
-    >>> c = m.bind('example.com', '/', 'kb')
-    >>> c.match("/")
-    ('kb/index', {})
-    >>> c.match("/browse/42/23")
-    ('kb/browse', {'id': 42, 'page': 23})
-
-    If matching fails you get a `NotFound` exception, if the rule thinks
-    it's a good idea to redirect (for example because the URL was defined
-    to have a slash at the end but the request was missing that slash) it
-    will raise a `RequestRedirect` exception.  Both are subclasses of the
-    `HTTPException` so you can use those errors as responses in the
-    application.
-
-    If matching succeeded but the URL rule was incompatible to the given
-    method (for example there were only rules for `GET` and `HEAD` and
-    routing system tried to match a `POST` request) a `MethodNotAllowed`
-    exception is raised.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import difflib
-import re
-import uuid
-import posixpath
-
-from pprint import pformat
-from threading import Lock
-
-from werkzeug.urls import url_encode, url_quote, url_join
-from werkzeug.utils import redirect, format_string
-from werkzeug.exceptions import HTTPException, NotFound, MethodNotAllowed, \
-     BadHost
-from werkzeug._internal import _get_environ, _encode_idna
-from werkzeug._compat import itervalues, iteritems, to_unicode, to_bytes, \
-    text_type, string_types, native_string_result, \
-    implements_to_string, wsgi_decoding_dance
-from werkzeug.datastructures import ImmutableDict, MultiDict
-from werkzeug.utils import cached_property
-
-
-_rule_re = re.compile(r'''
-    (?P<static>[^<]*)                           # static rule data
-    <
-    (?:
-        (?P<converter>[a-zA-Z_][a-zA-Z0-9_]*)   # converter name
-        (?:\((?P<args>.*?)\))?                  # converter arguments
-        \:                                      # variable delimiter
-    )?
-    (?P<variable>[a-zA-Z_][a-zA-Z0-9_]*)        # variable name
-    >
-''', re.VERBOSE)
-_simple_rule_re = re.compile(r'<([^>]+)>')
-_converter_args_re = re.compile(r'''
-    ((?P<name>\w+)\s*=\s*)?
-    (?P<value>
-        True|False|
-        \d+.\d+|
-        \d+.|
-        \d+|
-        [\w\d_.]+|
-        [urUR]?(?P<stringval>"[^"]*?"|'[^']*')
-    )\s*,
-''', re.VERBOSE | re.UNICODE)
-
-
-_PYTHON_CONSTANTS = {
-    'None':     None,
-    'True':     True,
-    'False':    False
-}
-
-
-def _pythonize(value):
-    if value in _PYTHON_CONSTANTS:
-        return _PYTHON_CONSTANTS[value]
-    for convert in int, float:
-        try:
-            return convert(value)
-        except ValueError:
-            pass
-    if value[:1] == value[-1:] and value[0] in '"\'':
-        value = value[1:-1]
-    return text_type(value)
-
-
-def parse_converter_args(argstr):
-    argstr += ','
-    args = []
-    kwargs = {}
-
-    for item in _converter_args_re.finditer(argstr):
-        value = item.group('stringval')
-        if value is None:
-            value = item.group('value')
-        value = _pythonize(value)
-        if not item.group('name'):
-            args.append(value)
-        else:
-            name = item.group('name')
-            kwargs[name] = value
-
-    return tuple(args), kwargs
-
-
-def parse_rule(rule):
-    """Parse a rule and return it as generator. Each iteration yields tuples
-    in the form ``(converter, arguments, variable)``. If the converter is
-    `None` it's a static url part, otherwise it's a dynamic one.
-
-    :internal:
-    """
-    pos = 0
-    end = len(rule)
-    do_match = _rule_re.match
-    used_names = set()
-    while pos < end:
-        m = do_match(rule, pos)
-        if m is None:
-            break
-        data = m.groupdict()
-        if data['static']:
-            yield None, None, data['static']
-        variable = data['variable']
-        converter = data['converter'] or 'default'
-        if variable in used_names:
-            raise ValueError('variable name %r used twice.' % variable)
-        used_names.add(variable)
-        yield converter, data['args'] or None, variable
-        pos = m.end()
-    if pos < end:
-        remaining = rule[pos:]
-        if '>' in remaining or '<' in remaining:
-            raise ValueError('malformed url rule: %r' % rule)
-        yield None, None, remaining
-
-
-class RoutingException(Exception):
-
-    """Special exceptions that require the application to redirect, notifying
-    about missing urls, etc.
-
-    :internal:
-    """
-
-
-class RequestRedirect(HTTPException, RoutingException):
-
-    """Raise if the map requests a redirect. This is for example the case if
-    `strict_slashes` are activated and an url that requires a trailing slash.
-
-    The attribute `new_url` contains the absolute destination url.
-    """
-    code = 301
-
-    def __init__(self, new_url):
-        RoutingException.__init__(self, new_url)
-        self.new_url = new_url
-
-    def get_response(self, environ):
-        return redirect(self.new_url, self.code)
-
-
-class RequestSlash(RoutingException):
-
-    """Internal exception."""
-
-
-class RequestAliasRedirect(RoutingException):
-
-    """This rule is an alias and wants to redirect to the canonical URL."""
-
-    def __init__(self, matched_values):
-        self.matched_values = matched_values
-
-
-@implements_to_string
-class BuildError(RoutingException, LookupError):
-
-    """Raised if the build system cannot find a URL for an endpoint with the
-    values provided.
-    """
-
-    def __init__(self, endpoint, values, method, adapter=None):
-        LookupError.__init__(self, endpoint, values, method)
-        self.endpoint = endpoint
-        self.values = values
-        self.method = method
-        self.adapter = adapter
-
-    @cached_property
-    def suggested(self):
-        return self.closest_rule(self.adapter)
-
-    def closest_rule(self, adapter):
-        def _score_rule(rule):
-            return sum([
-                0.98 * difflib.SequenceMatcher(
-                    None, rule.endpoint, self.endpoint
-                ).ratio(),
-                0.01 * bool(set(self.values or ()).issubset(rule.arguments)),
-                0.01 * bool(rule.methods and self.method in rule.methods)
-            ])
-
-        if adapter and adapter.map._rules:
-            return max(adapter.map._rules, key=_score_rule)
-
-    def __str__(self):
-        message = []
-        message.append('Could not build url for endpoint %r' % self.endpoint)
-        if self.method:
-            message.append(' (%r)' % self.method)
-        if self.values:
-            message.append(' with values %r' % sorted(self.values.keys()))
-        message.append('.')
-        if self.suggested:
-            if self.endpoint == self.suggested.endpoint:
-                if self.method and self.method not in self.suggested.methods:
-                    message.append(' Did you mean to use methods %r?' % sorted(
-                        self.suggested.methods
-                    ))
-                missing_values = self.suggested.arguments.union(
-                    set(self.suggested.defaults or ())
-                ) - set(self.values.keys())
-                if missing_values:
-                    message.append(
-                        ' Did you forget to specify values %r?' %
-                        sorted(missing_values)
-                    )
-            else:
-                message.append(
-                    ' Did you mean %r instead?' % self.suggested.endpoint
-                )
-        return u''.join(message)
-
-
-class ValidationError(ValueError):
-
-    """Validation error.  If a rule converter raises this exception the rule
-    does not match the current URL and the next URL is tried.
-    """
-
-
-class RuleFactory(object):
-
-    """As soon as you have more complex URL setups it's a good idea to use rule
-    factories to avoid repetitive tasks.  Some of them are builtin, others can
-    be added by subclassing `RuleFactory` and overriding `get_rules`.
-    """
-
-    def get_rules(self, map):
-        """Subclasses of `RuleFactory` have to override this method and return
-        an iterable of rules."""
-        raise NotImplementedError()
-
-
-class Subdomain(RuleFactory):
-
-    """All URLs provided by this factory have the subdomain set to a
-    specific domain. For example if you want to use the subdomain for
-    the current language this can be a good setup::
-
-        url_map = Map([
-            Rule('/', endpoint='#select_language'),
-            Subdomain('<string(length=2):lang_code>', [
-                Rule('/', endpoint='index'),
-                Rule('/about', endpoint='about'),
-                Rule('/help', endpoint='help')
-            ])
-        ])
-
-    All the rules except for the ``'#select_language'`` endpoint will now
-    listen on a two letter long subdomain that holds the language code
-    for the current request.
-    """
-
-    def __init__(self, subdomain, rules):
-        self.subdomain = subdomain
-        self.rules = rules
-
-    def get_rules(self, map):
-        for rulefactory in self.rules:
-            for rule in rulefactory.get_rules(map):
-                rule = rule.empty()
-                rule.subdomain = self.subdomain
-                yield rule
-
-
-class Submount(RuleFactory):
-
-    """Like `Subdomain` but prefixes the URL rule with a given string::
-
-        url_map = Map([
-            Rule('/', endpoint='index'),
-            Submount('/blog', [
-                Rule('/', endpoint='blog/index'),
-                Rule('/entry/<entry_slug>', endpoint='blog/show')
-            ])
-        ])
-
-    Now the rule ``'blog/show'`` matches ``/blog/entry/<entry_slug>``.
-    """
-
-    def __init__(self, path, rules):
-        self.path = path.rstrip('/')
-        self.rules = rules
-
-    def get_rules(self, map):
-        for rulefactory in self.rules:
-            for rule in rulefactory.get_rules(map):
-                rule = rule.empty()
-                rule.rule = self.path + rule.rule
-                yield rule
-
-
-class EndpointPrefix(RuleFactory):
-
-    """Prefixes all endpoints (which must be strings for this factory) with
-    another string. This can be useful for sub applications::
-
-        url_map = Map([
-            Rule('/', endpoint='index'),
-            EndpointPrefix('blog/', [Submount('/blog', [
-                Rule('/', endpoint='index'),
-                Rule('/entry/<entry_slug>', endpoint='show')
-            ])])
-        ])
-    """
-
-    def __init__(self, prefix, rules):
-        self.prefix = prefix
-        self.rules = rules
-
-    def get_rules(self, map):
-        for rulefactory in self.rules:
-            for rule in rulefactory.get_rules(map):
-                rule = rule.empty()
-                rule.endpoint = self.prefix + rule.endpoint
-                yield rule
-
-
-class RuleTemplate(object):
-
-    """Returns copies of the rules wrapped and expands string templates in
-    the endpoint, rule, defaults or subdomain sections.
-
-    Here a small example for such a rule template::
-
-        from werkzeug.routing import Map, Rule, RuleTemplate
-
-        resource = RuleTemplate([
-            Rule('/$name/', endpoint='$name.list'),
-            Rule('/$name/<int:id>', endpoint='$name.show')
-        ])
-
-        url_map = Map([resource(name='user'), resource(name='page')])
-
-    When a rule template is called the keyword arguments are used to
-    replace the placeholders in all the string parameters.
-    """
-
-    def __init__(self, rules):
-        self.rules = list(rules)
-
-    def __call__(self, *args, **kwargs):
-        return RuleTemplateFactory(self.rules, dict(*args, **kwargs))
-
-
-class RuleTemplateFactory(RuleFactory):
-
-    """A factory that fills in template variables into rules.  Used by
-    `RuleTemplate` internally.
-
-    :internal:
-    """
-
-    def __init__(self, rules, context):
-        self.rules = rules
-        self.context = context
-
-    def get_rules(self, map):
-        for rulefactory in self.rules:
-            for rule in rulefactory.get_rules(map):
-                new_defaults = subdomain = None
-                if rule.defaults:
-                    new_defaults = {}
-                    for key, value in iteritems(rule.defaults):
-                        if isinstance(value, string_types):
-                            value = format_string(value, self.context)
-                        new_defaults[key] = value
-                if rule.subdomain is not None:
-                    subdomain = format_string(rule.subdomain, self.context)
-                new_endpoint = rule.endpoint
-                if isinstance(new_endpoint, string_types):
-                    new_endpoint = format_string(new_endpoint, self.context)
-                yield Rule(
-                    format_string(rule.rule, self.context),
-                    new_defaults,
-                    subdomain,
-                    rule.methods,
-                    rule.build_only,
-                    new_endpoint,
-                    rule.strict_slashes
-                )
-
-
-@implements_to_string
-class Rule(RuleFactory):
-
-    """A Rule represents one URL pattern.  There are some options for `Rule`
-    that change the way it behaves and are passed to the `Rule` constructor.
-    Note that besides the rule-string all arguments *must* be keyword arguments
-    in order to not break the application on Werkzeug upgrades.
-
-    `string`
-        Rule strings basically are just normal URL paths with placeholders in
-        the format ``<converter(arguments):name>`` where the converter and the
-        arguments are optional.  If no converter is defined the `default`
-        converter is used which means `string` in the normal configuration.
-
-        URL rules that end with a slash are branch URLs, others are leaves.
-        If you have `strict_slashes` enabled (which is the default), all
-        branch URLs that are matched without a trailing slash will trigger a
-        redirect to the same URL with the missing slash appended.
-
-        The converters are defined on the `Map`.
-
-    `endpoint`
-        The endpoint for this rule. This can be anything. A reference to a
-        function, a string, a number etc.  The preferred way is using a string
-        because the endpoint is used for URL generation.
-
-    `defaults`
-        An optional dict with defaults for other rules with the same endpoint.
-        This is a bit tricky but useful if you want to have unique URLs::
-
-            url_map = Map([
-                Rule('/all/', defaults={'page': 1}, endpoint='all_entries'),
-                Rule('/all/page/<int:page>', endpoint='all_entries')
-            ])
-
-        If a user now visits ``http://example.com/all/page/1`` he will be
-        redirected to ``http://example.com/all/``.  If `redirect_defaults` is
-        disabled on the `Map` instance this will only affect the URL
-        generation.
-
-    `subdomain`
-        The subdomain rule string for this rule. If not specified the rule
-        only matches for the `default_subdomain` of the map.  If the map is
-        not bound to a subdomain this feature is disabled.
-
-        Can be useful if you want to have user profiles on different subdomains
-        and all subdomains are forwarded to your application::
-
-            url_map = Map([
-                Rule('/', subdomain='<username>', endpoint='user/homepage'),
-                Rule('/stats', subdomain='<username>', endpoint='user/stats')
-            ])
-
-    `methods`
-        A sequence of http methods this rule applies to.  If not specified, all
-        methods are allowed. For example this can be useful if you want different
-        endpoints for `POST` and `GET`.  If methods are defined and the path
-        matches but the method matched against is not in this list or in the
-        list of another rule for that path the error raised is of the type
-        `MethodNotAllowed` rather than `NotFound`.  If `GET` is present in the
-        list of methods and `HEAD` is not, `HEAD` is added automatically.
-
-        .. versionchanged:: 0.6.1
-           `HEAD` is now automatically added to the methods if `GET` is
-           present.  The reason for this is that existing code often did not
-           work properly in servers not rewriting `HEAD` to `GET`
-           automatically and it was not documented how `HEAD` should be
-           treated.  This was considered a bug in Werkzeug because of that.
-
-    `strict_slashes`
-        Override the `Map` setting for `strict_slashes` only for this rule. If
-        not specified the `Map` setting is used.
-
-    `build_only`
-        Set this to True and the rule will never match but will create a URL
-        that can be build. This is useful if you have resources on a subdomain
-        or folder that are not handled by the WSGI application (like static data)
-
-    `redirect_to`
-        If given this must be either a string or callable.  In case of a
-        callable it's called with the url adapter that triggered the match and
-        the values of the URL as keyword arguments and has to return the target
-        for the redirect, otherwise it has to be a string with placeholders in
-        rule syntax::
-
-            def foo_with_slug(adapter, id):
-                # ask the database for the slug for the old id.  this of
-                # course has nothing to do with werkzeug.
-                return 'foo/' + Foo.get_slug_for_id(id)
-
-            url_map = Map([
-                Rule('/foo/<slug>', endpoint='foo'),
-                Rule('/some/old/url/<slug>', redirect_to='foo/<slug>'),
-                Rule('/other/old/url/<int:id>', redirect_to=foo_with_slug)
-            ])
-
-        When the rule is matched the routing system will raise a
-        `RequestRedirect` exception with the target for the redirect.
-
-        Keep in mind that the URL will be joined against the URL root of the
-        script so don't use a leading slash on the target URL unless you
-        really mean root of that domain.
-
-    `alias`
-        If enabled this rule serves as an alias for another rule with the same
-        endpoint and arguments.
-
-    `host`
-        If provided and the URL map has host matching enabled this can be
-        used to provide a match rule for the whole host.  This also means
-        that the subdomain feature is disabled.
-
-    .. versionadded:: 0.7
-       The `alias` and `host` parameters were added.
-    """
-
-    def __init__(self, string, defaults=None, subdomain=None, methods=None,
-                 build_only=False, endpoint=None, strict_slashes=None,
-                 redirect_to=None, alias=False, host=None):
-        if not string.startswith('/'):
-            raise ValueError('urls must start with a leading slash')
-        self.rule = string
-        self.is_leaf = not string.endswith('/')
-
-        self.map = None
-        self.strict_slashes = strict_slashes
-        self.subdomain = subdomain
-        self.host = host
-        self.defaults = defaults
-        self.build_only = build_only
-        self.alias = alias
-        if methods is None:
-            self.methods = None
-        else:
-            if isinstance(methods, str):
-                raise TypeError('param `methods` should be `Iterable[str]`, not `str`')
-            self.methods = set([x.upper() for x in methods])
-            if 'HEAD' not in self.methods and 'GET' in self.methods:
-                self.methods.add('HEAD')
-        self.endpoint = endpoint
-        self.redirect_to = redirect_to
-
-        if defaults:
-            self.arguments = set(map(str, defaults))
-        else:
-            self.arguments = set()
-        self._trace = self._converters = self._regex = self._argument_weights = None
-
-    def empty(self):
-        """
-        Return an unbound copy of this rule.
-
-        This can be useful if want to reuse an already bound URL for another
-        map.  See ``get_empty_kwargs`` to override what keyword arguments are
-        provided to the new copy.
-        """
-        return type(self)(self.rule, **self.get_empty_kwargs())
-
-    def get_empty_kwargs(self):
-        """
-        Provides kwargs for instantiating empty copy with empty()
-
-        Use this method to provide custom keyword arguments to the subclass of
-        ``Rule`` when calling ``some_rule.empty()``.  Helpful when the subclass
-        has custom keyword arguments that are needed at instantiation.
-
-        Must return a ``dict`` that will be provided as kwargs to the new
-        instance of ``Rule``, following the initial ``self.rule`` value which
-        is always provided as the first, required positional argument.
-        """
-        defaults = None
-        if self.defaults:
-            defaults = dict(self.defaults)
-        return dict(defaults=defaults, subdomain=self.subdomain,
-                    methods=self.methods, build_only=self.build_only,
-                    endpoint=self.endpoint, strict_slashes=self.strict_slashes,
-                    redirect_to=self.redirect_to, alias=self.alias,
-                    host=self.host)
-
-    def get_rules(self, map):
-        yield self
-
-    def refresh(self):
-        """Rebinds and refreshes the URL.  Call this if you modified the
-        rule in place.
-
-        :internal:
-        """
-        self.bind(self.map, rebind=True)
-
-    def bind(self, map, rebind=False):
-        """Bind the url to a map and create a regular expression based on
-        the information from the rule itself and the defaults from the map.
-
-        :internal:
-        """
-        if self.map is not None and not rebind:
-            raise RuntimeError('url rule %r already bound to map %r' %
-                               (self, self.map))
-        self.map = map
-        if self.strict_slashes is None:
-            self.strict_slashes = map.strict_slashes
-        if self.subdomain is None:
-            self.subdomain = map.default_subdomain
-        self.compile()
-
-    def get_converter(self, variable_name, converter_name, args, kwargs):
-        """Looks up the converter for the given parameter.
-
-        .. versionadded:: 0.9
-        """
-        if converter_name not in self.map.converters:
-            raise LookupError('the converter %r does not exist' % converter_name)
-        return self.map.converters[converter_name](self.map, *args, **kwargs)
-
-    def compile(self):
-        """Compiles the regular expression and stores it."""
-        assert self.map is not None, 'rule not bound'
-
-        if self.map.host_matching:
-            domain_rule = self.host or ''
-        else:
-            domain_rule = self.subdomain or ''
-
-        self._trace = []
-        self._converters = {}
-        self._static_weights = []
-        self._argument_weights = []
-        regex_parts = []
-
-        def _build_regex(rule):
-            index = 0
-            for converter, arguments, variable in parse_rule(rule):
-                if converter is None:
-                    regex_parts.append(re.escape(variable))
-                    self._trace.append((False, variable))
-                    for part in variable.split('/'):
-                        if part:
-                            self._static_weights.append((index, -len(part)))
-                else:
-                    if arguments:
-                        c_args, c_kwargs = parse_converter_args(arguments)
-                    else:
-                        c_args = ()
-                        c_kwargs = {}
-                    convobj = self.get_converter(
-                        variable, converter, c_args, c_kwargs)
-                    regex_parts.append('(?P<%s>%s)' % (variable, convobj.regex))
-                    self._converters[variable] = convobj
-                    self._trace.append((True, variable))
-                    self._argument_weights.append(convobj.weight)
-                    self.arguments.add(str(variable))
-                index = index + 1
-
-        _build_regex(domain_rule)
-        regex_parts.append('\\|')
-        self._trace.append((False, '|'))
-        _build_regex(self.is_leaf and self.rule or self.rule.rstrip('/'))
-        if not self.is_leaf:
-            self._trace.append((False, '/'))
-
-        if self.build_only:
-            return
-        regex = r'^%s%s$' % (
-            u''.join(regex_parts),
-            (not self.is_leaf or not self.strict_slashes) and
-            '(?<!/)(?P<__suffix__>/?)' or ''
-        )
-        self._regex = re.compile(regex, re.UNICODE)
-
-    def match(self, path, method=None):
-        """Check if the rule matches a given path. Path is a string in the
-        form ``"subdomain|/path"`` and is assembled by the map.  If
-        the map is doing host matching the subdomain part will be the host
-        instead.
-
-        If the rule matches a dict with the converted values is returned,
-        otherwise the return value is `None`.
-
-        :internal:
-        """
-        if not self.build_only:
-            m = self._regex.search(path)
-            if m is not None:
-                groups = m.groupdict()
-                # we have a folder like part of the url without a trailing
-                # slash and strict slashes enabled. raise an exception that
-                # tells the map to redirect to the same url but with a
-                # trailing slash
-                if self.strict_slashes and not self.is_leaf and \
-                        not groups.pop('__suffix__') and \
-                        (method is None or self.methods is None or
-                         method in self.methods):
-                    raise RequestSlash()
-                # if we are not in strict slashes mode we have to remove
-                # a __suffix__
-                elif not self.strict_slashes:
-                    del groups['__suffix__']
-
-                result = {}
-                for name, value in iteritems(groups):
-                    try:
-                        value = self._converters[name].to_python(value)
-                    except ValidationError:
-                        return
-                    result[str(name)] = value
-                if self.defaults:
-                    result.update(self.defaults)
-
-                if self.alias and self.map.redirect_defaults:
-                    raise RequestAliasRedirect(result)
-
-                return result
-
-    def build(self, values, append_unknown=True):
-        """Assembles the relative url for that rule and the subdomain.
-        If building doesn't work for some reasons `None` is returned.
-
-        :internal:
-        """
-        tmp = []
-        add = tmp.append
-        processed = set(self.arguments)
-        for is_dynamic, data in self._trace:
-            if is_dynamic:
-                try:
-                    add(self._converters[data].to_url(values[data]))
-                except ValidationError:
-                    return
-                processed.add(data)
-            else:
-                add(url_quote(to_bytes(data, self.map.charset), safe='/:|+'))
-        domain_part, url = (u''.join(tmp)).split(u'|', 1)
-
-        if append_unknown:
-            query_vars = MultiDict(values)
-            for key in processed:
-                if key in query_vars:
-                    del query_vars[key]
-
-            if query_vars:
-                url += u'?' + url_encode(query_vars, charset=self.map.charset,
-                                         sort=self.map.sort_parameters,
-                                         key=self.map.sort_key)
-
-        return domain_part, url
-
-    def provides_defaults_for(self, rule):
-        """Check if this rule has defaults for a given rule.
-
-        :internal:
-        """
-        return not self.build_only and self.defaults and \
-            self.endpoint == rule.endpoint and self != rule and \
-            self.arguments == rule.arguments
-
-    def suitable_for(self, values, method=None):
-        """Check if the dict of values has enough data for url generation.
-
-        :internal:
-        """
-        # if a method was given explicitly and that method is not supported
-        # by this rule, this rule is not suitable.
-        if method is not None and self.methods is not None \
-           and method not in self.methods:
-            return False
-
-        defaults = self.defaults or ()
-
-        # all arguments required must be either in the defaults dict or
-        # the value dictionary otherwise it's not suitable
-        for key in self.arguments:
-            if key not in defaults and key not in values:
-                return False
-
-        # in case defaults are given we ensure taht either the value was
-        # skipped or the value is the same as the default value.
-        if defaults:
-            for key, value in iteritems(defaults):
-                if key in values and value != values[key]:
-                    return False
-
-        return True
-
-    def match_compare_key(self):
-        """The match compare key for sorting.
-
-        Current implementation:
-
-        1.  rules without any arguments come first for performance
-            reasons only as we expect them to match faster and some
-            common ones usually don't have any arguments (index pages etc.)
-        2.  rules with more static parts come first so the second argument
-            is the negative length of the number of the static weights.
-        3.  we order by static weights, which is a combination of index
-            and length
-        4.  The more complex rules come first so the next argument is the
-            negative length of the number of argument weights.
-        5.  lastly we order by the actual argument weights.
-
-        :internal:
-        """
-        return bool(self.arguments), -len(self._static_weights), self._static_weights,\
-            -len(self._argument_weights), self._argument_weights
-
-    def build_compare_key(self):
-        """The build compare key for sorting.
-
-        :internal:
-        """
-        return self.alias and 1 or 0, -len(self.arguments), \
-            -len(self.defaults or ())
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and \
-            self._trace == other._trace
-
-    __hash__ = None
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __str__(self):
-        return self.rule
-
-    @native_string_result
-    def __repr__(self):
-        if self.map is None:
-            return u'<%s (unbound)>' % self.__class__.__name__
-        tmp = []
-        for is_dynamic, data in self._trace:
-            if is_dynamic:
-                tmp.append(u'<%s>' % data)
-            else:
-                tmp.append(data)
-        return u'<%s %s%s -> %s>' % (
-            self.__class__.__name__,
-            repr((u''.join(tmp)).lstrip(u'|')).lstrip(u'u'),
-            self.methods is not None
-            and u' (%s)' % u', '.join(self.methods)
-            or u'',
-            self.endpoint
-        )
-
-
-class BaseConverter(object):
-
-    """Base class for all converters."""
-    regex = '[^/]+'
-    weight = 100
-
-    def __init__(self, map):
-        self.map = map
-
-    def to_python(self, value):
-        return value
-
-    def to_url(self, value):
-        return url_quote(value, charset=self.map.charset)
-
-
-class UnicodeConverter(BaseConverter):
-
-    """This converter is the default converter and accepts any string but
-    only one path segment.  Thus the string can not include a slash.
-
-    This is the default validator.
-
-    Example::
-
-        Rule('/pages/<page>'),
-        Rule('/<string(length=2):lang_code>')
-
-    :param map: the :class:`Map`.
-    :param minlength: the minimum length of the string.  Must be greater
-                      or equal 1.
-    :param maxlength: the maximum length of the string.
-    :param length: the exact length of the string.
-    """
-
-    def __init__(self, map, minlength=1, maxlength=None, length=None):
-        BaseConverter.__init__(self, map)
-        if length is not None:
-            length = '{%d}' % int(length)
-        else:
-            if maxlength is None:
-                maxlength = ''
-            else:
-                maxlength = int(maxlength)
-            length = '{%s,%s}' % (
-                int(minlength),
-                maxlength
-            )
-        self.regex = '[^/]' + length
-
-
-class AnyConverter(BaseConverter):
-
-    """Matches one of the items provided.  Items can either be Python
-    identifiers or strings::
-
-        Rule('/<any(about, help, imprint, class, "foo,bar"):page_name>')
-
-    :param map: the :class:`Map`.
-    :param items: this function accepts the possible items as positional
-                  arguments.
-    """
-
-    def __init__(self, map, *items):
-        BaseConverter.__init__(self, map)
-        self.regex = '(?:%s)' % '|'.join([re.escape(x) for x in items])
-
-
-class PathConverter(BaseConverter):
-
-    """Like the default :class:`UnicodeConverter`, but it also matches
-    slashes.  This is useful for wikis and similar applications::
-
-        Rule('/<path:wikipage>')
-        Rule('/<path:wikipage>/edit')
-
-    :param map: the :class:`Map`.
-    """
-    regex = '[^/].*?'
-    weight = 200
-
-
-class NumberConverter(BaseConverter):
-
-    """Baseclass for `IntegerConverter` and `FloatConverter`.
-
-    :internal:
-    """
-    weight = 50
-
-    def __init__(self, map, fixed_digits=0, min=None, max=None):
-        BaseConverter.__init__(self, map)
-        self.fixed_digits = fixed_digits
-        self.min = min
-        self.max = max
-
-    def to_python(self, value):
-        if (self.fixed_digits and len(value) != self.fixed_digits):
-            raise ValidationError()
-        value = self.num_convert(value)
-        if (self.min is not None and value < self.min) or \
-           (self.max is not None and value > self.max):
-            raise ValidationError()
-        return value
-
-    def to_url(self, value):
-        value = self.num_convert(value)
-        if self.fixed_digits:
-            value = ('%%0%sd' % self.fixed_digits) % value
-        return str(value)
-
-
-class IntegerConverter(NumberConverter):
-
-    """This converter only accepts integer values::
-
-        Rule('/page/<int:page>')
-
-    This converter does not support negative values.
-
-    :param map: the :class:`Map`.
-    :param fixed_digits: the number of fixed digits in the URL.  If you set
-                         this to ``4`` for example, the application will
-                         only match if the url looks like ``/0001/``.  The
-                         default is variable length.
-    :param min: the minimal value.
-    :param max: the maximal value.
-    """
-    regex = r'\d+'
-    num_convert = int
-
-
-class FloatConverter(NumberConverter):
-
-    """This converter only accepts floating point values::
-
-        Rule('/probability/<float:probability>')
-
-    This converter does not support negative values.
-
-    :param map: the :class:`Map`.
-    :param min: the minimal value.
-    :param max: the maximal value.
-    """
-    regex = r'\d+\.\d+'
-    num_convert = float
-
-    def __init__(self, map, min=None, max=None):
-        NumberConverter.__init__(self, map, 0, min, max)
-
-
-class UUIDConverter(BaseConverter):
-
-    """This converter only accepts UUID strings::
-
-        Rule('/object/<uuid:identifier>')
-
-    .. versionadded:: 0.10
-
-    :param map: the :class:`Map`.
-    """
-    regex = r'[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-' \
-            r'[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}'
-
-    def to_python(self, value):
-        return uuid.UUID(value)
-
-    def to_url(self, value):
-        return str(value)
-
-
-#: the default converter mapping for the map.
-DEFAULT_CONVERTERS = {
-    'default':          UnicodeConverter,
-    'string':           UnicodeConverter,
-    'any':              AnyConverter,
-    'path':             PathConverter,
-    'int':              IntegerConverter,
-    'float':            FloatConverter,
-    'uuid':             UUIDConverter,
-}
-
-
-class Map(object):
-
-    """The map class stores all the URL rules and some configuration
-    parameters.  Some of the configuration values are only stored on the
-    `Map` instance since those affect all rules, others are just defaults
-    and can be overridden for each rule.  Note that you have to specify all
-    arguments besides the `rules` as keyword arguments!
-
-    :param rules: sequence of url rules for this map.
-    :param default_subdomain: The default subdomain for rules without a
-                              subdomain defined.
-    :param charset: charset of the url. defaults to ``"utf-8"``
-    :param strict_slashes: Take care of trailing slashes.
-    :param redirect_defaults: This will redirect to the default rule if it
-                              wasn't visited that way. This helps creating
-                              unique URLs.
-    :param converters: A dict of converters that adds additional converters
-                       to the list of converters. If you redefine one
-                       converter this will override the original one.
-    :param sort_parameters: If set to `True` the url parameters are sorted.
-                            See `url_encode` for more details.
-    :param sort_key: The sort key function for `url_encode`.
-    :param encoding_errors: the error method to use for decoding
-    :param host_matching: if set to `True` it enables the host matching
-                          feature and disables the subdomain one.  If
-                          enabled the `host` parameter to rules is used
-                          instead of the `subdomain` one.
-
-    .. versionadded:: 0.5
-        `sort_parameters` and `sort_key` was added.
-
-    .. versionadded:: 0.7
-        `encoding_errors` and `host_matching` was added.
-    """
-
-    #: .. versionadded:: 0.6
-    #:    a dict of default converters to be used.
-    default_converters = ImmutableDict(DEFAULT_CONVERTERS)
-
-    def __init__(self, rules=None, default_subdomain='', charset='utf-8',
-                 strict_slashes=True, redirect_defaults=True,
-                 converters=None, sort_parameters=False, sort_key=None,
-                 encoding_errors='replace', host_matching=False):
-        self._rules = []
-        self._rules_by_endpoint = {}
-        self._remap = True
-        self._remap_lock = Lock()
-
-        self.default_subdomain = default_subdomain
-        self.charset = charset
-        self.encoding_errors = encoding_errors
-        self.strict_slashes = strict_slashes
-        self.redirect_defaults = redirect_defaults
-        self.host_matching = host_matching
-
-        self.converters = self.default_converters.copy()
-        if converters:
-            self.converters.update(converters)
-
-        self.sort_parameters = sort_parameters
-        self.sort_key = sort_key
-
-        for rulefactory in rules or ():
-            self.add(rulefactory)
-
-    def is_endpoint_expecting(self, endpoint, *arguments):
-        """Iterate over all rules and check if the endpoint expects
-        the arguments provided.  This is for example useful if you have
-        some URLs that expect a language code and others that do not and
-        you want to wrap the builder a bit so that the current language
-        code is automatically added if not provided but endpoints expect
-        it.
-
-        :param endpoint: the endpoint to check.
-        :param arguments: this function accepts one or more arguments
-                          as positional arguments.  Each one of them is
-                          checked.
-        """
-        self.update()
-        arguments = set(arguments)
-        for rule in self._rules_by_endpoint[endpoint]:
-            if arguments.issubset(rule.arguments):
-                return True
-        return False
-
-    def iter_rules(self, endpoint=None):
-        """Iterate over all rules or the rules of an endpoint.
-
-        :param endpoint: if provided only the rules for that endpoint
-                         are returned.
-        :return: an iterator
-        """
-        self.update()
-        if endpoint is not None:
-            return iter(self._rules_by_endpoint[endpoint])
-        return iter(self._rules)
-
-    def add(self, rulefactory):
-        """Add a new rule or factory to the map and bind it.  Requires that the
-        rule is not bound to another map.
-
-        :param rulefactory: a :class:`Rule` or :class:`RuleFactory`
-        """
-        for rule in rulefactory.get_rules(self):
-            rule.bind(self)
-            self._rules.append(rule)
-            self._rules_by_endpoint.setdefault(rule.endpoint, []).append(rule)
-        self._remap = True
-
-    def bind(self, server_name, script_name=None, subdomain=None,
-             url_scheme='http', default_method='GET', path_info=None,
-             query_args=None):
-        """Return a new :class:`MapAdapter` with the details specified to the
-        call.  Note that `script_name` will default to ``'/'`` if not further
-        specified or `None`.  The `server_name` at least is a requirement
-        because the HTTP RFC requires absolute URLs for redirects and so all
-        redirect exceptions raised by Werkzeug will contain the full canonical
-        URL.
-
-        If no path_info is passed to :meth:`match` it will use the default path
-        info passed to bind.  While this doesn't really make sense for
-        manual bind calls, it's useful if you bind a map to a WSGI
-        environment which already contains the path info.
-
-        `subdomain` will default to the `default_subdomain` for this map if
-        no defined. If there is no `default_subdomain` you cannot use the
-        subdomain feature.
-
-        .. versionadded:: 0.7
-           `query_args` added
-
-        .. versionadded:: 0.8
-           `query_args` can now also be a string.
-        """
-        server_name = server_name.lower()
-        if self.host_matching:
-            if subdomain is not None:
-                raise RuntimeError('host matching enabled and a '
-                                   'subdomain was provided')
-        elif subdomain is None:
-            subdomain = self.default_subdomain
-        if script_name is None:
-            script_name = '/'
-        try:
-            server_name = _encode_idna(server_name)
-        except UnicodeError:
-            raise BadHost()
-        return MapAdapter(self, server_name, script_name, subdomain,
-                          url_scheme, path_info, default_method, query_args)
-
-    def bind_to_environ(self, environ, server_name=None, subdomain=None):
-        """Like :meth:`bind` but you can pass it an WSGI environment and it
-        will fetch the information from that dictionary.  Note that because of
-        limitations in the protocol there is no way to get the current
-        subdomain and real `server_name` from the environment.  If you don't
-        provide it, Werkzeug will use `SERVER_NAME` and `SERVER_PORT` (or
-        `HTTP_HOST` if provided) as used `server_name` with disabled subdomain
-        feature.
-
-        If `subdomain` is `None` but an environment and a server name is
-        provided it will calculate the current subdomain automatically.
-        Example: `server_name` is ``'example.com'`` and the `SERVER_NAME`
-        in the wsgi `environ` is ``'staging.dev.example.com'`` the calculated
-        subdomain will be ``'staging.dev'``.
-
-        If the object passed as environ has an environ attribute, the value of
-        this attribute is used instead.  This allows you to pass request
-        objects.  Additionally `PATH_INFO` added as a default of the
-        :class:`MapAdapter` so that you don't have to pass the path info to
-        the match method.
-
-        .. versionchanged:: 0.5
-            previously this method accepted a bogus `calculate_subdomain`
-            parameter that did not have any effect.  It was removed because
-            of that.
-
-        .. versionchanged:: 0.8
-           This will no longer raise a ValueError when an unexpected server
-           name was passed.
-
-        :param environ: a WSGI environment.
-        :param server_name: an optional server name hint (see above).
-        :param subdomain: optionally the current subdomain (see above).
-        """
-        environ = _get_environ(environ)
-
-        if 'HTTP_HOST' in environ:
-            wsgi_server_name = environ['HTTP_HOST']
-
-            if environ['wsgi.url_scheme'] == 'http' \
-                    and wsgi_server_name.endswith(':80'):
-                wsgi_server_name = wsgi_server_name[:-3]
-            elif environ['wsgi.url_scheme'] == 'https' \
-                    and wsgi_server_name.endswith(':443'):
-                wsgi_server_name = wsgi_server_name[:-4]
-        else:
-            wsgi_server_name = environ['SERVER_NAME']
-
-            if (environ['wsgi.url_scheme'], environ['SERVER_PORT']) not \
-               in (('https', '443'), ('http', '80')):
-                wsgi_server_name += ':' + environ['SERVER_PORT']
-
-        wsgi_server_name = wsgi_server_name.lower()
-
-        if server_name is None:
-            server_name = wsgi_server_name
-        else:
-            server_name = server_name.lower()
-
-        if subdomain is None and not self.host_matching:
-            cur_server_name = wsgi_server_name.split('.')
-            real_server_name = server_name.split('.')
-            offset = -len(real_server_name)
-            if cur_server_name[offset:] != real_server_name:
-                # This can happen even with valid configs if the server was
-                # accesssed directly by IP address under some situations.
-                # Instead of raising an exception like in Werkzeug 0.7 or
-                # earlier we go by an invalid subdomain which will result
-                # in a 404 error on matching.
-                subdomain = '<invalid>'
-            else:
-                subdomain = '.'.join(filter(None, cur_server_name[:offset]))
-
-        def _get_wsgi_string(name):
-            val = environ.get(name)
-            if val is not None:
-                return wsgi_decoding_dance(val, self.charset)
-
-        script_name = _get_wsgi_string('SCRIPT_NAME')
-        path_info = _get_wsgi_string('PATH_INFO')
-        query_args = _get_wsgi_string('QUERY_STRING')
-        return Map.bind(self, server_name, script_name,
-                        subdomain, environ['wsgi.url_scheme'],
-                        environ['REQUEST_METHOD'], path_info,
-                        query_args=query_args)
-
-    def update(self):
-        """Called before matching and building to keep the compiled rules
-        in the correct order after things changed.
-        """
-        if not self._remap:
-            return
-
-        with self._remap_lock:
-            if not self._remap:
-                return
-
-            self._rules.sort(key=lambda x: x.match_compare_key())
-            for rules in itervalues(self._rules_by_endpoint):
-                rules.sort(key=lambda x: x.build_compare_key())
-            self._remap = False
-
-    def __repr__(self):
-        rules = self.iter_rules()
-        return '%s(%s)' % (self.__class__.__name__, pformat(list(rules)))
-
-
-class MapAdapter(object):
-
-    """Returned by :meth:`Map.bind` or :meth:`Map.bind_to_environ` and does
-    the URL matching and building based on runtime information.
-    """
-
-    def __init__(self, map, server_name, script_name, subdomain,
-                 url_scheme, path_info, default_method, query_args=None):
-        self.map = map
-        self.server_name = to_unicode(server_name)
-        script_name = to_unicode(script_name)
-        if not script_name.endswith(u'/'):
-            script_name += u'/'
-        self.script_name = script_name
-        self.subdomain = to_unicode(subdomain)
-        self.url_scheme = to_unicode(url_scheme)
-        self.path_info = to_unicode(path_info)
-        self.default_method = to_unicode(default_method)
-        self.query_args = query_args
-
-    def dispatch(self, view_func, path_info=None, method=None,
-                 catch_http_exceptions=False):
-        """Does the complete dispatching process.  `view_func` is called with
-        the endpoint and a dict with the values for the view.  It should
-        look up the view function, call it, and return a response object
-        or WSGI application.  http exceptions are not caught by default
-        so that applications can display nicer error messages by just
-        catching them by hand.  If you want to stick with the default
-        error messages you can pass it ``catch_http_exceptions=True`` and
-        it will catch the http exceptions.
-
-        Here a small example for the dispatch usage::
-
-            from werkzeug.wrappers import Request, Response
-            from werkzeug.wsgi import responder
-            from werkzeug.routing import Map, Rule
-
-            def on_index(request):
-                return Response('Hello from the index')
-
-            url_map = Map([Rule('/', endpoint='index')])
-            views = {'index': on_index}
-
-            @responder
-            def application(environ, start_response):
-                request = Request(environ)
-                urls = url_map.bind_to_environ(environ)
-                return urls.dispatch(lambda e, v: views[e](request, **v),
-                                     catch_http_exceptions=True)
-
-        Keep in mind that this method might return exception objects, too, so
-        use :class:`Response.force_type` to get a response object.
-
-        :param view_func: a function that is called with the endpoint as
-                          first argument and the value dict as second.  Has
-                          to dispatch to the actual view function with this
-                          information.  (see above)
-        :param path_info: the path info to use for matching.  Overrides the
-                          path info specified on binding.
-        :param method: the HTTP method used for matching.  Overrides the
-                       method specified on binding.
-        :param catch_http_exceptions: set to `True` to catch any of the
-                                      werkzeug :class:`HTTPException`\s.
-        """
-        try:
-            try:
-                endpoint, args = self.match(path_info, method)
-            except RequestRedirect as e:
-                return e
-            return view_func(endpoint, args)
-        except HTTPException as e:
-            if catch_http_exceptions:
-                return e
-            raise
-
-    def match(self, path_info=None, method=None, return_rule=False,
-              query_args=None):
-        """The usage is simple: you just pass the match method the current
-        path info as well as the method (which defaults to `GET`).  The
-        following things can then happen:
-
-        - you receive a `NotFound` exception that indicates that no URL is
-          matching.  A `NotFound` exception is also a WSGI application you
-          can call to get a default page not found page (happens to be the
-          same object as `werkzeug.exceptions.NotFound`)
-
-        - you receive a `MethodNotAllowed` exception that indicates that there
-          is a match for this URL but not for the current request method.
-          This is useful for RESTful applications.
-
-        - you receive a `RequestRedirect` exception with a `new_url`
-          attribute.  This exception is used to notify you about a request
-          Werkzeug requests from your WSGI application.  This is for example the
-          case if you request ``/foo`` although the correct URL is ``/foo/``
-          You can use the `RequestRedirect` instance as response-like object
-          similar to all other subclasses of `HTTPException`.
-
-        - you get a tuple in the form ``(endpoint, arguments)`` if there is
-          a match (unless `return_rule` is True, in which case you get a tuple
-          in the form ``(rule, arguments)``)
-
-        If the path info is not passed to the match method the default path
-        info of the map is used (defaults to the root URL if not defined
-        explicitly).
-
-        All of the exceptions raised are subclasses of `HTTPException` so they
-        can be used as WSGI responses. They will all render generic error or
-        redirect pages.
-
-        Here is a small example for matching:
-
-        >>> m = Map([
-        ...     Rule('/', endpoint='index'),
-        ...     Rule('/downloads/', endpoint='downloads/index'),
-        ...     Rule('/downloads/<int:id>', endpoint='downloads/show')
-        ... ])
-        >>> urls = m.bind("example.com", "/")
-        >>> urls.match("/", "GET")
-        ('index', {})
-        >>> urls.match("/downloads/42")
-        ('downloads/show', {'id': 42})
-
-        And here is what happens on redirect and missing URLs:
-
-        >>> urls.match("/downloads")
-        Traceback (most recent call last):
-          ...
-        RequestRedirect: http://example.com/downloads/
-        >>> urls.match("/missing")
-        Traceback (most recent call last):
-          ...
-        NotFound: 404 Not Found
-
-        :param path_info: the path info to use for matching.  Overrides the
-                          path info specified on binding.
-        :param method: the HTTP method used for matching.  Overrides the
-                       method specified on binding.
-        :param return_rule: return the rule that matched instead of just the
-                            endpoint (defaults to `False`).
-        :param query_args: optional query arguments that are used for
-                           automatic redirects as string or dictionary.  It's
-                           currently not possible to use the query arguments
-                           for URL matching.
-
-        .. versionadded:: 0.6
-           `return_rule` was added.
-
-        .. versionadded:: 0.7
-           `query_args` was added.
-
-        .. versionchanged:: 0.8
-           `query_args` can now also be a string.
-        """
-        self.map.update()
-        if path_info is None:
-            path_info = self.path_info
-        else:
-            path_info = to_unicode(path_info, self.map.charset)
-        if query_args is None:
-            query_args = self.query_args
-        method = (method or self.default_method).upper()
-
-        path = u'%s|%s' % (
-            self.map.host_matching and self.server_name or self.subdomain,
-            path_info and '/%s' % path_info.lstrip('/')
-        )
-
-        have_match_for = set()
-        for rule in self.map._rules:
-            try:
-                rv = rule.match(path, method)
-            except RequestSlash:
-                raise RequestRedirect(self.make_redirect_url(
-                    url_quote(path_info, self.map.charset,
-                              safe='/:|+') + '/', query_args))
-            except RequestAliasRedirect as e:
-                raise RequestRedirect(self.make_alias_redirect_url(
-                    path, rule.endpoint, e.matched_values, method, query_args))
-            if rv is None:
-                continue
-            if rule.methods is not None and method not in rule.methods:
-                have_match_for.update(rule.methods)
-                continue
-
-            if self.map.redirect_defaults:
-                redirect_url = self.get_default_redirect(rule, method, rv,
-                                                         query_args)
-                if redirect_url is not None:
-                    raise RequestRedirect(redirect_url)
-
-            if rule.redirect_to is not None:
-                if isinstance(rule.redirect_to, string_types):
-                    def _handle_match(match):
-                        value = rv[match.group(1)]
-                        return rule._converters[match.group(1)].to_url(value)
-                    redirect_url = _simple_rule_re.sub(_handle_match,
-                                                       rule.redirect_to)
-                else:
-                    redirect_url = rule.redirect_to(self, **rv)
-                raise RequestRedirect(str(url_join('%s://%s%s%s' % (
-                    self.url_scheme or 'http',
-                    self.subdomain and self.subdomain + '.' or '',
-                    self.server_name,
-                    self.script_name
-                ), redirect_url)))
-
-            if return_rule:
-                return rule, rv
-            else:
-                return rule.endpoint, rv
-
-        if have_match_for:
-            raise MethodNotAllowed(valid_methods=list(have_match_for))
-        raise NotFound()
-
-    def test(self, path_info=None, method=None):
-        """Test if a rule would match.  Works like `match` but returns `True`
-        if the URL matches, or `False` if it does not exist.
-
-        :param path_info: the path info to use for matching.  Overrides the
-                          path info specified on binding.
-        :param method: the HTTP method used for matching.  Overrides the
-                       method specified on binding.
-        """
-        try:
-            self.match(path_info, method)
-        except RequestRedirect:
-            pass
-        except HTTPException:
-            return False
-        return True
-
-    def allowed_methods(self, path_info=None):
-        """Returns the valid methods that match for a given path.
-
-        .. versionadded:: 0.7
-        """
-        try:
-            self.match(path_info, method='--')
-        except MethodNotAllowed as e:
-            return e.valid_methods
-        except HTTPException as e:
-            pass
-        return []
-
-    def get_host(self, domain_part):
-        """Figures out the full host name for the given domain part.  The
-        domain part is a subdomain in case host matching is disabled or
-        a full host name.
-        """
-        if self.map.host_matching:
-            if domain_part is None:
-                return self.server_name
-            return to_unicode(domain_part, 'ascii')
-        subdomain = domain_part
-        if subdomain is None:
-            subdomain = self.subdomain
-        else:
-            subdomain = to_unicode(subdomain, 'ascii')
-        return (subdomain and subdomain + u'.' or u'') + self.server_name
-
-    def get_default_redirect(self, rule, method, values, query_args):
-        """A helper that returns the URL to redirect to if it finds one.
-        This is used for default redirecting only.
-
-        :internal:
-        """
-        assert self.map.redirect_defaults
-        for r in self.map._rules_by_endpoint[rule.endpoint]:
-            # every rule that comes after this one, including ourself
-            # has a lower priority for the defaults.  We order the ones
-            # with the highest priority up for building.
-            if r is rule:
-                break
-            if r.provides_defaults_for(rule) and \
-               r.suitable_for(values, method):
-                values.update(r.defaults)
-                domain_part, path = r.build(values)
-                return self.make_redirect_url(
-                    path, query_args, domain_part=domain_part)
-
-    def encode_query_args(self, query_args):
-        if not isinstance(query_args, string_types):
-            query_args = url_encode(query_args, self.map.charset)
-        return query_args
-
-    def make_redirect_url(self, path_info, query_args=None, domain_part=None):
-        """Creates a redirect URL.
-
-        :internal:
-        """
-        suffix = ''
-        if query_args:
-            suffix = '?' + self.encode_query_args(query_args)
-        return str('%s://%s/%s%s' % (
-            self.url_scheme or 'http',
-            self.get_host(domain_part),
-            posixpath.join(self.script_name[:-1].lstrip('/'),
-                           path_info.lstrip('/')),
-            suffix
-        ))
-
-    def make_alias_redirect_url(self, path, endpoint, values, method, query_args):
-        """Internally called to make an alias redirect URL."""
-        url = self.build(endpoint, values, method, append_unknown=False,
-                         force_external=True)
-        if query_args:
-            url += '?' + self.encode_query_args(query_args)
-        assert url != path, 'detected invalid alias setting.  No canonical ' \
-            'URL found'
-        return url
-
-    def _partial_build(self, endpoint, values, method, append_unknown):
-        """Helper for :meth:`build`.  Returns subdomain and path for the
-        rule that accepts this endpoint, values and method.
-
-        :internal:
-        """
-        # in case the method is none, try with the default method first
-        if method is None:
-            rv = self._partial_build(endpoint, values, self.default_method,
-                                     append_unknown)
-            if rv is not None:
-                return rv
-
-        # default method did not match or a specific method is passed,
-        # check all and go with first result.
-        for rule in self.map._rules_by_endpoint.get(endpoint, ()):
-            if rule.suitable_for(values, method):
-                rv = rule.build(values, append_unknown)
-                if rv is not None:
-                    return rv
-
-    def build(self, endpoint, values=None, method=None, force_external=False,
-              append_unknown=True):
-        """Building URLs works pretty much the other way round.  Instead of
-        `match` you call `build` and pass it the endpoint and a dict of
-        arguments for the placeholders.
-
-        The `build` function also accepts an argument called `force_external`
-        which, if you set it to `True` will force external URLs. Per default
-        external URLs (include the server name) will only be used if the
-        target URL is on a different subdomain.
-
-        >>> m = Map([
-        ...     Rule('/', endpoint='index'),
-        ...     Rule('/downloads/', endpoint='downloads/index'),
-        ...     Rule('/downloads/<int:id>', endpoint='downloads/show')
-        ... ])
-        >>> urls = m.bind("example.com", "/")
-        >>> urls.build("index", {})
-        '/'
-        >>> urls.build("downloads/show", {'id': 42})
-        '/downloads/42'
-        >>> urls.build("downloads/show", {'id': 42}, force_external=True)
-        'http://example.com/downloads/42'
-
-        Because URLs cannot contain non ASCII data you will always get
-        bytestrings back.  Non ASCII characters are urlencoded with the
-        charset defined on the map instance.
-
-        Additional values are converted to unicode and appended to the URL as
-        URL querystring parameters:
-
-        >>> urls.build("index", {'q': 'My Searchstring'})
-        '/?q=My+Searchstring'
-
-        When processing those additional values, lists are furthermore
-        interpreted as multiple values (as per
-        :py:class:`werkzeug.datastructures.MultiDict`):
-
-        >>> urls.build("index", {'q': ['a', 'b', 'c']})
-        '/?q=a&q=b&q=c'
-
-        If a rule does not exist when building a `BuildError` exception is
-        raised.
-
-        The build method accepts an argument called `method` which allows you
-        to specify the method you want to have an URL built for if you have
-        different methods for the same endpoint specified.
-
-        .. versionadded:: 0.6
-           the `append_unknown` parameter was added.
-
-        :param endpoint: the endpoint of the URL to build.
-        :param values: the values for the URL to build.  Unhandled values are
-                       appended to the URL as query parameters.
-        :param method: the HTTP method for the rule if there are different
-                       URLs for different methods on the same endpoint.
-        :param force_external: enforce full canonical external URLs. If the URL
-                               scheme is not provided, this will generate
-                               a protocol-relative URL.
-        :param append_unknown: unknown parameters are appended to the generated
-                               URL as query string argument.  Disable this
-                               if you want the builder to ignore those.
-        """
-        self.map.update()
-        if values:
-            if isinstance(values, MultiDict):
-                valueiter = iteritems(values, multi=True)
-            else:
-                valueiter = iteritems(values)
-            values = dict((k, v) for k, v in valueiter if v is not None)
-        else:
-            values = {}
-
-        rv = self._partial_build(endpoint, values, method, append_unknown)
-        if rv is None:
-            raise BuildError(endpoint, values, method, self)
-        domain_part, path = rv
-
-        host = self.get_host(domain_part)
-
-        # shortcut this.
-        if not force_external and (
-            (self.map.host_matching and host == self.server_name) or
-            (not self.map.host_matching and domain_part == self.subdomain)
-        ):
-            return str(url_join(self.script_name, './' + path.lstrip('/')))
-        return str('%s//%s%s/%s' % (
-            self.url_scheme + ':' if self.url_scheme else '',
-            host,
-            self.script_name[:-1],
-            path.lstrip('/')
-        ))
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/script.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/script.py
deleted file mode 100644
index cfff3c117..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/script.py
+++ /dev/null
@@ -1,318 +0,0 @@
-# -*- coding: utf-8 -*-
-r'''
-    werkzeug.script
-    ~~~~~~~~~~~~~~~
-
-    .. admonition:: Deprecated Functionality
-
-       ``werkzeug.script`` is deprecated without replacement functionality.
-       Python's command line support improved greatly with :mod:`argparse`
-       and a bunch of alternative modules.
-
-    Most of the time you have recurring tasks while writing an application
-    such as starting up an interactive python interpreter with some prefilled
-    imports, starting the development server, initializing the database or
-    something similar.
-
-    For that purpose werkzeug provides the `werkzeug.script` module which
-    helps you writing such scripts.
-
-
-    Basic Usage
-    -----------
-
-    The following snippet is roughly the same in every werkzeug script::
-
-        #!/usr/bin/env python
-        # -*- coding: utf-8 -*-
-        from werkzeug import script
-
-        # actions go here
-
-        if __name__ == '__main__':
-            script.run()
-
-    Starting this script now does nothing because no actions are defined.
-    An action is a function in the same module starting with ``"action_"``
-    which takes a number of arguments where every argument has a default.  The
-    type of the default value specifies the type of the argument.
-
-    Arguments can then be passed by position or using ``--name=value`` from
-    the shell.
-
-    Because a runserver and shell command is pretty common there are two
-    factory functions that create such commands::
-
-        def make_app():
-            from yourapplication import YourApplication
-            return YourApplication(...)
-
-        action_runserver = script.make_runserver(make_app, use_reloader=True)
-        action_shell = script.make_shell(lambda: {'app': make_app()})
-
-
-    Using The Scripts
-    -----------------
-
-    The script from above can be used like this from the shell now:
-
-    .. sourcecode:: text
-
-        $ ./manage.py --help
-        $ ./manage.py runserver localhost 8080 --debugger --no-reloader
-        $ ./manage.py runserver -p 4000
-        $ ./manage.py shell
-
-    As you can see it's possible to pass parameters as positional arguments
-    or as named parameters, pretty much like Python function calls.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-'''
-from __future__ import print_function
-
-import sys
-import inspect
-import getopt
-from os.path import basename
-from werkzeug._compat import iteritems
-
-
-argument_types = {
-    bool:       'boolean',
-    str:        'string',
-    int:        'integer',
-    float:      'float'
-}
-
-
-converters = {
-    'boolean': lambda x: x.lower() in ('1', 'true', 'yes', 'on'),
-    'string':   str,
-    'integer':  int,
-    'float':    float
-}
-
-
-def run(namespace=None, action_prefix='action_', args=None):
-    """Run the script.  Participating actions are looked up in the caller's
-    namespace if no namespace is given, otherwise in the dict provided.
-    Only items that start with action_prefix are processed as actions.  If
-    you want to use all items in the namespace provided as actions set
-    action_prefix to an empty string.
-
-    :param namespace: An optional dict where the functions are looked up in.
-                      By default the local namespace of the caller is used.
-    :param action_prefix: The prefix for the functions.  Everything else
-                          is ignored.
-    :param args: the arguments for the function.  If not specified
-                 :data:`sys.argv` without the first argument is used.
-    """
-    if namespace is None:
-        namespace = sys._getframe(1).f_locals
-    actions = find_actions(namespace, action_prefix)
-
-    if args is None:
-        args = sys.argv[1:]
-    if not args or args[0] in ('-h', '--help'):
-        return print_usage(actions)
-    elif args[0] not in actions:
-        fail('Unknown action \'%s\'' % args[0])
-
-    arguments = {}
-    types = {}
-    key_to_arg = {}
-    long_options = []
-    formatstring = ''
-    func, doc, arg_def = actions[args.pop(0)]
-    for idx, (arg, shortcut, default, option_type) in enumerate(arg_def):
-        real_arg = arg.replace('-', '_')
-        if shortcut:
-            formatstring += shortcut
-            if not isinstance(default, bool):
-                formatstring += ':'
-            key_to_arg['-' + shortcut] = real_arg
-        long_options.append(isinstance(default, bool) and arg or arg + '=')
-        key_to_arg['--' + arg] = real_arg
-        key_to_arg[idx] = real_arg
-        types[real_arg] = option_type
-        arguments[real_arg] = default
-
-    try:
-        optlist, posargs = getopt.gnu_getopt(args, formatstring, long_options)
-    except getopt.GetoptError as e:
-        fail(str(e))
-
-    specified_arguments = set()
-    for key, value in enumerate(posargs):
-        try:
-            arg = key_to_arg[key]
-        except IndexError:
-            fail('Too many parameters')
-        specified_arguments.add(arg)
-        try:
-            arguments[arg] = converters[types[arg]](value)
-        except ValueError:
-            fail('Invalid value for argument %s (%s): %s' % (key, arg, value))
-
-    for key, value in optlist:
-        arg = key_to_arg[key]
-        if arg in specified_arguments:
-            fail('Argument \'%s\' is specified twice' % arg)
-        if types[arg] == 'boolean':
-            if arg.startswith('no_'):
-                value = 'no'
-            else:
-                value = 'yes'
-        try:
-            arguments[arg] = converters[types[arg]](value)
-        except ValueError:
-            fail('Invalid value for \'%s\': %s' % (key, value))
-
-    newargs = {}
-    for k, v in iteritems(arguments):
-        newargs[k.startswith('no_') and k[3:] or k] = v
-    arguments = newargs
-    return func(**arguments)
-
-
-def fail(message, code=-1):
-    """Fail with an error."""
-    print('Error: %s' % message, file=sys.stderr)
-    sys.exit(code)
-
-
-def find_actions(namespace, action_prefix):
-    """Find all the actions in the namespace."""
-    actions = {}
-    for key, value in iteritems(namespace):
-        if key.startswith(action_prefix):
-            actions[key[len(action_prefix):]] = analyse_action(value)
-    return actions
-
-
-def print_usage(actions):
-    """Print the usage information.  (Help screen)"""
-    actions = sorted(iteritems(actions))
-    print('usage: %s <action> [<options>]' % basename(sys.argv[0]))
-    print('       %s --help' % basename(sys.argv[0]))
-    print()
-    print('actions:')
-    for name, (func, doc, arguments) in actions:
-        print('  %s:' % name)
-        for line in doc.splitlines():
-            print('    %s' % line)
-        if arguments:
-            print()
-        for arg, shortcut, default, argtype in arguments:
-            if isinstance(default, bool):
-                print('    %s' % (
-                    (shortcut and '-%s, ' % shortcut or '') + '--' + arg
-                ))
-            else:
-                print('    %-30s%-10s%s' % (
-                    (shortcut and '-%s, ' % shortcut or '') + '--' + arg,
-                    argtype, default
-                ))
-        print()
-
-
-def analyse_action(func):
-    """Analyse a function."""
-    description = inspect.getdoc(func) or 'undocumented action'
-    arguments = []
-    args, varargs, kwargs, defaults = inspect.getargspec(func)
-    if varargs or kwargs:
-        raise TypeError('variable length arguments for action not allowed.')
-    if len(args) != len(defaults or ()):
-        raise TypeError('not all arguments have proper definitions')
-
-    for idx, (arg, definition) in enumerate(zip(args, defaults or ())):
-        if arg.startswith('_'):
-            raise TypeError('arguments may not start with an underscore')
-        if not isinstance(definition, tuple):
-            shortcut = None
-            default = definition
-        else:
-            shortcut, default = definition
-        argument_type = argument_types[type(default)]
-        if isinstance(default, bool) and default is True:
-            arg = 'no-' + arg
-        arguments.append((arg.replace('_', '-'), shortcut,
-                          default, argument_type))
-    return func, description, arguments
-
-
-def make_shell(init_func=None, banner=None, use_ipython=True):
-    """Returns an action callback that spawns a new interactive
-    python shell.
-
-    :param init_func: an optional initialization function that is
-                      called before the shell is started.  The return
-                      value of this function is the initial namespace.
-    :param banner: the banner that is displayed before the shell.  If
-                   not specified a generic banner is used instead.
-    :param use_ipython: if set to `True` ipython is used if available.
-    """
-    if banner is None:
-        banner = 'Interactive Werkzeug Shell'
-    if init_func is None:
-        init_func = dict
-
-    def action(ipython=use_ipython):
-        """Start a new interactive python session."""
-        namespace = init_func()
-        if ipython:
-            try:
-                try:
-                    from IPython.frontend.terminal.embed import InteractiveShellEmbed
-                    sh = InteractiveShellEmbed(banner1=banner)
-                except ImportError:
-                    from IPython.Shell import IPShellEmbed
-                    sh = IPShellEmbed(banner=banner)
-            except ImportError:
-                pass
-            else:
-                sh(global_ns={}, local_ns=namespace)
-                return
-        from code import interact
-        interact(banner, local=namespace)
-    return action
-
-
-def make_runserver(app_factory, hostname='localhost', port=5000,
-                   use_reloader=False, use_debugger=False, use_evalex=True,
-                   threaded=False, processes=1, static_files=None,
-                   extra_files=None, ssl_context=None):
-    """Returns an action callback that spawns a new development server.
-
-    .. versionadded:: 0.5
-       `static_files` and `extra_files` was added.
-
-    ..versionadded:: 0.6.1
-       `ssl_context` was added.
-
-    :param app_factory: a function that returns a new WSGI application.
-    :param hostname: the default hostname the server should listen on.
-    :param port: the default port of the server.
-    :param use_reloader: the default setting for the reloader.
-    :param use_evalex: the default setting for the evalex flag of the debugger.
-    :param threaded: the default threading setting.
-    :param processes: the default number of processes to start.
-    :param static_files: optional dict of static files.
-    :param extra_files: optional list of extra files to track for reloading.
-    :param ssl_context: optional SSL context for running server in HTTPS mode.
-    """
-    def action(hostname=('h', hostname), port=('p', port),
-               reloader=use_reloader, debugger=use_debugger,
-               evalex=use_evalex, threaded=threaded, processes=processes):
-        """Start a new development server."""
-        from werkzeug.serving import run_simple
-        app = app_factory()
-        run_simple(hostname, port, app,
-                   use_reloader=reloader, use_debugger=debugger,
-                   use_evalex=evalex, extra_files=extra_files,
-                   reloader_interval=1, threaded=threaded, processes=processes,
-                   static_files=static_files, ssl_context=ssl_context)
-    return action
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/security.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/security.py
deleted file mode 100644
index d4c5c9f48..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/security.py
+++ /dev/null
@@ -1,270 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.security
-    ~~~~~~~~~~~~~~~~~
-
-    Security related helpers such as secure password hashing tools.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import hmac
-import hashlib
-import posixpath
-import codecs
-from struct import Struct
-from random import SystemRandom
-from operator import xor
-from itertools import starmap
-
-from werkzeug._compat import range_type, PY2, text_type, izip, to_bytes, \
-    string_types, to_native
-
-
-SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-DEFAULT_PBKDF2_ITERATIONS = 50000
-
-
-_pack_int = Struct('>I').pack
-_builtin_safe_str_cmp = getattr(hmac, 'compare_digest', None)
-_sys_rng = SystemRandom()
-_os_alt_seps = list(sep for sep in [os.path.sep, os.path.altsep]
-                    if sep not in (None, '/'))
-
-
-def _find_hashlib_algorithms():
-    algos = getattr(hashlib, 'algorithms', None)
-    if algos is None:
-        algos = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
-    rv = {}
-    for algo in algos:
-        func = getattr(hashlib, algo, None)
-        if func is not None:
-            rv[algo] = func
-    return rv
-_hash_funcs = _find_hashlib_algorithms()
-
-
-def pbkdf2_hex(data, salt, iterations=DEFAULT_PBKDF2_ITERATIONS,
-               keylen=None, hashfunc=None):
-    """Like :func:`pbkdf2_bin`, but returns a hex-encoded string.
-
-    .. versionadded:: 0.9
-
-    :param data: the data to derive.
-    :param salt: the salt for the derivation.
-    :param iterations: the number of iterations.
-    :param keylen: the length of the resulting key.  If not provided,
-                   the digest size will be used.
-    :param hashfunc: the hash function to use.  This can either be the
-                     string name of a known hash function, or a function
-                     from the hashlib module.  Defaults to sha256.
-    """
-    rv = pbkdf2_bin(data, salt, iterations, keylen, hashfunc)
-    return to_native(codecs.encode(rv, 'hex_codec'))
-
-
-_has_native_pbkdf2 = hasattr(hashlib, 'pbkdf2_hmac')
-
-
-def pbkdf2_bin(data, salt, iterations=DEFAULT_PBKDF2_ITERATIONS,
-               keylen=None, hashfunc=None):
-    """Returns a binary digest for the PBKDF2 hash algorithm of `data`
-    with the given `salt`. It iterates `iterations` times and produces a
-    key of `keylen` bytes. By default, SHA-256 is used as hash function;
-    a different hashlib `hashfunc` can be provided.
-
-    .. versionadded:: 0.9
-
-    :param data: the data to derive.
-    :param salt: the salt for the derivation.
-    :param iterations: the number of iterations.
-    :param keylen: the length of the resulting key.  If not provided
-                   the digest size will be used.
-    :param hashfunc: the hash function to use.  This can either be the
-                     string name of a known hash function or a function
-                     from the hashlib module.  Defaults to sha256.
-    """
-    if isinstance(hashfunc, string_types):
-        hashfunc = _hash_funcs[hashfunc]
-    elif not hashfunc:
-        hashfunc = hashlib.sha256
-    data = to_bytes(data)
-    salt = to_bytes(salt)
-
-    # If we're on Python with pbkdf2_hmac we can try to use it for
-    # compatible digests.
-    if _has_native_pbkdf2:
-        _test_hash = hashfunc()
-        if hasattr(_test_hash, 'name') and \
-           _test_hash.name in _hash_funcs:
-            return hashlib.pbkdf2_hmac(_test_hash.name,
-                                       data, salt, iterations,
-                                       keylen)
-
-    mac = hmac.HMAC(data, None, hashfunc)
-    if not keylen:
-        keylen = mac.digest_size
-
-    def _pseudorandom(x, mac=mac):
-        h = mac.copy()
-        h.update(x)
-        return bytearray(h.digest())
-    buf = bytearray()
-    for block in range_type(1, -(-keylen // mac.digest_size) + 1):
-        rv = u = _pseudorandom(salt + _pack_int(block))
-        for i in range_type(iterations - 1):
-            u = _pseudorandom(bytes(u))
-            rv = bytearray(starmap(xor, izip(rv, u)))
-        buf.extend(rv)
-    return bytes(buf[:keylen])
-
-
-def safe_str_cmp(a, b):
-    """This function compares strings in somewhat constant time.  This
-    requires that the length of at least one string is known in advance.
-
-    Returns `True` if the two strings are equal, or `False` if they are not.
-
-    .. versionadded:: 0.7
-    """
-    if isinstance(a, text_type):
-        a = a.encode('utf-8')
-    if isinstance(b, text_type):
-        b = b.encode('utf-8')
-
-    if _builtin_safe_str_cmp is not None:
-        return _builtin_safe_str_cmp(a, b)
-
-    if len(a) != len(b):
-        return False
-
-    rv = 0
-    if PY2:
-        for x, y in izip(a, b):
-            rv |= ord(x) ^ ord(y)
-    else:
-        for x, y in izip(a, b):
-            rv |= x ^ y
-
-    return rv == 0
-
-
-def gen_salt(length):
-    """Generate a random string of SALT_CHARS with specified ``length``."""
-    if length <= 0:
-        raise ValueError('Salt length must be positive')
-    return ''.join(_sys_rng.choice(SALT_CHARS) for _ in range_type(length))
-
-
-def _hash_internal(method, salt, password):
-    """Internal password hash helper.  Supports plaintext without salt,
-    unsalted and salted passwords.  In case salted passwords are used
-    hmac is used.
-    """
-    if method == 'plain':
-        return password, method
-
-    if isinstance(password, text_type):
-        password = password.encode('utf-8')
-
-    if method.startswith('pbkdf2:'):
-        args = method[7:].split(':')
-        if len(args) not in (1, 2):
-            raise ValueError('Invalid number of arguments for PBKDF2')
-        method = args.pop(0)
-        iterations = args and int(args[0] or 0) or DEFAULT_PBKDF2_ITERATIONS
-        is_pbkdf2 = True
-        actual_method = 'pbkdf2:%s:%d' % (method, iterations)
-    else:
-        is_pbkdf2 = False
-        actual_method = method
-
-    hash_func = _hash_funcs.get(method)
-    if hash_func is None:
-        raise TypeError('invalid method %r' % method)
-
-    if is_pbkdf2:
-        if not salt:
-            raise ValueError('Salt is required for PBKDF2')
-        rv = pbkdf2_hex(password, salt, iterations,
-                        hashfunc=hash_func)
-    elif salt:
-        if isinstance(salt, text_type):
-            salt = salt.encode('utf-8')
-        rv = hmac.HMAC(salt, password, hash_func).hexdigest()
-    else:
-        h = hash_func()
-        h.update(password)
-        rv = h.hexdigest()
-    return rv, actual_method
-
-
-def generate_password_hash(password, method='pbkdf2:sha256', salt_length=8):
-    """Hash a password with the given method and salt with a string of
-    the given length. The format of the string returned includes the method
-    that was used so that :func:`check_password_hash` can check the hash.
-
-    The format for the hashed string looks like this::
-
-        method$salt$hash
-
-    This method can **not** generate unsalted passwords but it is possible
-    to set param method='plain' in order to enforce plaintext passwords.
-    If a salt is used, hmac is used internally to salt the password.
-
-    If PBKDF2 is wanted it can be enabled by setting the method to
-    ``pbkdf2:method:iterations`` where iterations is optional::
-
-        pbkdf2:sha256:80000$salt$hash
-        pbkdf2:sha256$salt$hash
-
-    :param password: the password to hash.
-    :param method: the hash method to use (one that hashlib supports). Can
-                   optionally be in the format ``pbkdf2:<method>[:iterations]``
-                   to enable PBKDF2.
-    :param salt_length: the length of the salt in letters.
-    """
-    salt = method != 'plain' and gen_salt(salt_length) or ''
-    h, actual_method = _hash_internal(method, salt, password)
-    return '%s$%s$%s' % (actual_method, salt, h)
-
-
-def check_password_hash(pwhash, password):
-    """check a password against a given salted and hashed password value.
-    In order to support unsalted legacy passwords this method supports
-    plain text passwords, md5 and sha1 hashes (both salted and unsalted).
-
-    Returns `True` if the password matched, `False` otherwise.
-
-    :param pwhash: a hashed string like returned by
-                   :func:`generate_password_hash`.
-    :param password: the plaintext password to compare against the hash.
-    """
-    if pwhash.count('$') < 2:
-        return False
-    method, salt, hashval = pwhash.split('$', 2)
-    return safe_str_cmp(_hash_internal(method, salt, password)[0], hashval)
-
-
-def safe_join(directory, *pathnames):
-    """Safely join `directory` and one or more untrusted `pathnames`.  If this
-    cannot be done, this function returns ``None``.
-
-    :param directory: the base directory.
-    :param pathnames: the untrusted pathnames relative to that directory.
-    """
-    parts = [directory]
-    for filename in pathnames:
-        if filename != '':
-            filename = posixpath.normpath(filename)
-        for sep in _os_alt_seps:
-            if sep in filename:
-                return None
-        if os.path.isabs(filename) or \
-           filename == '..' or \
-           filename.startswith('../'):
-            return None
-        parts.append(filename)
-    return posixpath.join(*parts)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/serving.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/serving.py
deleted file mode 100644
index 902f1aa1c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/serving.py
+++ /dev/null
@@ -1,862 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.serving
-    ~~~~~~~~~~~~~~~~
-
-    There are many ways to serve a WSGI application.  While you're developing
-    it you usually don't want a full blown webserver like Apache but a simple
-    standalone one.  From Python 2.5 onwards there is the `wsgiref`_ server in
-    the standard library.  If you're using older versions of Python you can
-    download the package from the cheeseshop.
-
-    However there are some caveats. Sourcecode won't reload itself when
-    changed and each time you kill the server using ``^C`` you get an
-    `KeyboardInterrupt` error.  While the latter is easy to solve the first
-    one can be a pain in the ass in some situations.
-
-    The easiest way is creating a small ``start-myproject.py`` that runs the
-    application::
-
-        #!/usr/bin/env python
-        # -*- coding: utf-8 -*-
-        from myproject import make_app
-        from werkzeug.serving import run_simple
-
-        app = make_app(...)
-        run_simple('localhost', 8080, app, use_reloader=True)
-
-    You can also pass it a `extra_files` keyword argument with a list of
-    additional files (like configuration files) you want to observe.
-
-    For bigger applications you should consider using `click`
-    (http://click.pocoo.org) instead of a simple start file.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from __future__ import with_statement
-
-import io
-import os
-import socket
-import sys
-import signal
-
-
-can_fork = hasattr(os, "fork")
-
-
-try:
-    import termcolor
-except ImportError:
-    termcolor = None
-
-try:
-    import ssl
-except ImportError:
-    class _SslDummy(object):
-        def __getattr__(self, name):
-            raise RuntimeError('SSL support unavailable')
-    ssl = _SslDummy()
-
-
-def _get_openssl_crypto_module():
-    try:
-        from OpenSSL import crypto
-    except ImportError:
-        raise TypeError('Using ad-hoc certificates requires the pyOpenSSL '
-                        'library.')
-    else:
-        return crypto
-
-
-try:
-    import SocketServer as socketserver
-    from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
-except ImportError:
-    import socketserver
-    from http.server import HTTPServer, BaseHTTPRequestHandler
-
-ThreadingMixIn = socketserver.ThreadingMixIn
-
-if can_fork:
-    ForkingMixIn = socketserver.ForkingMixIn
-else:
-    class ForkingMixIn(object):
-        pass
-
-# important: do not use relative imports here or python -m will break
-import werkzeug
-from werkzeug._internal import _log
-from werkzeug._compat import PY2, WIN, reraise, wsgi_encoding_dance
-from werkzeug.urls import url_parse, url_unquote
-from werkzeug.exceptions import InternalServerError
-
-
-LISTEN_QUEUE = 128
-can_open_by_fd = not WIN and hasattr(socket, 'fromfd')
-
-
-class DechunkedInput(io.RawIOBase):
-    """An input stream that handles Transfer-Encoding 'chunked'"""
-
-    def __init__(self, rfile):
-        self._rfile = rfile
-        self._done = False
-        self._len = 0
-
-    def readable(self):
-        return True
-
-    def read_chunk_len(self):
-        try:
-            line = self._rfile.readline().decode('latin1')
-            _len = int(line.strip(), 16)
-        except ValueError:
-            raise IOError('Invalid chunk header')
-        if _len < 0:
-            raise IOError('Negative chunk length not allowed')
-        return _len
-
-    def readinto(self, buf):
-        read = 0
-        while not self._done and read < len(buf):
-            if self._len == 0:
-                # This is the first chunk or we fully consumed the previous
-                # one. Read the next length of the next chunk
-                self._len = self.read_chunk_len()
-
-            if self._len == 0:
-                # Found the final chunk of size 0. The stream is now exhausted,
-                # but there is still a final newline that should be consumed
-                self._done = True
-
-            if self._len > 0:
-                # There is data (left) in this chunk, so append it to the
-                # buffer. If this operation fully consumes the chunk, this will
-                # reset self._len to 0.
-                n = min(len(buf), self._len)
-                buf[read:read + n] = self._rfile.read(n)
-                self._len -= n
-                read += n
-
-            if self._len == 0:
-                # Skip the terminating newline of a chunk that has been fully
-                # consumed. This also applies to the 0-sized final chunk
-                terminator = self._rfile.readline()
-                if terminator not in (b'\n', b'\r\n', b'\r'):
-                    raise IOError('Missing chunk terminating newline')
-
-        return read
-
-
-class WSGIRequestHandler(BaseHTTPRequestHandler, object):
-
-    """A request handler that implements WSGI dispatching."""
-
-    @property
-    def server_version(self):
-        return 'Werkzeug/' + werkzeug.__version__
-
-    def make_environ(self):
-        request_url = url_parse(self.path)
-
-        def shutdown_server():
-            self.server.shutdown_signal = True
-
-        url_scheme = self.server.ssl_context is None and 'http' or 'https'
-        path_info = url_unquote(request_url.path)
-
-        environ = {
-            'wsgi.version':         (1, 0),
-            'wsgi.url_scheme':      url_scheme,
-            'wsgi.input':           self.rfile,
-            'wsgi.errors':          sys.stderr,
-            'wsgi.multithread':     self.server.multithread,
-            'wsgi.multiprocess':    self.server.multiprocess,
-            'wsgi.run_once':        False,
-            'werkzeug.server.shutdown': shutdown_server,
-            'SERVER_SOFTWARE':      self.server_version,
-            'REQUEST_METHOD':       self.command,
-            'SCRIPT_NAME':          '',
-            'PATH_INFO':            wsgi_encoding_dance(path_info),
-            'QUERY_STRING':         wsgi_encoding_dance(request_url.query),
-            'REMOTE_ADDR':          self.address_string(),
-            'REMOTE_PORT':          self.port_integer(),
-            'SERVER_NAME':          self.server.server_address[0],
-            'SERVER_PORT':          str(self.server.server_address[1]),
-            'SERVER_PROTOCOL':      self.request_version
-        }
-
-        for key, value in self.headers.items():
-            key = key.upper().replace('-', '_')
-            if key not in ('CONTENT_TYPE', 'CONTENT_LENGTH'):
-                key = 'HTTP_' + key
-            environ[key] = value
-
-        if environ.get('HTTP_TRANSFER_ENCODING', '').strip().lower() == 'chunked':
-            environ['wsgi.input_terminated'] = True
-            environ['wsgi.input'] = DechunkedInput(environ['wsgi.input'])
-
-        if request_url.scheme and request_url.netloc:
-            environ['HTTP_HOST'] = request_url.netloc
-
-        return environ
-
-    def run_wsgi(self):
-        if self.headers.get('Expect', '').lower().strip() == '100-continue':
-            self.wfile.write(b'HTTP/1.1 100 Continue\r\n\r\n')
-
-        self.environ = environ = self.make_environ()
-        headers_set = []
-        headers_sent = []
-
-        def write(data):
-            assert headers_set, 'write() before start_response'
-            if not headers_sent:
-                status, response_headers = headers_sent[:] = headers_set
-                try:
-                    code, msg = status.split(None, 1)
-                except ValueError:
-                    code, msg = status, ""
-                code = int(code)
-                self.send_response(code, msg)
-                header_keys = set()
-                for key, value in response_headers:
-                    self.send_header(key, value)
-                    key = key.lower()
-                    header_keys.add(key)
-                if not ('content-length' in header_keys or
-                        environ['REQUEST_METHOD'] == 'HEAD' or
-                        code < 200 or code in (204, 304)):
-                    self.close_connection = True
-                    self.send_header('Connection', 'close')
-                if 'server' not in header_keys:
-                    self.send_header('Server', self.version_string())
-                if 'date' not in header_keys:
-                    self.send_header('Date', self.date_time_string())
-                self.end_headers()
-
-            assert isinstance(data, bytes), 'applications must write bytes'
-            self.wfile.write(data)
-            self.wfile.flush()
-
-        def start_response(status, response_headers, exc_info=None):
-            if exc_info:
-                try:
-                    if headers_sent:
-                        reraise(*exc_info)
-                finally:
-                    exc_info = None
-            elif headers_set:
-                raise AssertionError('Headers already set')
-            headers_set[:] = [status, response_headers]
-            return write
-
-        def execute(app):
-            application_iter = app(environ, start_response)
-            try:
-                for data in application_iter:
-                    write(data)
-                if not headers_sent:
-                    write(b'')
-            finally:
-                if hasattr(application_iter, 'close'):
-                    application_iter.close()
-                application_iter = None
-
-        try:
-            execute(self.server.app)
-        except (socket.error, socket.timeout) as e:
-            self.connection_dropped(e, environ)
-        except Exception:
-            if self.server.passthrough_errors:
-                raise
-            from werkzeug.debug.tbtools import get_current_traceback
-            traceback = get_current_traceback(ignore_system_exceptions=True)
-            try:
-                # if we haven't yet sent the headers but they are set
-                # we roll back to be able to set them again.
-                if not headers_sent:
-                    del headers_set[:]
-                execute(InternalServerError())
-            except Exception:
-                pass
-            self.server.log('error', 'Error on request:\n%s',
-                            traceback.plaintext)
-
-    def handle(self):
-        """Handles a request ignoring dropped connections."""
-        rv = None
-        try:
-            rv = BaseHTTPRequestHandler.handle(self)
-        except (socket.error, socket.timeout) as e:
-            self.connection_dropped(e)
-        except Exception:
-            if self.server.ssl_context is None or not is_ssl_error():
-                raise
-        if self.server.shutdown_signal:
-            self.initiate_shutdown()
-        return rv
-
-    def initiate_shutdown(self):
-        """A horrible, horrible way to kill the server for Python 2.6 and
-        later.  It's the best we can do.
-        """
-        # Windows does not provide SIGKILL, go with SIGTERM then.
-        sig = getattr(signal, 'SIGKILL', signal.SIGTERM)
-        # reloader active
-        if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
-            os.kill(os.getpid(), sig)
-        # python 2.7
-        self.server._BaseServer__shutdown_request = True
-        # python 2.6
-        self.server._BaseServer__serving = False
-
-    def connection_dropped(self, error, environ=None):
-        """Called if the connection was closed by the client.  By default
-        nothing happens.
-        """
-
-    def handle_one_request(self):
-        """Handle a single HTTP request."""
-        self.raw_requestline = self.rfile.readline()
-        if not self.raw_requestline:
-            self.close_connection = 1
-        elif self.parse_request():
-            return self.run_wsgi()
-
-    def send_response(self, code, message=None):
-        """Send the response header and log the response code."""
-        self.log_request(code)
-        if message is None:
-            message = code in self.responses and self.responses[code][0] or ''
-        if self.request_version != 'HTTP/0.9':
-            hdr = "%s %d %s\r\n" % (self.protocol_version, code, message)
-            self.wfile.write(hdr.encode('ascii'))
-
-    def version_string(self):
-        return BaseHTTPRequestHandler.version_string(self).strip()
-
-    def address_string(self):
-        if getattr(self, 'environ', None):
-            return self.environ['REMOTE_ADDR']
-        else:
-            return self.client_address[0]
-
-    def port_integer(self):
-        return self.client_address[1]
-
-    def log_request(self, code='-', size='-'):
-        msg = self.requestline
-        code = str(code)
-
-        if termcolor:
-            color = termcolor.colored
-
-            if code[0] == '1':    # 1xx - Informational
-                msg = color(msg, attrs=['bold'])
-            elif code[0] == '2':    # 2xx - Success
-                msg = color(msg, color='white')
-            elif code == '304':   # 304 - Resource Not Modified
-                msg = color(msg, color='cyan')
-            elif code[0] == '3':  # 3xx - Redirection
-                msg = color(msg, color='green')
-            elif code == '404':   # 404 - Resource Not Found
-                msg = color(msg, color='yellow')
-            elif code[0] == '4':  # 4xx - Client Error
-                msg = color(msg, color='red', attrs=['bold'])
-            else:                 # 5xx, or any other response
-                msg = color(msg, color='magenta', attrs=['bold'])
-
-        self.log('info', '"%s" %s %s', msg, code, size)
-
-    def log_error(self, *args):
-        self.log('error', *args)
-
-    def log_message(self, format, *args):
-        self.log('info', format, *args)
-
-    def log(self, type, message, *args):
-        _log(type, '%s - - [%s] %s\n' % (self.address_string(),
-                                         self.log_date_time_string(),
-                                         message % args))
-
-
-#: backwards compatible name if someone is subclassing it
-BaseRequestHandler = WSGIRequestHandler
-
-
-def generate_adhoc_ssl_pair(cn=None):
-    from random import random
-    crypto = _get_openssl_crypto_module()
-
-    # pretty damn sure that this is not actually accepted by anyone
-    if cn is None:
-        cn = '*'
-
-    cert = crypto.X509()
-    cert.set_serial_number(int(random() * sys.maxsize))
-    cert.gmtime_adj_notBefore(0)
-    cert.gmtime_adj_notAfter(60 * 60 * 24 * 365)
-
-    subject = cert.get_subject()
-    subject.CN = cn
-    subject.O = 'Dummy Certificate'  # noqa: E741
-
-    issuer = cert.get_issuer()
-    issuer.CN = 'Untrusted Authority'
-    issuer.O = 'Self-Signed'  # noqa: E741
-
-    pkey = crypto.PKey()
-    pkey.generate_key(crypto.TYPE_RSA, 2048)
-    cert.set_pubkey(pkey)
-    cert.sign(pkey, 'sha256')
-
-    return cert, pkey
-
-
-def make_ssl_devcert(base_path, host=None, cn=None):
-    """Creates an SSL key for development.  This should be used instead of
-    the ``'adhoc'`` key which generates a new cert on each server start.
-    It accepts a path for where it should store the key and cert and
-    either a host or CN.  If a host is given it will use the CN
-    ``*.host/CN=host``.
-
-    For more information see :func:`run_simple`.
-
-    .. versionadded:: 0.9
-
-    :param base_path: the path to the certificate and key.  The extension
-                      ``.crt`` is added for the certificate, ``.key`` is
-                      added for the key.
-    :param host: the name of the host.  This can be used as an alternative
-                 for the `cn`.
-    :param cn: the `CN` to use.
-    """
-    from OpenSSL import crypto
-    if host is not None:
-        cn = '*.%s/CN=%s' % (host, host)
-    cert, pkey = generate_adhoc_ssl_pair(cn=cn)
-
-    cert_file = base_path + '.crt'
-    pkey_file = base_path + '.key'
-
-    with open(cert_file, 'wb') as f:
-        f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
-    with open(pkey_file, 'wb') as f:
-        f.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey))
-
-    return cert_file, pkey_file
-
-
-def generate_adhoc_ssl_context():
-    """Generates an adhoc SSL context for the development server."""
-    crypto = _get_openssl_crypto_module()
-    import tempfile
-    import atexit
-
-    cert, pkey = generate_adhoc_ssl_pair()
-    cert_handle, cert_file = tempfile.mkstemp()
-    pkey_handle, pkey_file = tempfile.mkstemp()
-    atexit.register(os.remove, pkey_file)
-    atexit.register(os.remove, cert_file)
-
-    os.write(cert_handle, crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
-    os.write(pkey_handle, crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey))
-    os.close(cert_handle)
-    os.close(pkey_handle)
-    ctx = load_ssl_context(cert_file, pkey_file)
-    return ctx
-
-
-def load_ssl_context(cert_file, pkey_file=None, protocol=None):
-    """Loads SSL context from cert/private key files and optional protocol.
-    Many parameters are directly taken from the API of
-    :py:class:`ssl.SSLContext`.
-
-    :param cert_file: Path of the certificate to use.
-    :param pkey_file: Path of the private key to use. If not given, the key
-                      will be obtained from the certificate file.
-    :param protocol: One of the ``PROTOCOL_*`` constants in the stdlib ``ssl``
-                     module. Defaults to ``PROTOCOL_SSLv23``.
-    """
-    if protocol is None:
-        protocol = ssl.PROTOCOL_SSLv23
-    ctx = _SSLContext(protocol)
-    ctx.load_cert_chain(cert_file, pkey_file)
-    return ctx
-
-
-class _SSLContext(object):
-
-    '''A dummy class with a small subset of Python3's ``ssl.SSLContext``, only
-    intended to be used with and by Werkzeug.'''
-
-    def __init__(self, protocol):
-        self._protocol = protocol
-        self._certfile = None
-        self._keyfile = None
-        self._password = None
-
-    def load_cert_chain(self, certfile, keyfile=None, password=None):
-        self._certfile = certfile
-        self._keyfile = keyfile or certfile
-        self._password = password
-
-    def wrap_socket(self, sock, **kwargs):
-        return ssl.wrap_socket(sock, keyfile=self._keyfile,
-                               certfile=self._certfile,
-                               ssl_version=self._protocol, **kwargs)
-
-
-def is_ssl_error(error=None):
-    """Checks if the given error (or the current one) is an SSL error."""
-    exc_types = (ssl.SSLError,)
-    try:
-        from OpenSSL.SSL import Error
-        exc_types += (Error,)
-    except ImportError:
-        pass
-
-    if error is None:
-        error = sys.exc_info()[1]
-    return isinstance(error, exc_types)
-
-
-def select_ip_version(host, port):
-    """Returns AF_INET4 or AF_INET6 depending on where to connect to."""
-    # disabled due to problems with current ipv6 implementations
-    # and various operating systems.  Probably this code also is
-    # not supposed to work, but I can't come up with any other
-    # ways to implement this.
-    # try:
-    #     info = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
-    #                               socket.SOCK_STREAM, 0,
-    #                               socket.AI_PASSIVE)
-    #     if info:
-    #         return info[0][0]
-    # except socket.gaierror:
-    #     pass
-    if ':' in host and hasattr(socket, 'AF_INET6'):
-        return socket.AF_INET6
-    return socket.AF_INET
-
-
-def get_sockaddr(host, port, family):
-    """Returns a fully qualified socket address, that can properly used by
-    socket.bind"""
-    try:
-        res = socket.getaddrinfo(host, port, family,
-                                 socket.SOCK_STREAM, socket.SOL_TCP)
-    except socket.gaierror:
-        return (host, port)
-    return res[0][4]
-
-
-class BaseWSGIServer(HTTPServer, object):
-
-    """Simple single-threaded, single-process WSGI server."""
-    multithread = False
-    multiprocess = False
-    request_queue_size = LISTEN_QUEUE
-
-    def __init__(self, host, port, app, handler=None,
-                 passthrough_errors=False, ssl_context=None, fd=None):
-        if handler is None:
-            handler = WSGIRequestHandler
-
-        self.address_family = select_ip_version(host, port)
-
-        if fd is not None:
-            real_sock = socket.fromfd(fd, self.address_family,
-                                      socket.SOCK_STREAM)
-            port = 0
-        HTTPServer.__init__(self, get_sockaddr(host, int(port),
-                                               self.address_family), handler)
-        self.app = app
-        self.passthrough_errors = passthrough_errors
-        self.shutdown_signal = False
-        self.host = host
-        self.port = self.socket.getsockname()[1]
-
-        # Patch in the original socket.
-        if fd is not None:
-            self.socket.close()
-            self.socket = real_sock
-            self.server_address = self.socket.getsockname()
-
-        if ssl_context is not None:
-            if isinstance(ssl_context, tuple):
-                ssl_context = load_ssl_context(*ssl_context)
-            if ssl_context == 'adhoc':
-                ssl_context = generate_adhoc_ssl_context()
-            # If we are on Python 2 the return value from socket.fromfd
-            # is an internal socket object but what we need for ssl wrap
-            # is the wrapper around it :(
-            sock = self.socket
-            if PY2 and not isinstance(sock, socket.socket):
-                sock = socket.socket(sock.family, sock.type, sock.proto, sock)
-            self.socket = ssl_context.wrap_socket(sock, server_side=True)
-            self.ssl_context = ssl_context
-        else:
-            self.ssl_context = None
-
-    def log(self, type, message, *args):
-        _log(type, message, *args)
-
-    def serve_forever(self):
-        self.shutdown_signal = False
-        try:
-            HTTPServer.serve_forever(self)
-        except KeyboardInterrupt:
-            pass
-        finally:
-            self.server_close()
-
-    def handle_error(self, request, client_address):
-        if self.passthrough_errors:
-            raise
-        return HTTPServer.handle_error(self, request, client_address)
-
-    def get_request(self):
-        con, info = self.socket.accept()
-        return con, info
-
-
-class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer):
-
-    """A WSGI server that does threading."""
-    multithread = True
-    daemon_threads = True
-
-
-class ForkingWSGIServer(ForkingMixIn, BaseWSGIServer):
-
-    """A WSGI server that does forking."""
-    multiprocess = True
-
-    def __init__(self, host, port, app, processes=40, handler=None,
-                 passthrough_errors=False, ssl_context=None, fd=None):
-        if not can_fork:
-            raise ValueError('Your platform does not support forking.')
-        BaseWSGIServer.__init__(self, host, port, app, handler,
-                                passthrough_errors, ssl_context, fd)
-        self.max_children = processes
-
-
-def make_server(host=None, port=None, app=None, threaded=False, processes=1,
-                request_handler=None, passthrough_errors=False,
-                ssl_context=None, fd=None):
-    """Create a new server instance that is either threaded, or forks
-    or just processes one request after another.
-    """
-    if threaded and processes > 1:
-        raise ValueError("cannot have a multithreaded and "
-                         "multi process server.")
-    elif threaded:
-        return ThreadedWSGIServer(host, port, app, request_handler,
-                                  passthrough_errors, ssl_context, fd=fd)
-    elif processes > 1:
-        return ForkingWSGIServer(host, port, app, processes, request_handler,
-                                 passthrough_errors, ssl_context, fd=fd)
-    else:
-        return BaseWSGIServer(host, port, app, request_handler,
-                              passthrough_errors, ssl_context, fd=fd)
-
-
-def is_running_from_reloader():
-    """Checks if the application is running from within the Werkzeug
-    reloader subprocess.
-
-    .. versionadded:: 0.10
-    """
-    return os.environ.get('WERKZEUG_RUN_MAIN') == 'true'
-
-
-def run_simple(hostname, port, application, use_reloader=False,
-               use_debugger=False, use_evalex=True,
-               extra_files=None, reloader_interval=1,
-               reloader_type='auto', threaded=False,
-               processes=1, request_handler=None, static_files=None,
-               passthrough_errors=False, ssl_context=None):
-    """Start a WSGI application. Optional features include a reloader,
-    multithreading and fork support.
-
-    This function has a command-line interface too::
-
-        python -m werkzeug.serving --help
-
-    .. versionadded:: 0.5
-       `static_files` was added to simplify serving of static files as well
-       as `passthrough_errors`.
-
-    .. versionadded:: 0.6
-       support for SSL was added.
-
-    .. versionadded:: 0.8
-       Added support for automatically loading a SSL context from certificate
-       file and private key.
-
-    .. versionadded:: 0.9
-       Added command-line interface.
-
-    .. versionadded:: 0.10
-       Improved the reloader and added support for changing the backend
-       through the `reloader_type` parameter.  See :ref:`reloader`
-       for more information.
-
-    :param hostname: The host for the application.  eg: ``'localhost'``
-    :param port: The port for the server.  eg: ``8080``
-    :param application: the WSGI application to execute
-    :param use_reloader: should the server automatically restart the python
-                         process if modules were changed?
-    :param use_debugger: should the werkzeug debugging system be used?
-    :param use_evalex: should the exception evaluation feature be enabled?
-    :param extra_files: a list of files the reloader should watch
-                        additionally to the modules.  For example configuration
-                        files.
-    :param reloader_interval: the interval for the reloader in seconds.
-    :param reloader_type: the type of reloader to use.  The default is
-                          auto detection.  Valid values are ``'stat'`` and
-                          ``'watchdog'``. See :ref:`reloader` for more
-                          information.
-    :param threaded: should the process handle each request in a separate
-                     thread?
-    :param processes: if greater than 1 then handle each request in a new process
-                      up to this maximum number of concurrent processes.
-    :param request_handler: optional parameter that can be used to replace
-                            the default one.  You can use this to replace it
-                            with a different
-                            :class:`~BaseHTTPServer.BaseHTTPRequestHandler`
-                            subclass.
-    :param static_files: a list or dict of paths for static files.  This works
-                         exactly like :class:`SharedDataMiddleware`, it's actually
-                         just wrapping the application in that middleware before
-                         serving.
-    :param passthrough_errors: set this to `True` to disable the error catching.
-                               This means that the server will die on errors but
-                               it can be useful to hook debuggers in (pdb etc.)
-    :param ssl_context: an SSL context for the connection. Either an
-                        :class:`ssl.SSLContext`, a tuple in the form
-                        ``(cert_file, pkey_file)``, the string ``'adhoc'`` if
-                        the server should automatically create one, or ``None``
-                        to disable SSL (which is the default).
-    """
-    if not isinstance(port, int):
-        raise TypeError('port must be an integer')
-    if use_debugger:
-        from werkzeug.debug import DebuggedApplication
-        application = DebuggedApplication(application, use_evalex)
-    if static_files:
-        from werkzeug.wsgi import SharedDataMiddleware
-        application = SharedDataMiddleware(application, static_files)
-
-    def log_startup(sock):
-        display_hostname = hostname not in ('', '*') and hostname or 'localhost'
-        if ':' in display_hostname:
-            display_hostname = '[%s]' % display_hostname
-        quit_msg = '(Press CTRL+C to quit)'
-        port = sock.getsockname()[1]
-        _log('info', ' * Running on %s://%s:%d/ %s',
-             ssl_context is None and 'http' or 'https',
-             display_hostname, port, quit_msg)
-
-    def inner():
-        try:
-            fd = int(os.environ['WERKZEUG_SERVER_FD'])
-        except (LookupError, ValueError):
-            fd = None
-        srv = make_server(hostname, port, application, threaded,
-                          processes, request_handler,
-                          passthrough_errors, ssl_context,
-                          fd=fd)
-        if fd is None:
-            log_startup(srv.socket)
-        srv.serve_forever()
-
-    if use_reloader:
-        # If we're not running already in the subprocess that is the
-        # reloader we want to open up a socket early to make sure the
-        # port is actually available.
-        if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
-            if port == 0 and not can_open_by_fd:
-                raise ValueError('Cannot bind to a random port with enabled '
-                                 'reloader if the Python interpreter does '
-                                 'not support socket opening by fd.')
-
-            # Create and destroy a socket so that any exceptions are
-            # raised before we spawn a separate Python interpreter and
-            # lose this ability.
-            address_family = select_ip_version(hostname, port)
-            s = socket.socket(address_family, socket.SOCK_STREAM)
-            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            s.bind(get_sockaddr(hostname, port, address_family))
-            if hasattr(s, 'set_inheritable'):
-                s.set_inheritable(True)
-
-            # If we can open the socket by file descriptor, then we can just
-            # reuse this one and our socket will survive the restarts.
-            if can_open_by_fd:
-                os.environ['WERKZEUG_SERVER_FD'] = str(s.fileno())
-                s.listen(LISTEN_QUEUE)
-                log_startup(s)
-            else:
-                s.close()
-
-        # Do not use relative imports, otherwise "python -m werkzeug.serving"
-        # breaks.
-        from werkzeug._reloader import run_with_reloader
-        run_with_reloader(inner, extra_files, reloader_interval,
-                          reloader_type)
-    else:
-        inner()
-
-
-def run_with_reloader(*args, **kwargs):
-    # People keep using undocumented APIs.  Do not use this function
-    # please, we do not guarantee that it continues working.
-    from werkzeug._reloader import run_with_reloader
-    return run_with_reloader(*args, **kwargs)
-
-
-def main():
-    '''A simple command-line interface for :py:func:`run_simple`.'''
-
-    # in contrast to argparse, this works at least under Python < 2.7
-    import optparse
-    from werkzeug.utils import import_string
-
-    parser = optparse.OptionParser(
-        usage='Usage: %prog [options] app_module:app_object')
-    parser.add_option('-b', '--bind', dest='address',
-                      help='The hostname:port the app should listen on.')
-    parser.add_option('-d', '--debug', dest='use_debugger',
-                      action='store_true', default=False,
-                      help='Use Werkzeug\'s debugger.')
-    parser.add_option('-r', '--reload', dest='use_reloader',
-                      action='store_true', default=False,
-                      help='Reload Python process if modules change.')
-    options, args = parser.parse_args()
-
-    hostname, port = None, None
-    if options.address:
-        address = options.address.split(':')
-        hostname = address[0]
-        if len(address) > 1:
-            port = address[1]
-
-    if len(args) != 1:
-        sys.stdout.write('No application supplied, or too much. See --help\n')
-        sys.exit(1)
-    app = import_string(args[0])
-
-    run_simple(
-        hostname=(hostname or '127.0.0.1'), port=int(port or 5000),
-        application=app, use_reloader=options.use_reloader,
-        use_debugger=options.use_debugger
-    )
-
-if __name__ == '__main__':
-    main()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/test.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/test.py
deleted file mode 100644
index acd21793d..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/test.py
+++ /dev/null
@@ -1,948 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.test
-    ~~~~~~~~~~~~~
-
-    This module implements a client to WSGI applications for testing.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import sys
-import mimetypes
-from time import time
-from random import random
-from itertools import chain
-from tempfile import TemporaryFile
-from io import BytesIO
-
-try:
-    from urllib2 import Request as U2Request
-except ImportError:
-    from urllib.request import Request as U2Request
-try:
-    from http.cookiejar import CookieJar
-except ImportError:  # Py2
-    from cookielib import CookieJar
-
-from werkzeug._compat import iterlists, iteritems, itervalues, to_bytes, \
-    string_types, text_type, reraise, wsgi_encoding_dance, \
-    make_literal_wrapper
-from werkzeug._internal import _empty_stream, _get_environ
-from werkzeug.wrappers import BaseRequest
-from werkzeug.urls import url_encode, url_fix, iri_to_uri, url_unquote, \
-    url_unparse, url_parse
-from werkzeug.wsgi import get_host, get_current_url, ClosingIterator
-from werkzeug.utils import dump_cookie, get_content_type
-from werkzeug.datastructures import FileMultiDict, MultiDict, \
-    CombinedMultiDict, Headers, FileStorage, CallbackDict
-from werkzeug.http import dump_options_header, parse_options_header
-
-
-def stream_encode_multipart(values, use_tempfile=True, threshold=1024 * 500,
-                            boundary=None, charset='utf-8'):
-    """Encode a dict of values (either strings or file descriptors or
-    :class:`FileStorage` objects.) into a multipart encoded string stored
-    in a file descriptor.
-    """
-    if boundary is None:
-        boundary = '---------------WerkzeugFormPart_%s%s' % (time(), random())
-    _closure = [BytesIO(), 0, False]
-
-    if use_tempfile:
-        def write_binary(string):
-            stream, total_length, on_disk = _closure
-            if on_disk:
-                stream.write(string)
-            else:
-                length = len(string)
-                if length + _closure[1] <= threshold:
-                    stream.write(string)
-                else:
-                    new_stream = TemporaryFile('wb+')
-                    new_stream.write(stream.getvalue())
-                    new_stream.write(string)
-                    _closure[0] = new_stream
-                    _closure[2] = True
-                _closure[1] = total_length + length
-    else:
-        write_binary = _closure[0].write
-
-    def write(string):
-        write_binary(string.encode(charset))
-
-    if not isinstance(values, MultiDict):
-        values = MultiDict(values)
-
-    for key, values in iterlists(values):
-        for value in values:
-            write('--%s\r\nContent-Disposition: form-data; name="%s"' %
-                  (boundary, key))
-            reader = getattr(value, 'read', None)
-            if reader is not None:
-                filename = getattr(value, 'filename',
-                                   getattr(value, 'name', None))
-                content_type = getattr(value, 'content_type', None)
-                if content_type is None:
-                    content_type = filename and \
-                        mimetypes.guess_type(filename)[0] or \
-                        'application/octet-stream'
-                if filename is not None:
-                    write('; filename="%s"\r\n' % filename)
-                else:
-                    write('\r\n')
-                write('Content-Type: %s\r\n\r\n' % content_type)
-                while 1:
-                    chunk = reader(16384)
-                    if not chunk:
-                        break
-                    write_binary(chunk)
-            else:
-                if not isinstance(value, string_types):
-                    value = str(value)
-
-                value = to_bytes(value, charset)
-                write('\r\n\r\n')
-                write_binary(value)
-            write('\r\n')
-    write('--%s--\r\n' % boundary)
-
-    length = int(_closure[0].tell())
-    _closure[0].seek(0)
-    return _closure[0], length, boundary
-
-
-def encode_multipart(values, boundary=None, charset='utf-8'):
-    """Like `stream_encode_multipart` but returns a tuple in the form
-    (``boundary``, ``data``) where data is a bytestring.
-    """
-    stream, length, boundary = stream_encode_multipart(
-        values, use_tempfile=False, boundary=boundary, charset=charset)
-    return boundary, stream.read()
-
-
-def File(fd, filename=None, mimetype=None):
-    """Backwards compat."""
-    from warnings import warn
-    warn(DeprecationWarning('werkzeug.test.File is deprecated, use the '
-                            'EnvironBuilder or FileStorage instead'))
-    return FileStorage(fd, filename=filename, content_type=mimetype)
-
-
-class _TestCookieHeaders(object):
-
-    """A headers adapter for cookielib
-    """
-
-    def __init__(self, headers):
-        self.headers = headers
-
-    def getheaders(self, name):
-        headers = []
-        name = name.lower()
-        for k, v in self.headers:
-            if k.lower() == name:
-                headers.append(v)
-        return headers
-
-    def get_all(self, name, default=None):
-        rv = []
-        for k, v in self.headers:
-            if k.lower() == name.lower():
-                rv.append(v)
-        return rv or default or []
-
-
-class _TestCookieResponse(object):
-
-    """Something that looks like a httplib.HTTPResponse, but is actually just an
-    adapter for our test responses to make them available for cookielib.
-    """
-
-    def __init__(self, headers):
-        self.headers = _TestCookieHeaders(headers)
-
-    def info(self):
-        return self.headers
-
-
-class _TestCookieJar(CookieJar):
-
-    """A cookielib.CookieJar modified to inject and read cookie headers from
-    and to wsgi environments, and wsgi application responses.
-    """
-
-    def inject_wsgi(self, environ):
-        """Inject the cookies as client headers into the server's wsgi
-        environment.
-        """
-        cvals = []
-        for cookie in self:
-            cvals.append('%s=%s' % (cookie.name, cookie.value))
-        if cvals:
-            environ['HTTP_COOKIE'] = '; '.join(cvals)
-
-    def extract_wsgi(self, environ, headers):
-        """Extract the server's set-cookie headers as cookies into the
-        cookie jar.
-        """
-        self.extract_cookies(
-            _TestCookieResponse(headers),
-            U2Request(get_current_url(environ)),
-        )
-
-
-def _iter_data(data):
-    """Iterates over a `dict` or :class:`MultiDict` yielding all keys and
-    values.
-    This is used to iterate over the data passed to the
-    :class:`EnvironBuilder`.
-    """
-    if isinstance(data, MultiDict):
-        for key, values in iterlists(data):
-            for value in values:
-                yield key, value
-    else:
-        for key, values in iteritems(data):
-            if isinstance(values, list):
-                for value in values:
-                    yield key, value
-            else:
-                yield key, values
-
-
-class EnvironBuilder(object):
-
-    """This class can be used to conveniently create a WSGI environment
-    for testing purposes.  It can be used to quickly create WSGI environments
-    or request objects from arbitrary data.
-
-    The signature of this class is also used in some other places as of
-    Werkzeug 0.5 (:func:`create_environ`, :meth:`BaseResponse.from_values`,
-    :meth:`Client.open`).  Because of this most of the functionality is
-    available through the constructor alone.
-
-    Files and regular form data can be manipulated independently of each
-    other with the :attr:`form` and :attr:`files` attributes, but are
-    passed with the same argument to the constructor: `data`.
-
-    `data` can be any of these values:
-
-    -   a `str` or `bytes` object: The object is converted into an
-        :attr:`input_stream`, the :attr:`content_length` is set and you have to
-        provide a :attr:`content_type`.
-    -   a `dict` or :class:`MultiDict`: The keys have to be strings. The values
-        have to be either any of the following objects, or a list of any of the
-        following objects:
-
-        -   a :class:`file`-like object:  These are converted into
-            :class:`FileStorage` objects automatically.
-        -   a `tuple`:  The :meth:`~FileMultiDict.add_file` method is called
-            with the key and the unpacked `tuple` items as positional
-            arguments.
-        -   a `str`:  The string is set as form data for the associated key.
-    -   a file-like object: The object content is loaded in memory and then
-        handled like a regular `str` or a `bytes`.
-
-    .. versionadded:: 0.6
-       `path` and `base_url` can now be unicode strings that are encoded using
-       the :func:`iri_to_uri` function.
-
-    :param path: the path of the request.  In the WSGI environment this will
-                 end up as `PATH_INFO`.  If the `query_string` is not defined
-                 and there is a question mark in the `path` everything after
-                 it is used as query string.
-    :param base_url: the base URL is a URL that is used to extract the WSGI
-                     URL scheme, host (server name + server port) and the
-                     script root (`SCRIPT_NAME`).
-    :param query_string: an optional string or dict with URL parameters.
-    :param method: the HTTP method to use, defaults to `GET`.
-    :param input_stream: an optional input stream.  Do not specify this and
-                         `data`.  As soon as an input stream is set you can't
-                         modify :attr:`args` and :attr:`files` unless you
-                         set the :attr:`input_stream` to `None` again.
-    :param content_type: The content type for the request.  As of 0.5 you
-                         don't have to provide this when specifying files
-                         and form data via `data`.
-    :param content_length: The content length for the request.  You don't
-                           have to specify this when providing data via
-                           `data`.
-    :param errors_stream: an optional error stream that is used for
-                          `wsgi.errors`.  Defaults to :data:`stderr`.
-    :param multithread: controls `wsgi.multithread`.  Defaults to `False`.
-    :param multiprocess: controls `wsgi.multiprocess`.  Defaults to `False`.
-    :param run_once: controls `wsgi.run_once`.  Defaults to `False`.
-    :param headers: an optional list or :class:`Headers` object of headers.
-    :param data: a string or dict of form data or a file-object.
-                 See explanation above.
-    :param environ_base: an optional dict of environment defaults.
-    :param environ_overrides: an optional dict of environment overrides.
-    :param charset: the charset used to encode unicode data.
-    """
-
-    #: the server protocol to use.  defaults to HTTP/1.1
-    server_protocol = 'HTTP/1.1'
-
-    #: the wsgi version to use.  defaults to (1, 0)
-    wsgi_version = (1, 0)
-
-    #: the default request class for :meth:`get_request`
-    request_class = BaseRequest
-
-    def __init__(self, path='/', base_url=None, query_string=None,
-                 method='GET', input_stream=None, content_type=None,
-                 content_length=None, errors_stream=None, multithread=False,
-                 multiprocess=False, run_once=False, headers=None, data=None,
-                 environ_base=None, environ_overrides=None, charset='utf-8',
-                 mimetype=None):
-        path_s = make_literal_wrapper(path)
-        if query_string is None and path_s('?') in path:
-            path, query_string = path.split(path_s('?'), 1)
-        self.charset = charset
-        self.path = iri_to_uri(path)
-        if base_url is not None:
-            base_url = url_fix(iri_to_uri(base_url, charset), charset)
-        self.base_url = base_url
-        if isinstance(query_string, (bytes, text_type)):
-            self.query_string = query_string
-        else:
-            if query_string is None:
-                query_string = MultiDict()
-            elif not isinstance(query_string, MultiDict):
-                query_string = MultiDict(query_string)
-            self.args = query_string
-        self.method = method
-        if headers is None:
-            headers = Headers()
-        elif not isinstance(headers, Headers):
-            headers = Headers(headers)
-        self.headers = headers
-        if content_type is not None:
-            self.content_type = content_type
-        if errors_stream is None:
-            errors_stream = sys.stderr
-        self.errors_stream = errors_stream
-        self.multithread = multithread
-        self.multiprocess = multiprocess
-        self.run_once = run_once
-        self.environ_base = environ_base
-        self.environ_overrides = environ_overrides
-        self.input_stream = input_stream
-        self.content_length = content_length
-        self.closed = False
-
-        if data:
-            if input_stream is not None:
-                raise TypeError('can\'t provide input stream and data')
-            if hasattr(data, 'read'):
-                data = data.read()
-            if isinstance(data, text_type):
-                data = data.encode(self.charset)
-            if isinstance(data, bytes):
-                self.input_stream = BytesIO(data)
-                if self.content_length is None:
-                    self.content_length = len(data)
-            else:
-                for key, value in _iter_data(data):
-                    if isinstance(value, (tuple, dict)) or \
-                       hasattr(value, 'read'):
-                        self._add_file_from_data(key, value)
-                    else:
-                        self.form.setlistdefault(key).append(value)
-
-        if mimetype is not None:
-            self.mimetype = mimetype
-
-    def _add_file_from_data(self, key, value):
-        """Called in the EnvironBuilder to add files from the data dict."""
-        if isinstance(value, tuple):
-            self.files.add_file(key, *value)
-        elif isinstance(value, dict):
-            from warnings import warn
-            warn(DeprecationWarning('it\'s no longer possible to pass dicts '
-                                    'as `data`.  Use tuples or FileStorage '
-                                    'objects instead'), stacklevel=2)
-            value = dict(value)
-            mimetype = value.pop('mimetype', None)
-            if mimetype is not None:
-                value['content_type'] = mimetype
-            self.files.add_file(key, **value)
-        else:
-            self.files.add_file(key, value)
-
-    def _get_base_url(self):
-        return url_unparse((self.url_scheme, self.host,
-                            self.script_root, '', '')).rstrip('/') + '/'
-
-    def _set_base_url(self, value):
-        if value is None:
-            scheme = 'http'
-            netloc = 'localhost'
-            script_root = ''
-        else:
-            scheme, netloc, script_root, qs, anchor = url_parse(value)
-            if qs or anchor:
-                raise ValueError('base url must not contain a query string '
-                                 'or fragment')
-        self.script_root = script_root.rstrip('/')
-        self.host = netloc
-        self.url_scheme = scheme
-
-    base_url = property(_get_base_url, _set_base_url, doc='''
-        The base URL is a URL that is used to extract the WSGI
-        URL scheme, host (server name + server port) and the
-        script root (`SCRIPT_NAME`).''')
-    del _get_base_url, _set_base_url
-
-    def _get_content_type(self):
-        ct = self.headers.get('Content-Type')
-        if ct is None and not self._input_stream:
-            if self._files:
-                return 'multipart/form-data'
-            elif self._form:
-                return 'application/x-www-form-urlencoded'
-            return None
-        return ct
-
-    def _set_content_type(self, value):
-        if value is None:
-            self.headers.pop('Content-Type', None)
-        else:
-            self.headers['Content-Type'] = value
-
-    content_type = property(_get_content_type, _set_content_type, doc='''
-        The content type for the request.  Reflected from and to the
-        :attr:`headers`.  Do not set if you set :attr:`files` or
-        :attr:`form` for auto detection.''')
-    del _get_content_type, _set_content_type
-
-    def _get_content_length(self):
-        return self.headers.get('Content-Length', type=int)
-
-    def _get_mimetype(self):
-        ct = self.content_type
-        if ct:
-            return ct.split(';')[0].strip()
-
-    def _set_mimetype(self, value):
-        self.content_type = get_content_type(value, self.charset)
-
-    def _get_mimetype_params(self):
-        def on_update(d):
-            self.headers['Content-Type'] = \
-                dump_options_header(self.mimetype, d)
-        d = parse_options_header(self.headers.get('content-type', ''))[1]
-        return CallbackDict(d, on_update)
-
-    mimetype = property(_get_mimetype, _set_mimetype, doc='''
-        The mimetype (content type without charset etc.)
-
-        .. versionadded:: 0.14
-    ''')
-    mimetype_params = property(_get_mimetype_params, doc='''
-        The mimetype parameters as dict.  For example if the content
-        type is ``text/html; charset=utf-8`` the params would be
-        ``{'charset': 'utf-8'}``.
-
-        .. versionadded:: 0.14
-        ''')
-    del _get_mimetype, _set_mimetype, _get_mimetype_params
-
-    def _set_content_length(self, value):
-        if value is None:
-            self.headers.pop('Content-Length', None)
-        else:
-            self.headers['Content-Length'] = str(value)
-
-    content_length = property(_get_content_length, _set_content_length, doc='''
-        The content length as integer.  Reflected from and to the
-        :attr:`headers`.  Do not set if you set :attr:`files` or
-        :attr:`form` for auto detection.''')
-    del _get_content_length, _set_content_length
-
-    def form_property(name, storage, doc):
-        key = '_' + name
-
-        def getter(self):
-            if self._input_stream is not None:
-                raise AttributeError('an input stream is defined')
-            rv = getattr(self, key)
-            if rv is None:
-                rv = storage()
-                setattr(self, key, rv)
-
-            return rv
-
-        def setter(self, value):
-            self._input_stream = None
-            setattr(self, key, value)
-        return property(getter, setter, doc=doc)
-
-    form = form_property('form', MultiDict, doc='''
-        A :class:`MultiDict` of form values.''')
-    files = form_property('files', FileMultiDict, doc='''
-        A :class:`FileMultiDict` of uploaded files.  You can use the
-        :meth:`~FileMultiDict.add_file` method to add new files to the
-        dict.''')
-    del form_property
-
-    def _get_input_stream(self):
-        return self._input_stream
-
-    def _set_input_stream(self, value):
-        self._input_stream = value
-        self._form = self._files = None
-
-    input_stream = property(_get_input_stream, _set_input_stream, doc='''
-        An optional input stream.  If you set this it will clear
-        :attr:`form` and :attr:`files`.''')
-    del _get_input_stream, _set_input_stream
-
-    def _get_query_string(self):
-        if self._query_string is None:
-            if self._args is not None:
-                return url_encode(self._args, charset=self.charset)
-            return ''
-        return self._query_string
-
-    def _set_query_string(self, value):
-        self._query_string = value
-        self._args = None
-
-    query_string = property(_get_query_string, _set_query_string, doc='''
-        The query string.  If you set this to a string :attr:`args` will
-        no longer be available.''')
-    del _get_query_string, _set_query_string
-
-    def _get_args(self):
-        if self._query_string is not None:
-            raise AttributeError('a query string is defined')
-        if self._args is None:
-            self._args = MultiDict()
-        return self._args
-
-    def _set_args(self, value):
-        self._query_string = None
-        self._args = value
-
-    args = property(_get_args, _set_args, doc='''
-        The URL arguments as :class:`MultiDict`.''')
-    del _get_args, _set_args
-
-    @property
-    def server_name(self):
-        """The server name (read-only, use :attr:`host` to set)"""
-        return self.host.split(':', 1)[0]
-
-    @property
-    def server_port(self):
-        """The server port as integer (read-only, use :attr:`host` to set)"""
-        pieces = self.host.split(':', 1)
-        if len(pieces) == 2 and pieces[1].isdigit():
-            return int(pieces[1])
-        elif self.url_scheme == 'https':
-            return 443
-        return 80
-
-    def __del__(self):
-        try:
-            self.close()
-        except Exception:
-            pass
-
-    def close(self):
-        """Closes all files.  If you put real :class:`file` objects into the
-        :attr:`files` dict you can call this method to automatically close
-        them all in one go.
-        """
-        if self.closed:
-            return
-        try:
-            files = itervalues(self.files)
-        except AttributeError:
-            files = ()
-        for f in files:
-            try:
-                f.close()
-            except Exception:
-                pass
-        self.closed = True
-
-    def get_environ(self):
-        """Return the built environ."""
-        input_stream = self.input_stream
-        content_length = self.content_length
-
-        mimetype = self.mimetype
-        content_type = self.content_type
-
-        if input_stream is not None:
-            start_pos = input_stream.tell()
-            input_stream.seek(0, 2)
-            end_pos = input_stream.tell()
-            input_stream.seek(start_pos)
-            content_length = end_pos - start_pos
-        elif mimetype == 'multipart/form-data':
-            values = CombinedMultiDict([self.form, self.files])
-            input_stream, content_length, boundary = \
-                stream_encode_multipart(values, charset=self.charset)
-            content_type = mimetype + '; boundary="%s"' % boundary
-        elif mimetype == 'application/x-www-form-urlencoded':
-            # XXX: py2v3 review
-            values = url_encode(self.form, charset=self.charset)
-            values = values.encode('ascii')
-            content_length = len(values)
-            input_stream = BytesIO(values)
-        else:
-            input_stream = _empty_stream
-
-        result = {}
-        if self.environ_base:
-            result.update(self.environ_base)
-
-        def _path_encode(x):
-            return wsgi_encoding_dance(url_unquote(x, self.charset), self.charset)
-
-        qs = wsgi_encoding_dance(self.query_string)
-
-        result.update({
-            'REQUEST_METHOD':       self.method,
-            'SCRIPT_NAME':          _path_encode(self.script_root),
-            'PATH_INFO':            _path_encode(self.path),
-            'QUERY_STRING':         qs,
-            'SERVER_NAME':          self.server_name,
-            'SERVER_PORT':          str(self.server_port),
-            'HTTP_HOST':            self.host,
-            'SERVER_PROTOCOL':      self.server_protocol,
-            'CONTENT_TYPE':         content_type or '',
-            'CONTENT_LENGTH':       str(content_length or '0'),
-            'wsgi.version':         self.wsgi_version,
-            'wsgi.url_scheme':      self.url_scheme,
-            'wsgi.input':           input_stream,
-            'wsgi.errors':          self.errors_stream,
-            'wsgi.multithread':     self.multithread,
-            'wsgi.multiprocess':    self.multiprocess,
-            'wsgi.run_once':        self.run_once
-        })
-        for key, value in self.headers.to_wsgi_list():
-            result['HTTP_%s' % key.upper().replace('-', '_')] = value
-        if self.environ_overrides:
-            result.update(self.environ_overrides)
-        return result
-
-    def get_request(self, cls=None):
-        """Returns a request with the data.  If the request class is not
-        specified :attr:`request_class` is used.
-
-        :param cls: The request wrapper to use.
-        """
-        if cls is None:
-            cls = self.request_class
-        return cls(self.get_environ())
-
-
-class ClientRedirectError(Exception):
-
-    """
-    If a redirect loop is detected when using follow_redirects=True with
-    the :cls:`Client`, then this exception is raised.
-    """
-
-
-class Client(object):
-
-    """This class allows to send requests to a wrapped application.
-
-    The response wrapper can be a class or factory function that takes
-    three arguments: app_iter, status and headers.  The default response
-    wrapper just returns a tuple.
-
-    Example::
-
-        class ClientResponse(BaseResponse):
-            ...
-
-        client = Client(MyApplication(), response_wrapper=ClientResponse)
-
-    The use_cookies parameter indicates whether cookies should be stored and
-    sent for subsequent requests. This is True by default, but passing False
-    will disable this behaviour.
-
-    If you want to request some subdomain of your application you may set
-    `allow_subdomain_redirects` to `True` as if not no external redirects
-    are allowed.
-
-    .. versionadded:: 0.5
-       `use_cookies` is new in this version.  Older versions did not provide
-       builtin cookie support.
-
-    .. versionadded:: 0.14
-       The `mimetype` parameter was added.
-    """
-
-    def __init__(self, application, response_wrapper=None, use_cookies=True,
-                 allow_subdomain_redirects=False):
-        self.application = application
-        self.response_wrapper = response_wrapper
-        if use_cookies:
-            self.cookie_jar = _TestCookieJar()
-        else:
-            self.cookie_jar = None
-        self.allow_subdomain_redirects = allow_subdomain_redirects
-
-    def set_cookie(self, server_name, key, value='', max_age=None,
-                   expires=None, path='/', domain=None, secure=None,
-                   httponly=False, charset='utf-8'):
-        """Sets a cookie in the client's cookie jar.  The server name
-        is required and has to match the one that is also passed to
-        the open call.
-        """
-        assert self.cookie_jar is not None, 'cookies disabled'
-        header = dump_cookie(key, value, max_age, expires, path, domain,
-                             secure, httponly, charset)
-        environ = create_environ(path, base_url='http://' + server_name)
-        headers = [('Set-Cookie', header)]
-        self.cookie_jar.extract_wsgi(environ, headers)
-
-    def delete_cookie(self, server_name, key, path='/', domain=None):
-        """Deletes a cookie in the test client."""
-        self.set_cookie(server_name, key, expires=0, max_age=0,
-                        path=path, domain=domain)
-
-    def run_wsgi_app(self, environ, buffered=False):
-        """Runs the wrapped WSGI app with the given environment."""
-        if self.cookie_jar is not None:
-            self.cookie_jar.inject_wsgi(environ)
-        rv = run_wsgi_app(self.application, environ, buffered=buffered)
-        if self.cookie_jar is not None:
-            self.cookie_jar.extract_wsgi(environ, rv[2])
-        return rv
-
-    def resolve_redirect(self, response, new_location, environ, buffered=False):
-        """Resolves a single redirect and triggers the request again
-        directly on this redirect client.
-        """
-        scheme, netloc, script_root, qs, anchor = url_parse(new_location)
-        base_url = url_unparse((scheme, netloc, '', '', '')).rstrip('/') + '/'
-
-        cur_server_name = netloc.split(':', 1)[0].split('.')
-        real_server_name = get_host(environ).rsplit(':', 1)[0].split('.')
-        if cur_server_name == ['']:
-            # this is a local redirect having autocorrect_location_header=False
-            cur_server_name = real_server_name
-            base_url = EnvironBuilder(environ).base_url
-
-        if self.allow_subdomain_redirects:
-            allowed = cur_server_name[-len(real_server_name):] == real_server_name
-        else:
-            allowed = cur_server_name == real_server_name
-
-        if not allowed:
-            raise RuntimeError('%r does not support redirect to '
-                               'external targets' % self.__class__)
-
-        status_code = int(response[1].split(None, 1)[0])
-        if status_code == 307:
-            method = environ['REQUEST_METHOD']
-        else:
-            method = 'GET'
-
-        # For redirect handling we temporarily disable the response
-        # wrapper.  This is not threadsafe but not a real concern
-        # since the test client must not be shared anyways.
-        old_response_wrapper = self.response_wrapper
-        self.response_wrapper = None
-        try:
-            return self.open(path=script_root, base_url=base_url,
-                             query_string=qs, as_tuple=True,
-                             buffered=buffered, method=method)
-        finally:
-            self.response_wrapper = old_response_wrapper
-
-    def open(self, *args, **kwargs):
-        """Takes the same arguments as the :class:`EnvironBuilder` class with
-        some additions:  You can provide a :class:`EnvironBuilder` or a WSGI
-        environment as only argument instead of the :class:`EnvironBuilder`
-        arguments and two optional keyword arguments (`as_tuple`, `buffered`)
-        that change the type of the return value or the way the application is
-        executed.
-
-        .. versionchanged:: 0.5
-           If a dict is provided as file in the dict for the `data` parameter
-           the content type has to be called `content_type` now instead of
-           `mimetype`.  This change was made for consistency with
-           :class:`werkzeug.FileWrapper`.
-
-            The `follow_redirects` parameter was added to :func:`open`.
-
-        Additional parameters:
-
-        :param as_tuple: Returns a tuple in the form ``(environ, result)``
-        :param buffered: Set this to True to buffer the application run.
-                         This will automatically close the application for
-                         you as well.
-        :param follow_redirects: Set this to True if the `Client` should
-                                 follow HTTP redirects.
-        """
-        as_tuple = kwargs.pop('as_tuple', False)
-        buffered = kwargs.pop('buffered', False)
-        follow_redirects = kwargs.pop('follow_redirects', False)
-        environ = None
-        if not kwargs and len(args) == 1:
-            if isinstance(args[0], EnvironBuilder):
-                environ = args[0].get_environ()
-            elif isinstance(args[0], dict):
-                environ = args[0]
-        if environ is None:
-            builder = EnvironBuilder(*args, **kwargs)
-            try:
-                environ = builder.get_environ()
-            finally:
-                builder.close()
-
-        response = self.run_wsgi_app(environ, buffered=buffered)
-
-        # handle redirects
-        redirect_chain = []
-        while 1:
-            status_code = int(response[1].split(None, 1)[0])
-            if status_code not in (301, 302, 303, 305, 307) \
-               or not follow_redirects:
-                break
-            new_location = response[2]['location']
-            new_redirect_entry = (new_location, status_code)
-            if new_redirect_entry in redirect_chain:
-                raise ClientRedirectError('loop detected')
-            redirect_chain.append(new_redirect_entry)
-            environ, response = self.resolve_redirect(response, new_location,
-                                                      environ,
-                                                      buffered=buffered)
-
-        if self.response_wrapper is not None:
-            response = self.response_wrapper(*response)
-        if as_tuple:
-            return environ, response
-        return response
-
-    def get(self, *args, **kw):
-        """Like open but method is enforced to GET."""
-        kw['method'] = 'GET'
-        return self.open(*args, **kw)
-
-    def patch(self, *args, **kw):
-        """Like open but method is enforced to PATCH."""
-        kw['method'] = 'PATCH'
-        return self.open(*args, **kw)
-
-    def post(self, *args, **kw):
-        """Like open but method is enforced to POST."""
-        kw['method'] = 'POST'
-        return self.open(*args, **kw)
-
-    def head(self, *args, **kw):
-        """Like open but method is enforced to HEAD."""
-        kw['method'] = 'HEAD'
-        return self.open(*args, **kw)
-
-    def put(self, *args, **kw):
-        """Like open but method is enforced to PUT."""
-        kw['method'] = 'PUT'
-        return self.open(*args, **kw)
-
-    def delete(self, *args, **kw):
-        """Like open but method is enforced to DELETE."""
-        kw['method'] = 'DELETE'
-        return self.open(*args, **kw)
-
-    def options(self, *args, **kw):
-        """Like open but method is enforced to OPTIONS."""
-        kw['method'] = 'OPTIONS'
-        return self.open(*args, **kw)
-
-    def trace(self, *args, **kw):
-        """Like open but method is enforced to TRACE."""
-        kw['method'] = 'TRACE'
-        return self.open(*args, **kw)
-
-    def __repr__(self):
-        return '<%s %r>' % (
-            self.__class__.__name__,
-            self.application
-        )
-
-
-def create_environ(*args, **kwargs):
-    """Create a new WSGI environ dict based on the values passed.  The first
-    parameter should be the path of the request which defaults to '/'.  The
-    second one can either be an absolute path (in that case the host is
-    localhost:80) or a full path to the request with scheme, netloc port and
-    the path to the script.
-
-    This accepts the same arguments as the :class:`EnvironBuilder`
-    constructor.
-
-    .. versionchanged:: 0.5
-       This function is now a thin wrapper over :class:`EnvironBuilder` which
-       was added in 0.5.  The `headers`, `environ_base`, `environ_overrides`
-       and `charset` parameters were added.
-    """
-    builder = EnvironBuilder(*args, **kwargs)
-    try:
-        return builder.get_environ()
-    finally:
-        builder.close()
-
-
-def run_wsgi_app(app, environ, buffered=False):
-    """Return a tuple in the form (app_iter, status, headers) of the
-    application output.  This works best if you pass it an application that
-    returns an iterator all the time.
-
-    Sometimes applications may use the `write()` callable returned
-    by the `start_response` function.  This tries to resolve such edge
-    cases automatically.  But if you don't get the expected output you
-    should set `buffered` to `True` which enforces buffering.
-
-    If passed an invalid WSGI application the behavior of this function is
-    undefined.  Never pass non-conforming WSGI applications to this function.
-
-    :param app: the application to execute.
-    :param buffered: set to `True` to enforce buffering.
-    :return: tuple in the form ``(app_iter, status, headers)``
-    """
-    environ = _get_environ(environ)
-    response = []
-    buffer = []
-
-    def start_response(status, headers, exc_info=None):
-        if exc_info is not None:
-            reraise(*exc_info)
-        response[:] = [status, headers]
-        return buffer.append
-
-    app_rv = app(environ, start_response)
-    close_func = getattr(app_rv, 'close', None)
-    app_iter = iter(app_rv)
-
-    # when buffering we emit the close call early and convert the
-    # application iterator into a regular list
-    if buffered:
-        try:
-            app_iter = list(app_iter)
-        finally:
-            if close_func is not None:
-                close_func()
-
-    # otherwise we iterate the application iter until we have a response, chain
-    # the already received data with the already collected data and wrap it in
-    # a new `ClosingIterator` if we need to restore a `close` callable from the
-    # original return value.
-    else:
-        while not response:
-            buffer.append(next(app_iter))
-        if buffer:
-            app_iter = chain(buffer, app_iter)
-        if close_func is not None and app_iter is not app_rv:
-            app_iter = ClosingIterator(app_iter, close_func)
-
-    return app_iter, response[0], Headers(response[1])
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/testapp.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/testapp.py
deleted file mode 100644
index 595555a09..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/testapp.py
+++ /dev/null
@@ -1,230 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.testapp
-    ~~~~~~~~~~~~~~~~
-
-    Provide a small test application that can be used to test a WSGI server
-    and check it for WSGI compliance.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import sys
-import werkzeug
-from textwrap import wrap
-from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
-from werkzeug.utils import escape
-import base64
-
-logo = Response(base64.b64decode('''
-R0lGODlhoACgAOMIAAEDACwpAEpCAGdgAJaKAM28AOnVAP3rAP/////////
-//////////////////////yH5BAEKAAgALAAAAACgAKAAAAT+EMlJq704680R+F0ojmRpnuj0rWnrv
-nB8rbRs33gu0bzu/0AObxgsGn3D5HHJbCUFyqZ0ukkSDlAidctNFg7gbI9LZlrBaHGtzAae0eloe25
-7w9EDOX2fst/xenyCIn5/gFqDiVVDV4aGeYiKkhSFjnCQY5OTlZaXgZp8nJ2ekaB0SQOjqphrpnOiq
-ncEn65UsLGytLVmQ6m4sQazpbtLqL/HwpnER8bHyLrLOc3Oz8PRONPU1crXN9na263dMt/g4SzjMeX
-m5yDpLqgG7OzJ4u8lT/P69ej3JPn69kHzN2OIAHkB9RUYSFCFQYQJFTIkCDBiwoXWGnowaLEjRm7+G
-p9A7Hhx4rUkAUaSLJlxHMqVMD/aSycSZkyTplCqtGnRAM5NQ1Ly5OmzZc6gO4d6DGAUKA+hSocWYAo
-SlM6oUWX2O/o0KdaVU5vuSQLAa0ADwQgMEMB2AIECZhVSnTno6spgbtXmHcBUrQACcc2FrTrWS8wAf
-78cMFBgwIBgbN+qvTt3ayikRBk7BoyGAGABAdYyfdzRQGV3l4coxrqQ84GpUBmrdR3xNIDUPAKDBSA
-ADIGDhhqTZIWaDcrVX8EsbNzbkvCOxG8bN5w8ly9H8jyTJHC6DFndQydbguh2e/ctZJFXRxMAqqPVA
-tQH5E64SPr1f0zz7sQYjAHg0In+JQ11+N2B0XXBeeYZgBZFx4tqBToiTCPv0YBgQv8JqA6BEf6RhXx
-w1ENhRBnWV8ctEX4Ul2zc3aVGcQNC2KElyTDYyYUWvShdjDyMOGMuFjqnII45aogPhz/CodUHFwaDx
-lTgsaOjNyhGWJQd+lFoAGk8ObghI0kawg+EV5blH3dr+digkYuAGSaQZFHFz2P/cTaLmhF52QeSb45
-Jwxd+uSVGHlqOZpOeJpCFZ5J+rkAkFjQ0N1tah7JJSZUFNsrkeJUJMIBi8jyaEKIhKPomnC91Uo+NB
-yyaJ5umnnpInIFh4t6ZSpGaAVmizqjpByDegYl8tPE0phCYrhcMWSv+uAqHfgH88ak5UXZmlKLVJhd
-dj78s1Fxnzo6yUCrV6rrDOkluG+QzCAUTbCwf9SrmMLzK6p+OPHx7DF+bsfMRq7Ec61Av9i6GLw23r
-idnZ+/OO0a99pbIrJkproCQMA17OPG6suq3cca5ruDfXCCDoS7BEdvmJn5otdqscn+uogRHHXs8cbh
-EIfYaDY1AkrC0cqwcZpnM6ludx72x0p7Fo/hZAcpJDjax0UdHavMKAbiKltMWCF3xxh9k25N/Viud8
-ba78iCvUkt+V6BpwMlErmcgc502x+u1nSxJSJP9Mi52awD1V4yB/QHONsnU3L+A/zR4VL/indx/y64
-gqcj+qgTeweM86f0Qy1QVbvmWH1D9h+alqg254QD8HJXHvjQaGOqEqC22M54PcftZVKVSQG9jhkv7C
-JyTyDoAJfPdu8v7DRZAxsP/ky9MJ3OL36DJfCFPASC3/aXlfLOOON9vGZZHydGf8LnxYJuuVIbl83y
-Az5n/RPz07E+9+zw2A2ahz4HxHo9Kt79HTMx1Q7ma7zAzHgHqYH0SoZWyTuOLMiHwSfZDAQTn0ajk9
-YQqodnUYjByQZhZak9Wu4gYQsMyEpIOAOQKze8CmEF45KuAHTvIDOfHJNipwoHMuGHBnJElUoDmAyX
-c2Qm/R8Ah/iILCCJOEokGowdhDYc/yoL+vpRGwyVSCWFYZNljkhEirGXsalWcAgOdeAdoXcktF2udb
-qbUhjWyMQxYO01o6KYKOr6iK3fE4MaS+DsvBsGOBaMb0Y6IxADaJhFICaOLmiWTlDAnY1KzDG4ambL
-cWBA8mUzjJsN2KjSaSXGqMCVXYpYkj33mcIApyhQf6YqgeNAmNvuC0t4CsDbSshZJkCS1eNisKqlyG
-cF8G2JeiDX6tO6Mv0SmjCa3MFb0bJaGPMU0X7c8XcpvMaOQmCajwSeY9G0WqbBmKv34DsMIEztU6Y2
-KiDlFdt6jnCSqx7Dmt6XnqSKaFFHNO5+FmODxMCWBEaco77lNDGXBM0ECYB/+s7nKFdwSF5hgXumQe
-EZ7amRg39RHy3zIjyRCykQh8Zo2iviRKyTDn/zx6EefptJj2Cw+Ep2FSc01U5ry4KLPYsTyWnVGnvb
-UpyGlhjBUljyjHhWpf8OFaXwhp9O4T1gU9UeyPPa8A2l0p1kNqPXEVRm1AOs1oAGZU596t6SOR2mcB
-Oco1srWtkaVrMUzIErrKri85keKqRQYX9VX0/eAUK1hrSu6HMEX3Qh2sCh0q0D2CtnUqS4hj62sE/z
-aDs2Sg7MBS6xnQeooc2R2tC9YrKpEi9pLXfYXp20tDCpSP8rKlrD4axprb9u1Df5hSbz9QU0cRpfgn
-kiIzwKucd0wsEHlLpe5yHXuc6FrNelOl7pY2+11kTWx7VpRu97dXA3DO1vbkhcb4zyvERYajQgAADs
-='''), mimetype='image/png')
-
-
-TEMPLATE = u'''\
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
-<title>WSGI Information</title>
-<style type="text/css">
-  @import url(http://fonts.googleapis.com/css?family=Ubuntu);
-
-  body       { font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
-               'Verdana', sans-serif; background-color: white; color: #000;
-               font-size: 15px; text-align: center; }
-  #logo      { float: right; padding: 0 0 10px 10px; }
-  div.box    { text-align: left; width: 45em; margin: auto; padding: 50px 0;
-               background-color: white; }
-  h1, h2     { font-family: 'Ubuntu', 'Lucida Grande', 'Lucida Sans Unicode',
-               'Geneva', 'Verdana', sans-serif; font-weight: normal; }
-  h1         { margin: 0 0 30px 0; }
-  h2         { font-size: 1.4em; margin: 1em 0 0.5em 0; }
-  table      { width: 100%%; border-collapse: collapse; border: 1px solid #AFC5C9 }
-  table th   { background-color: #AFC1C4; color: white; font-size: 0.72em;
-               font-weight: normal; width: 18em; vertical-align: top;
-               padding: 0.5em 0 0.1em 0.5em; }
-  table td   { border: 1px solid #AFC5C9; padding: 0.1em 0 0.1em 0.5em; }
-  code       { font-family: 'Consolas', 'Monaco', 'Bitstream Vera Sans Mono',
-               monospace; font-size: 0.7em; }
-  ul li      { line-height: 1.5em; }
-  ul.path    { font-size: 0.7em; margin: 0 -30px; padding: 8px 30px;
-               list-style: none; background: #E8EFF0; }
-  ul.path li { line-height: 1.6em; }
-  li.virtual { color: #999; text-decoration: underline; }
-  li.exp     { background: white; }
-</style>
-<div class="box">
-  <img src="?resource=logo" id="logo" alt="[The Werkzeug Logo]" />
-  <h1>WSGI Information</h1>
-  <p>
-    This page displays all available information about the WSGI server and
-    the underlying Python interpreter.
-  <h2 id="python-interpreter">Python Interpreter</h2>
-  <table>
-    <tr>
-      <th>Python Version
-      <td>%(python_version)s
-    <tr>
-      <th>Platform
-      <td>%(platform)s [%(os)s]
-    <tr>
-      <th>API Version
-      <td>%(api_version)s
-    <tr>
-      <th>Byteorder
-      <td>%(byteorder)s
-    <tr>
-      <th>Werkzeug Version
-      <td>%(werkzeug_version)s
-  </table>
-  <h2 id="wsgi-environment">WSGI Environment</h2>
-  <table>%(wsgi_env)s</table>
-  <h2 id="installed-eggs">Installed Eggs</h2>
-  <p>
-    The following python packages were installed on the system as
-    Python eggs:
-  <ul>%(python_eggs)s</ul>
-  <h2 id="sys-path">System Path</h2>
-  <p>
-    The following paths are the current contents of the load path.  The
-    following entries are looked up for Python packages.  Note that not
-    all items in this path are folders.  Gray and underlined items are
-    entries pointing to invalid resources or used by custom import hooks
-    such as the zip importer.
-  <p>
-    Items with a bright background were expanded for display from a relative
-    path.  If you encounter such paths in the output you might want to check
-    your setup as relative paths are usually problematic in multithreaded
-    environments.
-  <ul class="path">%(sys_path)s</ul>
-</div>
-'''
-
-
-def iter_sys_path():
-    if os.name == 'posix':
-        def strip(x):
-            prefix = os.path.expanduser('~')
-            if x.startswith(prefix):
-                x = '~' + x[len(prefix):]
-            return x
-    else:
-        strip = lambda x: x
-
-    cwd = os.path.abspath(os.getcwd())
-    for item in sys.path:
-        path = os.path.join(cwd, item or os.path.curdir)
-        yield strip(os.path.normpath(path)), \
-            not os.path.isdir(path), path != item
-
-
-def render_testapp(req):
-    try:
-        import pkg_resources
-    except ImportError:
-        eggs = ()
-    else:
-        eggs = sorted(pkg_resources.working_set,
-                      key=lambda x: x.project_name.lower())
-    python_eggs = []
-    for egg in eggs:
-        try:
-            version = egg.version
-        except (ValueError, AttributeError):
-            version = 'unknown'
-        python_eggs.append('<li>%s <small>[%s]</small>' % (
-            escape(egg.project_name),
-            escape(version)
-        ))
-
-    wsgi_env = []
-    sorted_environ = sorted(req.environ.items(),
-                            key=lambda x: repr(x[0]).lower())
-    for key, value in sorted_environ:
-        wsgi_env.append('<tr><th>%s<td><code>%s</code>' % (
-            escape(str(key)),
-            ' '.join(wrap(escape(repr(value))))
-        ))
-
-    sys_path = []
-    for item, virtual, expanded in iter_sys_path():
-        class_ = []
-        if virtual:
-            class_.append('virtual')
-        if expanded:
-            class_.append('exp')
-        sys_path.append('<li%s>%s' % (
-            class_ and ' class="%s"' % ' '.join(class_) or '',
-            escape(item)
-        ))
-
-    return (TEMPLATE % {
-        'python_version':   '<br>'.join(escape(sys.version).splitlines()),
-        'platform':         escape(sys.platform),
-        'os':               escape(os.name),
-        'api_version':      sys.api_version,
-        'byteorder':        sys.byteorder,
-        'werkzeug_version': werkzeug.__version__,
-        'python_eggs':      '\n'.join(python_eggs),
-        'wsgi_env':         '\n'.join(wsgi_env),
-        'sys_path':         '\n'.join(sys_path)
-    }).encode('utf-8')
-
-
-def test_app(environ, start_response):
-    """Simple test application that dumps the environment.  You can use
-    it to check if Werkzeug is working properly:
-
-    .. sourcecode:: pycon
-
-        >>> from werkzeug.serving import run_simple
-        >>> from werkzeug.testapp import test_app
-        >>> run_simple('localhost', 3000, test_app)
-         * Running on http://localhost:3000/
-
-    The application displays important information from the WSGI environment,
-    the Python interpreter and the installed libraries.
-    """
-    req = Request(environ, populate_request=False)
-    if req.args.get('resource') == 'logo':
-        response = logo
-    else:
-        response = Response(render_testapp(req), mimetype='text/html')
-    return response(environ, start_response)
-
-
-if __name__ == '__main__':
-    from werkzeug.serving import run_simple
-    run_simple('localhost', 5000, test_app, use_reloader=True)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/urls.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/urls.py
deleted file mode 100644
index 5bd9a40d8..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/urls.py
+++ /dev/null
@@ -1,1007 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.urls
-    ~~~~~~~~~~~~~
-
-    ``werkzeug.urls`` used to provide several wrapper functions for Python 2
-    urlparse, whose main purpose were to work around the behavior of the Py2
-    stdlib and its lack of unicode support. While this was already a somewhat
-    inconvenient situation, it got even more complicated because Python 3's
-    ``urllib.parse`` actually does handle unicode properly. In other words,
-    this module would wrap two libraries with completely different behavior. So
-    now this module contains a 2-and-3-compatible backport of Python 3's
-    ``urllib.parse``, which is mostly API-compatible.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import re
-from werkzeug._compat import text_type, PY2, to_unicode, \
-    to_native, implements_to_string, try_coerce_native, \
-    normalize_string_tuple, make_literal_wrapper, \
-    fix_tuple_repr
-from werkzeug._internal import _encode_idna, _decode_idna
-from werkzeug.datastructures import MultiDict, iter_multi_items
-from collections import namedtuple
-
-
-# A regular expression for what a valid schema looks like
-_scheme_re = re.compile(r'^[a-zA-Z0-9+-.]+$')
-
-# Characters that are safe in any part of an URL.
-_always_safe = (b'abcdefghijklmnopqrstuvwxyz'
-                b'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.-+')
-
-_hexdigits = '0123456789ABCDEFabcdef'
-_hextobyte = dict(
-    ((a + b).encode(), int(a + b, 16))
-    for a in _hexdigits for b in _hexdigits
-)
-_bytetohex = [
-    ('%%%02X' % char).encode('ascii') for char in range(256)
-]
-
-
-_URLTuple = fix_tuple_repr(namedtuple(
-    '_URLTuple',
-    ['scheme', 'netloc', 'path', 'query', 'fragment']
-))
-
-
-class BaseURL(_URLTuple):
-
-    '''Superclass of :py:class:`URL` and :py:class:`BytesURL`.'''
-    __slots__ = ()
-
-    def replace(self, **kwargs):
-        """Return an URL with the same values, except for those parameters
-        given new values by whichever keyword arguments are specified."""
-        return self._replace(**kwargs)
-
-    @property
-    def host(self):
-        """The host part of the URL if available, otherwise `None`.  The
-        host is either the hostname or the IP address mentioned in the
-        URL.  It will not contain the port.
-        """
-        return self._split_host()[0]
-
-    @property
-    def ascii_host(self):
-        """Works exactly like :attr:`host` but will return a result that
-        is restricted to ASCII.  If it finds a netloc that is not ASCII
-        it will attempt to idna decode it.  This is useful for socket
-        operations when the URL might include internationalized characters.
-        """
-        rv = self.host
-        if rv is not None and isinstance(rv, text_type):
-            try:
-                rv = _encode_idna(rv)
-            except UnicodeError:
-                rv = rv.encode('ascii', 'ignore')
-        return to_native(rv, 'ascii', 'ignore')
-
-    @property
-    def port(self):
-        """The port in the URL as an integer if it was present, `None`
-        otherwise.  This does not fill in default ports.
-        """
-        try:
-            rv = int(to_native(self._split_host()[1]))
-            if 0 <= rv <= 65535:
-                return rv
-        except (ValueError, TypeError):
-            pass
-
-    @property
-    def auth(self):
-        """The authentication part in the URL if available, `None`
-        otherwise.
-        """
-        return self._split_netloc()[0]
-
-    @property
-    def username(self):
-        """The username if it was part of the URL, `None` otherwise.
-        This undergoes URL decoding and will always be a unicode string.
-        """
-        rv = self._split_auth()[0]
-        if rv is not None:
-            return _url_unquote_legacy(rv)
-
-    @property
-    def raw_username(self):
-        """The username if it was part of the URL, `None` otherwise.
-        Unlike :attr:`username` this one is not being decoded.
-        """
-        return self._split_auth()[0]
-
-    @property
-    def password(self):
-        """The password if it was part of the URL, `None` otherwise.
-        This undergoes URL decoding and will always be a unicode string.
-        """
-        rv = self._split_auth()[1]
-        if rv is not None:
-            return _url_unquote_legacy(rv)
-
-    @property
-    def raw_password(self):
-        """The password if it was part of the URL, `None` otherwise.
-        Unlike :attr:`password` this one is not being decoded.
-        """
-        return self._split_auth()[1]
-
-    def decode_query(self, *args, **kwargs):
-        """Decodes the query part of the URL.  Ths is a shortcut for
-        calling :func:`url_decode` on the query argument.  The arguments and
-        keyword arguments are forwarded to :func:`url_decode` unchanged.
-        """
-        return url_decode(self.query, *args, **kwargs)
-
-    def join(self, *args, **kwargs):
-        """Joins this URL with another one.  This is just a convenience
-        function for calling into :meth:`url_join` and then parsing the
-        return value again.
-        """
-        return url_parse(url_join(self, *args, **kwargs))
-
-    def to_url(self):
-        """Returns a URL string or bytes depending on the type of the
-        information stored.  This is just a convenience function
-        for calling :meth:`url_unparse` for this URL.
-        """
-        return url_unparse(self)
-
-    def decode_netloc(self):
-        """Decodes the netloc part into a string."""
-        rv = _decode_idna(self.host or '')
-
-        if ':' in rv:
-            rv = '[%s]' % rv
-        port = self.port
-        if port is not None:
-            rv = '%s:%d' % (rv, port)
-        auth = ':'.join(filter(None, [
-            _url_unquote_legacy(self.raw_username or '', '/:%@'),
-            _url_unquote_legacy(self.raw_password or '', '/:%@'),
-        ]))
-        if auth:
-            rv = '%s@%s' % (auth, rv)
-        return rv
-
-    def to_uri_tuple(self):
-        """Returns a :class:`BytesURL` tuple that holds a URI.  This will
-        encode all the information in the URL properly to ASCII using the
-        rules a web browser would follow.
-
-        It's usually more interesting to directly call :meth:`iri_to_uri` which
-        will return a string.
-        """
-        return url_parse(iri_to_uri(self).encode('ascii'))
-
-    def to_iri_tuple(self):
-        """Returns a :class:`URL` tuple that holds a IRI.  This will try
-        to decode as much information as possible in the URL without
-        losing information similar to how a web browser does it for the
-        URL bar.
-
-        It's usually more interesting to directly call :meth:`uri_to_iri` which
-        will return a string.
-        """
-        return url_parse(uri_to_iri(self))
-
-    def get_file_location(self, pathformat=None):
-        """Returns a tuple with the location of the file in the form
-        ``(server, location)``.  If the netloc is empty in the URL or
-        points to localhost, it's represented as ``None``.
-
-        The `pathformat` by default is autodetection but needs to be set
-        when working with URLs of a specific system.  The supported values
-        are ``'windows'`` when working with Windows or DOS paths and
-        ``'posix'`` when working with posix paths.
-
-        If the URL does not point to to a local file, the server and location
-        are both represented as ``None``.
-
-        :param pathformat: The expected format of the path component.
-                           Currently ``'windows'`` and ``'posix'`` are
-                           supported.  Defaults to ``None`` which is
-                           autodetect.
-        """
-        if self.scheme != 'file':
-            return None, None
-
-        path = url_unquote(self.path)
-        host = self.netloc or None
-
-        if pathformat is None:
-            if os.name == 'nt':
-                pathformat = 'windows'
-            else:
-                pathformat = 'posix'
-
-        if pathformat == 'windows':
-            if path[:1] == '/' and path[1:2].isalpha() and path[2:3] in '|:':
-                path = path[1:2] + ':' + path[3:]
-            windows_share = path[:3] in ('\\' * 3, '/' * 3)
-            import ntpath
-            path = ntpath.normpath(path)
-            # Windows shared drives are represented as ``\\host\\directory``.
-            # That results in a URL like ``file://///host/directory``, and a
-            # path like ``///host/directory``. We need to special-case this
-            # because the path contains the hostname.
-            if windows_share and host is None:
-                parts = path.lstrip('\\').split('\\', 1)
-                if len(parts) == 2:
-                    host, path = parts
-                else:
-                    host = parts[0]
-                    path = ''
-        elif pathformat == 'posix':
-            import posixpath
-            path = posixpath.normpath(path)
-        else:
-            raise TypeError('Invalid path format %s' % repr(pathformat))
-
-        if host in ('127.0.0.1', '::1', 'localhost'):
-            host = None
-
-        return host, path
-
-    def _split_netloc(self):
-        if self._at in self.netloc:
-            return self.netloc.split(self._at, 1)
-        return None, self.netloc
-
-    def _split_auth(self):
-        auth = self._split_netloc()[0]
-        if not auth:
-            return None, None
-        if self._colon not in auth:
-            return auth, None
-        return auth.split(self._colon, 1)
-
-    def _split_host(self):
-        rv = self._split_netloc()[1]
-        if not rv:
-            return None, None
-
-        if not rv.startswith(self._lbracket):
-            if self._colon in rv:
-                return rv.split(self._colon, 1)
-            return rv, None
-
-        idx = rv.find(self._rbracket)
-        if idx < 0:
-            return rv, None
-
-        host = rv[1:idx]
-        rest = rv[idx + 1:]
-        if rest.startswith(self._colon):
-            return host, rest[1:]
-        return host, None
-
-
-@implements_to_string
-class URL(BaseURL):
-
-    """Represents a parsed URL.  This behaves like a regular tuple but
-    also has some extra attributes that give further insight into the
-    URL.
-    """
-    __slots__ = ()
-    _at = '@'
-    _colon = ':'
-    _lbracket = '['
-    _rbracket = ']'
-
-    def __str__(self):
-        return self.to_url()
-
-    def encode_netloc(self):
-        """Encodes the netloc part to an ASCII safe URL as bytes."""
-        rv = self.ascii_host or ''
-        if ':' in rv:
-            rv = '[%s]' % rv
-        port = self.port
-        if port is not None:
-            rv = '%s:%d' % (rv, port)
-        auth = ':'.join(filter(None, [
-            url_quote(self.raw_username or '', 'utf-8', 'strict', '/:%'),
-            url_quote(self.raw_password or '', 'utf-8', 'strict', '/:%'),
-        ]))
-        if auth:
-            rv = '%s@%s' % (auth, rv)
-        return to_native(rv)
-
-    def encode(self, charset='utf-8', errors='replace'):
-        """Encodes the URL to a tuple made out of bytes.  The charset is
-        only being used for the path, query and fragment.
-        """
-        return BytesURL(
-            self.scheme.encode('ascii'),
-            self.encode_netloc(),
-            self.path.encode(charset, errors),
-            self.query.encode(charset, errors),
-            self.fragment.encode(charset, errors)
-        )
-
-
-class BytesURL(BaseURL):
-
-    """Represents a parsed URL in bytes."""
-    __slots__ = ()
-    _at = b'@'
-    _colon = b':'
-    _lbracket = b'['
-    _rbracket = b']'
-
-    def __str__(self):
-        return self.to_url().decode('utf-8', 'replace')
-
-    def encode_netloc(self):
-        """Returns the netloc unchanged as bytes."""
-        return self.netloc
-
-    def decode(self, charset='utf-8', errors='replace'):
-        """Decodes the URL to a tuple made out of strings.  The charset is
-        only being used for the path, query and fragment.
-        """
-        return URL(
-            self.scheme.decode('ascii'),
-            self.decode_netloc(),
-            self.path.decode(charset, errors),
-            self.query.decode(charset, errors),
-            self.fragment.decode(charset, errors)
-        )
-
-
-def _unquote_to_bytes(string, unsafe=''):
-    if isinstance(string, text_type):
-        string = string.encode('utf-8')
-    if isinstance(unsafe, text_type):
-        unsafe = unsafe.encode('utf-8')
-    unsafe = frozenset(bytearray(unsafe))
-    bits = iter(string.split(b'%'))
-    result = bytearray(next(bits, b''))
-    for item in bits:
-        try:
-            char = _hextobyte[item[:2]]
-            if char in unsafe:
-                raise KeyError()
-            result.append(char)
-            result.extend(item[2:])
-        except KeyError:
-            result.extend(b'%')
-            result.extend(item)
-    return bytes(result)
-
-
-def _url_encode_impl(obj, charset, encode_keys, sort, key):
-    iterable = iter_multi_items(obj)
-    if sort:
-        iterable = sorted(iterable, key=key)
-    for key, value in iterable:
-        if value is None:
-            continue
-        if not isinstance(key, bytes):
-            key = text_type(key).encode(charset)
-        if not isinstance(value, bytes):
-            value = text_type(value).encode(charset)
-        yield url_quote_plus(key) + '=' + url_quote_plus(value)
-
-
-def _url_unquote_legacy(value, unsafe=''):
-    try:
-        return url_unquote(value, charset='utf-8',
-                           errors='strict', unsafe=unsafe)
-    except UnicodeError:
-        return url_unquote(value, charset='latin1', unsafe=unsafe)
-
-
-def url_parse(url, scheme=None, allow_fragments=True):
-    """Parses a URL from a string into a :class:`URL` tuple.  If the URL
-    is lacking a scheme it can be provided as second argument. Otherwise,
-    it is ignored.  Optionally fragments can be stripped from the URL
-    by setting `allow_fragments` to `False`.
-
-    The inverse of this function is :func:`url_unparse`.
-
-    :param url: the URL to parse.
-    :param scheme: the default schema to use if the URL is schemaless.
-    :param allow_fragments: if set to `False` a fragment will be removed
-                            from the URL.
-    """
-    s = make_literal_wrapper(url)
-    is_text_based = isinstance(url, text_type)
-
-    if scheme is None:
-        scheme = s('')
-    netloc = query = fragment = s('')
-    i = url.find(s(':'))
-    if i > 0 and _scheme_re.match(to_native(url[:i], errors='replace')):
-        # make sure "iri" is not actually a port number (in which case
-        # "scheme" is really part of the path)
-        rest = url[i + 1:]
-        if not rest or any(c not in s('0123456789') for c in rest):
-            # not a port number
-            scheme, url = url[:i].lower(), rest
-
-    if url[:2] == s('//'):
-        delim = len(url)
-        for c in s('/?#'):
-            wdelim = url.find(c, 2)
-            if wdelim >= 0:
-                delim = min(delim, wdelim)
-        netloc, url = url[2:delim], url[delim:]
-        if (s('[') in netloc and s(']') not in netloc) or \
-           (s(']') in netloc and s('[') not in netloc):
-            raise ValueError('Invalid IPv6 URL')
-
-    if allow_fragments and s('#') in url:
-        url, fragment = url.split(s('#'), 1)
-    if s('?') in url:
-        url, query = url.split(s('?'), 1)
-
-    result_type = is_text_based and URL or BytesURL
-    return result_type(scheme, netloc, url, query, fragment)
-
-
-def url_quote(string, charset='utf-8', errors='strict', safe='/:', unsafe=''):
-    """URL encode a single string with a given encoding.
-
-    :param s: the string to quote.
-    :param charset: the charset to be used.
-    :param safe: an optional sequence of safe characters.
-    :param unsafe: an optional sequence of unsafe characters.
-
-    .. versionadded:: 0.9.2
-       The `unsafe` parameter was added.
-    """
-    if not isinstance(string, (text_type, bytes, bytearray)):
-        string = text_type(string)
-    if isinstance(string, text_type):
-        string = string.encode(charset, errors)
-    if isinstance(safe, text_type):
-        safe = safe.encode(charset, errors)
-    if isinstance(unsafe, text_type):
-        unsafe = unsafe.encode(charset, errors)
-    safe = frozenset(bytearray(safe) + _always_safe) - frozenset(bytearray(unsafe))
-    rv = bytearray()
-    for char in bytearray(string):
-        if char in safe:
-            rv.append(char)
-        else:
-            rv.extend(_bytetohex[char])
-    return to_native(bytes(rv))
-
-
-def url_quote_plus(string, charset='utf-8', errors='strict', safe=''):
-    """URL encode a single string with the given encoding and convert
-    whitespace to "+".
-
-    :param s: The string to quote.
-    :param charset: The charset to be used.
-    :param safe: An optional sequence of safe characters.
-    """
-    return url_quote(string, charset, errors, safe + ' ', '+').replace(' ', '+')
-
-
-def url_unparse(components):
-    """The reverse operation to :meth:`url_parse`.  This accepts arbitrary
-    as well as :class:`URL` tuples and returns a URL as a string.
-
-    :param components: the parsed URL as tuple which should be converted
-                       into a URL string.
-    """
-    scheme, netloc, path, query, fragment = \
-        normalize_string_tuple(components)
-    s = make_literal_wrapper(scheme)
-    url = s('')
-
-    # We generally treat file:///x and file:/x the same which is also
-    # what browsers seem to do.  This also allows us to ignore a schema
-    # register for netloc utilization or having to differenciate between
-    # empty and missing netloc.
-    if netloc or (scheme and path.startswith(s('/'))):
-        if path and path[:1] != s('/'):
-            path = s('/') + path
-        url = s('//') + (netloc or s('')) + path
-    elif path:
-        url += path
-    if scheme:
-        url = scheme + s(':') + url
-    if query:
-        url = url + s('?') + query
-    if fragment:
-        url = url + s('#') + fragment
-    return url
-
-
-def url_unquote(string, charset='utf-8', errors='replace', unsafe=''):
-    """URL decode a single string with a given encoding.  If the charset
-    is set to `None` no unicode decoding is performed and raw bytes
-    are returned.
-
-    :param s: the string to unquote.
-    :param charset: the charset of the query string.  If set to `None`
-                    no unicode decoding will take place.
-    :param errors: the error handling for the charset decoding.
-    """
-    rv = _unquote_to_bytes(string, unsafe)
-    if charset is not None:
-        rv = rv.decode(charset, errors)
-    return rv
-
-
-def url_unquote_plus(s, charset='utf-8', errors='replace'):
-    """URL decode a single string with the given `charset` and decode "+" to
-    whitespace.
-
-    Per default encoding errors are ignored.  If you want a different behavior
-    you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
-    :exc:`HTTPUnicodeError` is raised.
-
-    :param s: The string to unquote.
-    :param charset: the charset of the query string.  If set to `None`
-                    no unicode decoding will take place.
-    :param errors: The error handling for the `charset` decoding.
-    """
-    if isinstance(s, text_type):
-        s = s.replace(u'+', u' ')
-    else:
-        s = s.replace(b'+', b' ')
-    return url_unquote(s, charset, errors)
-
-
-def url_fix(s, charset='utf-8'):
-    r"""Sometimes you get an URL by a user that just isn't a real URL because
-    it contains unsafe characters like ' ' and so on. This function can fix
-    some of the problems in a similar way browsers handle data entered by the
-    user:
-
-    >>> url_fix(u'http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)')
-    'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)'
-
-    :param s: the string with the URL to fix.
-    :param charset: The target charset for the URL if the url was given as
-                    unicode string.
-    """
-    # First step is to switch to unicode processing and to convert
-    # backslashes (which are invalid in URLs anyways) to slashes.  This is
-    # consistent with what Chrome does.
-    s = to_unicode(s, charset, 'replace').replace('\\', '/')
-
-    # For the specific case that we look like a malformed windows URL
-    # we want to fix this up manually:
-    if s.startswith('file://') and s[7:8].isalpha() and s[8:10] in (':/', '|/'):
-        s = 'file:///' + s[7:]
-
-    url = url_parse(s)
-    path = url_quote(url.path, charset, safe='/%+$!*\'(),')
-    qs = url_quote_plus(url.query, charset, safe=':&%=+$!*\'(),')
-    anchor = url_quote_plus(url.fragment, charset, safe=':&%=+$!*\'(),')
-    return to_native(url_unparse((url.scheme, url.encode_netloc(),
-                                  path, qs, anchor)))
-
-
-def uri_to_iri(uri, charset='utf-8', errors='replace'):
-    r"""
-    Converts a URI in a given charset to a IRI.
-
-    Examples for URI versus IRI:
-
-    >>> uri_to_iri(b'http://xn--n3h.net/')
-    u'http://\u2603.net/'
-    >>> uri_to_iri(b'http://%C3%BCser:p%C3%A4ssword@xn--n3h.net/p%C3%A5th')
-    u'http://\xfcser:p\xe4ssword@\u2603.net/p\xe5th'
-
-    Query strings are left unchanged:
-
-    >>> uri_to_iri('/?foo=24&x=%26%2f')
-    u'/?foo=24&x=%26%2f'
-
-    .. versionadded:: 0.6
-
-    :param uri: The URI to convert.
-    :param charset: The charset of the URI.
-    :param errors: The error handling on decode.
-    """
-    if isinstance(uri, tuple):
-        uri = url_unparse(uri)
-    uri = url_parse(to_unicode(uri, charset))
-    path = url_unquote(uri.path, charset, errors, '%/;?')
-    query = url_unquote(uri.query, charset, errors, '%;/?:@&=+,$#')
-    fragment = url_unquote(uri.fragment, charset, errors, '%;/?:@&=+,$#')
-    return url_unparse((uri.scheme, uri.decode_netloc(),
-                        path, query, fragment))
-
-
-def iri_to_uri(iri, charset='utf-8', errors='strict', safe_conversion=False):
-    r"""
-    Converts any unicode based IRI to an acceptable ASCII URI. Werkzeug always
-    uses utf-8 URLs internally because this is what browsers and HTTP do as
-    well. In some places where it accepts an URL it also accepts a unicode IRI
-    and converts it into a URI.
-
-    Examples for IRI versus URI:
-
-    >>> iri_to_uri(u'http://☃.net/')
-    'http://xn--n3h.net/'
-    >>> iri_to_uri(u'http://üser:pässword@☃.net/påth')
-    'http://%C3%BCser:p%C3%A4ssword@xn--n3h.net/p%C3%A5th'
-
-    There is a general problem with IRI and URI conversion with some
-    protocols that appear in the wild that are in violation of the URI
-    specification.  In places where Werkzeug goes through a forced IRI to
-    URI conversion it will set the `safe_conversion` flag which will
-    not perform a conversion if the end result is already ASCII.  This
-    can mean that the return value is not an entirely correct URI but
-    it will not destroy such invalid URLs in the process.
-
-    As an example consider the following two IRIs::
-
-      magnet:?xt=uri:whatever
-      itms-services://?action=download-manifest
-
-    The internal representation after parsing of those URLs is the same
-    and there is no way to reconstruct the original one.  If safe
-    conversion is enabled however this function becomes a noop for both of
-    those strings as they both can be considered URIs.
-
-    .. versionadded:: 0.6
-
-    .. versionchanged:: 0.9.6
-       The `safe_conversion` parameter was added.
-
-    :param iri: The IRI to convert.
-    :param charset: The charset for the URI.
-    :param safe_conversion: indicates if a safe conversion should take place.
-                            For more information see the explanation above.
-    """
-    if isinstance(iri, tuple):
-        iri = url_unparse(iri)
-
-    if safe_conversion:
-        try:
-            native_iri = to_native(iri)
-            ascii_iri = to_native(iri).encode('ascii')
-            if ascii_iri.split() == [ascii_iri]:
-                return native_iri
-        except UnicodeError:
-            pass
-
-    iri = url_parse(to_unicode(iri, charset, errors))
-
-    netloc = iri.encode_netloc()
-    path = url_quote(iri.path, charset, errors, '/:~+%')
-    query = url_quote(iri.query, charset, errors, '%&[]:;$*()+,!?*/=')
-    fragment = url_quote(iri.fragment, charset, errors, '=%&[]:;$()+,!?*/')
-
-    return to_native(url_unparse((iri.scheme, netloc,
-                                  path, query, fragment)))
-
-
-def url_decode(s, charset='utf-8', decode_keys=False, include_empty=True,
-               errors='replace', separator='&', cls=None):
-    """
-    Parse a querystring and return it as :class:`MultiDict`.  There is a
-    difference in key decoding on different Python versions.  On Python 3
-    keys will always be fully decoded whereas on Python 2, keys will
-    remain bytestrings if they fit into ASCII.  On 2.x keys can be forced
-    to be unicode by setting `decode_keys` to `True`.
-
-    If the charset is set to `None` no unicode decoding will happen and
-    raw bytes will be returned.
-
-    Per default a missing value for a key will default to an empty key.  If
-    you don't want that behavior you can set `include_empty` to `False`.
-
-    Per default encoding errors are ignored.  If you want a different behavior
-    you can set `errors` to ``'replace'`` or ``'strict'``.  In strict mode a
-    `HTTPUnicodeError` is raised.
-
-    .. versionchanged:: 0.5
-       In previous versions ";" and "&" could be used for url decoding.
-       This changed in 0.5 where only "&" is supported.  If you want to
-       use ";" instead a different `separator` can be provided.
-
-       The `cls` parameter was added.
-
-    :param s: a string with the query string to decode.
-    :param charset: the charset of the query string.  If set to `None`
-                    no unicode decoding will take place.
-    :param decode_keys: Used on Python 2.x to control whether keys should
-                        be forced to be unicode objects.  If set to `True`
-                        then keys will be unicode in all cases. Otherwise,
-                        they remain `str` if they fit into ASCII.
-    :param include_empty: Set to `False` if you don't want empty values to
-                          appear in the dict.
-    :param errors: the decoding error behavior.
-    :param separator: the pair separator to be used, defaults to ``&``
-    :param cls: an optional dict class to use.  If this is not specified
-                       or `None` the default :class:`MultiDict` is used.
-    """
-    if cls is None:
-        cls = MultiDict
-    if isinstance(s, text_type) and not isinstance(separator, text_type):
-        separator = separator.decode(charset or 'ascii')
-    elif isinstance(s, bytes) and not isinstance(separator, bytes):
-        separator = separator.encode(charset or 'ascii')
-    return cls(_url_decode_impl(s.split(separator), charset, decode_keys,
-                                include_empty, errors))
-
-
-def url_decode_stream(stream, charset='utf-8', decode_keys=False,
-                      include_empty=True, errors='replace', separator='&',
-                      cls=None, limit=None, return_iterator=False):
-    """Works like :func:`url_decode` but decodes a stream.  The behavior
-    of stream and limit follows functions like
-    :func:`~werkzeug.wsgi.make_line_iter`.  The generator of pairs is
-    directly fed to the `cls` so you can consume the data while it's
-    parsed.
-
-    .. versionadded:: 0.8
-
-    :param stream: a stream with the encoded querystring
-    :param charset: the charset of the query string.  If set to `None`
-                    no unicode decoding will take place.
-    :param decode_keys: Used on Python 2.x to control whether keys should
-                        be forced to be unicode objects.  If set to `True`,
-                        keys will be unicode in all cases. Otherwise, they
-                        remain `str` if they fit into ASCII.
-    :param include_empty: Set to `False` if you don't want empty values to
-                          appear in the dict.
-    :param errors: the decoding error behavior.
-    :param separator: the pair separator to be used, defaults to ``&``
-    :param cls: an optional dict class to use.  If this is not specified
-                       or `None` the default :class:`MultiDict` is used.
-    :param limit: the content length of the URL data.  Not necessary if
-                  a limited stream is provided.
-    :param return_iterator: if set to `True` the `cls` argument is ignored
-                            and an iterator over all decoded pairs is
-                            returned
-    """
-    from werkzeug.wsgi import make_chunk_iter
-    if return_iterator:
-        cls = lambda x: x
-    elif cls is None:
-        cls = MultiDict
-    pair_iter = make_chunk_iter(stream, separator, limit)
-    return cls(_url_decode_impl(pair_iter, charset, decode_keys,
-                                include_empty, errors))
-
-
-def _url_decode_impl(pair_iter, charset, decode_keys, include_empty, errors):
-    for pair in pair_iter:
-        if not pair:
-            continue
-        s = make_literal_wrapper(pair)
-        equal = s('=')
-        if equal in pair:
-            key, value = pair.split(equal, 1)
-        else:
-            if not include_empty:
-                continue
-            key = pair
-            value = s('')
-        key = url_unquote_plus(key, charset, errors)
-        if charset is not None and PY2 and not decode_keys:
-            key = try_coerce_native(key)
-        yield key, url_unquote_plus(value, charset, errors)
-
-
-def url_encode(obj, charset='utf-8', encode_keys=False, sort=False, key=None,
-               separator=b'&'):
-    """URL encode a dict/`MultiDict`.  If a value is `None` it will not appear
-    in the result string.  Per default only values are encoded into the target
-    charset strings.  If `encode_keys` is set to ``True`` unicode keys are
-    supported too.
-
-    If `sort` is set to `True` the items are sorted by `key` or the default
-    sorting algorithm.
-
-    .. versionadded:: 0.5
-        `sort`, `key`, and `separator` were added.
-
-    :param obj: the object to encode into a query string.
-    :param charset: the charset of the query string.
-    :param encode_keys: set to `True` if you have unicode keys. (Ignored on
-                        Python 3.x)
-    :param sort: set to `True` if you want parameters to be sorted by `key`.
-    :param separator: the separator to be used for the pairs.
-    :param key: an optional function to be used for sorting.  For more details
-                check out the :func:`sorted` documentation.
-    """
-    separator = to_native(separator, 'ascii')
-    return separator.join(_url_encode_impl(obj, charset, encode_keys, sort, key))
-
-
-def url_encode_stream(obj, stream=None, charset='utf-8', encode_keys=False,
-                      sort=False, key=None, separator=b'&'):
-    """Like :meth:`url_encode` but writes the results to a stream
-    object.  If the stream is `None` a generator over all encoded
-    pairs is returned.
-
-    .. versionadded:: 0.8
-
-    :param obj: the object to encode into a query string.
-    :param stream: a stream to write the encoded object into or `None` if
-                   an iterator over the encoded pairs should be returned.  In
-                   that case the separator argument is ignored.
-    :param charset: the charset of the query string.
-    :param encode_keys: set to `True` if you have unicode keys. (Ignored on
-                        Python 3.x)
-    :param sort: set to `True` if you want parameters to be sorted by `key`.
-    :param separator: the separator to be used for the pairs.
-    :param key: an optional function to be used for sorting.  For more details
-                check out the :func:`sorted` documentation.
-    """
-    separator = to_native(separator, 'ascii')
-    gen = _url_encode_impl(obj, charset, encode_keys, sort, key)
-    if stream is None:
-        return gen
-    for idx, chunk in enumerate(gen):
-        if idx:
-            stream.write(separator)
-        stream.write(chunk)
-
-
-def url_join(base, url, allow_fragments=True):
-    """Join a base URL and a possibly relative URL to form an absolute
-    interpretation of the latter.
-
-    :param base: the base URL for the join operation.
-    :param url: the URL to join.
-    :param allow_fragments: indicates whether fragments should be allowed.
-    """
-    if isinstance(base, tuple):
-        base = url_unparse(base)
-    if isinstance(url, tuple):
-        url = url_unparse(url)
-
-    base, url = normalize_string_tuple((base, url))
-    s = make_literal_wrapper(base)
-
-    if not base:
-        return url
-    if not url:
-        return base
-
-    bscheme, bnetloc, bpath, bquery, bfragment = \
-        url_parse(base, allow_fragments=allow_fragments)
-    scheme, netloc, path, query, fragment = \
-        url_parse(url, bscheme, allow_fragments)
-    if scheme != bscheme:
-        return url
-    if netloc:
-        return url_unparse((scheme, netloc, path, query, fragment))
-    netloc = bnetloc
-
-    if path[:1] == s('/'):
-        segments = path.split(s('/'))
-    elif not path:
-        segments = bpath.split(s('/'))
-        if not query:
-            query = bquery
-    else:
-        segments = bpath.split(s('/'))[:-1] + path.split(s('/'))
-
-    # If the rightmost part is "./" we want to keep the slash but
-    # remove the dot.
-    if segments[-1] == s('.'):
-        segments[-1] = s('')
-
-    # Resolve ".." and "."
-    segments = [segment for segment in segments if segment != s('.')]
-    while 1:
-        i = 1
-        n = len(segments) - 1
-        while i < n:
-            if segments[i] == s('..') and \
-               segments[i - 1] not in (s(''), s('..')):
-                del segments[i - 1:i + 1]
-                break
-            i += 1
-        else:
-            break
-
-    # Remove trailing ".." if the URL is absolute
-    unwanted_marker = [s(''), s('..')]
-    while segments[:2] == unwanted_marker:
-        del segments[1]
-
-    path = s('/').join(segments)
-    return url_unparse((scheme, netloc, path, query, fragment))
-
-
-class Href(object):
-
-    """Implements a callable that constructs URLs with the given base. The
-    function can be called with any number of positional and keyword
-    arguments which than are used to assemble the URL.  Works with URLs
-    and posix paths.
-
-    Positional arguments are appended as individual segments to
-    the path of the URL:
-
-    >>> href = Href('/foo')
-    >>> href('bar', 23)
-    '/foo/bar/23'
-    >>> href('foo', bar=23)
-    '/foo/foo?bar=23'
-
-    If any of the arguments (positional or keyword) evaluates to `None` it
-    will be skipped.  If no keyword arguments are given the last argument
-    can be a :class:`dict` or :class:`MultiDict` (or any other dict subclass),
-    otherwise the keyword arguments are used for the query parameters, cutting
-    off the first trailing underscore of the parameter name:
-
-    >>> href(is_=42)
-    '/foo?is=42'
-    >>> href({'foo': 'bar'})
-    '/foo?foo=bar'
-
-    Combining of both methods is not allowed:
-
-    >>> href({'foo': 'bar'}, bar=42)
-    Traceback (most recent call last):
-      ...
-    TypeError: keyword arguments and query-dicts can't be combined
-
-    Accessing attributes on the href object creates a new href object with
-    the attribute name as prefix:
-
-    >>> bar_href = href.bar
-    >>> bar_href("blub")
-    '/foo/bar/blub'
-
-    If `sort` is set to `True` the items are sorted by `key` or the default
-    sorting algorithm:
-
-    >>> href = Href("/", sort=True)
-    >>> href(a=1, b=2, c=3)
-    '/?a=1&b=2&c=3'
-
-    .. versionadded:: 0.5
-        `sort` and `key` were added.
-    """
-
-    def __init__(self, base='./', charset='utf-8', sort=False, key=None):
-        if not base:
-            base = './'
-        self.base = base
-        self.charset = charset
-        self.sort = sort
-        self.key = key
-
-    def __getattr__(self, name):
-        if name[:2] == '__':
-            raise AttributeError(name)
-        base = self.base
-        if base[-1:] != '/':
-            base += '/'
-        return Href(url_join(base, name), self.charset, self.sort, self.key)
-
-    def __call__(self, *path, **query):
-        if path and isinstance(path[-1], dict):
-            if query:
-                raise TypeError('keyword arguments and query-dicts '
-                                'can\'t be combined')
-            query, path = path[-1], path[:-1]
-        elif query:
-            query = dict([(k.endswith('_') and k[:-1] or k, v)
-                          for k, v in query.items()])
-        path = '/'.join([to_unicode(url_quote(x, self.charset), 'ascii')
-                         for x in path if x is not None]).lstrip('/')
-        rv = self.base
-        if path:
-            if not rv.endswith('/'):
-                rv += '/'
-            rv = url_join(rv, './' + path)
-        if query:
-            rv += '?' + to_unicode(url_encode(query, self.charset, sort=self.sort,
-                                              key=self.key), 'ascii')
-        return to_native(rv)
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/useragents.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/useragents.py
deleted file mode 100644
index 4d7d41f1c..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/useragents.py
+++ /dev/null
@@ -1,212 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.useragents
-    ~~~~~~~~~~~~~~~~~~~
-
-    This module provides a helper to inspect user agent strings.  This module
-    is far from complete but should work for most of the currently available
-    browsers.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-
-
-class UserAgentParser(object):
-
-    """A simple user agent parser.  Used by the `UserAgent`."""
-
-    platforms = (
-        ('cros', 'chromeos'),
-        ('iphone|ios', 'iphone'),
-        ('ipad', 'ipad'),
-        (r'darwin|mac|os\s*x', 'macos'),
-        ('win', 'windows'),
-        (r'android', 'android'),
-        ('netbsd', 'netbsd'),
-        ('openbsd', 'openbsd'),
-        ('freebsd', 'freebsd'),
-        ('dragonfly', 'dragonflybsd'),
-        ('(sun|i86)os', 'solaris'),
-        (r'x11|lin(\b|ux)?', 'linux'),
-        (r'nintendo\s+wii', 'wii'),
-        ('irix', 'irix'),
-        ('hp-?ux', 'hpux'),
-        ('aix', 'aix'),
-        ('sco|unix_sv', 'sco'),
-        ('bsd', 'bsd'),
-        ('amiga', 'amiga'),
-        ('blackberry|playbook', 'blackberry'),
-        ('symbian', 'symbian')
-    )
-    browsers = (
-        ('googlebot', 'google'),
-        ('msnbot', 'msn'),
-        ('yahoo', 'yahoo'),
-        ('ask jeeves', 'ask'),
-        (r'aol|america\s+online\s+browser', 'aol'),
-        ('opera', 'opera'),
-        ('edge', 'edge'),
-        ('chrome', 'chrome'),
-        ('seamonkey', 'seamonkey'),
-        ('firefox|firebird|phoenix|iceweasel', 'firefox'),
-        ('galeon', 'galeon'),
-        ('safari|version', 'safari'),
-        ('webkit', 'webkit'),
-        ('camino', 'camino'),
-        ('konqueror', 'konqueror'),
-        ('k-meleon', 'kmeleon'),
-        ('netscape', 'netscape'),
-        (r'msie|microsoft\s+internet\s+explorer|trident/.+? rv:', 'msie'),
-        ('lynx', 'lynx'),
-        ('links', 'links'),
-        ('Baiduspider', 'baidu'),
-        ('bingbot', 'bing'),
-        ('mozilla', 'mozilla')
-    )
-
-    _browser_version_re = r'(?:%s)[/\sa-z(]*(\d+[.\da-z]+)?'
-    _language_re = re.compile(
-        r'(?:;\s*|\s+)(\b\w{2}\b(?:-\b\w{2}\b)?)\s*;|'
-        r'(?:\(|\[|;)\s*(\b\w{2}\b(?:-\b\w{2}\b)?)\s*(?:\]|\)|;)'
-    )
-
-    def __init__(self):
-        self.platforms = [(b, re.compile(a, re.I)) for a, b in self.platforms]
-        self.browsers = [(b, re.compile(self._browser_version_re % a, re.I))
-                         for a, b in self.browsers]
-
-    def __call__(self, user_agent):
-        for platform, regex in self.platforms:
-            match = regex.search(user_agent)
-            if match is not None:
-                break
-        else:
-            platform = None
-        for browser, regex in self.browsers:
-            match = regex.search(user_agent)
-            if match is not None:
-                version = match.group(1)
-                break
-        else:
-            browser = version = None
-        match = self._language_re.search(user_agent)
-        if match is not None:
-            language = match.group(1) or match.group(2)
-        else:
-            language = None
-        return platform, browser, version, language
-
-
-class UserAgent(object):
-
-    """Represents a user agent.  Pass it a WSGI environment or a user agent
-    string and you can inspect some of the details from the user agent
-    string via the attributes.  The following attributes exist:
-
-    .. attribute:: string
-
-       the raw user agent string
-
-    .. attribute:: platform
-
-       the browser platform.  The following platforms are currently
-       recognized:
-
-       -   `aix`
-       -   `amiga`
-       -   `android`
-       -   `blackberry`
-       -   `bsd`
-       -   `chromeos`
-       -   `dragonflybsd`
-       -   `freebsd`
-       -   `hpux`
-       -   `ipad`
-       -   `iphone`
-       -   `irix`
-       -   `linux`
-       -   `macos`
-       -   `netbsd`
-       -   `openbsd`
-       -   `sco`
-       -   `solaris`
-       -   `symbian`
-       -   `wii`
-       -   `windows`
-
-    .. attribute:: browser
-
-        the name of the browser.  The following browsers are currently
-        recognized:
-
-        -   `aol` *
-        -   `ask` *
-        -   `baidu` *
-        -   `bing` *
-        -   `camino`
-        -   `chrome`
-        -   `firefox`
-        -   `galeon`
-        -   `google` *
-        -   `kmeleon`
-        -   `konqueror`
-        -   `links`
-        -   `lynx`
-        -   `mozilla`
-        -   `msie`
-        -   `msn`
-        -   `netscape`
-        -   `opera`
-        -   `safari`
-        -   `seamonkey`
-        -   `webkit`
-        -   `yahoo` *
-
-        (Browsers marked with a star (``*``) are crawlers.)
-
-    .. attribute:: version
-
-        the version of the browser
-
-    .. attribute:: language
-
-        the language of the browser
-    """
-
-    _parser = UserAgentParser()
-
-    def __init__(self, environ_or_string):
-        if isinstance(environ_or_string, dict):
-            environ_or_string = environ_or_string.get('HTTP_USER_AGENT', '')
-        self.string = environ_or_string
-        self.platform, self.browser, self.version, self.language = \
-            self._parser(environ_or_string)
-
-    def to_header(self):
-        return self.string
-
-    def __str__(self):
-        return self.string
-
-    def __nonzero__(self):
-        return bool(self.browser)
-
-    __bool__ = __nonzero__
-
-    def __repr__(self):
-        return '<%s %r/%s>' % (
-            self.__class__.__name__,
-            self.browser,
-            self.version
-        )
-
-
-# conceptionally this belongs in this module but because we want to lazily
-# load the user agent module (which happens in wrappers.py) we have to import
-# it afterwards.  The class itself has the module set to this module so
-# pickle, inspect and similar modules treat the object as if it was really
-# implemented here.
-from werkzeug.wrappers import UserAgentMixin  # noqa
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/utils.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/utils.py
deleted file mode 100644
index 918e7e5b6..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/utils.py
+++ /dev/null
@@ -1,628 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.utils
-    ~~~~~~~~~~~~~~
-
-    This module implements various utilities for WSGI applications.  Most of
-    them are used by the request and response wrappers but especially for
-    middleware development it makes sense to use them without the wrappers.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import re
-import os
-import sys
-import pkgutil
-try:
-    from html.entities import name2codepoint
-except ImportError:
-    from htmlentitydefs import name2codepoint
-
-from werkzeug._compat import unichr, text_type, string_types, iteritems, \
-    reraise, PY2
-from werkzeug._internal import _DictAccessorProperty, \
-    _parse_signature, _missing
-
-
-_format_re = re.compile(r'\$(?:(%s)|\{(%s)\})' % (('[a-zA-Z_][a-zA-Z0-9_]*',) * 2))
-_entity_re = re.compile(r'&([^;]+);')
-_filename_ascii_strip_re = re.compile(r'[^A-Za-z0-9_.-]')
-_windows_device_files = ('CON', 'AUX', 'COM1', 'COM2', 'COM3', 'COM4', 'LPT1',
-                         'LPT2', 'LPT3', 'PRN', 'NUL')
-
-
-class cached_property(property):
-
-    """A decorator that converts a function into a lazy property.  The
-    function wrapped is called the first time to retrieve the result
-    and then that calculated result is used the next time you access
-    the value::
-
-        class Foo(object):
-
-            @cached_property
-            def foo(self):
-                # calculate something important here
-                return 42
-
-    The class has to have a `__dict__` in order for this property to
-    work.
-    """
-
-    # implementation detail: A subclass of python's builtin property
-    # decorator, we override __get__ to check for a cached value. If one
-    # choses to invoke __get__ by hand the property will still work as
-    # expected because the lookup logic is replicated in __get__ for
-    # manual invocation.
-
-    def __init__(self, func, name=None, doc=None):
-        self.__name__ = name or func.__name__
-        self.__module__ = func.__module__
-        self.__doc__ = doc or func.__doc__
-        self.func = func
-
-    def __set__(self, obj, value):
-        obj.__dict__[self.__name__] = value
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        value = obj.__dict__.get(self.__name__, _missing)
-        if value is _missing:
-            value = self.func(obj)
-            obj.__dict__[self.__name__] = value
-        return value
-
-
-class environ_property(_DictAccessorProperty):
-
-    """Maps request attributes to environment variables. This works not only
-    for the Werzeug request object, but also any other class with an
-    environ attribute:
-
-    >>> class Test(object):
-    ...     environ = {'key': 'value'}
-    ...     test = environ_property('key')
-    >>> var = Test()
-    >>> var.test
-    'value'
-
-    If you pass it a second value it's used as default if the key does not
-    exist, the third one can be a converter that takes a value and converts
-    it.  If it raises :exc:`ValueError` or :exc:`TypeError` the default value
-    is used. If no default value is provided `None` is used.
-
-    Per default the property is read only.  You have to explicitly enable it
-    by passing ``read_only=False`` to the constructor.
-    """
-
-    read_only = True
-
-    def lookup(self, obj):
-        return obj.environ
-
-
-class header_property(_DictAccessorProperty):
-
-    """Like `environ_property` but for headers."""
-
-    def lookup(self, obj):
-        return obj.headers
-
-
-class HTMLBuilder(object):
-
-    """Helper object for HTML generation.
-
-    Per default there are two instances of that class.  The `html` one, and
-    the `xhtml` one for those two dialects.  The class uses keyword parameters
-    and positional parameters to generate small snippets of HTML.
-
-    Keyword parameters are converted to XML/SGML attributes, positional
-    arguments are used as children.  Because Python accepts positional
-    arguments before keyword arguments it's a good idea to use a list with the
-    star-syntax for some children:
-
-    >>> html.p(class_='foo', *[html.a('foo', href='foo.html'), ' ',
-    ...                        html.a('bar', href='bar.html')])
-    u'<p class="foo"><a href="foo.html">foo</a> <a href="bar.html">bar</a></p>'
-
-    This class works around some browser limitations and can not be used for
-    arbitrary SGML/XML generation.  For that purpose lxml and similar
-    libraries exist.
-
-    Calling the builder escapes the string passed:
-
-    >>> html.p(html("<foo>"))
-    u'<p>&lt;foo&gt;</p>'
-    """
-
-    _entity_re = re.compile(r'&([^;]+);')
-    _entities = name2codepoint.copy()
-    _entities['apos'] = 39
-    _empty_elements = set([
-        'area', 'base', 'basefont', 'br', 'col', 'command', 'embed', 'frame',
-        'hr', 'img', 'input', 'keygen', 'isindex', 'link', 'meta', 'param',
-        'source', 'wbr'
-    ])
-    _boolean_attributes = set([
-        'selected', 'checked', 'compact', 'declare', 'defer', 'disabled',
-        'ismap', 'multiple', 'nohref', 'noresize', 'noshade', 'nowrap'
-    ])
-    _plaintext_elements = set(['textarea'])
-    _c_like_cdata = set(['script', 'style'])
-
-    def __init__(self, dialect):
-        self._dialect = dialect
-
-    def __call__(self, s):
-        return escape(s)
-
-    def __getattr__(self, tag):
-        if tag[:2] == '__':
-            raise AttributeError(tag)
-
-        def proxy(*children, **arguments):
-            buffer = '<' + tag
-            for key, value in iteritems(arguments):
-                if value is None:
-                    continue
-                if key[-1] == '_':
-                    key = key[:-1]
-                if key in self._boolean_attributes:
-                    if not value:
-                        continue
-                    if self._dialect == 'xhtml':
-                        value = '="' + key + '"'
-                    else:
-                        value = ''
-                else:
-                    value = '="' + escape(value) + '"'
-                buffer += ' ' + key + value
-            if not children and tag in self._empty_elements:
-                if self._dialect == 'xhtml':
-                    buffer += ' />'
-                else:
-                    buffer += '>'
-                return buffer
-            buffer += '>'
-
-            children_as_string = ''.join([text_type(x) for x in children
-                                          if x is not None])
-
-            if children_as_string:
-                if tag in self._plaintext_elements:
-                    children_as_string = escape(children_as_string)
-                elif tag in self._c_like_cdata and self._dialect == 'xhtml':
-                    children_as_string = '/*<![CDATA[*/' + \
-                                         children_as_string + '/*]]>*/'
-            buffer += children_as_string + '</' + tag + '>'
-            return buffer
-        return proxy
-
-    def __repr__(self):
-        return '<%s for %r>' % (
-            self.__class__.__name__,
-            self._dialect
-        )
-
-
-html = HTMLBuilder('html')
-xhtml = HTMLBuilder('xhtml')
-
-
-def get_content_type(mimetype, charset):
-    """Returns the full content type string with charset for a mimetype.
-
-    If the mimetype represents text the charset will be appended as charset
-    parameter, otherwise the mimetype is returned unchanged.
-
-    :param mimetype: the mimetype to be used as content type.
-    :param charset: the charset to be appended in case it was a text mimetype.
-    :return: the content type.
-    """
-    if mimetype.startswith('text/') or \
-       mimetype == 'application/xml' or \
-       (mimetype.startswith('application/') and
-            mimetype.endswith('+xml')):
-        mimetype += '; charset=' + charset
-    return mimetype
-
-
-def format_string(string, context):
-    """String-template format a string:
-
-    >>> format_string('$foo and ${foo}s', dict(foo=42))
-    '42 and 42s'
-
-    This does not do any attribute lookup etc.  For more advanced string
-    formattings have a look at the `werkzeug.template` module.
-
-    :param string: the format string.
-    :param context: a dict with the variables to insert.
-    """
-    def lookup_arg(match):
-        x = context[match.group(1) or match.group(2)]
-        if not isinstance(x, string_types):
-            x = type(string)(x)
-        return x
-    return _format_re.sub(lookup_arg, string)
-
-
-def secure_filename(filename):
-    r"""Pass it a filename and it will return a secure version of it.  This
-    filename can then safely be stored on a regular file system and passed
-    to :func:`os.path.join`.  The filename returned is an ASCII only string
-    for maximum portability.
-
-    On windows systems the function also makes sure that the file is not
-    named after one of the special device files.
-
-    >>> secure_filename("My cool movie.mov")
-    'My_cool_movie.mov'
-    >>> secure_filename("../../../etc/passwd")
-    'etc_passwd'
-    >>> secure_filename(u'i contain cool \xfcml\xe4uts.txt')
-    'i_contain_cool_umlauts.txt'
-
-    The function might return an empty filename.  It's your responsibility
-    to ensure that the filename is unique and that you generate random
-    filename if the function returned an empty one.
-
-    .. versionadded:: 0.5
-
-    :param filename: the filename to secure
-    """
-    if isinstance(filename, text_type):
-        from unicodedata import normalize
-        filename = normalize('NFKD', filename).encode('ascii', 'ignore')
-        if not PY2:
-            filename = filename.decode('ascii')
-    for sep in os.path.sep, os.path.altsep:
-        if sep:
-            filename = filename.replace(sep, ' ')
-    filename = str(_filename_ascii_strip_re.sub('', '_'.join(
-                   filename.split()))).strip('._')
-
-    # on nt a couple of special files are present in each folder.  We
-    # have to ensure that the target file is not such a filename.  In
-    # this case we prepend an underline
-    if os.name == 'nt' and filename and \
-       filename.split('.')[0].upper() in _windows_device_files:
-        filename = '_' + filename
-
-    return filename
-
-
-def escape(s, quote=None):
-    """Replace special characters "&", "<", ">" and (") to HTML-safe sequences.
-
-    There is a special handling for `None` which escapes to an empty string.
-
-    .. versionchanged:: 0.9
-       `quote` is now implicitly on.
-
-    :param s: the string to escape.
-    :param quote: ignored.
-    """
-    if s is None:
-        return ''
-    elif hasattr(s, '__html__'):
-        return text_type(s.__html__())
-    elif not isinstance(s, string_types):
-        s = text_type(s)
-    if quote is not None:
-        from warnings import warn
-        warn(DeprecationWarning('quote parameter is implicit now'), stacklevel=2)
-    s = s.replace('&', '&amp;').replace('<', '&lt;') \
-        .replace('>', '&gt;').replace('"', "&quot;")
-    return s
-
-
-def unescape(s):
-    """The reverse function of `escape`.  This unescapes all the HTML
-    entities, not only the XML entities inserted by `escape`.
-
-    :param s: the string to unescape.
-    """
-    def handle_match(m):
-        name = m.group(1)
-        if name in HTMLBuilder._entities:
-            return unichr(HTMLBuilder._entities[name])
-        try:
-            if name[:2] in ('#x', '#X'):
-                return unichr(int(name[2:], 16))
-            elif name.startswith('#'):
-                return unichr(int(name[1:]))
-        except ValueError:
-            pass
-        return u''
-    return _entity_re.sub(handle_match, s)
-
-
-def redirect(location, code=302, Response=None):
-    """Returns a response object (a WSGI application) that, if called,
-    redirects the client to the target location.  Supported codes are 301,
-    302, 303, 305, and 307.  300 is not supported because it's not a real
-    redirect and 304 because it's the answer for a request with a request
-    with defined If-Modified-Since headers.
-
-    .. versionadded:: 0.6
-       The location can now be a unicode string that is encoded using
-       the :func:`iri_to_uri` function.
-
-    .. versionadded:: 0.10
-        The class used for the Response object can now be passed in.
-
-    :param location: the location the response should redirect to.
-    :param code: the redirect status code. defaults to 302.
-    :param class Response: a Response class to use when instantiating a
-        response. The default is :class:`werkzeug.wrappers.Response` if
-        unspecified.
-    """
-    if Response is None:
-        from werkzeug.wrappers import Response
-
-    display_location = escape(location)
-    if isinstance(location, text_type):
-        # Safe conversion is necessary here as we might redirect
-        # to a broken URI scheme (for instance itms-services).
-        from werkzeug.urls import iri_to_uri
-        location = iri_to_uri(location, safe_conversion=True)
-    response = Response(
-        '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">\n'
-        '<title>Redirecting...</title>\n'
-        '<h1>Redirecting...</h1>\n'
-        '<p>You should be redirected automatically to target URL: '
-        '<a href="%s">%s</a>.  If not click the link.' %
-        (escape(location), display_location), code, mimetype='text/html')
-    response.headers['Location'] = location
-    return response
-
-
-def append_slash_redirect(environ, code=301):
-    """Redirects to the same URL but with a slash appended.  The behavior
-    of this function is undefined if the path ends with a slash already.
-
-    :param environ: the WSGI environment for the request that triggers
-                    the redirect.
-    :param code: the status code for the redirect.
-    """
-    new_path = environ['PATH_INFO'].strip('/') + '/'
-    query_string = environ.get('QUERY_STRING')
-    if query_string:
-        new_path += '?' + query_string
-    return redirect(new_path, code)
-
-
-def import_string(import_name, silent=False):
-    """Imports an object based on a string.  This is useful if you want to
-    use import paths as endpoints or something similar.  An import path can
-    be specified either in dotted notation (``xml.sax.saxutils.escape``)
-    or with a colon as object delimiter (``xml.sax.saxutils:escape``).
-
-    If `silent` is True the return value will be `None` if the import fails.
-
-    :param import_name: the dotted name for the object to import.
-    :param silent: if set to `True` import errors are ignored and
-                   `None` is returned instead.
-    :return: imported object
-    """
-    # force the import name to automatically convert to strings
-    # __import__ is not able to handle unicode strings in the fromlist
-    # if the module is a package
-    import_name = str(import_name).replace(':', '.')
-    try:
-        try:
-            __import__(import_name)
-        except ImportError:
-            if '.' not in import_name:
-                raise
-        else:
-            return sys.modules[import_name]
-
-        module_name, obj_name = import_name.rsplit('.', 1)
-        try:
-            module = __import__(module_name, None, None, [obj_name])
-        except ImportError:
-            # support importing modules not yet set up by the parent module
-            # (or package for that matter)
-            module = import_string(module_name)
-
-        try:
-            return getattr(module, obj_name)
-        except AttributeError as e:
-            raise ImportError(e)
-
-    except ImportError as e:
-        if not silent:
-            reraise(
-                ImportStringError,
-                ImportStringError(import_name, e),
-                sys.exc_info()[2])
-
-
-def find_modules(import_path, include_packages=False, recursive=False):
-    """Finds all the modules below a package.  This can be useful to
-    automatically import all views / controllers so that their metaclasses /
-    function decorators have a chance to register themselves on the
-    application.
-
-    Packages are not returned unless `include_packages` is `True`.  This can
-    also recursively list modules but in that case it will import all the
-    packages to get the correct load path of that module.
-
-    :param import_path: the dotted name for the package to find child modules.
-    :param include_packages: set to `True` if packages should be returned, too.
-    :param recursive: set to `True` if recursion should happen.
-    :return: generator
-    """
-    module = import_string(import_path)
-    path = getattr(module, '__path__', None)
-    if path is None:
-        raise ValueError('%r is not a package' % import_path)
-    basename = module.__name__ + '.'
-    for importer, modname, ispkg in pkgutil.iter_modules(path):
-        modname = basename + modname
-        if ispkg:
-            if include_packages:
-                yield modname
-            if recursive:
-                for item in find_modules(modname, include_packages, True):
-                    yield item
-        else:
-            yield modname
-
-
-def validate_arguments(func, args, kwargs, drop_extra=True):
-    """Checks if the function accepts the arguments and keyword arguments.
-    Returns a new ``(args, kwargs)`` tuple that can safely be passed to
-    the function without causing a `TypeError` because the function signature
-    is incompatible.  If `drop_extra` is set to `True` (which is the default)
-    any extra positional or keyword arguments are dropped automatically.
-
-    The exception raised provides three attributes:
-
-    `missing`
-        A set of argument names that the function expected but where
-        missing.
-
-    `extra`
-        A dict of keyword arguments that the function can not handle but
-        where provided.
-
-    `extra_positional`
-        A list of values that where given by positional argument but the
-        function cannot accept.
-
-    This can be useful for decorators that forward user submitted data to
-    a view function::
-
-        from werkzeug.utils import ArgumentValidationError, validate_arguments
-
-        def sanitize(f):
-            def proxy(request):
-                data = request.values.to_dict()
-                try:
-                    args, kwargs = validate_arguments(f, (request,), data)
-                except ArgumentValidationError:
-                    raise BadRequest('The browser failed to transmit all '
-                                     'the data expected.')
-                return f(*args, **kwargs)
-            return proxy
-
-    :param func: the function the validation is performed against.
-    :param args: a tuple of positional arguments.
-    :param kwargs: a dict of keyword arguments.
-    :param drop_extra: set to `False` if you don't want extra arguments
-                       to be silently dropped.
-    :return: tuple in the form ``(args, kwargs)``.
-    """
-    parser = _parse_signature(func)
-    args, kwargs, missing, extra, extra_positional = parser(args, kwargs)[:5]
-    if missing:
-        raise ArgumentValidationError(tuple(missing))
-    elif (extra or extra_positional) and not drop_extra:
-        raise ArgumentValidationError(None, extra, extra_positional)
-    return tuple(args), kwargs
-
-
-def bind_arguments(func, args, kwargs):
-    """Bind the arguments provided into a dict.  When passed a function,
-    a tuple of arguments and a dict of keyword arguments `bind_arguments`
-    returns a dict of names as the function would see it.  This can be useful
-    to implement a cache decorator that uses the function arguments to build
-    the cache key based on the values of the arguments.
-
-    :param func: the function the arguments should be bound for.
-    :param args: tuple of positional arguments.
-    :param kwargs: a dict of keyword arguments.
-    :return: a :class:`dict` of bound keyword arguments.
-    """
-    args, kwargs, missing, extra, extra_positional, \
-        arg_spec, vararg_var, kwarg_var = _parse_signature(func)(args, kwargs)
-    values = {}
-    for (name, has_default, default), value in zip(arg_spec, args):
-        values[name] = value
-    if vararg_var is not None:
-        values[vararg_var] = tuple(extra_positional)
-    elif extra_positional:
-        raise TypeError('too many positional arguments')
-    if kwarg_var is not None:
-        multikw = set(extra) & set([x[0] for x in arg_spec])
-        if multikw:
-            raise TypeError('got multiple values for keyword argument ' +
-                            repr(next(iter(multikw))))
-        values[kwarg_var] = extra
-    elif extra:
-        raise TypeError('got unexpected keyword argument ' +
-                        repr(next(iter(extra))))
-    return values
-
-
-class ArgumentValidationError(ValueError):
-
-    """Raised if :func:`validate_arguments` fails to validate"""
-
-    def __init__(self, missing=None, extra=None, extra_positional=None):
-        self.missing = set(missing or ())
-        self.extra = extra or {}
-        self.extra_positional = extra_positional or []
-        ValueError.__init__(self, 'function arguments invalid.  ('
-                            '%d missing, %d additional)' % (
-                                len(self.missing),
-                                len(self.extra) + len(self.extra_positional)
-                            ))
-
-
-class ImportStringError(ImportError):
-
-    """Provides information about a failed :func:`import_string` attempt."""
-
-    #: String in dotted notation that failed to be imported.
-    import_name = None
-    #: Wrapped exception.
-    exception = None
-
-    def __init__(self, import_name, exception):
-        self.import_name = import_name
-        self.exception = exception
-
-        msg = (
-            'import_string() failed for %r. Possible reasons are:\n\n'
-            '- missing __init__.py in a package;\n'
-            '- package or module path not included in sys.path;\n'
-            '- duplicated package or module name taking precedence in '
-            'sys.path;\n'
-            '- missing module, class, function or variable;\n\n'
-            'Debugged import:\n\n%s\n\n'
-            'Original exception:\n\n%s: %s')
-
-        name = ''
-        tracked = []
-        for part in import_name.replace(':', '.').split('.'):
-            name += (name and '.') + part
-            imported = import_string(name, silent=True)
-            if imported:
-                tracked.append((name, getattr(imported, '__file__', None)))
-            else:
-                track = ['- %r found in %r.' % (n, i) for n, i in tracked]
-                track.append('- %r not found.' % name)
-                msg = msg % (import_name, '\n'.join(track),
-                             exception.__class__.__name__, str(exception))
-                break
-
-        ImportError.__init__(self, msg)
-
-    def __repr__(self):
-        return '<%s(%r, %r)>' % (self.__class__.__name__, self.import_name,
-                                 self.exception)
-
-
-# DEPRECATED
-# these objects were previously in this module as well.  we import
-# them here for backwards compatibility with old pickles.
-from werkzeug.datastructures import (  # noqa
-    MultiDict, CombinedMultiDict, Headers, EnvironHeaders)
-from werkzeug.http import parse_cookie, dump_cookie  # noqa
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/websocket.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/websocket.py
deleted file mode 100644
index 764698b70..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/websocket.py
+++ /dev/null
@@ -1,337 +0,0 @@
-import re
-import errno
-import socket
-import struct
-import collections
-
-from base64 import b64decode, b64encode
-from hashlib import sha1
-
-
-WS_KEY = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-
-
-def pack_message(message):
-    """Pack the message inside ``00`` and ``FF``
-    As per the dataframing section (5.3) for the websocket spec
-    """
-    if isinstance(message, unicode):
-        message = message.encode('utf-8')
-    elif not isinstance(message, str):
-        message = str(message)
-    packed = "\x00%s\xFF" % message
-    return packed
-
-
-def encode_hybi(buf, opcode, base64=False):
-    """ Encode a HyBi style WebSocket frame.
-    Optional opcode:
-        0x0 - continuation
-        0x1 - text frame (base64 encode buf)
-        0x2 - binary frame (use raw buf)
-        0x8 - connection close
-        0x9 - ping
-        0xA - pong
-    """
-    if base64:
-        buf = b64encode(buf)
-    b1 = 0x80 | (opcode & 0x0f) # FIN + opcode
-    payload_len = len(buf)
-    if payload_len <= 125:
-        header = struct.pack('>BB', b1, payload_len)
-    elif payload_len > 125 and payload_len < 65536:
-        header = struct.pack('>BBH', b1, 126, payload_len)
-    elif payload_len >= 65536:
-        header = struct.pack('>BBQ', b1, 127, payload_len)
-    return header + buf, len(header), 0
-
-
-def decode_hybi(buf, base64=False):
-    """Decode HyBi style WebSocket packets."""
-    f = {'fin'          : 0,
-         'opcode'       : 0,
-         'mask'         : 0,
-         'hlen'         : 2,
-         'length'       : 0,
-         'payload'      : None,
-         'left'         : 0,
-         'close_code'   : None,
-         'close_reason' : None}
-
-    blen = len(buf)
-    f['left'] = blen
-
-    if blen < f['hlen']:
-        return f # Incomplete frame header
-
-    b1, b2 = struct.unpack_from(">BB", buf)
-    f['opcode'] = b1 & 0x0f
-    f['fin'] = (b1 & 0x80) >> 7
-    has_mask = (b2 & 0x80) >> 7
-
-    f['length'] = b2 & 0x7f
-
-    if f['length'] == 126:
-        f['hlen'] = 4
-        if blen < f['hlen']:
-            return f # Incomplete frame header
-        (f['length'],) = struct.unpack_from('>xxH', buf)
-    elif f['length'] == 127:
-        f['hlen'] = 10
-        if blen < f['hlen']:
-            return f # Incomplete frame header
-        (f['length'],) = struct.unpack_from('>xxQ', buf)
-
-    full_len = f['hlen'] + has_mask * 4 + f['length']
-
-    if blen < full_len: # Incomplete frame
-        return f # Incomplete frame header
-
-    # Number of bytes that are part of the next frame(s)
-    f['left'] = blen - full_len
-
-    # Process 1 frame
-    if has_mask:
-        # unmask payload
-        f['mask'] = buf[f['hlen']:f['hlen']+4]
-        b = c = ''
-        if f['length'] >= 4:
-            data = struct.unpack('<I', buf[f['hlen']:f['hlen']+4])[0]
-            of1 = f['hlen']+4
-            b = ''
-            for i in xrange(0, int(f['length']/4)):
-                mask = struct.unpack('<I', buf[of1+4*i:of1+4*(i+1)])[0]
-                b += struct.pack('I', data ^ mask)
-
-        if f['length'] % 4:
-            l = f['length'] % 4
-            of1 = f['hlen']
-            of2 = full_len - l
-            c = ''
-            for i in range(0, l):
-                mask = struct.unpack('B', buf[of1 + i])[0]
-                data = struct.unpack('B', buf[of2 + i])[0]
-                c += chr(data ^ mask)
-
-        f['payload'] = b + c
-    else:
-        f['payload'] = buf[(f['hlen'] + has_mask * 4):full_len]
-
-    if base64 and f['opcode'] in [1, 2]:
-        f['payload'] = b64decode(f['payload'])
-
-    if f['opcode'] == 0x08:
-        if f['length'] >= 2:
-            f['close_code'] = struct.unpack_from(">H", f['payload'])
-        if f['length'] > 3:
-            f['close_reason'] = f['payload'][2:]
-
-    return f
-
-
-class WebSocketWSGI(object):
-
-    def __init__(self, handler):
-        self.handler = handler
-
-    def verify_client(self, ws):
-        pass
-
-    def __call__(self, environ, start_response):
-        if not (environ.get('HTTP_CONNECTION').find('Upgrade') != -1 and
-            environ['HTTP_UPGRADE'].lower() == 'websocket'):
-            # need to check a few more things here for true compliance
-            start_response('400 Bad Request', [('Connection','close')])
-            return []
-
-        sock = environ['gunicorn.socket']
-
-        ws = WebSocket(sock, environ)
-
-        handshake_reply = ("HTTP/1.1 101 Switching Protocols\r\n"
-                   "Upgrade: websocket\r\n"
-                   "Connection: Upgrade\r\n")
-
-        path = environ['PATH_INFO']
-        key = environ.get('HTTP_SEC_WEBSOCKET_KEY')
-        if key:
-            ws_key = b64decode(key)
-            if len(ws_key) != 16:
-                start_response('400 Bad Request', [('Connection','close')])
-                return []
-
-            protocols = []
-            subprotocols = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL')
-            ws_protocols = []
-            if subprotocols:
-                for s in subprotocols.split(','):
-                    s = s.strip()
-                    if s in protocols:
-                        ws_protocols.append(s)
-            if ws_protocols:
-                handshake_reply += 'Sec-WebSocket-Protocol: %s\r\n' % ', '.join(ws_protocols)
-
-            exts = []
-            extensions = environ.get('HTTP_SEC_WEBSOCKET_EXTENSIONS')
-            ws_extensions = []
-            if extensions:
-                for ext in extensions.split(','):
-                    ext = ext.strip()
-                    if ext in exts:
-                        ws_extensions.append(ext)
-            if ws_extensions:
-                handshake_reply += 'Sec-WebSocket-Extensions: %s\r\n' % ', '.join(ws_extensions)
-
-            handshake_reply +=  (
-                "Sec-WebSocket-Origin: %s\r\n"
-                "Sec-WebSocket-Location: ws://%s%s\r\n"
-                "Sec-WebSocket-Version: %s\r\n"
-                "Sec-WebSocket-Accept: %s\r\n\r\n"
-                 % (
-                    environ.get('HTTP_ORIGIN'),
-                    environ.get('HTTP_HOST'),
-                    path,
-                    ws.version,
-                    b64encode(sha1(key + WS_KEY).digest())
-                ))
-
-        else:
-
-            handshake_reply += (
-                       "WebSocket-Origin: %s\r\n"
-                       "WebSocket-Location: ws://%s%s\r\n\r\n" % (
-                            environ.get('HTTP_ORIGIN'),
-                            environ.get('HTTP_HOST'),
-                            path))
-
-        sock.sendall(handshake_reply)
-
-        try:
-            self.handler(ws)
-        except socket.error as e:
-            if e[0] != errno.EPIPE:
-                raise
-
-        # use this undocumented feature of grainbows to ensure that it
-        # doesn't barf on the fact that we didn't call start_response
-        return ALREADY_HANDLED
-
-
-class WebSocket(object):
-
-    def __init__(self, sock, environ, version=76):
-        self._socket = sock
-        try:
-            version = int(environ.get('HTTP_SEC_WEBSOCKET_VERSION'))
-        except (ValueError, TypeError):
-            version = 76
-        self.version = version
-        self.closed = False
-        self.accepted = False
-        self._buf = b''
-        self._msgs = collections.deque()
-
-    def _parse_messages(self):
-        """ Parses for messages in the buffer *buf*.  It is assumed that
-        the buffer contains the start character for a message, but that it
-        may contain only part of the rest of the message.
-        Returns an array of messages, and the buffer remainder that
-        didn't contain any full messages."""
-        msgs = []
-        end_idx = 0
-        buf = self._buf
-        while buf:
-            if self.version in (7, 8, 13):
-                frame = decode_hybi(buf, base64=False)
-
-                if frame['payload'] == None:
-                    break
-                else:
-                    if frame['opcode'] == 0x8: # connection close
-                        self.closed = True
-                        break
-                    else:
-                        msgs.append(frame['payload']);
-                        if frame['left']:
-                            buf = buf[-frame['left']:]
-                        else:
-                            buf = b''
-
-            else:
-                frame_type = ord(buf[0])
-                if frame_type == 0:
-                    # Normal message.
-                    end_idx = buf.find("\xFF")
-                    if end_idx == -1: #pragma NO COVER
-                        break
-                    msgs.append(buf[1:end_idx].decode('utf-8', 'replace'))
-                    buf = buf[end_idx+1:]
-                elif frame_type == 255:
-                    # Closing handshake.
-                    assert ord(buf[1]) == 0, "Unexpected closing handshake: %r" % buf
-                    self.closed = True
-                    break
-                else:
-                    raise ValueError("Don't understand how to parse this type of message: %r" % buf)
-        self._buf = buf
-        return msgs
-
-    def send(self, message):
-        """Send a message to the browser.
-        *message* should be convertable to a string; unicode objects should be
-        encodable as utf-8.  Raises socket.error with errno of 32
-        (broken pipe) if the socket has already been closed by the client.
-        """
-        if self.version in (7, 8, 13):
-            packed, lenhead, lentail = encode_hybi(
-                message, opcode=0x01, base64=False)
-        else:
-            packed = pack_message(message)
-        self._socket.sendall(packed)
-
-    def wait(self):
-        """Waits for and deserializes messages.
-        Returns a single message; the oldest not yet processed. If the client
-        has already closed the connection, returns None.  This is different
-        from normal socket behavior because the empty string is a valid
-        websocket message."""
-        while not self._msgs:
-            # Websocket might be closed already.
-            if self.closed:
-                return None
-            # no parsed messages, must mean buf needs more data
-            delta = self._socket.recv(8096)
-            if delta == '':
-                return None
-            self._buf += delta
-            msgs = self._parse_messages()
-            self._msgs.extend(msgs)
-        return self._msgs.popleft()
-
-    def _send_closing_frame(self, ignore_send_errors=False):
-        """Sends the closing frame to the client, if required."""
-        if self.version in (7, 8, 13) and not self.closed:
-            msg = ''
-            #if code != None:
-            #    msg = struct.pack(">H%ds" % (len(reason)), code)
-
-            buf, h, t = encode_hybi(msg, opcode=0x08, base64=False)
-            self._socket.sendall(buf)
-            self.closed = True
-
-        elif self.version == 76 and not self.closed:
-            try:
-                self._socket.sendall("\xff\x00")
-            except socket.error:
-                # Sometimes, like when the remote side cuts off the connection,
-                # we don't care about this.
-                if not ignore_send_errors: #pragma NO COVER
-                    raise
-            self.closed = True
-
-    def close(self):
-        """Forcibly close the websocket; generally it is preferable to
-        return from the handler method."""
-        self._send_closing_frame()
-        self._socket.shutdown(True)
-        self._socket.close()
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wrappers.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wrappers.py
deleted file mode 100644
index 92dfa5dac..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wrappers.py
+++ /dev/null
@@ -1,2028 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.wrappers
-    ~~~~~~~~~~~~~~~~~
-
-    The wrappers are simple request and response objects which you can
-    subclass to do whatever you want them to do.  The request object contains
-    the information transmitted by the client (webbrowser) and the response
-    object contains all the information sent back to the browser.
-
-    An important detail is that the request object is created with the WSGI
-    environ and will act as high-level proxy whereas the response object is an
-    actual WSGI application.
-
-    Like everything else in Werkzeug these objects will work correctly with
-    unicode data.  Incoming form data parsed by the response object will be
-    decoded into an unicode object if possible and if it makes sense.
-
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-from functools import update_wrapper
-from datetime import datetime, timedelta
-from warnings import warn
-
-from werkzeug.http import HTTP_STATUS_CODES, \
-    parse_accept_header, parse_cache_control_header, parse_etags, \
-    parse_date, generate_etag, is_resource_modified, unquote_etag, \
-    quote_etag, parse_set_header, parse_authorization_header, \
-    parse_www_authenticate_header, remove_entity_headers, \
-    parse_options_header, dump_options_header, http_date, \
-    parse_if_range_header, parse_cookie, dump_cookie, \
-    parse_range_header, parse_content_range_header, dump_header, \
-    parse_age, dump_age
-from werkzeug.urls import url_decode, iri_to_uri, url_join
-from werkzeug.formparser import FormDataParser, default_stream_factory
-from werkzeug.utils import cached_property, environ_property, \
-    header_property, get_content_type
-from werkzeug.wsgi import get_current_url, get_host, \
-    ClosingIterator, get_input_stream, get_content_length, _RangeWrapper
-from werkzeug.datastructures import MultiDict, CombinedMultiDict, Headers, \
-    EnvironHeaders, ImmutableMultiDict, ImmutableTypeConversionDict, \
-    ImmutableList, MIMEAccept, CharsetAccept, LanguageAccept, \
-    ResponseCacheControl, RequestCacheControl, CallbackDict, \
-    ContentRange, iter_multi_items
-from werkzeug._internal import _get_environ
-from werkzeug._compat import to_bytes, string_types, text_type, \
-    integer_types, wsgi_decoding_dance, wsgi_get_bytes, \
-    to_unicode, to_native, BytesIO
-
-
-def _run_wsgi_app(*args):
-    """This function replaces itself to ensure that the test module is not
-    imported unless required.  DO NOT USE!
-    """
-    global _run_wsgi_app
-    from werkzeug.test import run_wsgi_app as _run_wsgi_app
-    return _run_wsgi_app(*args)
-
-
-def _warn_if_string(iterable):
-    """Helper for the response objects to check if the iterable returned
-    to the WSGI server is not a string.
-    """
-    if isinstance(iterable, string_types):
-        warn(Warning('response iterable was set to a string.  This appears '
-                     'to work but means that the server will send the '
-                     'data to the client char, by char.  This is almost '
-                     'never intended behavior, use response.data to assign '
-                     'strings to the response object.'), stacklevel=2)
-
-
-def _assert_not_shallow(request):
-    if request.shallow:
-        raise RuntimeError('A shallow request tried to consume '
-                           'form data.  If you really want to do '
-                           'that, set `shallow` to False.')
-
-
-def _iter_encoded(iterable, charset):
-    for item in iterable:
-        if isinstance(item, text_type):
-            yield item.encode(charset)
-        else:
-            yield item
-
-
-def _clean_accept_ranges(accept_ranges):
-    if accept_ranges is True:
-        return "bytes"
-    elif accept_ranges is False:
-        return "none"
-    elif isinstance(accept_ranges, text_type):
-        return to_native(accept_ranges)
-    raise ValueError("Invalid accept_ranges value")
-
-
-class BaseRequest(object):
-
-    """Very basic request object.  This does not implement advanced stuff like
-    entity tag parsing or cache controls.  The request object is created with
-    the WSGI environment as first argument and will add itself to the WSGI
-    environment as ``'werkzeug.request'`` unless it's created with
-    `populate_request` set to False.
-
-    There are a couple of mixins available that add additional functionality
-    to the request object, there is also a class called `Request` which
-    subclasses `BaseRequest` and all the important mixins.
-
-    It's a good idea to create a custom subclass of the :class:`BaseRequest`
-    and add missing functionality either via mixins or direct implementation.
-    Here an example for such subclasses::
-
-        from werkzeug.wrappers import BaseRequest, ETagRequestMixin
-
-        class Request(BaseRequest, ETagRequestMixin):
-            pass
-
-    Request objects are **read only**.  As of 0.5 modifications are not
-    allowed in any place.  Unlike the lower level parsing functions the
-    request object will use immutable objects everywhere possible.
-
-    Per default the request object will assume all the text data is `utf-8`
-    encoded.  Please refer to `the unicode chapter <unicode.txt>`_ for more
-    details about customizing the behavior.
-
-    Per default the request object will be added to the WSGI
-    environment as `werkzeug.request` to support the debugging system.
-    If you don't want that, set `populate_request` to `False`.
-
-    If `shallow` is `True` the environment is initialized as shallow
-    object around the environ.  Every operation that would modify the
-    environ in any way (such as consuming form data) raises an exception
-    unless the `shallow` attribute is explicitly set to `False`.  This
-    is useful for middlewares where you don't want to consume the form
-    data by accident.  A shallow request is not populated to the WSGI
-    environment.
-
-    .. versionchanged:: 0.5
-       read-only mode was enforced by using immutables classes for all
-       data.
-    """
-
-    #: the charset for the request, defaults to utf-8
-    charset = 'utf-8'
-
-    #: the error handling procedure for errors, defaults to 'replace'
-    encoding_errors = 'replace'
-
-    #: the maximum content length.  This is forwarded to the form data
-    #: parsing function (:func:`parse_form_data`).  When set and the
-    #: :attr:`form` or :attr:`files` attribute is accessed and the
-    #: parsing fails because more than the specified value is transmitted
-    #: a :exc:`~werkzeug.exceptions.RequestEntityTooLarge` exception is raised.
-    #:
-    #: Have a look at :ref:`dealing-with-request-data` for more details.
-    #:
-    #: .. versionadded:: 0.5
-    max_content_length = None
-
-    #: the maximum form field size.  This is forwarded to the form data
-    #: parsing function (:func:`parse_form_data`).  When set and the
-    #: :attr:`form` or :attr:`files` attribute is accessed and the
-    #: data in memory for post data is longer than the specified value a
-    #: :exc:`~werkzeug.exceptions.RequestEntityTooLarge` exception is raised.
-    #:
-    #: Have a look at :ref:`dealing-with-request-data` for more details.
-    #:
-    #: .. versionadded:: 0.5
-    max_form_memory_size = None
-
-    #: the class to use for `args` and `form`.  The default is an
-    #: :class:`~werkzeug.datastructures.ImmutableMultiDict` which supports
-    #: multiple values per key.  alternatively it makes sense to use an
-    #: :class:`~werkzeug.datastructures.ImmutableOrderedMultiDict` which
-    #: preserves order or a :class:`~werkzeug.datastructures.ImmutableDict`
-    #: which is the fastest but only remembers the last key.  It is also
-    #: possible to use mutable structures, but this is not recommended.
-    #:
-    #: .. versionadded:: 0.6
-    parameter_storage_class = ImmutableMultiDict
-
-    #: the type to be used for list values from the incoming WSGI environment.
-    #: By default an :class:`~werkzeug.datastructures.ImmutableList` is used
-    #: (for example for :attr:`access_list`).
-    #:
-    #: .. versionadded:: 0.6
-    list_storage_class = ImmutableList
-
-    #: the type to be used for dict values from the incoming WSGI environment.
-    #: By default an
-    #: :class:`~werkzeug.datastructures.ImmutableTypeConversionDict` is used
-    #: (for example for :attr:`cookies`).
-    #:
-    #: .. versionadded:: 0.6
-    dict_storage_class = ImmutableTypeConversionDict
-
-    #: The form data parser that shoud be used.  Can be replaced to customize
-    #: the form date parsing.
-    form_data_parser_class = FormDataParser
-
-    #: Optionally a list of hosts that is trusted by this request.  By default
-    #: all hosts are trusted which means that whatever the client sends the
-    #: host is will be accepted.
-    #:
-    #: This is the recommended setup as a webserver should manually be set up
-    #: to only route correct hosts to the application, and remove the
-    #: `X-Forwarded-Host` header if it is not being used (see
-    #: :func:`werkzeug.wsgi.get_host`).
-    #:
-    #: .. versionadded:: 0.9
-    trusted_hosts = None
-
-    #: Indicates whether the data descriptor should be allowed to read and
-    #: buffer up the input stream.  By default it's enabled.
-    #:
-    #: .. versionadded:: 0.9
-    disable_data_descriptor = False
-
-    def __init__(self, environ, populate_request=True, shallow=False):
-        self.environ = environ
-        if populate_request and not shallow:
-            self.environ['werkzeug.request'] = self
-        self.shallow = shallow
-
-    def __repr__(self):
-        # make sure the __repr__ even works if the request was created
-        # from an invalid WSGI environment.  If we display the request
-        # in a debug session we don't want the repr to blow up.
-        args = []
-        try:
-            args.append("'%s'" % to_native(self.url, self.url_charset))
-            args.append('[%s]' % self.method)
-        except Exception:
-            args.append('(invalid WSGI environ)')
-
-        return '<%s %s>' % (
-            self.__class__.__name__,
-            ' '.join(args)
-        )
-
-    @property
-    def url_charset(self):
-        """The charset that is assumed for URLs.  Defaults to the value
-        of :attr:`charset`.
-
-        .. versionadded:: 0.6
-        """
-        return self.charset
-
-    @classmethod
-    def from_values(cls, *args, **kwargs):
-        """Create a new request object based on the values provided.  If
-        environ is given missing values are filled from there.  This method is
-        useful for small scripts when you need to simulate a request from an URL.
-        Do not use this method for unittesting, there is a full featured client
-        object (:class:`Client`) that allows to create multipart requests,
-        support for cookies etc.
-
-        This accepts the same options as the
-        :class:`~werkzeug.test.EnvironBuilder`.
-
-        .. versionchanged:: 0.5
-           This method now accepts the same arguments as
-           :class:`~werkzeug.test.EnvironBuilder`.  Because of this the
-           `environ` parameter is now called `environ_overrides`.
-
-        :return: request object
-        """
-        from werkzeug.test import EnvironBuilder
-        charset = kwargs.pop('charset', cls.charset)
-        kwargs['charset'] = charset
-        builder = EnvironBuilder(*args, **kwargs)
-        try:
-            return builder.get_request(cls)
-        finally:
-            builder.close()
-
-    @classmethod
-    def application(cls, f):
-        """Decorate a function as responder that accepts the request as first
-        argument.  This works like the :func:`responder` decorator but the
-        function is passed the request object as first argument and the
-        request object will be closed automatically::
-
-            @Request.application
-            def my_wsgi_app(request):
-                return Response('Hello World!')
-
-        As of Werkzeug 0.14 HTTP exceptions are automatically caught and
-        converted to responses instead of failing.
-
-        :param f: the WSGI callable to decorate
-        :return: a new WSGI callable
-        """
-        #: return a callable that wraps the -2nd argument with the request
-        #: and calls the function with all the arguments up to that one and
-        #: the request.  The return value is then called with the latest
-        #: two arguments.  This makes it possible to use this decorator for
-        #: both methods and standalone WSGI functions.
-        from werkzeug.exceptions import HTTPException
-
-        def application(*args):
-            request = cls(args[-2])
-            with request:
-                try:
-                    resp = f(*args[:-2] + (request,))
-                except HTTPException as e:
-                    resp = e.get_response(args[-2])
-                return resp(*args[-2:])
-
-        return update_wrapper(application, f)
-
-    def _get_file_stream(self, total_content_length, content_type, filename=None,
-                         content_length=None):
-        """Called to get a stream for the file upload.
-
-        This must provide a file-like class with `read()`, `readline()`
-        and `seek()` methods that is both writeable and readable.
-
-        The default implementation returns a temporary file if the total
-        content length is higher than 500KB.  Because many browsers do not
-        provide a content length for the files only the total content
-        length matters.
-
-        :param total_content_length: the total content length of all the
-                                     data in the request combined.  This value
-                                     is guaranteed to be there.
-        :param content_type: the mimetype of the uploaded file.
-        :param filename: the filename of the uploaded file.  May be `None`.
-        :param content_length: the length of this file.  This value is usually
-                               not provided because webbrowsers do not provide
-                               this value.
-        """
-        return default_stream_factory(
-            total_content_length=total_content_length,
-            content_type=content_type,
-            filename=filename,
-            content_length=content_length)
-
-    @property
-    def want_form_data_parsed(self):
-        """Returns True if the request method carries content.  As of
-        Werkzeug 0.9 this will be the case if a content type is transmitted.
-
-        .. versionadded:: 0.8
-        """
-        return bool(self.environ.get('CONTENT_TYPE'))
-
-    def make_form_data_parser(self):
-        """Creates the form data parser. Instantiates the
-        :attr:`form_data_parser_class` with some parameters.
-
-        .. versionadded:: 0.8
-        """
-        return self.form_data_parser_class(self._get_file_stream,
-                                           self.charset,
-                                           self.encoding_errors,
-                                           self.max_form_memory_size,
-                                           self.max_content_length,
-                                           self.parameter_storage_class)
-
-    def _load_form_data(self):
-        """Method used internally to retrieve submitted data.  After calling
-        this sets `form` and `files` on the request object to multi dicts
-        filled with the incoming form data.  As a matter of fact the input
-        stream will be empty afterwards.  You can also call this method to
-        force the parsing of the form data.
-
-        .. versionadded:: 0.8
-        """
-        # abort early if we have already consumed the stream
-        if 'form' in self.__dict__:
-            return
-
-        _assert_not_shallow(self)
-
-        if self.want_form_data_parsed:
-            content_type = self.environ.get('CONTENT_TYPE', '')
-            content_length = get_content_length(self.environ)
-            mimetype, options = parse_options_header(content_type)
-            parser = self.make_form_data_parser()
-            data = parser.parse(self._get_stream_for_parsing(),
-                                mimetype, content_length, options)
-        else:
-            data = (self.stream, self.parameter_storage_class(),
-                    self.parameter_storage_class())
-
-        # inject the values into the instance dict so that we bypass
-        # our cached_property non-data descriptor.
-        d = self.__dict__
-        d['stream'], d['form'], d['files'] = data
-
-    def _get_stream_for_parsing(self):
-        """This is the same as accessing :attr:`stream` with the difference
-        that if it finds cached data from calling :meth:`get_data` first it
-        will create a new stream out of the cached data.
-
-        .. versionadded:: 0.9.3
-        """
-        cached_data = getattr(self, '_cached_data', None)
-        if cached_data is not None:
-            return BytesIO(cached_data)
-        return self.stream
-
-    def close(self):
-        """Closes associated resources of this request object.  This
-        closes all file handles explicitly.  You can also use the request
-        object in a with statement which will automatically close it.
-
-        .. versionadded:: 0.9
-        """
-        files = self.__dict__.get('files')
-        for key, value in iter_multi_items(files or ()):
-            value.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close()
-
-    @cached_property
-    def stream(self):
-        """
-        If the incoming form data was not encoded with a known mimetype
-        the data is stored unmodified in this stream for consumption.  Most
-        of the time it is a better idea to use :attr:`data` which will give
-        you that data as a string.  The stream only returns the data once.
-
-        Unlike :attr:`input_stream` this stream is properly guarded that you
-        can't accidentally read past the length of the input.  Werkzeug will
-        internally always refer to this stream to read data which makes it
-        possible to wrap this object with a stream that does filtering.
-
-        .. versionchanged:: 0.9
-           This stream is now always available but might be consumed by the
-           form parser later on.  Previously the stream was only set if no
-           parsing happened.
-        """
-        _assert_not_shallow(self)
-        return get_input_stream(self.environ)
-
-    input_stream = environ_property('wsgi.input', """
-    The WSGI input stream.
-
-    In general it's a bad idea to use this one because you can easily read past
-    the boundary.  Use the :attr:`stream` instead.
-    """)
-
-    @cached_property
-    def args(self):
-        """The parsed URL parameters (the part in the URL after the question
-        mark).
-
-        By default an
-        :class:`~werkzeug.datastructures.ImmutableMultiDict`
-        is returned from this function.  This can be changed by setting
-        :attr:`parameter_storage_class` to a different type.  This might
-        be necessary if the order of the form data is important.
-        """
-        return url_decode(wsgi_get_bytes(self.environ.get('QUERY_STRING', '')),
-                          self.url_charset, errors=self.encoding_errors,
-                          cls=self.parameter_storage_class)
-
-    @cached_property
-    def data(self):
-        """
-        Contains the incoming request data as string in case it came with
-        a mimetype Werkzeug does not handle.
-        """
-
-        if self.disable_data_descriptor:
-            raise AttributeError('data descriptor is disabled')
-        # XXX: this should eventually be deprecated.
-
-        # We trigger form data parsing first which means that the descriptor
-        # will not cache the data that would otherwise be .form or .files
-        # data.  This restores the behavior that was there in Werkzeug
-        # before 0.9.  New code should use :meth:`get_data` explicitly as
-        # this will make behavior explicit.
-        return self.get_data(parse_form_data=True)
-
-    def get_data(self, cache=True, as_text=False, parse_form_data=False):
-        """This reads the buffered incoming data from the client into one
-        bytestring.  By default this is cached but that behavior can be
-        changed by setting `cache` to `False`.
-
-        Usually it's a bad idea to call this method without checking the
-        content length first as a client could send dozens of megabytes or more
-        to cause memory problems on the server.
-
-        Note that if the form data was already parsed this method will not
-        return anything as form data parsing does not cache the data like
-        this method does.  To implicitly invoke form data parsing function
-        set `parse_form_data` to `True`.  When this is done the return value
-        of this method will be an empty string if the form parser handles
-        the data.  This generally is not necessary as if the whole data is
-        cached (which is the default) the form parser will used the cached
-        data to parse the form data.  Please be generally aware of checking
-        the content length first in any case before calling this method
-        to avoid exhausting server memory.
-
-        If `as_text` is set to `True` the return value will be a decoded
-        unicode string.
-
-        .. versionadded:: 0.9
-        """
-        rv = getattr(self, '_cached_data', None)
-        if rv is None:
-            if parse_form_data:
-                self._load_form_data()
-            rv = self.stream.read()
-            if cache:
-                self._cached_data = rv
-        if as_text:
-            rv = rv.decode(self.charset, self.encoding_errors)
-        return rv
-
-    @cached_property
-    def form(self):
-        """The form parameters.  By default an
-        :class:`~werkzeug.datastructures.ImmutableMultiDict`
-        is returned from this function.  This can be changed by setting
-        :attr:`parameter_storage_class` to a different type.  This might
-        be necessary if the order of the form data is important.
-
-        Please keep in mind that file uploads will not end up here, but instead
-        in the :attr:`files` attribute.
-
-        .. versionchanged:: 0.9
-
-            Previous to Werkzeug 0.9 this would only contain form data for POST
-            and PUT requests.
-        """
-        self._load_form_data()
-        return self.form
-
-    @cached_property
-    def values(self):
-        """A :class:`werkzeug.datastructures.CombinedMultiDict` that combines
-        :attr:`args` and :attr:`form`."""
-        args = []
-        for d in self.args, self.form:
-            if not isinstance(d, MultiDict):
-                d = MultiDict(d)
-            args.append(d)
-        return CombinedMultiDict(args)
-
-    @cached_property
-    def files(self):
-        """:class:`~werkzeug.datastructures.MultiDict` object containing
-        all uploaded files.  Each key in :attr:`files` is the name from the
-        ``<input type="file" name="">``.  Each value in :attr:`files` is a
-        Werkzeug :class:`~werkzeug.datastructures.FileStorage` object.
-
-        It basically behaves like a standard file object you know from Python,
-        with the difference that it also has a
-        :meth:`~werkzeug.datastructures.FileStorage.save` function that can
-        store the file on the filesystem.
-
-        Note that :attr:`files` will only contain data if the request method was
-        POST, PUT or PATCH and the ``<form>`` that posted to the request had
-        ``enctype="multipart/form-data"``.  It will be empty otherwise.
-
-        See the :class:`~werkzeug.datastructures.MultiDict` /
-        :class:`~werkzeug.datastructures.FileStorage` documentation for
-        more details about the used data structure.
-        """
-        self._load_form_data()
-        return self.files
-
-    @cached_property
-    def cookies(self):
-        """A :class:`dict` with the contents of all cookies transmitted with
-        the request."""
-        return parse_cookie(self.environ, self.charset,
-                            self.encoding_errors,
-                            cls=self.dict_storage_class)
-
-    @cached_property
-    def headers(self):
-        """The headers from the WSGI environ as immutable
-        :class:`~werkzeug.datastructures.EnvironHeaders`.
-        """
-        return EnvironHeaders(self.environ)
-
-    @cached_property
-    def path(self):
-        """Requested path as unicode.  This works a bit like the regular path
-        info in the WSGI environment but will always include a leading slash,
-        even if the URL root is accessed.
-        """
-        raw_path = wsgi_decoding_dance(self.environ.get('PATH_INFO') or '',
-                                       self.charset, self.encoding_errors)
-        return '/' + raw_path.lstrip('/')
-
-    @cached_property
-    def full_path(self):
-        """Requested path as unicode, including the query string."""
-        return self.path + u'?' + to_unicode(self.query_string, self.url_charset)
-
-    @cached_property
-    def script_root(self):
-        """The root path of the script without the trailing slash."""
-        raw_path = wsgi_decoding_dance(self.environ.get('SCRIPT_NAME') or '',
-                                       self.charset, self.encoding_errors)
-        return raw_path.rstrip('/')
-
-    @cached_property
-    def url(self):
-        """The reconstructed current URL as IRI.
-        See also: :attr:`trusted_hosts`.
-        """
-        return get_current_url(self.environ,
-                               trusted_hosts=self.trusted_hosts)
-
-    @cached_property
-    def base_url(self):
-        """Like :attr:`url` but without the querystring
-        See also: :attr:`trusted_hosts`.
-        """
-        return get_current_url(self.environ, strip_querystring=True,
-                               trusted_hosts=self.trusted_hosts)
-
-    @cached_property
-    def url_root(self):
-        """The full URL root (with hostname), this is the application
-        root as IRI.
-        See also: :attr:`trusted_hosts`.
-        """
-        return get_current_url(self.environ, True,
-                               trusted_hosts=self.trusted_hosts)
-
-    @cached_property
-    def host_url(self):
-        """Just the host with scheme as IRI.
-        See also: :attr:`trusted_hosts`.
-        """
-        return get_current_url(self.environ, host_only=True,
-                               trusted_hosts=self.trusted_hosts)
-
-    @cached_property
-    def host(self):
-        """Just the host including the port if available.
-        See also: :attr:`trusted_hosts`.
-        """
-        return get_host(self.environ, trusted_hosts=self.trusted_hosts)
-
-    query_string = environ_property(
-        'QUERY_STRING', '', read_only=True,
-        load_func=wsgi_get_bytes, doc='The URL parameters as raw bytestring.')
-    method = environ_property(
-        'REQUEST_METHOD', 'GET', read_only=True,
-        load_func=lambda x: x.upper(),
-        doc="The request method. (For example ``'GET'`` or ``'POST'``).")
-
-    @cached_property
-    def access_route(self):
-        """If a forwarded header exists this is a list of all ip addresses
-        from the client ip to the last proxy server.
-        """
-        if 'HTTP_X_FORWARDED_FOR' in self.environ:
-            addr = self.environ['HTTP_X_FORWARDED_FOR'].split(',')
-            return self.list_storage_class([x.strip() for x in addr])
-        elif 'REMOTE_ADDR' in self.environ:
-            return self.list_storage_class([self.environ['REMOTE_ADDR']])
-        return self.list_storage_class()
-
-    @property
-    def remote_addr(self):
-        """The remote address of the client."""
-        return self.environ.get('REMOTE_ADDR')
-
-    remote_user = environ_property('REMOTE_USER', doc='''
-        If the server supports user authentication, and the script is
-        protected, this attribute contains the username the user has
-        authenticated as.''')
-
-    scheme = environ_property('wsgi.url_scheme', doc='''
-        URL scheme (http or https).
-
-        .. versionadded:: 0.7''')
-
-    @property
-    def is_xhr(self):
-        """True if the request was triggered via a JavaScript XMLHttpRequest.
-        This only works with libraries that support the ``X-Requested-With``
-        header and set it to "XMLHttpRequest".  Libraries that do that are
-        prototype, jQuery and Mochikit and probably some more.
-
-        .. deprecated:: 0.13
-            ``X-Requested-With`` is not standard and is unreliable.
-        """
-        warn(DeprecationWarning(
-            'Request.is_xhr is deprecated. Given that the X-Requested-With '
-            'header is not a part of any spec, it is not reliable'
-        ), stacklevel=2)
-        return self.environ.get(
-            'HTTP_X_REQUESTED_WITH', ''
-        ).lower() == 'xmlhttprequest'
-
-    is_secure = property(lambda x: x.environ['wsgi.url_scheme'] == 'https',
-                         doc='`True` if the request is secure.')
-    is_multithread = environ_property('wsgi.multithread', doc='''
-        boolean that is `True` if the application is served by
-        a multithreaded WSGI server.''')
-    is_multiprocess = environ_property('wsgi.multiprocess', doc='''
-        boolean that is `True` if the application is served by
-        a WSGI server that spawns multiple processes.''')
-    is_run_once = environ_property('wsgi.run_once', doc='''
-        boolean that is `True` if the application will be executed only
-        once in a process lifetime.  This is the case for CGI for example,
-        but it's not guaranteed that the execution only happens one time.''')
-
-
-class BaseResponse(object):
-
-    """Base response class.  The most important fact about a response object
-    is that it's a regular WSGI application.  It's initialized with a couple
-    of response parameters (headers, body, status code etc.) and will start a
-    valid WSGI response when called with the environ and start response
-    callable.
-
-    Because it's a WSGI application itself processing usually ends before the
-    actual response is sent to the server.  This helps debugging systems
-    because they can catch all the exceptions before responses are started.
-
-    Here a small example WSGI application that takes advantage of the
-    response objects::
-
-        from werkzeug.wrappers import BaseResponse as Response
-
-        def index():
-            return Response('Index page')
-
-        def application(environ, start_response):
-            path = environ.get('PATH_INFO') or '/'
-            if path == '/':
-                response = index()
-            else:
-                response = Response('Not Found', status=404)
-            return response(environ, start_response)
-
-    Like :class:`BaseRequest` which object is lacking a lot of functionality
-    implemented in mixins.  This gives you a better control about the actual
-    API of your response objects, so you can create subclasses and add custom
-    functionality.  A full featured response object is available as
-    :class:`Response` which implements a couple of useful mixins.
-
-    To enforce a new type of already existing responses you can use the
-    :meth:`force_type` method.  This is useful if you're working with different
-    subclasses of response objects and you want to post process them with a
-    known interface.
-
-    Per default the response object will assume all the text data is `utf-8`
-    encoded.  Please refer to `the unicode chapter <unicode.txt>`_ for more
-    details about customizing the behavior.
-
-    Response can be any kind of iterable or string.  If it's a string it's
-    considered being an iterable with one item which is the string passed.
-    Headers can be a list of tuples or a
-    :class:`~werkzeug.datastructures.Headers` object.
-
-    Special note for `mimetype` and `content_type`:  For most mime types
-    `mimetype` and `content_type` work the same, the difference affects
-    only 'text' mimetypes.  If the mimetype passed with `mimetype` is a
-    mimetype starting with `text/`, the charset parameter of the response
-    object is appended to it.  In contrast the `content_type` parameter is
-    always added as header unmodified.
-
-    .. versionchanged:: 0.5
-       the `direct_passthrough` parameter was added.
-
-    :param response: a string or response iterable.
-    :param status: a string with a status or an integer with the status code.
-    :param headers: a list of headers or a
-                    :class:`~werkzeug.datastructures.Headers` object.
-    :param mimetype: the mimetype for the response.  See notice above.
-    :param content_type: the content type for the response.  See notice above.
-    :param direct_passthrough: if set to `True` :meth:`iter_encoded` is not
-                               called before iteration which makes it
-                               possible to pass special iterators through
-                               unchanged (see :func:`wrap_file` for more
-                               details.)
-    """
-
-    #: the charset of the response.
-    charset = 'utf-8'
-
-    #: the default status if none is provided.
-    default_status = 200
-
-    #: the default mimetype if none is provided.
-    default_mimetype = 'text/plain'
-
-    #: if set to `False` accessing properties on the response object will
-    #: not try to consume the response iterator and convert it into a list.
-    #:
-    #: .. versionadded:: 0.6.2
-    #:
-    #:    That attribute was previously called `implicit_seqence_conversion`.
-    #:    (Notice the typo).  If you did use this feature, you have to adapt
-    #:    your code to the name change.
-    implicit_sequence_conversion = True
-
-    #: Should this response object correct the location header to be RFC
-    #: conformant?  This is true by default.
-    #:
-    #: .. versionadded:: 0.8
-    autocorrect_location_header = True
-
-    #: Should this response object automatically set the content-length
-    #: header if possible?  This is true by default.
-    #:
-    #: .. versionadded:: 0.8
-    automatically_set_content_length = True
-
-    #: Warn if a cookie header exceeds this size. The default, 4093, should be
-    #: safely `supported by most browsers <cookie_>`_. A cookie larger than
-    #: this size will still be sent, but it may be ignored or handled
-    #: incorrectly by some browsers. Set to 0 to disable this check.
-    #:
-    #: .. versionadded:: 0.13
-    #:
-    #: .. _`cookie`: http://browsercookielimits.squawky.net/
-    max_cookie_size = 4093
-
-    def __init__(self, response=None, status=None, headers=None,
-                 mimetype=None, content_type=None, direct_passthrough=False):
-        if isinstance(headers, Headers):
-            self.headers = headers
-        elif not headers:
-            self.headers = Headers()
-        else:
-            self.headers = Headers(headers)
-
-        if content_type is None:
-            if mimetype is None and 'content-type' not in self.headers:
-                mimetype = self.default_mimetype
-            if mimetype is not None:
-                mimetype = get_content_type(mimetype, self.charset)
-            content_type = mimetype
-        if content_type is not None:
-            self.headers['Content-Type'] = content_type
-        if status is None:
-            status = self.default_status
-        if isinstance(status, integer_types):
-            self.status_code = status
-        else:
-            self.status = status
-
-        self.direct_passthrough = direct_passthrough
-        self._on_close = []
-
-        # we set the response after the headers so that if a class changes
-        # the charset attribute, the data is set in the correct charset.
-        if response is None:
-            self.response = []
-        elif isinstance(response, (text_type, bytes, bytearray)):
-            self.set_data(response)
-        else:
-            self.response = response
-
-    def call_on_close(self, func):
-        """Adds a function to the internal list of functions that should
-        be called as part of closing down the response.  Since 0.7 this
-        function also returns the function that was passed so that this
-        can be used as a decorator.
-
-        .. versionadded:: 0.6
-        """
-        self._on_close.append(func)
-        return func
-
-    def __repr__(self):
-        if self.is_sequence:
-            body_info = '%d bytes' % sum(map(len, self.iter_encoded()))
-        else:
-            body_info = 'streamed' if self.is_streamed else 'likely-streamed'
-        return '<%s %s [%s]>' % (
-            self.__class__.__name__,
-            body_info,
-            self.status
-        )
-
-    @classmethod
-    def force_type(cls, response, environ=None):
-        """Enforce that the WSGI response is a response object of the current
-        type.  Werkzeug will use the :class:`BaseResponse` internally in many
-        situations like the exceptions.  If you call :meth:`get_response` on an
-        exception you will get back a regular :class:`BaseResponse` object, even
-        if you are using a custom subclass.
-
-        This method can enforce a given response type, and it will also
-        convert arbitrary WSGI callables into response objects if an environ
-        is provided::
-
-            # convert a Werkzeug response object into an instance of the
-            # MyResponseClass subclass.
-            response = MyResponseClass.force_type(response)
-
-            # convert any WSGI application into a response object
-            response = MyResponseClass.force_type(response, environ)
-
-        This is especially useful if you want to post-process responses in
-        the main dispatcher and use functionality provided by your subclass.
-
-        Keep in mind that this will modify response objects in place if
-        possible!
-
-        :param response: a response object or wsgi application.
-        :param environ: a WSGI environment object.
-        :return: a response object.
-        """
-        if not isinstance(response, BaseResponse):
-            if environ is None:
-                raise TypeError('cannot convert WSGI application into '
-                                'response objects without an environ')
-            response = BaseResponse(*_run_wsgi_app(response, environ))
-        response.__class__ = cls
-        return response
-
-    @classmethod
-    def from_app(cls, app, environ, buffered=False):
-        """Create a new response object from an application output.  This
-        works best if you pass it an application that returns a generator all
-        the time.  Sometimes applications may use the `write()` callable
-        returned by the `start_response` function.  This tries to resolve such
-        edge cases automatically.  But if you don't get the expected output
-        you should set `buffered` to `True` which enforces buffering.
-
-        :param app: the WSGI application to execute.
-        :param environ: the WSGI environment to execute against.
-        :param buffered: set to `True` to enforce buffering.
-        :return: a response object.
-        """
-        return cls(*_run_wsgi_app(app, environ, buffered))
-
-    def _get_status_code(self):
-        return self._status_code
-
-    def _set_status_code(self, code):
-        self._status_code = code
-        try:
-            self._status = '%d %s' % (code, HTTP_STATUS_CODES[code].upper())
-        except KeyError:
-            self._status = '%d UNKNOWN' % code
-    status_code = property(_get_status_code, _set_status_code,
-                           doc='The HTTP Status code as number')
-    del _get_status_code, _set_status_code
-
-    def _get_status(self):
-        return self._status
-
-    def _set_status(self, value):
-        try:
-            self._status = to_native(value)
-        except AttributeError:
-            raise TypeError('Invalid status argument')
-
-        try:
-            self._status_code = int(self._status.split(None, 1)[0])
-        except ValueError:
-            self._status_code = 0
-            self._status = '0 %s' % self._status
-        except IndexError:
-            raise ValueError('Empty status argument')
-    status = property(_get_status, _set_status, doc='The HTTP Status code')
-    del _get_status, _set_status
-
-    def get_data(self, as_text=False):
-        """The string representation of the request body.  Whenever you call
-        this property the request iterable is encoded and flattened.  This
-        can lead to unwanted behavior if you stream big data.
-
-        This behavior can be disabled by setting
-        :attr:`implicit_sequence_conversion` to `False`.
-
-        If `as_text` is set to `True` the return value will be a decoded
-        unicode string.
-
-        .. versionadded:: 0.9
-        """
-        self._ensure_sequence()
-        rv = b''.join(self.iter_encoded())
-        if as_text:
-            rv = rv.decode(self.charset)
-        return rv
-
-    def set_data(self, value):
-        """Sets a new string as response.  The value set must either by a
-        unicode or bytestring.  If a unicode string is set it's encoded
-        automatically to the charset of the response (utf-8 by default).
-
-        .. versionadded:: 0.9
-        """
-        # if an unicode string is set, it's encoded directly so that we
-        # can set the content length
-        if isinstance(value, text_type):
-            value = value.encode(self.charset)
-        else:
-            value = bytes(value)
-        self.response = [value]
-        if self.automatically_set_content_length:
-            self.headers['Content-Length'] = str(len(value))
-
-    data = property(get_data, set_data, doc='''
-        A descriptor that calls :meth:`get_data` and :meth:`set_data`.  This
-        should not be used and will eventually get deprecated.
-        ''')
-
-    def calculate_content_length(self):
-        """Returns the content length if available or `None` otherwise."""
-        try:
-            self._ensure_sequence()
-        except RuntimeError:
-            return None
-        return sum(len(x) for x in self.iter_encoded())
-
-    def _ensure_sequence(self, mutable=False):
-        """This method can be called by methods that need a sequence.  If
-        `mutable` is true, it will also ensure that the response sequence
-        is a standard Python list.
-
-        .. versionadded:: 0.6
-        """
-        if self.is_sequence:
-            # if we need a mutable object, we ensure it's a list.
-            if mutable and not isinstance(self.response, list):
-                self.response = list(self.response)
-            return
-        if self.direct_passthrough:
-            raise RuntimeError('Attempted implicit sequence conversion '
-                               'but the response object is in direct '
-                               'passthrough mode.')
-        if not self.implicit_sequence_conversion:
-            raise RuntimeError('The response object required the iterable '
-                               'to be a sequence, but the implicit '
-                               'conversion was disabled.  Call '
-                               'make_sequence() yourself.')
-        self.make_sequence()
-
-    def make_sequence(self):
-        """Converts the response iterator in a list.  By default this happens
-        automatically if required.  If `implicit_sequence_conversion` is
-        disabled, this method is not automatically called and some properties
-        might raise exceptions.  This also encodes all the items.
-
-        .. versionadded:: 0.6
-        """
-        if not self.is_sequence:
-            # if we consume an iterable we have to ensure that the close
-            # method of the iterable is called if available when we tear
-            # down the response
-            close = getattr(self.response, 'close', None)
-            self.response = list(self.iter_encoded())
-            if close is not None:
-                self.call_on_close(close)
-
-    def iter_encoded(self):
-        """Iter the response encoded with the encoding of the response.
-        If the response object is invoked as WSGI application the return
-        value of this method is used as application iterator unless
-        :attr:`direct_passthrough` was activated.
-        """
-        if __debug__:
-            _warn_if_string(self.response)
-        # Encode in a separate function so that self.response is fetched
-        # early.  This allows us to wrap the response with the return
-        # value from get_app_iter or iter_encoded.
-        return _iter_encoded(self.response, self.charset)
-
-    def set_cookie(self, key, value='', max_age=None, expires=None,
-                   path='/', domain=None, secure=False, httponly=False,
-                   samesite=None):
-        """Sets a cookie. The parameters are the same as in the cookie `Morsel`
-        object in the Python standard library but it accepts unicode data, too.
-
-        A warning is raised if the size of the cookie header exceeds
-        :attr:`max_cookie_size`, but the header will still be set.
-
-        :param key: the key (name) of the cookie to be set.
-        :param value: the value of the cookie.
-        :param max_age: should be a number of seconds, or `None` (default) if
-                        the cookie should last only as long as the client's
-                        browser session.
-        :param expires: should be a `datetime` object or UNIX timestamp.
-        :param path: limits the cookie to a given path, per default it will
-                     span the whole domain.
-        :param domain: if you want to set a cross-domain cookie.  For example,
-                       ``domain=".example.com"`` will set a cookie that is
-                       readable by the domain ``www.example.com``,
-                       ``foo.example.com`` etc.  Otherwise, a cookie will only
-                       be readable by the domain that set it.
-        :param secure: If `True`, the cookie will only be available via HTTPS
-        :param httponly: disallow JavaScript to access the cookie.  This is an
-                         extension to the cookie standard and probably not
-                         supported by all browsers.
-        :param samesite: Limits the scope of the cookie such that it will only
-                         be attached to requests if those requests are
-                         "same-site".
-        """
-        self.headers.add('Set-Cookie', dump_cookie(
-            key,
-            value=value,
-            max_age=max_age,
-            expires=expires,
-            path=path,
-            domain=domain,
-            secure=secure,
-            httponly=httponly,
-            charset=self.charset,
-            max_size=self.max_cookie_size,
-            samesite=samesite
-        ))
-
-    def delete_cookie(self, key, path='/', domain=None):
-        """Delete a cookie.  Fails silently if key doesn't exist.
-
-        :param key: the key (name) of the cookie to be deleted.
-        :param path: if the cookie that should be deleted was limited to a
-                     path, the path has to be defined here.
-        :param domain: if the cookie that should be deleted was limited to a
-                       domain, that domain has to be defined here.
-        """
-        self.set_cookie(key, expires=0, max_age=0, path=path, domain=domain)
-
-    @property
-    def is_streamed(self):
-        """If the response is streamed (the response is not an iterable with
-        a length information) this property is `True`.  In this case streamed
-        means that there is no information about the number of iterations.
-        This is usually `True` if a generator is passed to the response object.
-
-        This is useful for checking before applying some sort of post
-        filtering that should not take place for streamed responses.
-        """
-        try:
-            len(self.response)
-        except (TypeError, AttributeError):
-            return True
-        return False
-
-    @property
-    def is_sequence(self):
-        """If the iterator is buffered, this property will be `True`.  A
-        response object will consider an iterator to be buffered if the
-        response attribute is a list or tuple.
-
-        .. versionadded:: 0.6
-        """
-        return isinstance(self.response, (tuple, list))
-
-    def close(self):
-        """Close the wrapped response if possible.  You can also use the object
-        in a with statement which will automatically close it.
-
-        .. versionadded:: 0.9
-           Can now be used in a with statement.
-        """
-        if hasattr(self.response, 'close'):
-            self.response.close()
-        for func in self._on_close:
-            func()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close()
-
-    def freeze(self):
-        """Call this method if you want to make your response object ready for
-        being pickled.  This buffers the generator if there is one.  It will
-        also set the `Content-Length` header to the length of the body.
-
-        .. versionchanged:: 0.6
-           The `Content-Length` header is now set.
-        """
-        # we explicitly set the length to a list of the *encoded* response
-        # iterator.  Even if the implicit sequence conversion is disabled.
-        self.response = list(self.iter_encoded())
-        self.headers['Content-Length'] = str(sum(map(len, self.response)))
-
-    def get_wsgi_headers(self, environ):
-        """This is automatically called right before the response is started
-        and returns headers modified for the given environment.  It returns a
-        copy of the headers from the response with some modifications applied
-        if necessary.
-
-        For example the location header (if present) is joined with the root
-        URL of the environment.  Also the content length is automatically set
-        to zero here for certain status codes.
-
-        .. versionchanged:: 0.6
-           Previously that function was called `fix_headers` and modified
-           the response object in place.  Also since 0.6, IRIs in location
-           and content-location headers are handled properly.
-
-           Also starting with 0.6, Werkzeug will attempt to set the content
-           length if it is able to figure it out on its own.  This is the
-           case if all the strings in the response iterable are already
-           encoded and the iterable is buffered.
-
-        :param environ: the WSGI environment of the request.
-        :return: returns a new :class:`~werkzeug.datastructures.Headers`
-                 object.
-        """
-        headers = Headers(self.headers)
-        location = None
-        content_location = None
-        content_length = None
-        status = self.status_code
-
-        # iterate over the headers to find all values in one go.  Because
-        # get_wsgi_headers is used each response that gives us a tiny
-        # speedup.
-        for key, value in headers:
-            ikey = key.lower()
-            if ikey == u'location':
-                location = value
-            elif ikey == u'content-location':
-                content_location = value
-            elif ikey == u'content-length':
-                content_length = value
-
-        # make sure the location header is an absolute URL
-        if location is not None:
-            old_location = location
-            if isinstance(location, text_type):
-                # Safe conversion is necessary here as we might redirect
-                # to a broken URI scheme (for instance itms-services).
-                location = iri_to_uri(location, safe_conversion=True)
-
-            if self.autocorrect_location_header:
-                current_url = get_current_url(environ, root_only=True)
-                if isinstance(current_url, text_type):
-                    current_url = iri_to_uri(current_url)
-                location = url_join(current_url, location)
-            if location != old_location:
-                headers['Location'] = location
-
-        # make sure the content location is a URL
-        if content_location is not None and \
-           isinstance(content_location, text_type):
-            headers['Content-Location'] = iri_to_uri(content_location)
-
-        if status in (304, 412):
-            remove_entity_headers(headers)
-
-        # if we can determine the content length automatically, we
-        # should try to do that.  But only if this does not involve
-        # flattening the iterator or encoding of unicode strings in
-        # the response.  We however should not do that if we have a 304
-        # response.
-        if self.automatically_set_content_length and \
-           self.is_sequence and content_length is None and \
-           status not in (204, 304) and \
-           not (100 <= status < 200):
-            try:
-                content_length = sum(len(to_bytes(x, 'ascii'))
-                                     for x in self.response)
-            except UnicodeError:
-                # aha, something non-bytestringy in there, too bad, we
-                # can't safely figure out the length of the response.
-                pass
-            else:
-                headers['Content-Length'] = str(content_length)
-
-        return headers
-
-    def get_app_iter(self, environ):
-        """Returns the application iterator for the given environ.  Depending
-        on the request method and the current status code the return value
-        might be an empty response rather than the one from the response.
-
-        If the request method is `HEAD` or the status code is in a range
-        where the HTTP specification requires an empty response, an empty
-        iterable is returned.
-
-        .. versionadded:: 0.6
-
-        :param environ: the WSGI environment of the request.
-        :return: a response iterable.
-        """
-        status = self.status_code
-        if environ['REQUEST_METHOD'] == 'HEAD' or \
-           100 <= status < 200 or status in (204, 304, 412):
-            iterable = ()
-        elif self.direct_passthrough:
-            if __debug__:
-                _warn_if_string(self.response)
-            return self.response
-        else:
-            iterable = self.iter_encoded()
-        return ClosingIterator(iterable, self.close)
-
-    def get_wsgi_response(self, environ):
-        """Returns the final WSGI response as tuple.  The first item in
-        the tuple is the application iterator, the second the status and
-        the third the list of headers.  The response returned is created
-        specially for the given environment.  For example if the request
-        method in the WSGI environment is ``'HEAD'`` the response will
-        be empty and only the headers and status code will be present.
-
-        .. versionadded:: 0.6
-
-        :param environ: the WSGI environment of the request.
-        :return: an ``(app_iter, status, headers)`` tuple.
-        """
-        headers = self.get_wsgi_headers(environ)
-        app_iter = self.get_app_iter(environ)
-        return app_iter, self.status, headers.to_wsgi_list()
-
-    def __call__(self, environ, start_response):
-        """Process this response as WSGI application.
-
-        :param environ: the WSGI environment.
-        :param start_response: the response callable provided by the WSGI
-                               server.
-        :return: an application iterator
-        """
-        app_iter, status, headers = self.get_wsgi_response(environ)
-        start_response(status, headers)
-        return app_iter
-
-
-class AcceptMixin(object):
-
-    """A mixin for classes with an :attr:`~BaseResponse.environ` attribute
-    to get all the HTTP accept headers as
-    :class:`~werkzeug.datastructures.Accept` objects (or subclasses
-    thereof).
-    """
-
-    @cached_property
-    def accept_mimetypes(self):
-        """List of mimetypes this client supports as
-        :class:`~werkzeug.datastructures.MIMEAccept` object.
-        """
-        return parse_accept_header(self.environ.get('HTTP_ACCEPT'), MIMEAccept)
-
-    @cached_property
-    def accept_charsets(self):
-        """List of charsets this client supports as
-        :class:`~werkzeug.datastructures.CharsetAccept` object.
-        """
-        return parse_accept_header(self.environ.get('HTTP_ACCEPT_CHARSET'),
-                                   CharsetAccept)
-
-    @cached_property
-    def accept_encodings(self):
-        """List of encodings this client accepts.  Encodings in a HTTP term
-        are compression encodings such as gzip.  For charsets have a look at
-        :attr:`accept_charset`.
-        """
-        return parse_accept_header(self.environ.get('HTTP_ACCEPT_ENCODING'))
-
-    @cached_property
-    def accept_languages(self):
-        """List of languages this client accepts as
-        :class:`~werkzeug.datastructures.LanguageAccept` object.
-
-        .. versionchanged 0.5
-           In previous versions this was a regular
-           :class:`~werkzeug.datastructures.Accept` object.
-        """
-        return parse_accept_header(self.environ.get('HTTP_ACCEPT_LANGUAGE'),
-                                   LanguageAccept)
-
-
-class ETagRequestMixin(object):
-
-    """Add entity tag and cache descriptors to a request object or object with
-    a WSGI environment available as :attr:`~BaseRequest.environ`.  This not
-    only provides access to etags but also to the cache control header.
-    """
-
-    @cached_property
-    def cache_control(self):
-        """A :class:`~werkzeug.datastructures.RequestCacheControl` object
-        for the incoming cache control headers.
-        """
-        cache_control = self.environ.get('HTTP_CACHE_CONTROL')
-        return parse_cache_control_header(cache_control, None,
-                                          RequestCacheControl)
-
-    @cached_property
-    def if_match(self):
-        """An object containing all the etags in the `If-Match` header.
-
-        :rtype: :class:`~werkzeug.datastructures.ETags`
-        """
-        return parse_etags(self.environ.get('HTTP_IF_MATCH'))
-
-    @cached_property
-    def if_none_match(self):
-        """An object containing all the etags in the `If-None-Match` header.
-
-        :rtype: :class:`~werkzeug.datastructures.ETags`
-        """
-        return parse_etags(self.environ.get('HTTP_IF_NONE_MATCH'))
-
-    @cached_property
-    def if_modified_since(self):
-        """The parsed `If-Modified-Since` header as datetime object."""
-        return parse_date(self.environ.get('HTTP_IF_MODIFIED_SINCE'))
-
-    @cached_property
-    def if_unmodified_since(self):
-        """The parsed `If-Unmodified-Since` header as datetime object."""
-        return parse_date(self.environ.get('HTTP_IF_UNMODIFIED_SINCE'))
-
-    @cached_property
-    def if_range(self):
-        """The parsed `If-Range` header.
-
-        .. versionadded:: 0.7
-
-        :rtype: :class:`~werkzeug.datastructures.IfRange`
-        """
-        return parse_if_range_header(self.environ.get('HTTP_IF_RANGE'))
-
-    @cached_property
-    def range(self):
-        """The parsed `Range` header.
-
-        .. versionadded:: 0.7
-
-        :rtype: :class:`~werkzeug.datastructures.Range`
-        """
-        return parse_range_header(self.environ.get('HTTP_RANGE'))
-
-
-class UserAgentMixin(object):
-
-    """Adds a `user_agent` attribute to the request object which contains the
-    parsed user agent of the browser that triggered the request as a
-    :class:`~werkzeug.useragents.UserAgent` object.
-    """
-
-    @cached_property
-    def user_agent(self):
-        """The current user agent."""
-        from werkzeug.useragents import UserAgent
-        return UserAgent(self.environ)
-
-
-class AuthorizationMixin(object):
-
-    """Adds an :attr:`authorization` property that represents the parsed
-    value of the `Authorization` header as
-    :class:`~werkzeug.datastructures.Authorization` object.
-    """
-
-    @cached_property
-    def authorization(self):
-        """The `Authorization` object in parsed form."""
-        header = self.environ.get('HTTP_AUTHORIZATION')
-        return parse_authorization_header(header)
-
-
-class StreamOnlyMixin(object):
-
-    """If mixed in before the request object this will change the bahavior
-    of it to disable handling of form parsing.  This disables the
-    :attr:`files`, :attr:`form` attributes and will just provide a
-    :attr:`stream` attribute that however is always available.
-
-    .. versionadded:: 0.9
-    """
-
-    disable_data_descriptor = True
-    want_form_data_parsed = False
-
-
-class ETagResponseMixin(object):
-
-    """Adds extra functionality to a response object for etag and cache
-    handling.  This mixin requires an object with at least a `headers`
-    object that implements a dict like interface similar to
-    :class:`~werkzeug.datastructures.Headers`.
-
-    If you want the :meth:`freeze` method to automatically add an etag, you
-    have to mixin this method before the response base class.  The default
-    response class does not do that.
-    """
-
-    @property
-    def cache_control(self):
-        """The Cache-Control general-header field is used to specify
-        directives that MUST be obeyed by all caching mechanisms along the
-        request/response chain.
-        """
-        def on_update(cache_control):
-            if not cache_control and 'cache-control' in self.headers:
-                del self.headers['cache-control']
-            elif cache_control:
-                self.headers['Cache-Control'] = cache_control.to_header()
-        return parse_cache_control_header(self.headers.get('cache-control'),
-                                          on_update,
-                                          ResponseCacheControl)
-
-    def _wrap_response(self, start, length):
-        """Wrap existing Response in case of Range Request context."""
-        if self.status_code == 206:
-            self.response = _RangeWrapper(self.response, start, length)
-
-    def _is_range_request_processable(self, environ):
-        """Return ``True`` if `Range` header is present and if underlying
-        resource is considered unchanged when compared with `If-Range` header.
-        """
-        return (
-            'HTTP_IF_RANGE' not in environ
-            or not is_resource_modified(
-                environ, self.headers.get('etag'), None,
-                self.headers.get('last-modified'), ignore_if_range=False
-            )
-        ) and 'HTTP_RANGE' in environ
-
-    def _process_range_request(self, environ, complete_length=None, accept_ranges=None):
-        """Handle Range Request related headers (RFC7233).  If `Accept-Ranges`
-        header is valid, and Range Request is processable, we set the headers
-        as described by the RFC, and wrap the underlying response in a
-        RangeWrapper.
-
-        Returns ``True`` if Range Request can be fulfilled, ``False`` otherwise.
-
-        :raises: :class:`~werkzeug.exceptions.RequestedRangeNotSatisfiable`
-                 if `Range` header could not be parsed or satisfied.
-        """
-        from werkzeug.exceptions import RequestedRangeNotSatisfiable
-        if accept_ranges is None:
-            return False
-        self.headers['Accept-Ranges'] = accept_ranges
-        if not self._is_range_request_processable(environ) or complete_length is None:
-            return False
-        parsed_range = parse_range_header(environ.get('HTTP_RANGE'))
-        if parsed_range is None:
-            raise RequestedRangeNotSatisfiable(complete_length)
-        range_tuple = parsed_range.range_for_length(complete_length)
-        content_range_header = parsed_range.to_content_range_header(complete_length)
-        if range_tuple is None or content_range_header is None:
-            raise RequestedRangeNotSatisfiable(complete_length)
-        content_length = range_tuple[1] - range_tuple[0]
-        # Be sure not to send 206 response
-        # if requested range is the full content.
-        if content_length != complete_length:
-            self.headers['Content-Length'] = content_length
-            self.content_range = content_range_header
-            self.status_code = 206
-            self._wrap_response(range_tuple[0], content_length)
-            return True
-        return False
-
-    def make_conditional(self, request_or_environ, accept_ranges=False,
-                         complete_length=None):
-        """Make the response conditional to the request.  This method works
-        best if an etag was defined for the response already.  The `add_etag`
-        method can be used to do that.  If called without etag just the date
-        header is set.
-
-        This does nothing if the request method in the request or environ is
-        anything but GET or HEAD.
-
-        For optimal performance when handling range requests, it's recommended
-        that your response data object implements `seekable`, `seek` and `tell`
-        methods as described by :py:class:`io.IOBase`.  Objects returned by
-        :meth:`~werkzeug.wsgi.wrap_file` automatically implement those methods.
-
-        It does not remove the body of the response because that's something
-        the :meth:`__call__` function does for us automatically.
-
-        Returns self so that you can do ``return resp.make_conditional(req)``
-        but modifies the object in-place.
-
-        :param request_or_environ: a request object or WSGI environment to be
-                                   used to make the response conditional
-                                   against.
-        :param accept_ranges: This parameter dictates the value of
-                              `Accept-Ranges` header. If ``False`` (default),
-                              the header is not set. If ``True``, it will be set
-                              to ``"bytes"``. If ``None``, it will be set to
-                              ``"none"``. If it's a string, it will use this
-                              value.
-        :param complete_length: Will be used only in valid Range Requests.
-                                It will set `Content-Range` complete length
-                                value and compute `Content-Length` real value.
-                                This parameter is mandatory for successful
-                                Range Requests completion.
-        :raises: :class:`~werkzeug.exceptions.RequestedRangeNotSatisfiable`
-                 if `Range` header could not be parsed or satisfied.
-        """
-        environ = _get_environ(request_or_environ)
-        if environ['REQUEST_METHOD'] in ('GET', 'HEAD'):
-            # if the date is not in the headers, add it now.  We however
-            # will not override an already existing header.  Unfortunately
-            # this header will be overriden by many WSGI servers including
-            # wsgiref.
-            if 'date' not in self.headers:
-                self.headers['Date'] = http_date()
-            accept_ranges = _clean_accept_ranges(accept_ranges)
-            is206 = self._process_range_request(environ, complete_length, accept_ranges)
-            if not is206 and not is_resource_modified(
-                environ, self.headers.get('etag'), None,
-                self.headers.get('last-modified')
-            ):
-                if parse_etags(environ.get('HTTP_IF_MATCH')):
-                    self.status_code = 412
-                else:
-                    self.status_code = 304
-            if self.automatically_set_content_length and 'content-length' not in self.headers:
-                length = self.calculate_content_length()
-                if length is not None:
-                    self.headers['Content-Length'] = length
-        return self
-
-    def add_etag(self, overwrite=False, weak=False):
-        """Add an etag for the current response if there is none yet."""
-        if overwrite or 'etag' not in self.headers:
-            self.set_etag(generate_etag(self.get_data()), weak)
-
-    def set_etag(self, etag, weak=False):
-        """Set the etag, and override the old one if there was one."""
-        self.headers['ETag'] = quote_etag(etag, weak)
-
-    def get_etag(self):
-        """Return a tuple in the form ``(etag, is_weak)``.  If there is no
-        ETag the return value is ``(None, None)``.
-        """
-        return unquote_etag(self.headers.get('ETag'))
-
-    def freeze(self, no_etag=False):
-        """Call this method if you want to make your response object ready for
-        pickeling.  This buffers the generator if there is one.  This also
-        sets the etag unless `no_etag` is set to `True`.
-        """
-        if not no_etag:
-            self.add_etag()
-        super(ETagResponseMixin, self).freeze()
-
-    accept_ranges = header_property('Accept-Ranges', doc='''
-        The `Accept-Ranges` header.  Even though the name would indicate
-        that multiple values are supported, it must be one string token only.
-
-        The values ``'bytes'`` and ``'none'`` are common.
-
-        .. versionadded:: 0.7''')
-
-    def _get_content_range(self):
-        def on_update(rng):
-            if not rng:
-                del self.headers['content-range']
-            else:
-                self.headers['Content-Range'] = rng.to_header()
-        rv = parse_content_range_header(self.headers.get('content-range'),
-                                        on_update)
-        # always provide a content range object to make the descriptor
-        # more user friendly.  It provides an unset() method that can be
-        # used to remove the header quickly.
-        if rv is None:
-            rv = ContentRange(None, None, None, on_update=on_update)
-        return rv
-
-    def _set_content_range(self, value):
-        if not value:
-            del self.headers['content-range']
-        elif isinstance(value, string_types):
-            self.headers['Content-Range'] = value
-        else:
-            self.headers['Content-Range'] = value.to_header()
-    content_range = property(_get_content_range, _set_content_range, doc='''
-        The `Content-Range` header as
-        :class:`~werkzeug.datastructures.ContentRange` object.  Even if the
-        header is not set it wil provide such an object for easier
-        manipulation.
-
-        .. versionadded:: 0.7''')
-    del _get_content_range, _set_content_range
-
-
-class ResponseStream(object):
-
-    """A file descriptor like object used by the :class:`ResponseStreamMixin` to
-    represent the body of the stream.  It directly pushes into the response
-    iterable of the response object.
-    """
-
-    mode = 'wb+'
-
-    def __init__(self, response):
-        self.response = response
-        self.closed = False
-
-    def write(self, value):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        self.response._ensure_sequence(mutable=True)
-        self.response.response.append(value)
-        self.response.headers.pop('Content-Length', None)
-        return len(value)
-
-    def writelines(self, seq):
-        for item in seq:
-            self.write(item)
-
-    def close(self):
-        self.closed = True
-
-    def flush(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-
-    def isatty(self):
-        if self.closed:
-            raise ValueError('I/O operation on closed file')
-        return False
-
-    def tell(self):
-        self.response._ensure_sequence()
-        return sum(map(len, self.response.response))
-
-    @property
-    def encoding(self):
-        return self.response.charset
-
-
-class ResponseStreamMixin(object):
-
-    """Mixin for :class:`BaseRequest` subclasses.  Classes that inherit from
-    this mixin will automatically get a :attr:`stream` property that provides
-    a write-only interface to the response iterable.
-    """
-
-    @cached_property
-    def stream(self):
-        """The response iterable as write-only stream."""
-        return ResponseStream(self)
-
-
-class CommonRequestDescriptorsMixin(object):
-
-    """A mixin for :class:`BaseRequest` subclasses.  Request objects that
-    mix this class in will automatically get descriptors for a couple of
-    HTTP headers with automatic type conversion.
-
-    .. versionadded:: 0.5
-    """
-
-    content_type = environ_property('CONTENT_TYPE', doc='''
-        The Content-Type entity-header field indicates the media type of
-        the entity-body sent to the recipient or, in the case of the HEAD
-        method, the media type that would have been sent had the request
-        been a GET.''')
-
-    @cached_property
-    def content_length(self):
-        """The Content-Length entity-header field indicates the size of the
-        entity-body in bytes or, in the case of the HEAD method, the size of
-        the entity-body that would have been sent had the request been a
-        GET.
-        """
-        return get_content_length(self.environ)
-
-    content_encoding = environ_property('HTTP_CONTENT_ENCODING', doc='''
-        The Content-Encoding entity-header field is used as a modifier to the
-        media-type.  When present, its value indicates what additional content
-        codings have been applied to the entity-body, and thus what decoding
-        mechanisms must be applied in order to obtain the media-type
-        referenced by the Content-Type header field.
-
-        .. versionadded:: 0.9''')
-    content_md5 = environ_property('HTTP_CONTENT_MD5', doc='''
-         The Content-MD5 entity-header field, as defined in RFC 1864, is an
-         MD5 digest of the entity-body for the purpose of providing an
-         end-to-end message integrity check (MIC) of the entity-body.  (Note:
-         a MIC is good for detecting accidental modification of the
-         entity-body in transit, but is not proof against malicious attacks.)
-
-        .. versionadded:: 0.9''')
-    referrer = environ_property('HTTP_REFERER', doc='''
-        The Referer[sic] request-header field allows the client to specify,
-        for the server's benefit, the address (URI) of the resource from which
-        the Request-URI was obtained (the "referrer", although the header
-        field is misspelled).''')
-    date = environ_property('HTTP_DATE', None, parse_date, doc='''
-        The Date general-header field represents the date and time at which
-        the message was originated, having the same semantics as orig-date
-        in RFC 822.''')
-    max_forwards = environ_property('HTTP_MAX_FORWARDS', None, int, doc='''
-         The Max-Forwards request-header field provides a mechanism with the
-         TRACE and OPTIONS methods to limit the number of proxies or gateways
-         that can forward the request to the next inbound server.''')
-
-    def _parse_content_type(self):
-        if not hasattr(self, '_parsed_content_type'):
-            self._parsed_content_type = \
-                parse_options_header(self.environ.get('CONTENT_TYPE', ''))
-
-    @property
-    def mimetype(self):
-        """Like :attr:`content_type`, but without parameters (eg, without
-        charset, type etc.) and always lowercase.  For example if the content
-        type is ``text/HTML; charset=utf-8`` the mimetype would be
-        ``'text/html'``.
-        """
-        self._parse_content_type()
-        return self._parsed_content_type[0].lower()
-
-    @property
-    def mimetype_params(self):
-        """The mimetype parameters as dict.  For example if the content
-        type is ``text/html; charset=utf-8`` the params would be
-        ``{'charset': 'utf-8'}``.
-        """
-        self._parse_content_type()
-        return self._parsed_content_type[1]
-
-    @cached_property
-    def pragma(self):
-        """The Pragma general-header field is used to include
-        implementation-specific directives that might apply to any recipient
-        along the request/response chain.  All pragma directives specify
-        optional behavior from the viewpoint of the protocol; however, some
-        systems MAY require that behavior be consistent with the directives.
-        """
-        return parse_set_header(self.environ.get('HTTP_PRAGMA', ''))
-
-
-class CommonResponseDescriptorsMixin(object):
-
-    """A mixin for :class:`BaseResponse` subclasses.  Response objects that
-    mix this class in will automatically get descriptors for a couple of
-    HTTP headers with automatic type conversion.
-    """
-
-    def _get_mimetype(self):
-        ct = self.headers.get('content-type')
-        if ct:
-            return ct.split(';')[0].strip()
-
-    def _set_mimetype(self, value):
-        self.headers['Content-Type'] = get_content_type(value, self.charset)
-
-    def _get_mimetype_params(self):
-        def on_update(d):
-            self.headers['Content-Type'] = \
-                dump_options_header(self.mimetype, d)
-        d = parse_options_header(self.headers.get('content-type', ''))[1]
-        return CallbackDict(d, on_update)
-
-    mimetype = property(_get_mimetype, _set_mimetype, doc='''
-        The mimetype (content type without charset etc.)''')
-    mimetype_params = property(_get_mimetype_params, doc='''
-        The mimetype parameters as dict.  For example if the content
-        type is ``text/html; charset=utf-8`` the params would be
-        ``{'charset': 'utf-8'}``.
-
-        .. versionadded:: 0.5
-        ''')
-    location = header_property('Location', doc='''
-        The Location response-header field is used to redirect the recipient
-        to a location other than the Request-URI for completion of the request
-        or identification of a new resource.''')
-    age = header_property('Age', None, parse_age, dump_age, doc='''
-        The Age response-header field conveys the sender's estimate of the
-        amount of time since the response (or its revalidation) was
-        generated at the origin server.
-
-        Age values are non-negative decimal integers, representing time in
-        seconds.''')
-    content_type = header_property('Content-Type', doc='''
-        The Content-Type entity-header field indicates the media type of the
-        entity-body sent to the recipient or, in the case of the HEAD method,
-        the media type that would have been sent had the request been a GET.
-    ''')
-    content_length = header_property('Content-Length', None, int, str, doc='''
-        The Content-Length entity-header field indicates the size of the
-        entity-body, in decimal number of OCTETs, sent to the recipient or,
-        in the case of the HEAD method, the size of the entity-body that would
-        have been sent had the request been a GET.''')
-    content_location = header_property('Content-Location', doc='''
-        The Content-Location entity-header field MAY be used to supply the
-        resource location for the entity enclosed in the message when that
-        entity is accessible from a location separate from the requested
-        resource's URI.''')
-    content_encoding = header_property('Content-Encoding', doc='''
-        The Content-Encoding entity-header field is used as a modifier to the
-        media-type.  When present, its value indicates what additional content
-        codings have been applied to the entity-body, and thus what decoding
-        mechanisms must be applied in order to obtain the media-type
-        referenced by the Content-Type header field.''')
-    content_md5 = header_property('Content-MD5', doc='''
-         The Content-MD5 entity-header field, as defined in RFC 1864, is an
-         MD5 digest of the entity-body for the purpose of providing an
-         end-to-end message integrity check (MIC) of the entity-body.  (Note:
-         a MIC is good for detecting accidental modification of the
-         entity-body in transit, but is not proof against malicious attacks.)
-        ''')
-    date = header_property('Date', None, parse_date, http_date, doc='''
-        The Date general-header field represents the date and time at which
-        the message was originated, having the same semantics as orig-date
-        in RFC 822.''')
-    expires = header_property('Expires', None, parse_date, http_date, doc='''
-        The Expires entity-header field gives the date/time after which the
-        response is considered stale. A stale cache entry may not normally be
-        returned by a cache.''')
-    last_modified = header_property('Last-Modified', None, parse_date,
-                                    http_date, doc='''
-        The Last-Modified entity-header field indicates the date and time at
-        which the origin server believes the variant was last modified.''')
-
-    def _get_retry_after(self):
-        value = self.headers.get('retry-after')
-        if value is None:
-            return
-        elif value.isdigit():
-            return datetime.utcnow() + timedelta(seconds=int(value))
-        return parse_date(value)
-
-    def _set_retry_after(self, value):
-        if value is None:
-            if 'retry-after' in self.headers:
-                del self.headers['retry-after']
-            return
-        elif isinstance(value, datetime):
-            value = http_date(value)
-        else:
-            value = str(value)
-        self.headers['Retry-After'] = value
-
-    retry_after = property(_get_retry_after, _set_retry_after, doc='''
-        The Retry-After response-header field can be used with a 503 (Service
-        Unavailable) response to indicate how long the service is expected
-        to be unavailable to the requesting client.
-
-        Time in seconds until expiration or date.''')
-
-    def _set_property(name, doc=None):
-        def fget(self):
-            def on_update(header_set):
-                if not header_set and name in self.headers:
-                    del self.headers[name]
-                elif header_set:
-                    self.headers[name] = header_set.to_header()
-            return parse_set_header(self.headers.get(name), on_update)
-
-        def fset(self, value):
-            if not value:
-                del self.headers[name]
-            elif isinstance(value, string_types):
-                self.headers[name] = value
-            else:
-                self.headers[name] = dump_header(value)
-        return property(fget, fset, doc=doc)
-
-    vary = _set_property('Vary', doc='''
-         The Vary field value indicates the set of request-header fields that
-         fully determines, while the response is fresh, whether a cache is
-         permitted to use the response to reply to a subsequent request
-         without revalidation.''')
-    content_language = _set_property('Content-Language', doc='''
-         The Content-Language entity-header field describes the natural
-         language(s) of the intended audience for the enclosed entity.  Note
-         that this might not be equivalent to all the languages used within
-         the entity-body.''')
-    allow = _set_property('Allow', doc='''
-        The Allow entity-header field lists the set of methods supported
-        by the resource identified by the Request-URI. The purpose of this
-        field is strictly to inform the recipient of valid methods
-        associated with the resource. An Allow header field MUST be
-        present in a 405 (Method Not Allowed) response.''')
-
-    del _set_property, _get_mimetype, _set_mimetype, _get_retry_after, \
-        _set_retry_after
-
-
-class WWWAuthenticateMixin(object):
-
-    """Adds a :attr:`www_authenticate` property to a response object."""
-
-    @property
-    def www_authenticate(self):
-        """The `WWW-Authenticate` header in a parsed form."""
-        def on_update(www_auth):
-            if not www_auth and 'www-authenticate' in self.headers:
-                del self.headers['www-authenticate']
-            elif www_auth:
-                self.headers['WWW-Authenticate'] = www_auth.to_header()
-        header = self.headers.get('www-authenticate')
-        return parse_www_authenticate_header(header, on_update)
-
-
-class Request(BaseRequest, AcceptMixin, ETagRequestMixin,
-              UserAgentMixin, AuthorizationMixin,
-              CommonRequestDescriptorsMixin):
-
-    """Full featured request object implementing the following mixins:
-
-    - :class:`AcceptMixin` for accept header parsing
-    - :class:`ETagRequestMixin` for etag and cache control handling
-    - :class:`UserAgentMixin` for user agent introspection
-    - :class:`AuthorizationMixin` for http auth handling
-    - :class:`CommonRequestDescriptorsMixin` for common headers
-    """
-
-
-class PlainRequest(StreamOnlyMixin, Request):
-
-    """A request object without special form parsing capabilities.
-
-    .. versionadded:: 0.9
-    """
-
-
-class Response(BaseResponse, ETagResponseMixin, ResponseStreamMixin,
-               CommonResponseDescriptorsMixin,
-               WWWAuthenticateMixin):
-
-    """Full featured response object implementing the following mixins:
-
-    - :class:`ETagResponseMixin` for etag and cache control handling
-    - :class:`ResponseStreamMixin` to add support for the `stream` property
-    - :class:`CommonResponseDescriptorsMixin` for various HTTP descriptors
-    - :class:`WWWAuthenticateMixin` for HTTP authentication support
-    """
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wsgi.py b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wsgi.py
deleted file mode 100644
index c30021a7b..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/lib/python3.5/site-packages/werkzeug/wsgi.py
+++ /dev/null
@@ -1,1364 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug.wsgi
-    ~~~~~~~~~~~~~
-
-    This module implements WSGI related helpers.
-
-    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
-    :license: BSD, see LICENSE for more details.
-"""
-import io
-try:
-    import httplib
-except ImportError:
-    from http import client as httplib
-import mimetypes
-import os
-import posixpath
-import re
-import socket
-from datetime import datetime
-from functools import partial, update_wrapper
-from itertools import chain
-from time import mktime, time
-from zlib import adler32
-
-from werkzeug._compat import BytesIO, PY2, implements_iterator, iteritems, \
-    make_literal_wrapper, string_types, text_type, to_bytes, to_unicode, \
-    try_coerce_native, wsgi_get_bytes
-from werkzeug._internal import _empty_stream, _encode_idna
-from werkzeug.filesystem import get_filesystem_encoding
-from werkzeug.http import http_date, is_resource_modified, \
-    is_hop_by_hop_header
-from werkzeug.urls import uri_to_iri, url_join, url_parse, url_quote
-from werkzeug.datastructures import EnvironHeaders
-
-
-def responder(f):
-    """Marks a function as responder.  Decorate a function with it and it
-    will automatically call the return value as WSGI application.
-
-    Example::
-
-        @responder
-        def application(environ, start_response):
-            return Response('Hello World!')
-    """
-    return update_wrapper(lambda *a: f(*a)(*a[-2:]), f)
-
-
-def get_current_url(environ, root_only=False, strip_querystring=False,
-                    host_only=False, trusted_hosts=None):
-    """A handy helper function that recreates the full URL as IRI for the
-    current request or parts of it.  Here's an example:
-
-    >>> from werkzeug.test import create_environ
-    >>> env = create_environ("/?param=foo", "http://localhost/script")
-    >>> get_current_url(env)
-    'http://localhost/script/?param=foo'
-    >>> get_current_url(env, root_only=True)
-    'http://localhost/script/'
-    >>> get_current_url(env, host_only=True)
-    'http://localhost/'
-    >>> get_current_url(env, strip_querystring=True)
-    'http://localhost/script/'
-
-    This optionally it verifies that the host is in a list of trusted hosts.
-    If the host is not in there it will raise a
-    :exc:`~werkzeug.exceptions.SecurityError`.
-
-    Note that the string returned might contain unicode characters as the
-    representation is an IRI not an URI.  If you need an ASCII only
-    representation you can use the :func:`~werkzeug.urls.iri_to_uri`
-    function:
-
-    >>> from werkzeug.urls import iri_to_uri
-    >>> iri_to_uri(get_current_url(env))
-    'http://localhost/script/?param=foo'
-
-    :param environ: the WSGI environment to get the current URL from.
-    :param root_only: set `True` if you only want the root URL.
-    :param strip_querystring: set to `True` if you don't want the querystring.
-    :param host_only: set to `True` if the host URL should be returned.
-    :param trusted_hosts: a list of trusted hosts, see :func:`host_is_trusted`
-                          for more information.
-    """
-    tmp = [environ['wsgi.url_scheme'], '://', get_host(environ, trusted_hosts)]
-    cat = tmp.append
-    if host_only:
-        return uri_to_iri(''.join(tmp) + '/')
-    cat(url_quote(wsgi_get_bytes(environ.get('SCRIPT_NAME', ''))).rstrip('/'))
-    cat('/')
-    if not root_only:
-        cat(url_quote(wsgi_get_bytes(environ.get('PATH_INFO', '')).lstrip(b'/')))
-        if not strip_querystring:
-            qs = get_query_string(environ)
-            if qs:
-                cat('?' + qs)
-    return uri_to_iri(''.join(tmp))
-
-
-def host_is_trusted(hostname, trusted_list):
-    """Checks if a host is trusted against a list.  This also takes care
-    of port normalization.
-
-    .. versionadded:: 0.9
-
-    :param hostname: the hostname to check
-    :param trusted_list: a list of hostnames to check against.  If a
-                         hostname starts with a dot it will match against
-                         all subdomains as well.
-    """
-    if not hostname:
-        return False
-
-    if isinstance(trusted_list, string_types):
-        trusted_list = [trusted_list]
-
-    def _normalize(hostname):
-        if ':' in hostname:
-            hostname = hostname.rsplit(':', 1)[0]
-        return _encode_idna(hostname)
-
-    try:
-        hostname = _normalize(hostname)
-    except UnicodeError:
-        return False
-    for ref in trusted_list:
-        if ref.startswith('.'):
-            ref = ref[1:]
-            suffix_match = True
-        else:
-            suffix_match = False
-        try:
-            ref = _normalize(ref)
-        except UnicodeError:
-            return False
-        if ref == hostname:
-            return True
-        if suffix_match and hostname.endswith(b'.' + ref):
-            return True
-    return False
-
-
-def get_host(environ, trusted_hosts=None):
-    """Return the real host for the given WSGI environment.  This first checks
-    the `X-Forwarded-Host` header, then the normal `Host` header, and finally
-    the `SERVER_NAME` environment variable (using the first one it finds).
-
-    Optionally it verifies that the host is in a list of trusted hosts.
-    If the host is not in there it will raise a
-    :exc:`~werkzeug.exceptions.SecurityError`.
-
-    :param environ: the WSGI environment to get the host of.
-    :param trusted_hosts: a list of trusted hosts, see :func:`host_is_trusted`
-                          for more information.
-    """
-    if 'HTTP_X_FORWARDED_HOST' in environ:
-        rv = environ['HTTP_X_FORWARDED_HOST'].split(',', 1)[0].strip()
-    elif 'HTTP_HOST' in environ:
-        rv = environ['HTTP_HOST']
-    else:
-        rv = environ['SERVER_NAME']
-        if (environ['wsgi.url_scheme'], environ['SERVER_PORT']) not \
-           in (('https', '443'), ('http', '80')):
-            rv += ':' + environ['SERVER_PORT']
-    if trusted_hosts is not None:
-        if not host_is_trusted(rv, trusted_hosts):
-            from werkzeug.exceptions import SecurityError
-            raise SecurityError('Host "%s" is not trusted' % rv)
-    return rv
-
-
-def get_content_length(environ):
-    """Returns the content length from the WSGI environment as
-    integer. If it's not available or chunked transfer encoding is used,
-    ``None`` is returned.
-
-    .. versionadded:: 0.9
-
-    :param environ: the WSGI environ to fetch the content length from.
-    """
-    if environ.get('HTTP_TRANSFER_ENCODING', '') == 'chunked':
-        return None
-
-    content_length = environ.get('CONTENT_LENGTH')
-    if content_length is not None:
-        try:
-            return max(0, int(content_length))
-        except (ValueError, TypeError):
-            pass
-
-
-def get_input_stream(environ, safe_fallback=True):
-    """Returns the input stream from the WSGI environment and wraps it
-    in the most sensible way possible. The stream returned is not the
-    raw WSGI stream in most cases but one that is safe to read from
-    without taking into account the content length.
-
-    If content length is not set, the stream will be empty for safety reasons.
-    If the WSGI server supports chunked or infinite streams, it should set
-    the ``wsgi.input_terminated`` value in the WSGI environ to indicate that.
-
-    .. versionadded:: 0.9
-
-    :param environ: the WSGI environ to fetch the stream from.
-    :param safe_fallback: use an empty stream as a safe fallback when the
-        content length is not set. Disabling this allows infinite streams,
-        which can be a denial-of-service risk.
-    """
-    stream = environ['wsgi.input']
-    content_length = get_content_length(environ)
-
-    # A wsgi extension that tells us if the input is terminated.  In
-    # that case we return the stream unchanged as we know we can safely
-    # read it until the end.
-    if environ.get('wsgi.input_terminated'):
-        return stream
-
-    # If the request doesn't specify a content length, returning the stream is
-    # potentially dangerous because it could be infinite, malicious or not. If
-    # safe_fallback is true, return an empty stream instead for safety.
-    if content_length is None:
-        return safe_fallback and _empty_stream or stream
-
-    # Otherwise limit the stream to the content length
-    return LimitedStream(stream, content_length)
-
-
-def get_query_string(environ):
-    """Returns the `QUERY_STRING` from the WSGI environment.  This also takes
-    care about the WSGI decoding dance on Python 3 environments as a
-    native string.  The string returned will be restricted to ASCII
-    characters.
-
-    .. versionadded:: 0.9
-
-    :param environ: the WSGI environment object to get the query string from.
-    """
-    qs = wsgi_get_bytes(environ.get('QUERY_STRING', ''))
-    # QUERY_STRING really should be ascii safe but some browsers
-    # will send us some unicode stuff (I am looking at you IE).
-    # In that case we want to urllib quote it badly.
-    return try_coerce_native(url_quote(qs, safe=':&%=+$!*\'(),'))
-
-
-def get_path_info(environ, charset='utf-8', errors='replace'):
-    """Returns the `PATH_INFO` from the WSGI environment and properly
-    decodes it.  This also takes care about the WSGI decoding dance
-    on Python 3 environments.  if the `charset` is set to `None` a
-    bytestring is returned.
-
-    .. versionadded:: 0.9
-
-    :param environ: the WSGI environment object to get the path from.
-    :param charset: the charset for the path info, or `None` if no
-                    decoding should be performed.
-    :param errors: the decoding error handling.
-    """
-    path = wsgi_get_bytes(environ.get('PATH_INFO', ''))
-    return to_unicode(path, charset, errors, allow_none_charset=True)
-
-
-def get_script_name(environ, charset='utf-8', errors='replace'):
-    """Returns the `SCRIPT_NAME` from the WSGI environment and properly
-    decodes it.  This also takes care about the WSGI decoding dance
-    on Python 3 environments.  if the `charset` is set to `None` a
-    bytestring is returned.
-
-    .. versionadded:: 0.9
-
-    :param environ: the WSGI environment object to get the path from.
-    :param charset: the charset for the path, or `None` if no
-                    decoding should be performed.
-    :param errors: the decoding error handling.
-    """
-    path = wsgi_get_bytes(environ.get('SCRIPT_NAME', ''))
-    return to_unicode(path, charset, errors, allow_none_charset=True)
-
-
-def pop_path_info(environ, charset='utf-8', errors='replace'):
-    """Removes and returns the next segment of `PATH_INFO`, pushing it onto
-    `SCRIPT_NAME`.  Returns `None` if there is nothing left on `PATH_INFO`.
-
-    If the `charset` is set to `None` a bytestring is returned.
-
-    If there are empty segments (``'/foo//bar``) these are ignored but
-    properly pushed to the `SCRIPT_NAME`:
-
-    >>> env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b'}
-    >>> pop_path_info(env)
-    'a'
-    >>> env['SCRIPT_NAME']
-    '/foo/a'
-    >>> pop_path_info(env)
-    'b'
-    >>> env['SCRIPT_NAME']
-    '/foo/a/b'
-
-    .. versionadded:: 0.5
-
-    .. versionchanged:: 0.9
-       The path is now decoded and a charset and encoding
-       parameter can be provided.
-
-    :param environ: the WSGI environment that is modified.
-    """
-    path = environ.get('PATH_INFO')
-    if not path:
-        return None
-
-    script_name = environ.get('SCRIPT_NAME', '')
-
-    # shift multiple leading slashes over
-    old_path = path
-    path = path.lstrip('/')
-    if path != old_path:
-        script_name += '/' * (len(old_path) - len(path))
-
-    if '/' not in path:
-        environ['PATH_INFO'] = ''
-        environ['SCRIPT_NAME'] = script_name + path
-        rv = wsgi_get_bytes(path)
-    else:
-        segment, path = path.split('/', 1)
-        environ['PATH_INFO'] = '/' + path
-        environ['SCRIPT_NAME'] = script_name + segment
-        rv = wsgi_get_bytes(segment)
-
-    return to_unicode(rv, charset, errors, allow_none_charset=True)
-
-
-def peek_path_info(environ, charset='utf-8', errors='replace'):
-    """Returns the next segment on the `PATH_INFO` or `None` if there
-    is none.  Works like :func:`pop_path_info` without modifying the
-    environment:
-
-    >>> env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b'}
-    >>> peek_path_info(env)
-    'a'
-    >>> peek_path_info(env)
-    'a'
-
-    If the `charset` is set to `None` a bytestring is returned.
-
-    .. versionadded:: 0.5
-
-    .. versionchanged:: 0.9
-       The path is now decoded and a charset and encoding
-       parameter can be provided.
-
-    :param environ: the WSGI environment that is checked.
-    """
-    segments = environ.get('PATH_INFO', '').lstrip('/').split('/', 1)
-    if segments:
-        return to_unicode(wsgi_get_bytes(segments[0]),
-                          charset, errors, allow_none_charset=True)
-
-
-def extract_path_info(environ_or_baseurl, path_or_url, charset='utf-8',
-                      errors='replace', collapse_http_schemes=True):
-    """Extracts the path info from the given URL (or WSGI environment) and
-    path.  The path info returned is a unicode string, not a bytestring
-    suitable for a WSGI environment.  The URLs might also be IRIs.
-
-    If the path info could not be determined, `None` is returned.
-
-    Some examples:
-
-    >>> extract_path_info('http://example.com/app', '/app/hello')
-    u'/hello'
-    >>> extract_path_info('http://example.com/app',
-    ...                   'https://example.com/app/hello')
-    u'/hello'
-    >>> extract_path_info('http://example.com/app',
-    ...                   'https://example.com/app/hello',
-    ...                   collapse_http_schemes=False) is None
-    True
-
-    Instead of providing a base URL you can also pass a WSGI environment.
-
-    .. versionadded:: 0.6
-
-    :param environ_or_baseurl: a WSGI environment dict, a base URL or
-                               base IRI.  This is the root of the
-                               application.
-    :param path_or_url: an absolute path from the server root, a
-                        relative path (in which case it's the path info)
-                        or a full URL.  Also accepts IRIs and unicode
-                        parameters.
-    :param charset: the charset for byte data in URLs
-    :param errors: the error handling on decode
-    :param collapse_http_schemes: if set to `False` the algorithm does
-                                  not assume that http and https on the
-                                  same server point to the same
-                                  resource.
-    """
-    def _normalize_netloc(scheme, netloc):
-        parts = netloc.split(u'@', 1)[-1].split(u':', 1)
-        if len(parts) == 2:
-            netloc, port = parts
-            if (scheme == u'http' and port == u'80') or \
-               (scheme == u'https' and port == u'443'):
-                port = None
-        else:
-            netloc = parts[0]
-            port = None
-        if port is not None:
-            netloc += u':' + port
-        return netloc
-
-    # make sure whatever we are working on is a IRI and parse it
-    path = uri_to_iri(path_or_url, charset, errors)
-    if isinstance(environ_or_baseurl, dict):
-        environ_or_baseurl = get_current_url(environ_or_baseurl,
-                                             root_only=True)
-    base_iri = uri_to_iri(environ_or_baseurl, charset, errors)
-    base_scheme, base_netloc, base_path = url_parse(base_iri)[:3]
-    cur_scheme, cur_netloc, cur_path, = \
-        url_parse(url_join(base_iri, path))[:3]
-
-    # normalize the network location
-    base_netloc = _normalize_netloc(base_scheme, base_netloc)
-    cur_netloc = _normalize_netloc(cur_scheme, cur_netloc)
-
-    # is that IRI even on a known HTTP scheme?
-    if collapse_http_schemes:
-        for scheme in base_scheme, cur_scheme:
-            if scheme not in (u'http', u'https'):
-                return None
-    else:
-        if not (base_scheme in (u'http', u'https') and
-                base_scheme == cur_scheme):
-            return None
-
-    # are the netlocs compatible?
-    if base_netloc != cur_netloc:
-        return None
-
-    # are we below the application path?
-    base_path = base_path.rstrip(u'/')
-    if not cur_path.startswith(base_path):
-        return None
-
-    return u'/' + cur_path[len(base_path):].lstrip(u'/')
-
-
-class ProxyMiddleware(object):
-    """This middleware routes some requests to the provided WSGI app and
-    proxies some requests to an external server.  This is not something that
-    can generally be done on the WSGI layer and some HTTP requests will not
-    tunnel through correctly (for instance websocket requests cannot be
-    proxied through WSGI).  As a result this is only really useful for some
-    basic requests that can be forwarded.
-
-    Example configuration::
-
-        app = ProxyMiddleware(app, {
-            '/static/': {
-                'target': 'http://127.0.0.1:5001/',
-            }
-        })
-
-    For each host options can be specified.  The following options are
-    supported:
-
-    ``target``:
-        the target URL to dispatch to
-    ``remove_prefix``:
-        if set to `True` the prefix is chopped off the URL before
-        dispatching it to the server.
-    ``host``:
-        When set to ``'<auto>'`` which is the default the host header is
-        automatically rewritten to the URL of the target.  If set to `None`
-        then the host header is unmodified from the client request.  Any
-        other value overwrites the host header with that value.
-    ``headers``:
-        An optional dictionary of headers that should be sent with the
-        request to the target host.
-    ``ssl_context``:
-        In case this is an HTTPS target host then an SSL context can be
-        provided here (:class:`ssl.SSLContext`).  This can be used for instance
-        to disable SSL verification.
-
-    In this case everything below ``'/static/'`` is proxied to the server on
-    port 5001.  The host header is automatically rewritten and so are request
-    URLs (eg: the leading `/static/` prefix here gets chopped off).
-
-    .. versionadded:: 0.14
-    """
-
-    def __init__(self, app, targets, chunk_size=2 << 13, timeout=10):
-        def _set_defaults(opts):
-            opts.setdefault('remove_prefix', False)
-            opts.setdefault('host', '<auto>')
-            opts.setdefault('headers', {})
-            opts.setdefault('ssl_context', None)
-            return opts
-        self.app = app
-        self.targets = dict(('/%s/' % k.strip('/'), _set_defaults(v))
-                            for k, v in iteritems(targets))
-        self.chunk_size = chunk_size
-        self.timeout = timeout
-
-    def proxy_to(self, opts, path, prefix):
-        target = url_parse(opts['target'])
-
-        def application(environ, start_response):
-            headers = list(EnvironHeaders(environ).items())
-            headers[:] = [(k, v) for k, v in headers
-                          if not is_hop_by_hop_header(k) and
-                          k.lower() not in ('content-length', 'host')]
-            headers.append(('Connection', 'close'))
-            if opts['host'] == '<auto>':
-                headers.append(('Host', target.ascii_host))
-            elif opts['host'] is None:
-                headers.append(('Host', environ['HTTP_HOST']))
-            else:
-                headers.append(('Host', opts['host']))
-            headers.extend(opts['headers'].items())
-
-            remote_path = path
-            if opts['remove_prefix']:
-                remote_path = '%s/%s' % (
-                    target.path.rstrip('/'),
-                    remote_path[len(prefix):].lstrip('/')
-                )
-
-            content_length = environ.get('CONTENT_LENGTH')
-            chunked = False
-            if content_length not in ('', None):
-                headers.append(('Content-Length', content_length))
-            elif content_length is not None:
-                headers.append(('Transfer-Encoding', 'chunked'))
-                chunked = True
-
-            try:
-                if target.scheme == 'http':
-                    con = httplib.HTTPConnection(
-                        target.ascii_host, target.port or 80,
-                        timeout=self.timeout)
-                elif target.scheme == 'https':
-                    con = httplib.HTTPSConnection(
-                        target.ascii_host, target.port or 443,
-                        timeout=self.timeout,
-                        context=opts['ssl_context'])
-                con.connect()
-                con.putrequest(environ['REQUEST_METHOD'], url_quote(remote_path),
-                               skip_host=True)
-
-                for k, v in headers:
-                    if k.lower() == 'connection':
-                        v = 'close'
-                    con.putheader(k, v)
-                con.endheaders()
-
-                stream = get_input_stream(environ)
-                while 1:
-                    data = stream.read(self.chunk_size)
-                    if not data:
-                        break
-                    if chunked:
-                        con.send(b'%x\r\n%s\r\n' % (len(data), data))
-                    else:
-                        con.send(data)
-
-                resp = con.getresponse()
-            except socket.error:
-                from werkzeug.exceptions import BadGateway
-                return BadGateway()(environ, start_response)
-
-            start_response('%d %s' % (resp.status, resp.reason),
-                           [(k.title(), v) for k, v in resp.getheaders()
-                            if not is_hop_by_hop_header(k)])
-
-            def read():
-                while 1:
-                    try:
-                        data = resp.read(self.chunk_size)
-                    except socket.error:
-                        break
-                    if not data:
-                        break
-                    yield data
-            return read()
-        return application
-
-    def __call__(self, environ, start_response):
-        path = environ['PATH_INFO']
-        app = self.app
-        for prefix, opts in iteritems(self.targets):
-            if path.startswith(prefix):
-                app = self.proxy_to(opts, path, prefix)
-                break
-        return app(environ, start_response)
-
-
-class SharedDataMiddleware(object):
-
-    """A WSGI middleware that provides static content for development
-    environments or simple server setups. Usage is quite simple::
-
-        import os
-        from werkzeug.wsgi import SharedDataMiddleware
-
-        app = SharedDataMiddleware(app, {
-            '/shared': os.path.join(os.path.dirname(__file__), 'shared')
-        })
-
-    The contents of the folder ``./shared`` will now be available on
-    ``http://example.com/shared/``.  This is pretty useful during development
-    because a standalone media server is not required.  One can also mount
-    files on the root folder and still continue to use the application because
-    the shared data middleware forwards all unhandled requests to the
-    application, even if the requests are below one of the shared folders.
-
-    If `pkg_resources` is available you can also tell the middleware to serve
-    files from package data::
-
-        app = SharedDataMiddleware(app, {
-            '/shared': ('myapplication', 'shared_files')
-        })
-
-    This will then serve the ``shared_files`` folder in the `myapplication`
-    Python package.
-
-    The optional `disallow` parameter can be a list of :func:`~fnmatch.fnmatch`
-    rules for files that are not accessible from the web.  If `cache` is set to
-    `False` no caching headers are sent.
-
-    Currently the middleware does not support non ASCII filenames.  If the
-    encoding on the file system happens to be the encoding of the URI it may
-    work but this could also be by accident.  We strongly suggest using ASCII
-    only file names for static files.
-
-    The middleware will guess the mimetype using the Python `mimetype`
-    module.  If it's unable to figure out the charset it will fall back
-    to `fallback_mimetype`.
-
-    .. versionchanged:: 0.5
-       The cache timeout is configurable now.
-
-    .. versionadded:: 0.6
-       The `fallback_mimetype` parameter was added.
-
-    :param app: the application to wrap.  If you don't want to wrap an
-                application you can pass it :exc:`NotFound`.
-    :param exports: a list or dict of exported files and folders.
-    :param disallow: a list of :func:`~fnmatch.fnmatch` rules.
-    :param fallback_mimetype: the fallback mimetype for unknown files.
-    :param cache: enable or disable caching headers.
-    :param cache_timeout: the cache timeout in seconds for the headers.
-    """
-
-    def __init__(self, app, exports, disallow=None, cache=True,
-                 cache_timeout=60 * 60 * 12, fallback_mimetype='text/plain'):
-        self.app = app
-        self.exports = []
-        self.cache = cache
-        self.cache_timeout = cache_timeout
-        if hasattr(exports, 'items'):
-            exports = iteritems(exports)
-        for key, value in exports:
-            if isinstance(value, tuple):
-                loader = self.get_package_loader(*value)
-            elif isinstance(value, string_types):
-                if os.path.isfile(value):
-                    loader = self.get_file_loader(value)
-                else:
-                    loader = self.get_directory_loader(value)
-            else:
-                raise TypeError('unknown def %r' % value)
-            self.exports.append((key, loader))
-        if disallow is not None:
-            from fnmatch import fnmatch
-            self.is_allowed = lambda x: not fnmatch(x, disallow)
-        self.fallback_mimetype = fallback_mimetype
-
-    def is_allowed(self, filename):
-        """Subclasses can override this method to disallow the access to
-        certain files.  However by providing `disallow` in the constructor
-        this method is overwritten.
-        """
-        return True
-
-    def _opener(self, filename):
-        return lambda: (
-            open(filename, 'rb'),
-            datetime.utcfromtimestamp(os.path.getmtime(filename)),
-            int(os.path.getsize(filename))
-        )
-
-    def get_file_loader(self, filename):
-        return lambda x: (os.path.basename(filename), self._opener(filename))
-
-    def get_package_loader(self, package, package_path):
-        from pkg_resources import DefaultProvider, ResourceManager, \
-            get_provider
-        loadtime = datetime.utcnow()
-        provider = get_provider(package)
-        manager = ResourceManager()
-        filesystem_bound = isinstance(provider, DefaultProvider)
-
-        def loader(path):
-            if path is None:
-                return None, None
-            path = posixpath.join(package_path, path)
-            if not provider.has_resource(path):
-                return None, None
-            basename = posixpath.basename(path)
-            if filesystem_bound:
-                return basename, self._opener(
-                    provider.get_resource_filename(manager, path))
-            s = provider.get_resource_string(manager, path)
-            return basename, lambda: (
-                BytesIO(s),
-                loadtime,
-                len(s)
-            )
-        return loader
-
-    def get_directory_loader(self, directory):
-        def loader(path):
-            if path is not None:
-                path = os.path.join(directory, path)
-            else:
-                path = directory
-            if os.path.isfile(path):
-                return os.path.basename(path), self._opener(path)
-            return None, None
-        return loader
-
-    def generate_etag(self, mtime, file_size, real_filename):
-        if not isinstance(real_filename, bytes):
-            real_filename = real_filename.encode(get_filesystem_encoding())
-        return 'wzsdm-%d-%s-%s' % (
-            mktime(mtime.timetuple()),
-            file_size,
-            adler32(real_filename) & 0xffffffff
-        )
-
-    def __call__(self, environ, start_response):
-        cleaned_path = get_path_info(environ)
-        if PY2:
-            cleaned_path = cleaned_path.encode(get_filesystem_encoding())
-        # sanitize the path for non unix systems
-        cleaned_path = cleaned_path.strip('/')
-        for sep in os.sep, os.altsep:
-            if sep and sep != '/':
-                cleaned_path = cleaned_path.replace(sep, '/')
-        path = '/' + '/'.join(x for x in cleaned_path.split('/')
-                              if x and x != '..')
-        file_loader = None
-        for search_path, loader in self.exports:
-            if search_path == path:
-                real_filename, file_loader = loader(None)
-                if file_loader is not None:
-                    break
-            if not search_path.endswith('/'):
-                search_path += '/'
-            if path.startswith(search_path):
-                real_filename, file_loader = loader(path[len(search_path):])
-                if file_loader is not None:
-                    break
-        if file_loader is None or not self.is_allowed(real_filename):
-            return self.app(environ, start_response)
-
-        guessed_type = mimetypes.guess_type(real_filename)
-        mime_type = guessed_type[0] or self.fallback_mimetype
-        f, mtime, file_size = file_loader()
-
-        headers = [('Date', http_date())]
-        if self.cache:
-            timeout = self.cache_timeout
-            etag = self.generate_etag(mtime, file_size, real_filename)
-            headers += [
-                ('Etag', '"%s"' % etag),
-                ('Cache-Control', 'max-age=%d, public' % timeout)
-            ]
-            if not is_resource_modified(environ, etag, last_modified=mtime):
-                f.close()
-                start_response('304 Not Modified', headers)
-                return []
-            headers.append(('Expires', http_date(time() + timeout)))
-        else:
-            headers.append(('Cache-Control', 'public'))
-
-        headers.extend((
-            ('Content-Type', mime_type),
-            ('Content-Length', str(file_size)),
-            ('Last-Modified', http_date(mtime))
-        ))
-        start_response('200 OK', headers)
-        return wrap_file(environ, f)
-
-
-class DispatcherMiddleware(object):
-
-    """Allows one to mount middlewares or applications in a WSGI application.
-    This is useful if you want to combine multiple WSGI applications::
-
-        app = DispatcherMiddleware(app, {
-            '/app2':        app2,
-            '/app3':        app3
-        })
-    """
-
-    def __init__(self, app, mounts=None):
-        self.app = app
-        self.mounts = mounts or {}
-
-    def __call__(self, environ, start_response):
-        script = environ.get('PATH_INFO', '')
-        path_info = ''
-        while '/' in script:
-            if script in self.mounts:
-                app = self.mounts[script]
-                break
-            script, last_item = script.rsplit('/', 1)
-            path_info = '/%s%s' % (last_item, path_info)
-        else:
-            app = self.mounts.get(script, self.app)
-        original_script_name = environ.get('SCRIPT_NAME', '')
-        environ['SCRIPT_NAME'] = original_script_name + script
-        environ['PATH_INFO'] = path_info
-        return app(environ, start_response)
-
-
-@implements_iterator
-class ClosingIterator(object):
-
-    """The WSGI specification requires that all middlewares and gateways
-    respect the `close` callback of an iterator.  Because it is useful to add
-    another close action to a returned iterator and adding a custom iterator
-    is a boring task this class can be used for that::
-
-        return ClosingIterator(app(environ, start_response), [cleanup_session,
-                                                              cleanup_locals])
-
-    If there is just one close function it can be passed instead of the list.
-
-    A closing iterator is not needed if the application uses response objects
-    and finishes the processing if the response is started::
-
-        try:
-            return response(environ, start_response)
-        finally:
-            cleanup_session()
-            cleanup_locals()
-    """
-
-    def __init__(self, iterable, callbacks=None):
-        iterator = iter(iterable)
-        self._next = partial(next, iterator)
-        if callbacks is None:
-            callbacks = []
-        elif callable(callbacks):
-            callbacks = [callbacks]
-        else:
-            callbacks = list(callbacks)
-        iterable_close = getattr(iterator, 'close', None)
-        if iterable_close:
-            callbacks.insert(0, iterable_close)
-        self._callbacks = callbacks
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self._next()
-
-    def close(self):
-        for callback in self._callbacks:
-            callback()
-
-
-def wrap_file(environ, file, buffer_size=8192):
-    """Wraps a file.  This uses the WSGI server's file wrapper if available
-    or otherwise the generic :class:`FileWrapper`.
-
-    .. versionadded:: 0.5
-
-    If the file wrapper from the WSGI server is used it's important to not
-    iterate over it from inside the application but to pass it through
-    unchanged.  If you want to pass out a file wrapper inside a response
-    object you have to set :attr:`~BaseResponse.direct_passthrough` to `True`.
-
-    More information about file wrappers are available in :pep:`333`.
-
-    :param file: a :class:`file`-like object with a :meth:`~file.read` method.
-    :param buffer_size: number of bytes for one iteration.
-    """
-    return environ.get('wsgi.file_wrapper', FileWrapper)(file, buffer_size)
-
-
-@implements_iterator
-class FileWrapper(object):
-
-    """This class can be used to convert a :class:`file`-like object into
-    an iterable.  It yields `buffer_size` blocks until the file is fully
-    read.
-
-    You should not use this class directly but rather use the
-    :func:`wrap_file` function that uses the WSGI server's file wrapper
-    support if it's available.
-
-    .. versionadded:: 0.5
-
-    If you're using this object together with a :class:`BaseResponse` you have
-    to use the `direct_passthrough` mode.
-
-    :param file: a :class:`file`-like object with a :meth:`~file.read` method.
-    :param buffer_size: number of bytes for one iteration.
-    """
-
-    def __init__(self, file, buffer_size=8192):
-        self.file = file
-        self.buffer_size = buffer_size
-
-    def close(self):
-        if hasattr(self.file, 'close'):
-            self.file.close()
-
-    def seekable(self):
-        if hasattr(self.file, 'seekable'):
-            return self.file.seekable()
-        if hasattr(self.file, 'seek'):
-            return True
-        return False
-
-    def seek(self, *args):
-        if hasattr(self.file, 'seek'):
-            self.file.seek(*args)
-
-    def tell(self):
-        if hasattr(self.file, 'tell'):
-            return self.file.tell()
-        return None
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        data = self.file.read(self.buffer_size)
-        if data:
-            return data
-        raise StopIteration()
-
-
-@implements_iterator
-class _RangeWrapper(object):
-    # private for now, but should we make it public in the future ?
-
-    """This class can be used to convert an iterable object into
-    an iterable that will only yield a piece of the underlying content.
-    It yields blocks until the underlying stream range is fully read.
-    The yielded blocks will have a size that can't exceed the original
-    iterator defined block size, but that can be smaller.
-
-    If you're using this object together with a :class:`BaseResponse` you have
-    to use the `direct_passthrough` mode.
-
-    :param iterable: an iterable object with a :meth:`__next__` method.
-    :param start_byte: byte from which read will start.
-    :param byte_range: how many bytes to read.
-    """
-
-    def __init__(self, iterable, start_byte=0, byte_range=None):
-        self.iterable = iter(iterable)
-        self.byte_range = byte_range
-        self.start_byte = start_byte
-        self.end_byte = None
-        if byte_range is not None:
-            self.end_byte = self.start_byte + self.byte_range
-        self.read_length = 0
-        self.seekable = hasattr(iterable, 'seekable') and iterable.seekable()
-        self.end_reached = False
-
-    def __iter__(self):
-        return self
-
-    def _next_chunk(self):
-        try:
-            chunk = next(self.iterable)
-            self.read_length += len(chunk)
-            return chunk
-        except StopIteration:
-            self.end_reached = True
-            raise
-
-    def _first_iteration(self):
-        chunk = None
-        if self.seekable:
-            self.iterable.seek(self.start_byte)
-            self.read_length = self.iterable.tell()
-            contextual_read_length = self.read_length
-        else:
-            while self.read_length <= self.start_byte:
-                chunk = self._next_chunk()
-            if chunk is not None:
-                chunk = chunk[self.start_byte - self.read_length:]
-            contextual_read_length = self.start_byte
-        return chunk, contextual_read_length
-
-    def _next(self):
-        if self.end_reached:
-            raise StopIteration()
-        chunk = None
-        contextual_read_length = self.read_length
-        if self.read_length == 0:
-            chunk, contextual_read_length = self._first_iteration()
-        if chunk is None:
-            chunk = self._next_chunk()
-        if self.end_byte is not None and self.read_length >= self.end_byte:
-            self.end_reached = True
-            return chunk[:self.end_byte - contextual_read_length]
-        return chunk
-
-    def __next__(self):
-        chunk = self._next()
-        if chunk:
-            return chunk
-        self.end_reached = True
-        raise StopIteration()
-
-    def close(self):
-        if hasattr(self.iterable, 'close'):
-            self.iterable.close()
-
-
-def _make_chunk_iter(stream, limit, buffer_size):
-    """Helper for the line and chunk iter functions."""
-    if isinstance(stream, (bytes, bytearray, text_type)):
-        raise TypeError('Passed a string or byte object instead of '
-                        'true iterator or stream.')
-    if not hasattr(stream, 'read'):
-        for item in stream:
-            if item:
-                yield item
-        return
-    if not isinstance(stream, LimitedStream) and limit is not None:
-        stream = LimitedStream(stream, limit)
-    _read = stream.read
-    while 1:
-        item = _read(buffer_size)
-        if not item:
-            break
-        yield item
-
-
-def make_line_iter(stream, limit=None, buffer_size=10 * 1024,
-                   cap_at_buffer=False):
-    """Safely iterates line-based over an input stream.  If the input stream
-    is not a :class:`LimitedStream` the `limit` parameter is mandatory.
-
-    This uses the stream's :meth:`~file.read` method internally as opposite
-    to the :meth:`~file.readline` method that is unsafe and can only be used
-    in violation of the WSGI specification.  The same problem applies to the
-    `__iter__` function of the input stream which calls :meth:`~file.readline`
-    without arguments.
-
-    If you need line-by-line processing it's strongly recommended to iterate
-    over the input stream using this helper function.
-
-    .. versionchanged:: 0.8
-       This function now ensures that the limit was reached.
-
-    .. versionadded:: 0.9
-       added support for iterators as input stream.
-
-    .. versionadded:: 0.11.10
-       added support for the `cap_at_buffer` parameter.
-
-    :param stream: the stream or iterate to iterate over.
-    :param limit: the limit in bytes for the stream.  (Usually
-                  content length.  Not necessary if the `stream`
-                  is a :class:`LimitedStream`.
-    :param buffer_size: The optional buffer size.
-    :param cap_at_buffer: if this is set chunks are split if they are longer
-                          than the buffer size.  Internally this is implemented
-                          that the buffer size might be exhausted by a factor
-                          of two however.
-    """
-    _iter = _make_chunk_iter(stream, limit, buffer_size)
-
-    first_item = next(_iter, '')
-    if not first_item:
-        return
-
-    s = make_literal_wrapper(first_item)
-    empty = s('')
-    cr = s('\r')
-    lf = s('\n')
-    crlf = s('\r\n')
-
-    _iter = chain((first_item,), _iter)
-
-    def _iter_basic_lines():
-        _join = empty.join
-        buffer = []
-        while 1:
-            new_data = next(_iter, '')
-            if not new_data:
-                break
-            new_buf = []
-            buf_size = 0
-            for item in chain(buffer, new_data.splitlines(True)):
-                new_buf.append(item)
-                buf_size += len(item)
-                if item and item[-1:] in crlf:
-                    yield _join(new_buf)
-                    new_buf = []
-                elif cap_at_buffer and buf_size >= buffer_size:
-                    rv = _join(new_buf)
-                    while len(rv) >= buffer_size:
-                        yield rv[:buffer_size]
-                        rv = rv[buffer_size:]
-                    new_buf = [rv]
-            buffer = new_buf
-        if buffer:
-            yield _join(buffer)
-
-    # This hackery is necessary to merge 'foo\r' and '\n' into one item
-    # of 'foo\r\n' if we were unlucky and we hit a chunk boundary.
-    previous = empty
-    for item in _iter_basic_lines():
-        if item == lf and previous[-1:] == cr:
-            previous += item
-            item = empty
-        if previous:
-            yield previous
-        previous = item
-    if previous:
-        yield previous
-
-
-def make_chunk_iter(stream, separator, limit=None, buffer_size=10 * 1024,
-                    cap_at_buffer=False):
-    """Works like :func:`make_line_iter` but accepts a separator
-    which divides chunks.  If you want newline based processing
-    you should use :func:`make_line_iter` instead as it
-    supports arbitrary newline markers.
-
-    .. versionadded:: 0.8
-
-    .. versionadded:: 0.9
-       added support for iterators as input stream.
-
-    .. versionadded:: 0.11.10
-       added support for the `cap_at_buffer` parameter.
-
-    :param stream: the stream or iterate to iterate over.
-    :param separator: the separator that divides chunks.
-    :param limit: the limit in bytes for the stream.  (Usually
-                  content length.  Not necessary if the `stream`
-                  is otherwise already limited).
-    :param buffer_size: The optional buffer size.
-    :param cap_at_buffer: if this is set chunks are split if they are longer
-                          than the buffer size.  Internally this is implemented
-                          that the buffer size might be exhausted by a factor
-                          of two however.
-    """
-    _iter = _make_chunk_iter(stream, limit, buffer_size)
-
-    first_item = next(_iter, '')
-    if not first_item:
-        return
-
-    _iter = chain((first_item,), _iter)
-    if isinstance(first_item, text_type):
-        separator = to_unicode(separator)
-        _split = re.compile(r'(%s)' % re.escape(separator)).split
-        _join = u''.join
-    else:
-        separator = to_bytes(separator)
-        _split = re.compile(b'(' + re.escape(separator) + b')').split
-        _join = b''.join
-
-    buffer = []
-    while 1:
-        new_data = next(_iter, '')
-        if not new_data:
-            break
-        chunks = _split(new_data)
-        new_buf = []
-        buf_size = 0
-        for item in chain(buffer, chunks):
-            if item == separator:
-                yield _join(new_buf)
-                new_buf = []
-                buf_size = 0
-            else:
-                buf_size += len(item)
-                new_buf.append(item)
-
-                if cap_at_buffer and buf_size >= buffer_size:
-                    rv = _join(new_buf)
-                    while len(rv) >= buffer_size:
-                        yield rv[:buffer_size]
-                        rv = rv[buffer_size:]
-                    new_buf = [rv]
-                    buf_size = len(rv)
-
-        buffer = new_buf
-    if buffer:
-        yield _join(buffer)
-
-
-@implements_iterator
-class LimitedStream(io.IOBase):
-
-    """Wraps a stream so that it doesn't read more than n bytes.  If the
-    stream is exhausted and the caller tries to get more bytes from it
-    :func:`on_exhausted` is called which by default returns an empty
-    string.  The return value of that function is forwarded
-    to the reader function.  So if it returns an empty string
-    :meth:`read` will return an empty string as well.
-
-    The limit however must never be higher than what the stream can
-    output.  Otherwise :meth:`readlines` will try to read past the
-    limit.
-
-    .. admonition:: Note on WSGI compliance
-
-       calls to :meth:`readline` and :meth:`readlines` are not
-       WSGI compliant because it passes a size argument to the
-       readline methods.  Unfortunately the WSGI PEP is not safely
-       implementable without a size argument to :meth:`readline`
-       because there is no EOF marker in the stream.  As a result
-       of that the use of :meth:`readline` is discouraged.
-
-       For the same reason iterating over the :class:`LimitedStream`
-       is not portable.  It internally calls :meth:`readline`.
-
-       We strongly suggest using :meth:`read` only or using the
-       :func:`make_line_iter` which safely iterates line-based
-       over a WSGI input stream.
-
-    :param stream: the stream to wrap.
-    :param limit: the limit for the stream, must not be longer than
-                  what the string can provide if the stream does not
-                  end with `EOF` (like `wsgi.input`)
-    """
-
-    def __init__(self, stream, limit):
-        self._read = stream.read
-        self._readline = stream.readline
-        self._pos = 0
-        self.limit = limit
-
-    def __iter__(self):
-        return self
-
-    @property
-    def is_exhausted(self):
-        """If the stream is exhausted this attribute is `True`."""
-        return self._pos >= self.limit
-
-    def on_exhausted(self):
-        """This is called when the stream tries to read past the limit.
-        The return value of this function is returned from the reading
-        function.
-        """
-        # Read null bytes from the stream so that we get the
-        # correct end of stream marker.
-        return self._read(0)
-
-    def on_disconnect(self):
-        """What should happen if a disconnect is detected?  The return
-        value of this function is returned from read functions in case
-        the client went away.  By default a
-        :exc:`~werkzeug.exceptions.ClientDisconnected` exception is raised.
-        """
-        from werkzeug.exceptions import ClientDisconnected
-        raise ClientDisconnected()
-
-    def exhaust(self, chunk_size=1024 * 64):
-        """Exhaust the stream.  This consumes all the data left until the
-        limit is reached.
-
-        :param chunk_size: the size for a chunk.  It will read the chunk
-                           until the stream is exhausted and throw away
-                           the results.
-        """
-        to_read = self.limit - self._pos
-        chunk = chunk_size
-        while to_read > 0:
-            chunk = min(to_read, chunk)
-            self.read(chunk)
-            to_read -= chunk
-
-    def read(self, size=None):
-        """Read `size` bytes or if size is not provided everything is read.
-
-        :param size: the number of bytes read.
-        """
-        if self._pos >= self.limit:
-            return self.on_exhausted()
-        if size is None or size == -1:  # -1 is for consistence with file
-            size = self.limit
-        to_read = min(self.limit - self._pos, size)
-        try:
-            read = self._read(to_read)
-        except (IOError, ValueError):
-            return self.on_disconnect()
-        if to_read and len(read) != to_read:
-            return self.on_disconnect()
-        self._pos += len(read)
-        return read
-
-    def readline(self, size=None):
-        """Reads one line from the stream."""
-        if self._pos >= self.limit:
-            return self.on_exhausted()
-        if size is None:
-            size = self.limit - self._pos
-        else:
-            size = min(size, self.limit - self._pos)
-        try:
-            line = self._readline(size)
-        except (ValueError, IOError):
-            return self.on_disconnect()
-        if size and not line:
-            return self.on_disconnect()
-        self._pos += len(line)
-        return line
-
-    def readlines(self, size=None):
-        """Reads a file into a list of strings.  It calls :meth:`readline`
-        until the file is read to the end.  It does support the optional
-        `size` argument if the underlaying stream supports it for
-        `readline`.
-        """
-        last_pos = self._pos
-        result = []
-        if size is not None:
-            end = min(self.limit, last_pos + size)
-        else:
-            end = self.limit
-        while 1:
-            if size is not None:
-                size -= last_pos - self._pos
-            if self._pos >= end:
-                break
-            result.append(self.readline(size))
-            if size is not None:
-                last_pos = self._pos
-        return result
-
-    def tell(self):
-        """Returns the position of the stream.
-
-        .. versionadded:: 0.9
-        """
-        return self._pos
-
-    def __next__(self):
-        line = self.readline()
-        if not line:
-            raise StopIteration()
-        return line
-
-    def readable(self):
-        return True
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/pyvenv.cfg b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/pyvenv.cfg
deleted file mode 100644
index d6d0bda98..000000000
--- a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/pyvenv.cfg
+++ /dev/null
@@ -1,3 +0,0 @@
-home = /usr/bin
-include-system-site-packages = false
-version = 3.5.3
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/CacheControl-0.11.7-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/CacheControl-0.11.7-py2.py3-none-any.whl
deleted file mode 100644
index 53d4ebfb9..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/CacheControl-0.11.7-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/appdirs-1.4.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/appdirs-1.4.0-py2.py3-none-any.whl
deleted file mode 100644
index ac0f9a22a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/appdirs-1.4.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/chardet-2.3.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/chardet-2.3.0-py2.py3-none-any.whl
deleted file mode 100644
index 3070099c0..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/chardet-2.3.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/colorama-0.3.7-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/colorama-0.3.7-py2.py3-none-any.whl
deleted file mode 100644
index 527a7a2ca..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/colorama-0.3.7-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distlib-0.2.4-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distlib-0.2.4-py2.py3-none-any.whl
deleted file mode 100644
index 07247517a..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distlib-0.2.4-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distro-1.0.1-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distro-1.0.1-py2.py3-none-any.whl
deleted file mode 100644
index 267e53523..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/distro-1.0.1-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/html5lib-0.999999999-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/html5lib-0.999999999-py2.py3-none-any.whl
deleted file mode 100644
index b4a8e5f34..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/html5lib-0.999999999-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/ipaddress-0.0.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/ipaddress-0.0.0-py2.py3-none-any.whl
deleted file mode 100644
index 8fe7a4c27..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/ipaddress-0.0.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/lockfile-0.12.2-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/lockfile-0.12.2-py2.py3-none-any.whl
deleted file mode 100644
index 142d66ab7..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/lockfile-0.12.2-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/packaging-16.8-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/packaging-16.8-py2.py3-none-any.whl
deleted file mode 100644
index a9b470c74..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/packaging-16.8-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pip-9.0.1-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pip-9.0.1-py2.py3-none-any.whl
deleted file mode 100644
index 2cbe16a21..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pip-9.0.1-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pkg_resources-0.0.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pkg_resources-0.0.0-py2.py3-none-any.whl
deleted file mode 100644
index d27afd564..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pkg_resources-0.0.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/progress-1.2-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/progress-1.2-py2.py3-none-any.whl
deleted file mode 100644
index de3e9d094..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/progress-1.2-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pyparsing-2.1.10-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pyparsing-2.1.10-py2.py3-none-any.whl
deleted file mode 100644
index 77d874cfd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/pyparsing-2.1.10-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/requests-2.12.4-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/requests-2.12.4-py2.py3-none-any.whl
deleted file mode 100644
index 5ad0c06cd..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/requests-2.12.4-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/retrying-1.3.3-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/retrying-1.3.3-py2.py3-none-any.whl
deleted file mode 100644
index 09683603b..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/retrying-1.3.3-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/setuptools-33.1.1-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/setuptools-33.1.1-py2.py3-none-any.whl
deleted file mode 100644
index 87154771c..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/setuptools-33.1.1-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/six-1.10.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/six-1.10.0-py2.py3-none-any.whl
deleted file mode 100644
index a94c6743f..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/six-1.10.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/urllib3-1.19.1-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/urllib3-1.19.1-py2.py3-none-any.whl
deleted file mode 100644
index 2f4181400..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/urllib3-1.19.1-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/webencodings-0.5-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/webencodings-0.5-py2.py3-none-any.whl
deleted file mode 100644
index 11fef3171..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/webencodings-0.5-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/wheel-0.29.0-py2.py3-none-any.whl b/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/wheel-0.29.0-py2.py3-none-any.whl
deleted file mode 100644
index c9491dc94..000000000
Binary files a/mender/image-tools/artifact-builder/raspbian-setup/files/web-service/venv/share/python-wheels/wheel-0.29.0-py2.py3-none-any.whl and /dev/null differ
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/01-dependencies b/mender/image-tools/artifact-builder/raspbian-setup/scripts/01-dependencies
index 68ec764f7..8794171d2 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/01-dependencies
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/01-dependencies
@@ -14,6 +14,7 @@ if [ -e /home.base ] ; then
 fi
 
 apt-get update
+apt-get upgrade -y
 
 # WARNING: If you want new builds to update the kernel and all new packages
 # enable the following lines. This very much may break your build. Upgrading 
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/02-create-default-user b/mender/image-tools/artifact-builder/raspbian-setup/scripts/02-create-default-user
index 42aee7221..644cf9aa7 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/02-create-default-user
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/02-create-default-user
@@ -13,7 +13,7 @@ fi
 
 # Create new user that is a sudo user
 useradd --create-home \
-	--groups sudo,adm,dialout,cdrom,audio,plugdev,games,users,input,netdev,gpio,i2c,spi \
+	--groups sudo,adm,dialout,cdrom,audio,plugdev,games,users,input,netdev,gpio,i2c,video,spi \
 	--shell /bin/bash \
 	$username 
 echo "$username:$password" | chpasswd
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/04-network b/mender/image-tools/artifact-builder/raspbian-setup/scripts/04-network
index ae2da5e26..a13c98e0a 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/04-network
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/04-network
@@ -17,6 +17,7 @@ if [ -f /etc/network/interfaces ]; then
 	rm /etc/network/interfaces
 fi
 
+cp network/rfkill-unblock.service /etc/systemd/system/
 cp network/01-wired.network /etc/systemd/network/
 cp network/02-wireless.network /etc/systemd/network/
 
@@ -41,3 +42,4 @@ chmod +x /root/first-boot.sh
 cp first-boot.service /etc/systemd/system/
 
 systemctl enable first-boot.service
+systemctl enable rfkill-unblock.service
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/10-web-service b/mender/image-tools/artifact-builder/raspbian-setup/scripts/10-web-service
index c5a6cd4d9..503764965 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/10-web-service
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/10-web-service
@@ -8,6 +8,8 @@ cp nginx.conf /etc/nginx/
 
 mkdir -p /var/flaskapp
 cp -R web-service /var/flaskapp
+tar -C /var/flaskapp/web-service -xvf venv.tar
+chmod +x /var/flaskapp/web-service/start.sh
 chown -R www-data:www-data /var/flaskapp/web-service
 
 cp web-service.conf /etc/supervisor/conf.d/
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/11-browser b/mender/image-tools/artifact-builder/raspbian-setup/scripts/11-browser
index 66108b796..e698457de 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/11-browser
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/11-browser
@@ -3,11 +3,16 @@ cd $files
 
 set -ex
 
+ln -sf /opt/vc/lib/libbrcmGLESv2.so /opt/vc/lib/libGLESv2.so.2
+ln -sf /opt/vc/lib/libbrcmEGL.so /opt/vc/lib/libEGL.so
+ldconfig
 cp launch-browser.sh $home_dir/
 cp sites.txt /root/
 
 # Updates auto-login for X11 to point to tty2
 envsubst '${username}' < autologin@.service > /etc/systemd/system/autologin@.service
+mkdir -p /etc/systemd/system/getty@tty2.service.d
+envsubst '${username}' < autologin.conf > /etc/systemd/system/getty@tty2.service.d/autologin.conf
 
 chown $username:$username $home_dir/launch-browser.sh
 
@@ -15,4 +20,7 @@ systemctl set-default graphical.target
 gpasswd -a $username tty
 
 mkdir -p /etc/systemd/system/getty.target.wants
-ln -fs /etc/systemd/system/autologin@.service /etc/systemd/system/getty.target.wants/getty@tty2.service
+ln -fs /lib/systemd/system/getty@.service /etc/systemd/system/getty.target.wants/getty@tty2.service
+
+#Update Xwrapper to remove Virtual Console permission denied error
+cp Xwrapper.config /etc/X11/
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/13-cleanup b/mender/image-tools/artifact-builder/raspbian-setup/scripts/13-cleanup
index 5db07b1a7..02fc62914 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/13-cleanup
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/13-cleanup
@@ -28,6 +28,19 @@ shopt -s extglob
 rm -rf /usr/share/locale/!(en|en*|locale.alias)
 rm -rf /usr/share/i18n/locales/!(en|en*|translit)
 
+# Add Reboot at Midnight
+echo '0  0     * * *   root    reboot' >> /etc/crontab
+
+# Setup Watchdog to reboot if PI crashes
+cat << END_TEXT > /etc/watchdog.conf
+max-load-1 = 24
+min-memory = 1
+watchdog-device = /dev/watchdog	
+watchdog-timeout=15
+END_TEXT
+
+sed -i 's/default.target/multi-user.target/g' /lib/systemd/system/watchdog.service
+
 # Restore init_resize
 mkdir -p /usr/lib/raspi-config/
 cp /root/init_resize.sh /usr/lib/raspi-config/
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/scripts/15-prepare-base-image-localdata b/mender/image-tools/artifact-builder/raspbian-setup/scripts/15-prepare-base-image-localdata
index 923178bd5..78cb2f6aa 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/scripts/15-prepare-base-image-localdata
+++ b/mender/image-tools/artifact-builder/raspbian-setup/scripts/15-prepare-base-image-localdata
@@ -25,3 +25,5 @@ ln -snf /data/mender /var.base/lib/mender
 # These lines make it so mender-convert doesn't complain
 mkdir -p /var/lib
 ln -snf /data/mender /var/lib/mender
+
+echo Completed All Scripts!!!
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_01_firewall b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_01_firewall
index aff783b13..e47057db1 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_01_firewall
+++ b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_01_firewall
@@ -2,6 +2,8 @@
 
 mount / -o remount,rw
 
+sed -i 's/IPV6=yes/IPV6=no/g' /etc/default/ufw
+systemctl daemon-reload
 ufw default deny incoming 
 ufw default allow outgoing
 ufw allow 443
@@ -10,3 +12,4 @@ ufw allow ntp
 ufw --force enable
 
 mount / -o remount,ro
+exit 0
\ No newline at end of file
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_02_localdata b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_02_localdata
index edb8ece2b..84d766067 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_02_localdata
+++ b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactCommit_Leave_02_localdata
@@ -17,4 +17,5 @@ mount / -o remount,ro
 systemctl restart network-watchdog.service
 systemctl restart video-updater.service
 
-killall chromium-browser
+pkill -f -- "chromium-browser"
+exit 0
diff --git a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactReboot_Enter_01_hardward_config b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactReboot_Enter_01_hardward_config
index 3310eeb2f..28fc862b2 100755
--- a/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactReboot_Enter_01_hardward_config
+++ b/mender/image-tools/artifact-builder/raspbian-setup/state-scripts/ArtifactReboot_Enter_01_hardward_config
@@ -9,9 +9,18 @@ disable_splash=1
 hdmi_force_hotplug=1
 
 # To remove the undervoltage warning:
-avoid_warnings=1 
+avoid_warnings=1
+
+# Increase GPU Memory
+gpu_mem_1024=64
+
+#enable GPU Driver
+dtoverlay=vc4-kms-v3d
+dtparam=watchdog=on
+
 END_TEXT
 
 cat << END_TEXT > /uboot/cmdline.txt
 dwc_otg.lpm_enable=0 console=serial0,115200 root=\${mender_kernel_root} rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait logo.nologo
 END_TEXT
+exit 0
diff --git a/mender/image-tools/bootstrap-builder/prepare-raspbian/Dockerfile b/mender/image-tools/bootstrap-builder/prepare-raspbian/Dockerfile
index cf397b1f3..37bec0393 100644
--- a/mender/image-tools/bootstrap-builder/prepare-raspbian/Dockerfile
+++ b/mender/image-tools/bootstrap-builder/prepare-raspbian/Dockerfile
@@ -1,6 +1,6 @@
-FROM ubuntu:18.04
+FROM ubuntu:19.04
 
-ARG MENDER_ARTIFACT_VERSION=2.3.0
+ARG MENDER_ARTIFACT_VERSION=3.3.0
 
 RUN apt-get update && apt-get install -y \
     simg2img img2simg \
diff --git a/mender/image-tools/bootstrap-builder/shrink-image/Dockerfile b/mender/image-tools/bootstrap-builder/shrink-image/Dockerfile
index f6b80c188..6dd1765e2 100644
--- a/mender/image-tools/bootstrap-builder/shrink-image/Dockerfile
+++ b/mender/image-tools/bootstrap-builder/shrink-image/Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:18.04
+FROM ubuntu:19.04
 
 RUN apt-get update && apt-get install -y \
     parted util-linux 
diff --git a/mender/image-tools/bootstrap-builder/shrink-image/README-pishrink.md b/mender/image-tools/bootstrap-builder/shrink-image/README-pishrink.md
index f7a75fc0b..57928909c 100644
--- a/mender/image-tools/bootstrap-builder/shrink-image/README-pishrink.md
+++ b/mender/image-tools/bootstrap-builder/shrink-image/README-pishrink.md
@@ -6,6 +6,9 @@ PiShrink is a bash script that automatically shrink a pi image that will then re
 
 If the `-s` option is given the script will skip the autoexpanding part of the process.  If you specify the `newimagefile.img` parameter, the script will make a copy of `imagefile.img` and work off that. You will need enough space to make a full copy of the image to use that option.
 
+# Note: We updated the file to increase the space for updates. Specifically, this line:
+for space in 150000 120000 99000; do
+
 ## Prerequisites ##
 If you are trying to shrink a [NOOBS](https://github.com/raspberrypi/noobs) image it will likely fail. This is due to [NOOBS partitioning](https://github.com/raspberrypi/noobs/wiki/NOOBS-partitioning-explained) being significantly different than Raspbian's. Hopefully PiShrink will be able to support NOOBS in the near future.
 
diff --git a/mender/image-tools/bootstrap-builder/shrink-image/pishrink.sh b/mender/image-tools/bootstrap-builder/shrink-image/pishrink.sh
index 4214fb6fe..00acc059f 100755
--- a/mender/image-tools/bootstrap-builder/shrink-image/pishrink.sh
+++ b/mender/image-tools/bootstrap-builder/shrink-image/pishrink.sh
@@ -1,24 +1,122 @@
-#! /bin/bash
+#!/bin/bash
+
+version="v0.1.2"
+
+CURRENT_DIR=$(pwd)
+SCRIPTNAME="${0##*/}"
+LOGFILE=${CURRENT_DIR}/${SCRIPTNAME%.*}.log
+
+function info() {
+	echo "$SCRIPTNAME: $1..."
+}
+
+function error() {
+	echo -n "$SCRIPTNAME: ERROR occured in line $1: "
+	shift
+	echo "$@"
+}
 
 function cleanup() {
-  if losetup $loopback &>/dev/null; then
-  losetup -d "$loopback"
-  fi
+	if losetup "$loopback" &>/dev/null; then
+		losetup -d "$loopback"
+	fi
+	if [ "$debug" = true ]; then
+		local old_owner=$(stat -c %u:%g "$src")
+		chown "$old_owner" "$LOGFILE"
+	fi
+
+}
+
+function logVariables() {
+	if [ "$debug" = true ]; then
+		echo "Line $1" >> "$LOGFILE"
+		shift
+		local v var
+		for var in "$@"; do
+			eval "v=\$$var"
+			echo "$var: $v" >> "$LOGFILE"
+		done
+	fi
 }
 
-usage() { echo "Usage: $0 [-s] imagefile.img [newimagefile.img]"; exit -1; }
+function checkFilesystem() {
+	info "Checking filesystem"
+	e2fsck -pf "$loopback"
+	(( $? < 4 )) && return
+
+	info "Filesystem error detected!"
+
+	info "Trying to recover corrupted filesystem"
+	e2fsck -y "$loopback"
+	(( $? < 4 )) && return
+
+if [[ $repair == true ]]; then
+	info "Trying to recover corrupted filesystem - Phase 2"
+	e2fsck -fy -b 32768 "$loopback"
+	(( $? < 4 )) && return
+fi
+	error $LINENO "Filesystem recoveries failed. Giving up..."
+	exit -9
+
+}
+
+help() {
+	local help
+	read -r -d '' help << EOM
+Usage: $0 [-sdrpzh] imagefile.img [newimagefile.img]
+
+  -s: Don't expand filesystem when image is booted the first time
+  -d: Write debug messages in a debug log file
+  -r: Use advanced filesystem repair option if the normal one fails
+  -p: Remove logs, apt archives, dhcp leases and ssh hostkeys
+  -z: Gzip compress image after shrinking
+EOM
+	echo "$help"
+	exit -1
+}
+
+usage() {
+	echo "Usage: $0 [-sdrpzh] imagefile.img [newimagefile.img]"
+	echo ""
+	echo "  -s: Skip autoexpand"
+	echo "  -d: Debug mode on"
+	echo "  -r: Use advanced repair options"
+	echo "  -p: Remove logs, apt archives, dhcp leases and ssh hostkeys"
+	echo "  -z: Gzip compress image after shrinking"
+	echo "  -h: display help text"
+	exit -1
+}
 
 should_skip_autoexpand=false
+debug=false
+repair=false
+gzip_compress=false
+prep=false
 
-while getopts ":s" opt; do
+while getopts ":sdrpzh" opt; do
   case "${opt}" in
     s) should_skip_autoexpand=true ;;
+    d) debug=true;;
+    r) repair=true;;
+    p) prep=true;;
+    z) gzip_compress=true;;
+    h) help;;
     *) usage ;;
   esac
 done
 shift $((OPTIND-1))
 
+if [ "$debug" = true ]; then
+	info "Creating log file $LOGFILE"
+	rm "$LOGFILE" &>/dev/null
+	exec 1> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&1)
+	exec 2> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&2)
+fi
+
+echo "${0##*/} $version"
+
 #Args
+src="$1"
 img="$1"
 
 #Usage checks
@@ -26,33 +124,33 @@ if [[ -z "$img" ]]; then
   usage
 fi
 if [[ ! -f "$img" ]]; then
-  echo "ERROR: $img is not a file..."
+  error $LINENO "$img is not a file..."
   exit -2
 fi
 if (( EUID != 0 )); then
-  echo "ERROR: You need to be running as root."
+  error $LINENO "You need to be running as root."
   exit -3
 fi
 
 #Check that what we need is installed
 for command in parted losetup tune2fs md5sum e2fsck resize2fs; do
-  which $command 2>&1 >/dev/null
+  command -v $command >/dev/null 2>&1
   if (( $? != 0 )); then
-    echo "ERROR: $command is not installed."
+    error $LINENO "$command is not installed."
     exit -4
   fi
 done
 
 #Copy to new file if requested
 if [ -n "$2" ]; then
-  echo "Copying $1 to $2..."
+  info "Copying $1 to $2..."
   cp --reflink=auto --sparse=always "$1" "$2"
   if (( $? != 0 )); then
-    echo "ERROR: Could not copy file..."
+    error $LINENO "Could not copy file..."
     exit -5
   fi
   old_owner=$(stat -c %u:%g "$1")
-  chown $old_owner "$2"
+  chown "$old_owner" "$2"
   img="$2"
 fi
 
@@ -60,22 +158,25 @@ fi
 trap cleanup ERR EXIT
 
 #Gather info
+info "Gathering data"
 beforesize=$(ls -lh "$img" | cut -d ' ' -f 5)
 parted_output=$(parted -ms "$img" unit B print | tail -n 1)
 partnum=$(echo "$parted_output" | cut -d ':' -f 1)
 partstart=$(echo "$parted_output" | cut -d ':' -f 2 | tr -d 'B')
-loopback=$(losetup -f --show -o $partstart "$img")
+loopback=$(losetup -f --show -o "$partstart" "$img")
 tune2fs_output=$(tune2fs -l "$loopback")
 currentsize=$(echo "$tune2fs_output" | grep '^Block count:' | tr -d ' ' | cut -d ':' -f 2)
 blocksize=$(echo "$tune2fs_output" | grep '^Block size:' | tr -d ' ' | cut -d ':' -f 2)
 
+logVariables $LINENO tune2fs_output currentsize blocksize
+
 #Check if we should make pi expand rootfs on next boot
 if [ "$should_skip_autoexpand" = false ]; then
   #Make pi expand rootfs on next boot
   mountdir=$(mktemp -d)
   mount "$loopback" "$mountdir"
 
-  if [ $(md5sum "$mountdir/etc/rc.local" | cut -d ' ' -f 1) != "0542054e9ff2d2e0507ea1ffe7d4fc87" ]; then
+  if [ "$(md5sum "$mountdir/etc/rc.local" | cut -d ' ' -f 1)" != "0542054e9ff2d2e0507ea1ffe7d4fc87" ]; then
     echo "Creating new /etc/rc.local"
     mv "$mountdir/etc/rc.local" "$mountdir/etc/rc.local.bak"
     #####Do not touch the following lines#####
@@ -145,55 +246,94 @@ else
   echo "Skipping autoexpanding process..."
 fi
 
-#Make sure filesystem is ok
-e2fsck -p -f "$loopback"
-rc=$?
-if (( $rc != 0 )); then
-  echo "Error $rc occured when checking filesystem. Retrying ..."
-  e2fsck -f -y "$loopback"
-  rc=$?
-  if (( $rc >= 4 )); then
-    echo "ERROR: Uncorrectable error $rc occured when checking filesystem"
-    exit -6
-  fi
+if [[ $prep == true ]]; then
+  info "Syspreping: Removing logs, apt archives, dhcp leases and ssh hostkeys"
+  mountdir=$(mktemp -d)
+  mount "$loopback" "$mountdir"
+  rm -rf "$mountdir/var/cache/apt/archives/*" "$mountdir/var/lib/dhcpcd5/*" "$mountdir/var/log/*" "$mountdir/var/tmp/*" "$mountdir/tmp/*" "$mountdir/etc/ssh/*_host_*" 
+  umount "$mountdir"
 fi
 
-minsize=$(resize2fs -P "$loopback" | cut -d ':' -f 2 | tr -d ' ')
+
+#Make sure filesystem is ok
+checkFilesystem
+
+if ! minsize=$(resize2fs -P "$loopback"); then
+	rc=$?
+	error $LINENO "resize2fs failed with rc $rc"
+	exit -10
+fi
+minsize=$(cut -d ':' -f 2 <<< "$minsize" | tr -d ' ')
+logVariables $LINENO minsize
 if [[ $currentsize -eq $minsize ]]; then
-  echo "ERROR: Image already shrunk to smallest size"
-  exit -6
+  error $LINENO "Image already shrunk to smallest size"
+  exit -11
 fi
 
-#Add some free space to the end of the filesystem
+#Add some free space to the end of the filesystem to help with patching in the future
 extra_space=$(($currentsize - $minsize))
-for space in 5000 1000 100; do
+logVariables $LINENO extra_space
+for space in 150000 120000 99000; do
   if [[ $extra_space -gt $space ]]; then
     minsize=$(($minsize + $space))
     break
   fi
 done
+logVariables $LINENO minsize
 
 #Shrink filesystem
+info "Shrinking filesystem"
 resize2fs -p "$loopback" $minsize
 if [[ $? != 0 ]]; then
-  echo "ERROR: resize2fs failed..."
+  error $LINENO "resize2fs failed"
   mount "$loopback" "$mountdir"
   mv "$mountdir/etc/rc.local.bak" "$mountdir/etc/rc.local"
   umount "$mountdir"
   losetup -d "$loopback"
-  exit -7
+  exit -12
 fi
 sleep 1
 
 #Shrink partition
 partnewsize=$(($minsize * $blocksize))
 newpartend=$(($partstart + $partnewsize))
-parted -s -a minimal "$img" rm $partnum >/dev/null
-parted -s "$img" unit B mkpart primary $partstart $newpartend >/dev/null
+logVariables $LINENO partnewsize newpartend
+if ! parted -s -a minimal "$img" rm "$partnum"; then
+	rc=$?
+	error $LINENO "parted failed with rc $rc"
+	exit -13
+fi
+
+if ! parted -s "$img" unit B mkpart primary "$partstart" "$newpartend"; then
+	rc=$?
+	error $LINENO "parted failed with rc $rc"
+	exit -14
+fi
 
 #Truncate the file
-endresult=$(parted -ms "$img" unit B print free | tail -1 | cut -d ':' -f 2 | tr -d 'B')
-truncate -s $endresult "$img"
+info "Shrinking image"
+if ! endresult=$(parted -ms "$img" unit B print free); then
+	rc=$?
+	error $LINENO "parted failed with rc $rc"
+	exit -15
+fi
+
+endresult=$(tail -1 <<< "$endresult" | cut -d ':' -f 2 | tr -d 'B')
+logVariables $LINENO endresult
+if ! truncate -s "$endresult" "$img"; then
+	rc=$?
+	error $LINENO "trunate failed with rc $rc"
+	exit -16
+fi
+
+if [[ $gzip_compress == true ]]; then
+    info "Gzipping the shrunk image"
+    if [[ ! $(gzip -f9 "$img") ]]; then
+        img=$img.gz
+    fi
+fi
+
 aftersize=$(ls -lh "$img" | cut -d ' ' -f 5)
+logVariables $LINENO aftersize
 
-echo "Shrunk $img from $beforesize to $aftersize"
\ No newline at end of file
+info "Shrunk $img from $beforesize to $aftersize"
\ No newline at end of file
diff --git a/mender/image-tools/mender-image-patcher/Dockerfile b/mender/image-tools/mender-image-patcher/Dockerfile
index 261d447c0..4f6b2c9a8 100644
--- a/mender/image-tools/mender-image-patcher/Dockerfile
+++ b/mender/image-tools/mender-image-patcher/Dockerfile
@@ -1,6 +1,6 @@
-FROM ubuntu:18.04
+FROM ubuntu:19.04
 
-ARG MENDER_ARTIFACT_VERSION=2.3.0
+ARG MENDER_ARTIFACT_VERSION=3.3.0
 
 RUN apt-get update && apt-get install -y \
     simg2img img2simg jq gettext \