1 files changed, 163 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py
new file mode 100644
index 0000000..f4572ab
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py
@@ -0,0 +1,163 @@
+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._internal.compat import WINDOWS
+from pip._internal.index import PackageFinder
+from pip._internal.locations import USER_CACHE_DIR, running_under_virtualenv
+from pip._internal.utils.filesystem import check_path_owner
+from pip._internal.utils.misc import ensure_dir, get_installed_version
+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, options):
+    """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 not installed_version:
+        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 (current_time - last_check).total_seconds() < 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:
+            # Lets use PackageFinder to see what the latest pip version is
+            finder = PackageFinder(
+                find_links=options.find_links,
+                index_urls=[options.index_url] + options.extra_index_urls,
+                allow_all_prereleases=False,  # Explicitly set to False
+                trusted_hosts=options.trusted_hosts,
+                process_dependency_links=options.process_dependency_links,
+                session=session,
+            )
+            all_candidates = finder.find_all_candidates("pip")
+            if not all_candidates:
+                return
+            pypi_version = str(
+                max(all_candidates, key=lambda c: c.version).version
+            )
+            # 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/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py new file mode 100644 index 0000000..f4572ab --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_internal/utils/outdated.py
@@ -0,0 +1,163 @@
	1	from __future__ import absolute_import
	2
	3	import datetime
	4	import json
	5	import logging
	6	import os.path
	7	import sys
	8
	9	from pip._vendor import lockfile
	10	from pip._vendor.packaging import version as packaging_version
	11
	12	from pip._internal.compat import WINDOWS
	13	from pip._internal.index import PackageFinder
	14	from pip._internal.locations import USER_CACHE_DIR, running_under_virtualenv
	15	from pip._internal.utils.filesystem import check_path_owner
	16	from pip._internal.utils.misc import ensure_dir, get_installed_version
	17
	18	SELFCHECK_DATE_FMT = "%Y-%m-%dT%H:%M:%SZ"
	19
	20
	21	logger = logging.getLogger(__name__)
	22
	23
	24	class VirtualenvSelfCheckState(object):
	25	def __init__(self):
	26	self.statefile_path = os.path.join(sys.prefix, "pip-selfcheck.json")
	27
	28	# Load the existing state
	29	try:
	30	with open(self.statefile_path) as statefile:
	31	self.state = json.load(statefile)
	32	except (IOError, ValueError):
	33	self.state = {}
	34
	35	def save(self, pypi_version, current_time):
	36	# Attempt to write out our version check file
	37	with open(self.statefile_path, "w") as statefile:
	38	json.dump(
	39	{
	40	"last_check": current_time.strftime(SELFCHECK_DATE_FMT),
	41	"pypi_version": pypi_version,
	42	},
	43	statefile,
	44	sort_keys=True,
	45	separators=(",", ":")
	46	)
	47
	48
	49	class GlobalSelfCheckState(object):
	50	def __init__(self):
	51	self.statefile_path = os.path.join(USER_CACHE_DIR, "selfcheck.json")
	52
	53	# Load the existing state
	54	try:
	55	with open(self.statefile_path) as statefile:
	56	self.state = json.load(statefile)[sys.prefix]
	57	except (IOError, ValueError, KeyError):
	58	self.state = {}
	59
	60	def save(self, pypi_version, current_time):
	61	# Check to make sure that we own the directory
	62	if not check_path_owner(os.path.dirname(self.statefile_path)):
	63	return
	64
	65	# Now that we've ensured the directory is owned by this user, we'll go
	66	# ahead and make sure that all our directories are created.
	67	ensure_dir(os.path.dirname(self.statefile_path))
	68
	69	# Attempt to write out our version check file
	70	with lockfile.LockFile(self.statefile_path):
	71	if os.path.exists(self.statefile_path):
	72	with open(self.statefile_path) as statefile:
	73	state = json.load(statefile)
	74	else:
	75	state = {}
	76
	77	state[sys.prefix] = {
	78	"last_check": current_time.strftime(SELFCHECK_DATE_FMT),
	79	"pypi_version": pypi_version,
	80	}
	81
	82	with open(self.statefile_path, "w") as statefile:
	83	json.dump(state, statefile, sort_keys=True,
	84	separators=(",", ":"))
	85
	86
	87	def load_selfcheck_statefile():
	88	if running_under_virtualenv():
	89	return VirtualenvSelfCheckState()
	90	else:
	91	return GlobalSelfCheckState()
	92
	93
	94	def pip_version_check(session, options):
	95	"""Check for an update for pip.
	96
	97	Limit the frequency of checks to once per week. State is stored either in
	98	the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
	99	of the pip script path.
	100	"""
	101	installed_version = get_installed_version("pip")
	102	if not installed_version:
	103	return
	104
	105	pip_version = packaging_version.parse(installed_version)
	106	pypi_version = None
	107
	108	try:
	109	state = load_selfcheck_statefile()
	110
	111	current_time = datetime.datetime.utcnow()
	112	# Determine if we need to refresh the state
	113	if "last_check" in state.state and "pypi_version" in state.state:
	114	last_check = datetime.datetime.strptime(
	115	state.state["last_check"],
	116	SELFCHECK_DATE_FMT
	117	)
	118	if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60:
	119	pypi_version = state.state["pypi_version"]
	120
	121	# Refresh the version if we need to or just see if we need to warn
	122	if pypi_version is None:
	123	# Lets use PackageFinder to see what the latest pip version is
	124	finder = PackageFinder(
	125	find_links=options.find_links,
	126	index_urls=[options.index_url] + options.extra_index_urls,
	127	allow_all_prereleases=False, # Explicitly set to False
	128	trusted_hosts=options.trusted_hosts,
	129	process_dependency_links=options.process_dependency_links,
	130	session=session,
	131	)
	132	all_candidates = finder.find_all_candidates("pip")
	133	if not all_candidates:
	134	return
	135	pypi_version = str(
	136	max(all_candidates, key=lambda c: c.version).version
	137	)
	138
	139	# save that we've performed a check
	140	state.save(pypi_version, current_time)
	141
	142	remote_version = packaging_version.parse(pypi_version)
	143
	144	# Determine if our pypi_version is older
	145	if (pip_version < remote_version and
	146	pip_version.base_version != remote_version.base_version):
	147	# Advise "python -m pip" on Windows to avoid issues
	148	# with overwriting pip.exe.
	149	if WINDOWS:
	150	pip_cmd = "python -m pip"
	151	else:
	152	pip_cmd = "pip"
	153	logger.warning(
	154	"You are using pip version %s, however version %s is "
	155	"available.\nYou should consider upgrading via the "
	156	"'%s install --upgrade pip' command.",
	157	pip_version, pypi_version, pip_cmd
	158	)
	159	except Exception:
	160	logger.debug(
	161	"There was an error checking the latest version of pip",
	162	exc_info=True,
	163	)