#12256

pending completion

Build # #12256

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/datajoint/datajoint-python/commit/<a class=hub.com/datajoint/datajoint-python/commit/<a class="double-link" href="https://git"><a class=hub.com/datajoint/datajoint-python/commit/<a class="double-link" href="https://git"><a class=hub.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa02ca">161dc54f7<a href="https://github.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa02ca">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/datajoint/datajoint-python/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datajoint/datajoint-python/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa02ca&quot;&gt;161dc54f7&lt;/a&gt;&lt;a href=&quot;https://github.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa02ca&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677f&lt;/a&gt;d7fa02ca&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datajoint/datajoint-python/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datajoint/datajoint-python/commit/<a class="double-link" href="https://github.com/datajoint/datajoint-python/commit/cd46161801524a781d528aab64a24412471833db">cd4616180</a><a href="https://github.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa02ca">&amp;quot;&amp;gt;cd4616180&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;cd4616180&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/datajoint/datajoint-python/commit/161dc54f7d1227bae9560914bb17677fd7fa0&lt;/a&gt;2ca&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/datajoint/datajoint-python/commit/<a class="double-link" href="https://github.com/datajoint/datajoint-python/commit/e2aa1ad38">e2aa1ad38">e2aa1ad38</a>

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

3062 of 3387 relevant lines covered (90.4%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.83

/datajoint/autopopulate.py

"""This module defines class dj.AutoPopulate"""
import logging
import datetime
import traceback
import random
import inspect
from tqdm import tqdm
from .expression import QueryExpression, AndList
from .errors import DataJointError, LostConnectionError
import signal
import multiprocessing as mp

# noinspection PyExceptionInherit,PyCallingNonCallable

logger = logging.getLogger(__name__)


# --- helper functions for multiprocessing --


def _initialize_populate(table, jobs, populate_kwargs):
    """
    Initialize the process for mulitprocessing.
    Saves the unpickled copy of the table to the current process and reconnects.
    """
    process = mp.current_process()
    process.table = table
    process.jobs = jobs
    process.populate_kwargs = populate_kwargs
    table.connection.connect()  # reconnect


def _call_populate1(key):
    """
    Call current process' table._populate1()
    :key - a dict specifying job to compute
    :return: key, error if error, otherwise None
    """
    process = mp.current_process()
    return process.table._populate1(key, process.jobs, **process.populate_kwargs)


class AutoPopulate:
    """
    AutoPopulate is a mixin class that adds the method populate() to a Relation class.
    Auto-populated relations must inherit from both Relation and AutoPopulate,
    must define the property `key_source`, and must define the callback method `make`.
    """

    _key_source = None
    _allow_insert = False

    @property
    def key_source(self):
        """
        :return: the query expression that yields primary key values to be passed,
        sequentially, to the ``make`` method when populate() is called.
        The default value is the join of the parent tables references from the primary key.
        Subclasses may override they key_source to change the scope or the granularity
        of the make calls.
        """

        def _rename_attributes(table, props):
            return (
                table.proj(
                    **{
                        attr: ref
                        for attr, ref in props["attr_map"].items()
                        if attr != ref
                    }
                )
                if props["aliased"]
                else table.proj()
            )

        if self._key_source is None:
            parents = self.target.parents(
                primary=True, as_objects=True, foreign_key_info=True
            )
            if not parents:
                raise DataJointError(
                    "A table must have dependencies "
                    "from its primary key for auto-populate to work"
                )
            self._key_source = _rename_attributes(*parents[0])
            for q in parents[1:]:
                self._key_source *= _rename_attributes(*q)
        return self._key_source

    def make(self, key):
        """
        Derived classes must implement method `make` that fetches data from tables
        above them in the dependency hierarchy, restricting by the given key,
        computes secondary attributes, and inserts the new tuples into self.
        """
        raise NotImplementedError(
            "Subclasses of AutoPopulate must implement the method `make`"
        )

    @property
    def target(self):
        """
        :return: table to be populated.
        In the typical case, dj.AutoPopulate is mixed into a dj.Table class by
        inheritance and the target is self.
        """
        return self

    def _job_key(self, key):
        """
        :param key:  they key returned for the job from the key source
        :return: the dict to use to generate the job reservation hash
        This method allows subclasses to control the job reservation granularity.
        """
        return key

    def _jobs_to_do(self, restrictions):
        """
        :return: the relation containing the keys to be computed (derived from self.key_source)
        """
        if self.restriction:
            raise DataJointError(
                "Cannot call populate on a restricted table. "
                "Instead, pass conditions to populate() as arguments."
            )
        todo = self.key_source

        # key_source is a QueryExpression subclass -- trigger instantiation
        if inspect.isclass(todo) and issubclass(todo, QueryExpression):
            todo = todo()

        if not isinstance(todo, QueryExpression):
            raise DataJointError("Invalid key_source value")

        try:
            # check if target lacks any attributes from the primary key of key_source
            raise DataJointError(
                "The populate target lacks attribute %s "
                "from the primary key of key_source"
                % next(
                    name
                    for name in todo.heading.primary_key
                    if name not in self.target.heading
                )
            )
        except StopIteration:
            pass
        return (todo & AndList(restrictions)).proj()

    def populate(
        self,
        *restrictions,
        suppress_errors=False,
        return_exception_objects=False,
        reserve_jobs=False,
        order="original",
        limit=None,
        max_calls=None,
        display_progress=False,
        processes=1,
        make_kwargs=None
    ):
        """
        ``table.populate()`` calls ``table.make(key)`` for every primary key in
        ``self.key_source`` for which there is not already a tuple in table.

        :param restrictions: a list of restrictions each restrict
            (table.key_source - target.proj())
        :param suppress_errors: if True, do not terminate execution.
        :param return_exception_objects: return error objects instead of just error messages
        :param reserve_jobs: if True, reserve jobs to populate in asynchronous fashion
        :param order: "original"|"reverse"|"random"  - the order of execution
        :param limit: if not None, check at most this many keys
        :param max_calls: if not None, populate at most this many keys
        :param display_progress: if True, report progress_bar
        :param processes: number of processes to use. Set to None to use all cores
        :param make_kwargs: Keyword arguments which do not affect the result of computation
            to be passed down to each ``make()`` call. Computation arguments should be
            specified within the pipeline e.g. using a `dj.Lookup` table.
        :type make_kwargs: dict, optional
        """
        if self.connection.in_transaction:
            raise DataJointError("Populate cannot be called during a transaction.")

        valid_order = ["original", "reverse", "random"]
        if order not in valid_order:
            raise DataJointError(
                "The order argument must be one of %s" % str(valid_order)
            )
        jobs = (
            self.connection.schemas[self.target.database].jobs if reserve_jobs else None
        )

        # define and set up signal handler for SIGTERM:
        if reserve_jobs:

            def handler(signum, frame):
                logger.info("Populate terminated by SIGTERM")
                raise SystemExit("SIGTERM received")

            old_handler = signal.signal(signal.SIGTERM, handler)

        keys = (self._jobs_to_do(restrictions) - self.target).fetch("KEY", limit=limit)
        if order == "reverse":
            keys.reverse()
        elif order == "random":
            random.shuffle(keys)

        logger.info("Found %d keys to populate" % len(keys))

        keys = keys[:max_calls]
        nkeys = len(keys)
        if not nkeys:
            return

        processes = min(*(_ for _ in (processes, nkeys, mp.cpu_count()) if _))

        error_list = []
        populate_kwargs = dict(
            suppress_errors=suppress_errors,
            return_exception_objects=return_exception_objects,
            make_kwargs=make_kwargs,
        )

        if processes == 1:
            for key in (
                tqdm(keys, desc=self.__class__.__name__) if display_progress else keys
            ):
                error = self._populate1(key, jobs, **populate_kwargs)
                if error is not None:
                    error_list.append(error)
        else:
            # spawn multiple processes
            self.connection.close()  # disconnect parent process from MySQL server
            del self.connection._conn.ctx  # SSLContext is not pickleable
            with mp.Pool(
                processes, _initialize_populate, (self, jobs, populate_kwargs)
            ) as pool:
                if display_progress:
                    with tqdm(desc="Processes: ", total=nkeys) as pbar:
                        for error in pool.imap(_call_populate1, keys, chunksize=1):
                            if error is not None:
                                error_list.append(error)
                            pbar.update()
                else:
                    for error in pool.imap(_call_populate1, keys):
                        if error is not None:
                            error_list.append(error)
            self.connection.connect()  # reconnect parent process to MySQL server

        # restore original signal handler:
        if reserve_jobs:
            signal.signal(signal.SIGTERM, old_handler)

        if suppress_errors:
            return error_list

    def _populate1(
        self, key, jobs, suppress_errors, return_exception_objects, make_kwargs=None
    ):
        """
        populates table for one source key, calling self.make inside a transaction.
        :param jobs: the jobs table or None if not reserve_jobs
        :param key: dict specifying job to populate
        :param suppress_errors: bool if errors should be suppressed and returned
        :param return_exception_objects: if True, errors must be returned as objects
        :return: (key, error) when suppress_errors=True, otherwise None
        """
        make = self._make_tuples if hasattr(self, "_make_tuples") else self.make

        if jobs is None or jobs.reserve(self.target.table_name, self._job_key(key)):
            self.connection.start_transaction()
            if key in self.target:  # already populated
                self.connection.cancel_transaction()
                if jobs is not None:
                    jobs.complete(self.target.table_name, self._job_key(key))
            else:
                logger.info("Populating: " + str(key))
                self.__class__._allow_insert = True
                try:
                    make(dict(key), **(make_kwargs or {}))
                except (KeyboardInterrupt, SystemExit, Exception) as error:
                    try:
                        self.connection.cancel_transaction()
                    except LostConnectionError:
                        pass
                    error_message = "{exception}{msg}".format(
                        exception=error.__class__.__name__,
                        msg=": " + str(error) if str(error) else "",
                    )
                    if jobs is not None:
                        # show error name and error message (if any)
                        jobs.error(
                            self.target.table_name,
                            self._job_key(key),
                            error_message=error_message,
                            error_stack=traceback.format_exc(),
                        )
                    if not suppress_errors or isinstance(error, SystemExit):
                        raise
                    else:
                        logger.error(error)
                        return key, error if return_exception_objects else error_message
                else:
                    self.connection.commit_transaction()
                    if jobs is not None:
                        jobs.complete(self.target.table_name, self._job_key(key))
                finally:
                    self.__class__._allow_insert = False

    def progress(self, *restrictions, display=True):
        """
        Report the progress of populating the table.
        :return: (remaining, total) -- numbers of tuples to be populated
        """
        todo = self._jobs_to_do(restrictions)
        total = len(todo)
        remaining = len(todo - self.target)
        if display:
            print(
                "%-20s" % self.__class__.__name__,
                "Completed %d of %d (%2.1f%%)   %s"
                % (
                    total - remaining,
                    total,
                    100 - 100 * remaining / (total + 1e-12),
                    datetime.datetime.strftime(
                        datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"
                    ),
                ),
                flush=True,
            )
        return remaining, total

1	"""This module defines class dj.AutoPopulate"""
2	import logging	1✔
3	import datetime	1✔
4	import traceback	1✔
5	import random	1✔
6	import inspect	1✔
7	from tqdm import tqdm	1✔
8	from .expression import QueryExpression, AndList	1✔
9	from .errors import DataJointError, LostConnectionError	1✔
10	import signal	1✔
11	import multiprocessing as mp	1✔
12
13	# noinspection PyExceptionInherit,PyCallingNonCallable
14
15	logger = logging.getLogger(__name__)	1✔
16
17
18	# --- helper functions for multiprocessing --
19
20
21	def _initialize_populate(table, jobs, populate_kwargs):	1✔
22	"""
23	Initialize the process for mulitprocessing.
24	Saves the unpickled copy of the table to the current process and reconnects.
25	"""
26	process = mp.current_process()	×
27	process.table = table	×
28	process.jobs = jobs	×
29	process.populate_kwargs = populate_kwargs	×
30	table.connection.connect() # reconnect	×
31
32
33	def _call_populate1(key):	1✔
34	"""
35	Call current process' table._populate1()
36	:key - a dict specifying job to compute
37	:return: key, error if error, otherwise None
38	"""
39	process = mp.current_process()	×
40	return process.table._populate1(key, process.jobs, **process.populate_kwargs)	×
41
42
43	class AutoPopulate:	1✔
44	"""
45	AutoPopulate is a mixin class that adds the method populate() to a Relation class.
46	Auto-populated relations must inherit from both Relation and AutoPopulate,
47	must define the property `key_source`, and must define the callback method `make`.
48	"""
49
50	_key_source = None	1✔
51	_allow_insert = False	1✔
52
53	@property	1✔
54	def key_source(self):	1✔
55	"""
56	:return: the query expression that yields primary key values to be passed,
57	sequentially, to the ``make`` method when populate() is called.
58	The default value is the join of the parent tables references from the primary key.
59	Subclasses may override they key_source to change the scope or the granularity
60	of the make calls.
61	"""
62
63	def _rename_attributes(table, props):	1✔
64	return (	1✔
65	table.proj(
66	**{
67	attr: ref
68	for attr, ref in props["attr_map"].items()
69	if attr != ref
70	}
71	)
72	if props["aliased"]
73	else table.proj()
74	)
75
76	if self._key_source is None:	1✔
77	parents = self.target.parents(	1✔
78	primary=True, as_objects=True, foreign_key_info=True
79	)
80	if not parents:	1✔
81	raise DataJointError(	×
82	"A table must have dependencies "
83	"from its primary key for auto-populate to work"
84	)
85	self._key_source = _rename_attributes(*parents[0])	1✔
86	for q in parents[1:]:	1✔
87	self._key_source = _rename_attributes(q)	1✔
88	return self._key_source	1✔
89
90	def make(self, key):	1✔
91	"""
92	Derived classes must implement method `make` that fetches data from tables
93	above them in the dependency hierarchy, restricting by the given key,
94	computes secondary attributes, and inserts the new tuples into self.
95	"""
96	raise NotImplementedError(	×
97	"Subclasses of AutoPopulate must implement the method `make`"
98	)
99
100	@property	1✔
101	def target(self):	1✔
102	"""
103	:return: table to be populated.
104	In the typical case, dj.AutoPopulate is mixed into a dj.Table class by
105	inheritance and the target is self.
106	"""
107	return self	1✔
108
109	def _job_key(self, key):	1✔
110	"""
111	:param key: they key returned for the job from the key source
112	:return: the dict to use to generate the job reservation hash
113	This method allows subclasses to control the job reservation granularity.
114	"""
115	return key	1✔
116
117	def _jobs_to_do(self, restrictions):	1✔
118	"""
119	:return: the relation containing the keys to be computed (derived from self.key_source)
120	"""
121	if self.restriction:	1✔
122	raise DataJointError(	×
123	"Cannot call populate on a restricted table. "
124	"Instead, pass conditions to populate() as arguments."
125	)
126	todo = self.key_source	1✔
127
128	# key_source is a QueryExpression subclass -- trigger instantiation
129	if inspect.isclass(todo) and issubclass(todo, QueryExpression):	1✔
130	todo = todo()	1✔
131
132	if not isinstance(todo, QueryExpression):	1✔
133	raise DataJointError("Invalid key_source value")	×
134
135	try:	1✔
136	# check if target lacks any attributes from the primary key of key_source
137	raise DataJointError(	1✔
138	"The populate target lacks attribute %s "
139	"from the primary key of key_source"
140	% next(
141	name
142	for name in todo.heading.primary_key
143	if name not in self.target.heading
144	)
145	)
146	except StopIteration:	1✔
147	pass	1✔
148	return (todo & AndList(restrictions)).proj()	1✔
149
150	def populate(	1✔
151	self,
152	*restrictions,
153	suppress_errors=False,
154	return_exception_objects=False,
155	reserve_jobs=False,
156	order="original",
157	limit=None,
158	max_calls=None,
159	display_progress=False,
160	processes=1,
161	make_kwargs=None
162	):
163	"""
164	``table.populate()`` calls ``table.make(key)`` for every primary key in
165	``self.key_source`` for which there is not already a tuple in table.
166
167	:param restrictions: a list of restrictions each restrict
168	(table.key_source - target.proj())
169	:param suppress_errors: if True, do not terminate execution.
170	:param return_exception_objects: return error objects instead of just error messages
171	:param reserve_jobs: if True, reserve jobs to populate in asynchronous fashion
172	:param order: "original"\|"reverse"\|"random" - the order of execution
173	:param limit: if not None, check at most this many keys
174	:param max_calls: if not None, populate at most this many keys
175	:param display_progress: if True, report progress_bar
176	:param processes: number of processes to use. Set to None to use all cores
177	:param make_kwargs: Keyword arguments which do not affect the result of computation
178	to be passed down to each ``make()`` call. Computation arguments should be
179	specified within the pipeline e.g. using a `dj.Lookup` table.
180	:type make_kwargs: dict, optional
181	"""
182	if self.connection.in_transaction:	1✔
183	raise DataJointError("Populate cannot be called during a transaction.")	×
184
185	valid_order = ["original", "reverse", "random"]	1✔
186	if order not in valid_order:	1✔
187	raise DataJointError(	×
188	"The order argument must be one of %s" % str(valid_order)
189	)
190	jobs = (	1✔
191	self.connection.schemas[self.target.database].jobs if reserve_jobs else None
192	)
193
194	# define and set up signal handler for SIGTERM:
195	if reserve_jobs:	1✔
196
197	def handler(signum, frame):	1✔
198	logger.info("Populate terminated by SIGTERM")	×
199	raise SystemExit("SIGTERM received")	×
200
201	old_handler = signal.signal(signal.SIGTERM, handler)	1✔
202
203	keys = (self._jobs_to_do(restrictions) - self.target).fetch("KEY", limit=limit)	1✔
204	if order == "reverse":	1✔
205	keys.reverse()	×
206	elif order == "random":	1✔
207	random.shuffle(keys)	×
208
209	logger.info("Found %d keys to populate" % len(keys))	1✔
210
211	keys = keys[:max_calls]	1✔
212	nkeys = len(keys)	1✔
213	if not nkeys:	1✔
214	return	1✔
215
216	processes = min(*(_ for _ in (processes, nkeys, mp.cpu_count()) if _))	1✔
217
218	error_list = []	1✔
219	populate_kwargs = dict(	1✔
220	suppress_errors=suppress_errors,
221	return_exception_objects=return_exception_objects,
222	make_kwargs=make_kwargs,
223	)
224
225	if processes == 1:	1✔
226	for key in (	1✔
227	tqdm(keys, desc=self.__class__.__name__) if display_progress else keys
228	):
229	error = self._populate1(key, jobs, **populate_kwargs)	1✔
230	if error is not None:	1✔
231	error_list.append(error)	1✔
232	else:
233	# spawn multiple processes
234	self.connection.close() # disconnect parent process from MySQL server	1✔
235	del self.connection._conn.ctx # SSLContext is not pickleable	1✔
236	with mp.Pool(	1✔
237	processes, _initialize_populate, (self, jobs, populate_kwargs)
238	) as pool:
239	if display_progress:	1✔
240	with tqdm(desc="Processes: ", total=nkeys) as pbar:	×
241	for error in pool.imap(_call_populate1, keys, chunksize=1):	×
242	if error is not None:	×
243	error_list.append(error)	×
244	pbar.update()	×
245	else:
246	for error in pool.imap(_call_populate1, keys):	1✔
247	if error is not None:	1✔
248	error_list.append(error)	×
249	self.connection.connect() # reconnect parent process to MySQL server	1✔
250
251	# restore original signal handler:
252	if reserve_jobs:	1✔
253	signal.signal(signal.SIGTERM, old_handler)	1✔
254
255	if suppress_errors:	1✔
256	return error_list	1✔
257
258	def _populate1(	1✔
259	self, key, jobs, suppress_errors, return_exception_objects, make_kwargs=None
260	):
261	"""
262	populates table for one source key, calling self.make inside a transaction.
263	:param jobs: the jobs table or None if not reserve_jobs
264	:param key: dict specifying job to populate
265	:param suppress_errors: bool if errors should be suppressed and returned
266	:param return_exception_objects: if True, errors must be returned as objects
267	:return: (key, error) when suppress_errors=True, otherwise None
268	"""
269	make = self._make_tuples if hasattr(self, "_make_tuples") else self.make	1✔
270
271	if jobs is None or jobs.reserve(self.target.table_name, self._job_key(key)):	1✔
272	self.connection.start_transaction()	1✔
273	if key in self.target: # already populated	1✔
274	self.connection.cancel_transaction()	×
275	if jobs is not None:	×
276	jobs.complete(self.target.table_name, self._job_key(key))	×
277	else:
278	logger.info("Populating: " + str(key))	1✔
279	self.__class__._allow_insert = True	1✔
280	try:	1✔
281	make(dict(key), **(make_kwargs or {}))	1✔
282	except (KeyboardInterrupt, SystemExit, Exception) as error:	1✔
283	try:	1✔
284	self.connection.cancel_transaction()	1✔
285	except LostConnectionError:	×
286	pass	×
287	error_message = "{exception}{msg}".format(	1✔
288	exception=error.__class__.__name__,
289	msg=": " + str(error) if str(error) else "",
290	)
291	if jobs is not None:	1✔
292	# show error name and error message (if any)
293	jobs.error(	1✔
294	self.target.table_name,
295	self._job_key(key),
296	error_message=error_message,
297	error_stack=traceback.format_exc(),
298	)
299	if not suppress_errors or isinstance(error, SystemExit):	1✔
300	raise	1✔
301	else:
302	logger.error(error)	1✔
303	return key, error if return_exception_objects else error_message	1✔
304	else:
305	self.connection.commit_transaction()	1✔
306	if jobs is not None:	1✔
307	jobs.complete(self.target.table_name, self._job_key(key))	×
308	finally:
309	self.__class__._allow_insert = False	1✔
310
311	def progress(self, *restrictions, display=True):	1✔
312	"""
313	Report the progress of populating the table.
314	:return: (remaining, total) -- numbers of tuples to be populated
315	"""
316	todo = self._jobs_to_do(restrictions)	1✔
317	total = len(todo)	1✔
318	remaining = len(todo - self.target)	1✔
319	if display:	1✔
320	print(	1✔
321	"%-20s" % self.__class__.__name__,
322	"Completed %d of %d (%2.1f%%) %s"
323	% (
324	total - remaining,
325	total,
326	100 - 100 * remaining / (total + 1e-12),
327	datetime.datetime.strftime(
328	datetime.datetime.now(), "%Y-%m-%d %H:%M:%S"
329	),
330	),
331	flush=True,
332	)
333	return remaining, total	1✔

datajoint / datajoint-python / #12256

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous