First commit

author: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
committer: Shubham Saini <shubham6405@gmail.com> 2018-12-11 10:01:23 +0000
commit: 68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree: 345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py
1 files changed, 156 insertions, 0 deletions
diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py
new file mode 100644
index 0000000..278dff4
--- /dev/null
+++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py
@@ -0,0 +1,156 @@
+from __future__ import absolute_import, division
+import time
+import os
+try:
+    unicode
+except NameError:
+    unicode = str
+from . import LockBase, NotLocked, NotMyLock, LockTimeout, AlreadyLocked
+class SQLiteLockFile(LockBase):
+    "Demonstrate SQL-based locking."
+    testdb = None
+    def __init__(self, path, threaded=True, timeout=None):
+        """
+        >>> lock = SQLiteLockFile('somefile')
+        >>> lock = SQLiteLockFile('somefile', threaded=False)
+        """
+        LockBase.__init__(self, path, threaded, timeout)
+        self.lock_file = unicode(self.lock_file)
+        self.unique_name = unicode(self.unique_name)
+        if SQLiteLockFile.testdb is None:
+            import tempfile
+            _fd, testdb = tempfile.mkstemp()
+            os.close(_fd)
+            os.unlink(testdb)
+            del _fd, tempfile
+            SQLiteLockFile.testdb = testdb
+        import sqlite3
+        self.connection = sqlite3.connect(SQLiteLockFile.testdb)
+        c = self.connection.cursor()
+        try:
+            c.execute("create table locks"
+                      "("
+                      "   lock_file varchar(32),"
+                      "   unique_name varchar(32)"
+                      ")")
+        except sqlite3.OperationalError:
+            pass
+        else:
+            self.connection.commit()
+            import atexit
+            atexit.register(os.unlink, SQLiteLockFile.testdb)
+    def acquire(self, timeout=None):
+        timeout = timeout if timeout is not None else self.timeout
+        end_time = time.time()
+        if timeout is not None and timeout > 0:
+            end_time += timeout
+        if timeout is None:
+            wait = 0.1
+        elif timeout <= 0:
+            wait = 0
+        else:
+            wait = timeout / 10
+        cursor = self.connection.cursor()
+        while True:
+            if not self.is_locked():
+                # Not locked.  Try to lock it.
+                cursor.execute("insert into locks"
+                               "  (lock_file, unique_name)"
+                               "  values"
+                               "  (?, ?)",
+                               (self.lock_file, self.unique_name))
+                self.connection.commit()
+                # Check to see if we are the only lock holder.
+                cursor.execute("select * from locks"
+                               "  where unique_name = ?",
+                               (self.unique_name,))
+                rows = cursor.fetchall()
+                if len(rows) > 1:
+                    # Nope.  Someone else got there.  Remove our lock.
+                    cursor.execute("delete from locks"
+                                   "  where unique_name = ?",
+                                   (self.unique_name,))
+                    self.connection.commit()
+                else:
+                    # Yup.  We're done, so go home.
+                    return
+            else:
+                # Check to see if we are the only lock holder.
+                cursor.execute("select * from locks"
+                               "  where unique_name = ?",
+                               (self.unique_name,))
+                rows = cursor.fetchall()
+                if len(rows) == 1:
+                    # We're the locker, so go home.
+                    return
+            # Maybe we should wait a bit longer.
+            if timeout is not None and time.time() > end_time:
+                if timeout > 0:
+                    # No more waiting.
+                    raise LockTimeout("Timeout waiting to acquire"
+                                      " lock for %s" %
+                                      self.path)
+                else:
+                    # Someone else has the lock and we are impatient..
+                    raise AlreadyLocked("%s is already locked" % self.path)
+            # Well, okay.  We'll give it a bit longer.
+            time.sleep(wait)
+    def release(self):
+        if not self.is_locked():
+            raise NotLocked("%s is not locked" % self.path)
+        if not self.i_am_locking():
+            raise NotMyLock("%s is locked, but not by me (by %s)" %
+                            (self.unique_name, self._who_is_locking()))
+        cursor = self.connection.cursor()
+        cursor.execute("delete from locks"
+                       "  where unique_name = ?",
+                       (self.unique_name,))
+        self.connection.commit()
+    def _who_is_locking(self):
+        cursor = self.connection.cursor()
+        cursor.execute("select unique_name from locks"
+                       "  where lock_file = ?",
+                       (self.lock_file,))
+        return cursor.fetchone()[0]
+    def is_locked(self):
+        cursor = self.connection.cursor()
+        cursor.execute("select * from locks"
+                       "  where lock_file = ?",
+                       (self.lock_file,))
+        rows = cursor.fetchall()
+        return not not rows
+    def i_am_locking(self):
+        cursor = self.connection.cursor()
+        cursor.execute("select * from locks"
+                       "  where lock_file = ?"
+                       "    and unique_name = ?",
+                       (self.lock_file, self.unique_name))
+        return not not cursor.fetchall()
+    def break_lock(self):
+        cursor = self.connection.cursor()
+        cursor.execute("delete from locks"
+                       "  where lock_file = ?",
+                       (self.lock_file,))
+        self.connection.commit()
author	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
committer	Shubham Saini <shubham6405@gmail.com>	2018-12-11 10:01:23 +0000
commit	68df54d6629ec019142eb149dd037774f2d11e7c (patch)
tree	345bc22d46b4e01a4ba8303b94278952a4ed2b9e /venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py

