eric: comparison eric7/DebugClients/Python/coverage/sqldata.py

-:ca8e477c590c
+:2fc945191992
 self._file_map = {}
 # Maps thread ids to SqliteDb objects.
 self._dbs = {}
 self._pid = os.getpid()
 # Synchronize the operations used during collection.
-self._lock = threading.Lock()
+self._lock = threading.RLock()
 # Are we in sync with the data file?
 self._have_used = False
 self._has_lines = False
 def _locked(method):            # pylint: disable=no-self-argument
 """A decorator for methods that should hold self._lock."""
 @functools.wraps(method)
 def _wrapped(self, *args, **kwargs):
+if self._debug.should("lock"):
+self._debug.write(f"Locking {self._lock!r} for {method.__name__}")
 with self._lock:
+if self._debug.should("lock"):
+self._debug.write(f"Locked  {self._lock!r} for {method.__name__}")
 # pylint: disable=not-callable
 return method(self, *args, **kwargs)
 return _wrapped
 def _choose_filename(self):
 self._dbs = {}
 self._file_map = {}
 self._have_used = False
 self._current_context_id = None
-def _create_db(self):
-"""Create a db file that doesn't exist yet.
-Initializes the schema and certain metadata.
-"""
-if self._debug.should("dataio"):
-self._debug.write(f"Creating data file {self._filename!r}")
-self._dbs[threading.get_ident()] = db = SqliteDb(self._filename, self._debug)
-with db:
-db.executescript(SCHEMA)
-db.execute("insert into coverage_schema (version) values (?)", (SCHEMA_VERSION,))
-db.executemany(
-"insert into meta (key, value) values (?, ?)",
-[
-("sys_argv", str(getattr(sys, "argv", None))),
-("version", __version__),
-("when", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
-]
-)
 def _open_db(self):
 """Open an existing db file, and read its metadata."""
 if self._debug.should("dataio"):
 self._debug.write(f"Opening data file {self._filename!r}")
 self._dbs[threading.get_ident()] = SqliteDb(self._filename, self._debug)
 """Read the metadata from a database so that we are ready to use it."""
 with self._dbs[threading.get_ident()] as db:
 try:
 schema_version, = db.execute_one("select version from coverage_schema")
 except Exception as exc:
-raise DataError(
+if "no such table: coverage_schema" in str(exc):
-"Data file {!r} doesn't seem to be a coverage data file: {}".format(
+self._init_db(db)
-self._filename, exc
+else:
-)
+raise DataError(
-) from exc
+"Data file {!r} doesn't seem to be a coverage data file: {}".format(
+self._filename, exc
+)
+) from exc
 else:
 if schema_version != SCHEMA_VERSION:
 raise DataError(
 "Couldn't use data file {!r}: wrong schema: {} instead of {}".format(
 self._filename, schema_version, SCHEMA_VERSION
 self._has_lines = not self._has_arcs
 for path, file_id in db.execute("select path, id from file"):
 self._file_map[path] = file_id
+def _init_db(self, db):
+"""Write the initial contents of the database."""
+if self._debug.should("dataio"):
+self._debug.write(f"Initing data file {self._filename!r}")
+db.executescript(SCHEMA)
+db.execute("insert into coverage_schema (version) values (?)", (SCHEMA_VERSION,))
+db.executemany(
+"insert or ignore into meta (key, value) values (?, ?)",
+[
+("sys_argv", str(getattr(sys, "argv", None))),
+("version", __version__),
+("when", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
+]
+)
 def _connect(self):
 """Get the SqliteDb object to use."""
 if threading.get_ident() not in self._dbs:
-if os.path.exists(self._filename):
+self._open_db()
-self._open_db()
-else:
-self._create_db()
 return self._dbs[threading.get_ident()]
 def __bool__(self):
 if (threading.get_ident() not in self._dbs and not os.path.exists(self._filename)):
 return False
 """
 if self._debug.should("dataio"):
 self._debug.write(f"Dumping data from data file {self._filename!r}")
 with self._connect() as con:
-return b"z" + zlib.compress(con.dump().encode("utf-8"))
+script = con.dump()
+return b"z" + zlib.compress(script.encode("utf-8"))
 @contract(data="bytes")
 def loads(self, data):
 """Deserialize data from :meth:`dumps`.
 return
 with self._connect() as con:
 self._set_context_id()
 for filename, arcs in arc_data.items():
 file_id = self._file_id(filename, add=True)
+from coverage import env
+if env.PYVERSION == (3, 11, 0, "alpha", 4, 0):
+arcs = [(a, b) for a, b in arcs if a is not None and b is not None]
 data = [(file_id, self._current_context_id, fromno, tono) for fromno, tono in arcs]
 con.executemany(
 "insert or ignore into arc " +
 "(file_id, context_id, fromno, tono) values (?, ?, ?, ?)",
 data,
 def _choose_lines_or_arcs(self, lines=False, arcs=False):
 """Force the data file to choose between lines and arcs."""
 assert lines or arcs
 assert not (lines and arcs)
 if lines and self._has_arcs:
+if self._debug.should("dataop"):
+self._debug.write("Error: Can't add line measurements to existing branch data")
 raise DataError("Can't add line measurements to existing branch data")
 if arcs and self._has_lines:
+if self._debug.should("dataop"):
+self._debug.write("Error: Can't add branch measurements to existing line data")
 raise DataError("Can't add branch measurements to existing line data")
 if not self._has_arcs and not self._has_lines:
 self._has_lines = lines
 self._has_arcs = arcs
 with self._connect() as con:
 con.execute(
-"insert into meta (key, value) values (?, ?)",
+"insert or ignore into meta (key, value) values (?, ?)",
 ("has_arcs", str(int(arcs)))
 )
 @_locked
 def add_file_tracers(self, file_tracers):

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/sqldata.py

eric7/DebugClients/Python/coverage/sqldata.py