diff --git a/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py new file mode 100644 index 0000000..278dff4 --- /dev/null +++ b/venv/lib/python3.7/site-packages/pip-10.0.1-py3.7.egg/pip/_vendor/lockfile/sqlitelockfile.py
@@ -0,0 +1,156 @@
	1	from __future__ import absolute_import, division
	2
	3	import time
	4	import os
	5
	6	try:
	7	unicode
	8	except NameError:
	9	unicode = str
	10
	11	from . import LockBase, NotLocked, NotMyLock, LockTimeout, AlreadyLocked
	12
	13
	14	class SQLiteLockFile(LockBase):
	15	"Demonstrate SQL-based locking."
	16
	17	testdb = None
	18
	19	def __init__(self, path, threaded=True, timeout=None):
	20	"""
	21	>>> lock = SQLiteLockFile('somefile')
	22	>>> lock = SQLiteLockFile('somefile', threaded=False)
	23	"""
	24	LockBase.__init__(self, path, threaded, timeout)
	25	self.lock_file = unicode(self.lock_file)
	26	self.unique_name = unicode(self.unique_name)
	27
	28	if SQLiteLockFile.testdb is None:
	29	import tempfile
	30	_fd, testdb = tempfile.mkstemp()
	31	os.close(_fd)
	32	os.unlink(testdb)
	33	del _fd, tempfile
	34	SQLiteLockFile.testdb = testdb
	35
	36	import sqlite3
	37	self.connection = sqlite3.connect(SQLiteLockFile.testdb)
	38
	39	c = self.connection.cursor()
	40	try:
	41	c.execute("create table locks"
	42	"("
	43	" lock_file varchar(32),"
	44	" unique_name varchar(32)"
	45	")")
	46	except sqlite3.OperationalError:
	47	pass
	48	else:
	49	self.connection.commit()
	50	import atexit
	51	atexit.register(os.unlink, SQLiteLockFile.testdb)
	52
	53	def acquire(self, timeout=None):
	54	timeout = timeout if timeout is not None else self.timeout
	55	end_time = time.time()
	56	if timeout is not None and timeout > 0:
	57	end_time += timeout
	58
	59	if timeout is None:
	60	wait = 0.1
	61	elif timeout <= 0:
	62	wait = 0
	63	else:
	64	wait = timeout / 10
	65
	66	cursor = self.connection.cursor()
	67
	68	while True:
	69	if not self.is_locked():
	70	# Not locked. Try to lock it.
	71	cursor.execute("insert into locks"
	72	" (lock_file, unique_name)"
	73	" values"
	74	" (?, ?)",
	75	(self.lock_file, self.unique_name))
	76	self.connection.commit()
	77
	78	# Check to see if we are the only lock holder.
	79	cursor.execute("select * from locks"
	80	" where unique_name = ?",
	81	(self.unique_name,))
	82	rows = cursor.fetchall()
	83	if len(rows) > 1:
	84	# Nope. Someone else got there. Remove our lock.
	85	cursor.execute("delete from locks"
	86	" where unique_name = ?",
	87	(self.unique_name,))
	88	self.connection.commit()
	89	else:
	90	# Yup. We're done, so go home.
	91	return
	92	else:
	93	# Check to see if we are the only lock holder.
	94	cursor.execute("select * from locks"
	95	" where unique_name = ?",
	96	(self.unique_name,))
	97	rows = cursor.fetchall()
	98	if len(rows) == 1:
	99	# We're the locker, so go home.
	100	return
	101
	102	# Maybe we should wait a bit longer.
	103	if timeout is not None and time.time() > end_time:
	104	if timeout > 0:
	105	# No more waiting.
	106	raise LockTimeout("Timeout waiting to acquire"
	107	" lock for %s" %
	108	self.path)
	109	else:
	110	# Someone else has the lock and we are impatient..
	111	raise AlreadyLocked("%s is already locked" % self.path)
	112
	113	# Well, okay. We'll give it a bit longer.
	114	time.sleep(wait)
	115
	116	def release(self):
	117	if not self.is_locked():
	118	raise NotLocked("%s is not locked" % self.path)
	119	if not self.i_am_locking():
	120	raise NotMyLock("%s is locked, but not by me (by %s)" %
	121	(self.unique_name, self._who_is_locking()))
	122	cursor = self.connection.cursor()
	123	cursor.execute("delete from locks"
	124	" where unique_name = ?",
	125	(self.unique_name,))
	126	self.connection.commit()
	127
	128	def _who_is_locking(self):
	129	cursor = self.connection.cursor()
	130	cursor.execute("select unique_name from locks"
	131	" where lock_file = ?",
	132	(self.lock_file,))
	133	return cursor.fetchone()[0]
	134
	135	def is_locked(self):
	136	cursor = self.connection.cursor()
	137	cursor.execute("select * from locks"
	138	" where lock_file = ?",
	139	(self.lock_file,))
	140	rows = cursor.fetchall()
	141	return not not rows
	142
	143	def i_am_locking(self):
	144	cursor = self.connection.cursor()
	145	cursor.execute("select * from locks"
	146	" where lock_file = ?"
	147	" and unique_name = ?",
	148	(self.lock_file, self.unique_name))
	149	return not not cursor.fetchall()
	150
	151	def break_lock(self):
	152	cursor = self.connection.cursor()
	153	cursor.execute("delete from locks"
	154	" where lock_file = ?",
	155	(self.lock_file,))
	156	self.connection.commit()