MongoObserver.log_metrics() - Code Metrics - Inspection of "Feature/data logger" - IDSIA/sacred - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#184)

by Martin

created 2017-06-28 16:35 UTC

MongoObserver.log_metrics() B

↳ Parent: MongoObserver

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	4
c	3
b	0
f	0
dl	0
loc	25
rs	8.5806

#!/usr/bin/env python
# coding=utf-8
from __future__ import division, print_function, unicode_literals

import pickle
import re
import os.path
import sys
import time

import bson
import gridfs
import pymongo
import sacred.optional as opt
from pymongo.errors import AutoReconnect, InvalidDocument, DuplicateKeyError
from sacred.commandline_options import CommandLineOption
from sacred.dependencies import get_digest
from sacred.observers.base import RunObserver
from sacred.serializer import flatten
from sacred.utils import ObserverError


DEFAULT_MONGO_PRIORITY = 30


def force_valid_bson_key(key):
    key = str(key)
    if key.startswith('$'):
        key = '@' + key[1:]
    key = key.replace('.', ',')
    return key


def force_bson_encodeable(obj):
    if isinstance(obj, dict):
        try:
            bson.BSON.encode(obj, check_keys=True)
            return obj
        except bson.InvalidDocument:
            return {force_valid_bson_key(k): force_bson_encodeable(v)
                    for k, v in obj.items()}

    elif opt.has_numpy and isinstance(obj, opt.np.ndarray):
        return obj
    else:
        try:
            bson.BSON.encode({'dict_just_for_testing': obj})
            return obj
        except bson.InvalidDocument:
            return str(obj)


class MongoObserver(RunObserver):
    COLLECTION_NAME_BLACKLIST = {'fs.files', 'fs.chunks', '_properties',
                                 'system.indexes', 'seach_space'}
    VERSION = 'MongoObserver-0.7.0'

    @staticmethod
    def create(url='localhost', db_name='sacred', collection='runs',
               overwrite=None, priority=DEFAULT_MONGO_PRIORITY, **kwargs):
        client = pymongo.MongoClient(url, **kwargs)
        database = client[db_name]
        if collection in MongoObserver.COLLECTION_NAME_BLACKLIST:
            raise KeyError('Collection name "{}" is reserved. '
                           'Please use a different one.'.format(collection))
        runs_collection = database[collection]
        metrics_collection = database["metrics"]
        fs = gridfs.GridFS(database)
        return MongoObserver(runs_collection,
                             fs, overwrite=overwrite,
                             metrics_collection=metrics_collection,
                             priority=priority)

    def __init__(self, runs_collection,
                 fs, overwrite=None, metrics_collection=None,
                 priority=DEFAULT_MONGO_PRIORITY):
        self.runs = runs_collection
        self.metrics = metrics_collection
        self.fs = fs
        self.overwrite = overwrite
        self.run_entry = None
        self.priority = priority

    def queued_event(self, ex_info, command, queue_time, config, meta_info,
                     _id):
        if self.overwrite is not None:
            raise RuntimeError("Can't overwrite with QUEUED run.")
        self.run_entry = {
            'experiment': dict(ex_info),
            'command': command,
            'config': flatten(config),
            'meta': meta_info,
            'status': 'QUEUED'
        }
        # set ID if given
        if _id is not None:
            self.run_entry['_id'] = _id
        # save sources
        self.run_entry['experiment']['sources'] = self.save_sources(ex_info)
        self.insert()
        return self.run_entry['_id']

    def started_event(self, ex_info, command, host_info, start_time, config,
                      meta_info, _id):
        if self.overwrite is None:
            self.run_entry = {'_id': _id}
        else:
            if self.run_entry is not None:
                raise RuntimeError("Cannot overwrite more than once!")
            # sanity checks
            if self.overwrite['experiment']['sources'] != ex_info['sources']:
                raise RuntimeError("Sources don't match")
            self.run_entry = self.overwrite

        self.run_entry.update({
            'experiment': dict(ex_info),
            'format': self.VERSION,
            'command': command,
            'host': dict(host_info),
            'start_time': start_time,
            'config': flatten(config),
            'meta': meta_info,
            'status': 'RUNNING',
            'resources': [],
            'artifacts': [],
            'captured_out': '',
            'info': {},
            'heartbeat': None
        })

        # save sources
        self.run_entry['experiment']['sources'] = self.save_sources(ex_info)
        self.insert()
        return self.run_entry['_id']

    def heartbeat_event(self, info, captured_out, beat_time, result):
        self.run_entry['info'] = flatten(info)
        self.run_entry['captured_out'] = captured_out
        self.run_entry['heartbeat'] = beat_time
        self.run_entry['result'] = result
        self.save()

    def completed_event(self, stop_time, result):
        self.run_entry['stop_time'] = stop_time
        self.run_entry['result'] = flatten(result)
        self.run_entry['status'] = 'COMPLETED'
        self.final_save(attempts=10)

    def interrupted_event(self, interrupt_time, status):
        self.run_entry['stop_time'] = interrupt_time
        self.run_entry['status'] = status
        self.final_save(attempts=3)

    def failed_event(self, fail_time, fail_trace):
        self.run_entry['stop_time'] = fail_time
        self.run_entry['status'] = 'FAILED'
        self.run_entry['fail_trace'] = fail_trace
        self.final_save(attempts=1)

    def resource_event(self, filename):
        if self.fs.exists(filename=filename):
            md5hash = get_digest(filename)
            if self.fs.exists(filename=filename, md5=md5hash):
                resource = (filename, md5hash)
                if resource not in self.run_entry['resources']:
                    self.run_entry['resources'].append(resource)
                    self.save()
                return
        with open(filename, 'rb') as f:
            file_id = self.fs.put(f, filename=filename)
        md5hash = self.fs.get(file_id).md5
        self.run_entry['resources'].append((filename, md5hash))
        self.save()

    def artifact_event(self, name, filename):
        with open(filename, 'rb') as f:
            run_id = self.run_entry['_id']
            db_filename = 'artifact://{}/{}/{}'.format(self.runs.name, run_id,
                                                       name)
            file_id = self.fs.put(f, filename=db_filename)
        self.run_entry['artifacts'].append({'name': name,
                                            'file_id': file_id})
        self.save()

    def log_metrics(self, metrics_by_name, info):
        """Store new measurements to the database.

        Take measurements and store them into
        the metrics collection in the database.
        Additionally, reference the metrics
        in the info["metrics"] dictionary.
        """
        if self.metrics is None:
            # If, for whatever reason, the metrics collection has not been set
            # do not try to save there anything
            return
        for key in metrics_by_name:
            query = {"run_id": self.run_entry['_id'],
                     "name": key}
            push = {"steps": {"$each": metrics_by_name[key]["steps"]},
                    "values": {"$each": metrics_by_name[key]["values"]},
                    "timestamps": {"$each": metrics_by_name[key]["timestamps"]}
                    }
            update = {"$push": push}
            result = self.metrics.update_one(query, update, upsert=True)
            if result.upserted_id is not None:
                # This is the first time we are storing this metric
                info.setdefault("metrics", []) \
                    .append({"name": key, "id": str(result.upserted_id)})

    def insert(self):
        if self.overwrite:
            return self.save()

        autoinc_key = self.run_entry.get('_id') is None
        while True:
            if autoinc_key:
                c = self.runs.find({}, {'_id': 1})
                c = c.sort('_id', pymongo.DESCENDING).limit(1)
                self.run_entry['_id'] = c.next()['_id'] + 1 if c.count() else 1
            try:
                self.runs.insert_one(self.run_entry)
            except InvalidDocument:
                raise ObserverError('Run contained an unserializable entry.'
                                    '(most likely in the info)')
            except DuplicateKeyError:
                if not autoinc_key:
                    raise
            return

    def save(self):
        try:
            self.runs.replace_one({'_id': self.run_entry['_id']},
                                  self.run_entry)
        except AutoReconnect:
            pass  # just wait for the next save
        except InvalidDocument:
            raise ObserverError('Run contained an unserializable entry.'
                                '(most likely in the info)')

    def final_save(self, attempts):
        for i in range(attempts):
            try:
                self.runs.save(self.run_entry)
                return
            except AutoReconnect:
                if i < attempts - 1:
                    time.sleep(1)
            except InvalidDocument:
                self.run_entry = force_bson_encodeable(self.run_entry)
                print("Warning: Some of the entries of the run were not "
                      "BSON-serializable!\n They have been altered such that "
                      "they can be stored, but you should fix your experiment!"
                      "Most likely it is either the 'info' or the 'result'.",
                      file=sys.stderr)

        from tempfile import NamedTemporaryFile
        with NamedTemporaryFile(suffix='.pickle', delete=False,
                                prefix='sacred_mongo_fail_') as f:
            pickle.dump(self.run_entry, f)
            print("Warning: saving to MongoDB failed! "
                  "Stored experiment entry in '{}'".format(f.name),
                  file=sys.stderr)

    def save_sources(self, ex_info):
        base_dir = ex_info['base_dir']
        source_info = []
        for source_name, md5 in ex_info['sources']:
            abs_path = os.path.join(base_dir, source_name)
            file = self.fs.find_one({'filename': abs_path, 'md5': md5})
            if file:
                _id = file._id
            else:
                with open(abs_path, 'rb') as f:
                    _id = self.fs.put(f, filename=abs_path)
            source_info.append([source_name, _id])
        return source_info

    def __eq__(self, other):
        if isinstance(other, MongoObserver):
            return self.runs == other.runs
        return False

    def __ne__(self, other):
        return not self.__eq__(other)


class MongoDbOption(CommandLineOption):
    """Add a MongoDB Observer to the experiment."""

    arg = 'DB'
    arg_description = "Database specification. Can be " \
                      "[host:port:]db_name[.collection][!priority]"

    DB_NAME_PATTERN = r"[_A-Za-z][0-9A-Za-z#%&'()+\-;=@\[\]^_{}.]{0,63}"
    HOSTNAME_PATTERN = \
        r"(?=.{1,255}$)" \
        r"[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?" \
        r"(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?)*" \
        r"\.?"
    URL_PATTERN = "(?:" + HOSTNAME_PATTERN + ")" + ":" + "(?:[0-9]{1,5})"
    PRIORITY_PATTERN = "(?P<priority>!-?\d+)?"
    DB_NAME = re.compile("^" + DB_NAME_PATTERN + PRIORITY_PATTERN + "$")
    URL = re.compile("^" + URL_PATTERN + PRIORITY_PATTERN + "$")
    URL_DB_NAME = re.compile("^(?P<url>" + URL_PATTERN + ")" + ":" +
                             "(?P<db_name>" + DB_NAME_PATTERN + ")" +
                             PRIORITY_PATTERN + "$")

    @classmethod
    def apply(cls, args, run):
        url, db_name, collection, priority = cls.parse_mongo_db_arg(args)
        if collection:
            mongo = MongoObserver.create(db_name=db_name, url=url,
                                         collection=collection,
                                         priority=priority)
        else:
            mongo = MongoObserver.create(db_name=db_name, url=url,
                                         priority=priority)

        run.observers.append(mongo)

    @classmethod
    def parse_mongo_db_arg(cls, mongo_db):
        def get_priority(pattern):
            prio_str = pattern.match(mongo_db).group('priority')
            if prio_str is None:
                return DEFAULT_MONGO_PRIORITY
            else:
                return int(prio_str[1:])

        if cls.DB_NAME.match(mongo_db):
            db_name, _, collection = mongo_db.partition('.')
            return ('localhost:27017', db_name, collection,
                    get_priority(cls.DB_NAME))
        elif cls.URL.match(mongo_db):
            return mongo_db, 'sacred', '', get_priority(cls.URL)
        elif cls.URL_DB_NAME.match(mongo_db):
            match = cls.URL_DB_NAME.match(mongo_db)
            db_name, _, collection = match.group('db_name').partition('.')
            return (match.group('url'), db_name, collection,
                    get_priority(cls.URL_DB_NAME))
        else:
            raise ValueError('mongo_db argument must have the form "db_name" '
                             'or "host:port[:db_name]" but was {}'
                             .format(mongo_db))


1			#!/usr/bin/env python
2			# coding=utf-8
3			from __future__ import division, print_function, unicode_literals
4
5			import pickle
6			import re
7			import os.path
8			import sys
9			import time
10
11			import bson
12			import gridfs
13			import pymongo
14			import sacred.optional as opt
15			from pymongo.errors import AutoReconnect, InvalidDocument, DuplicateKeyError
16			from sacred.commandline_options import CommandLineOption
17			from sacred.dependencies import get_digest
18			from sacred.observers.base import RunObserver
19			from sacred.serializer import flatten
20			from sacred.utils import ObserverError
21
22
23			DEFAULT_MONGO_PRIORITY = 30
24
25
26			def force_valid_bson_key(key):
27			key = str(key)
28			if key.startswith('$'):
29			key = '@' + key[1:]
30			key = key.replace('.', ',')
31			return key
32
33
34			def force_bson_encodeable(obj):
35			if isinstance(obj, dict):
36			try:
37			bson.BSON.encode(obj, check_keys=True)
38			return obj
39			except bson.InvalidDocument:
40			return {force_valid_bson_key(k): force_bson_encodeable(v)
41			for k, v in obj.items()}
42
43			elif opt.has_numpy and isinstance(obj, opt.np.ndarray):
44			return obj
45			else:
46			try:
47			bson.BSON.encode({'dict_just_for_testing': obj})
48			return obj
49			except bson.InvalidDocument:
50			return str(obj)
51
52
53			class MongoObserver(RunObserver):
54			COLLECTION_NAME_BLACKLIST = {'fs.files', 'fs.chunks', '_properties',
55			'system.indexes', 'seach_space'}
56			VERSION = 'MongoObserver-0.7.0'
57
58			@staticmethod
59			def create(url='localhost', db_name='sacred', collection='runs',
60			overwrite=None, priority=DEFAULT_MONGO_PRIORITY, **kwargs):
61			client = pymongo.MongoClient(url, **kwargs)
62			database = client[db_name]
63			if collection in MongoObserver.COLLECTION_NAME_BLACKLIST:
64			raise KeyError('Collection name "{}" is reserved. '
65			'Please use a different one.'.format(collection))
66			runs_collection = database[collection]
67			metrics_collection = database["metrics"]
68			fs = gridfs.GridFS(database)
69			return MongoObserver(runs_collection,
70			fs, overwrite=overwrite,
71			metrics_collection=metrics_collection,
72			priority=priority)
73
74			def __init__(self, runs_collection,
75			fs, overwrite=None, metrics_collection=None,
76			priority=DEFAULT_MONGO_PRIORITY):
77			self.runs = runs_collection
78			self.metrics = metrics_collection
79			self.fs = fs
80			self.overwrite = overwrite
81			self.run_entry = None
82			self.priority = priority
83
84			def queued_event(self, ex_info, command, queue_time, config, meta_info,
85			_id):
86			if self.overwrite is not None:
87			raise RuntimeError("Can't overwrite with QUEUED run.")
88			self.run_entry = {
89			'experiment': dict(ex_info),
90			'command': command,
91			'config': flatten(config),
92			'meta': meta_info,
93			'status': 'QUEUED'
94			}
95			# set ID if given
96			if _id is not None:
97			self.run_entry['_id'] = _id
98			# save sources
99			self.run_entry['experiment']['sources'] = self.save_sources(ex_info)
100			self.insert()
101			return self.run_entry['_id']
102
103			def started_event(self, ex_info, command, host_info, start_time, config,
104			meta_info, _id):
105			if self.overwrite is None:
106			self.run_entry = {'_id': _id}
107			else:
108			if self.run_entry is not None:
109			raise RuntimeError("Cannot overwrite more than once!")
110			# sanity checks
111			if self.overwrite['experiment']['sources'] != ex_info['sources']:
112			raise RuntimeError("Sources don't match")
113			self.run_entry = self.overwrite
114
115			self.run_entry.update({
116			'experiment': dict(ex_info),
117			'format': self.VERSION,
118			'command': command,
119			'host': dict(host_info),
120			'start_time': start_time,
121			'config': flatten(config),
122			'meta': meta_info,
123			'status': 'RUNNING',
124			'resources': [],
125			'artifacts': [],
126			'captured_out': '',
127			'info': {},
128			'heartbeat': None
129			})
130
131			# save sources
132			self.run_entry['experiment']['sources'] = self.save_sources(ex_info)
133			self.insert()
134			return self.run_entry['_id']
135
136			def heartbeat_event(self, info, captured_out, beat_time, result):
137			self.run_entry['info'] = flatten(info)
138			self.run_entry['captured_out'] = captured_out
139			self.run_entry['heartbeat'] = beat_time
140			self.run_entry['result'] = result
141			self.save()
142
143			def completed_event(self, stop_time, result):
144			self.run_entry['stop_time'] = stop_time
145			self.run_entry['result'] = flatten(result)
146			self.run_entry['status'] = 'COMPLETED'
147			self.final_save(attempts=10)
148
149			def interrupted_event(self, interrupt_time, status):
150			self.run_entry['stop_time'] = interrupt_time
151			self.run_entry['status'] = status
152			self.final_save(attempts=3)
153
154			def failed_event(self, fail_time, fail_trace):
155			self.run_entry['stop_time'] = fail_time
156			self.run_entry['status'] = 'FAILED'
157			self.run_entry['fail_trace'] = fail_trace
158			self.final_save(attempts=1)
159
160			def resource_event(self, filename):
161			if self.fs.exists(filename=filename):
162			md5hash = get_digest(filename)
163			if self.fs.exists(filename=filename, md5=md5hash):
164			resource = (filename, md5hash)
165			if resource not in self.run_entry['resources']:
166			self.run_entry['resources'].append(resource)
167			self.save()
168			return
169			with open(filename, 'rb') as f:
170			file_id = self.fs.put(f, filename=filename)
171			md5hash = self.fs.get(file_id).md5
172			self.run_entry['resources'].append((filename, md5hash))
173			self.save()
174
175			def artifact_event(self, name, filename):
176			with open(filename, 'rb') as f:
177			run_id = self.run_entry['_id']
178			db_filename = 'artifact://{}/{}/{}'.format(self.runs.name, run_id,
179			name)
180			file_id = self.fs.put(f, filename=db_filename)
181			self.run_entry['artifacts'].append({'name': name,
182			'file_id': file_id})
183			self.save()
184
185			def log_metrics(self, metrics_by_name, info):
186			"""Store new measurements to the database.
187
188			Take measurements and store them into
189			the metrics collection in the database.
190			Additionally, reference the metrics
191			in the info["metrics"] dictionary.
192			"""
193			if self.metrics is None:
194			# If, for whatever reason, the metrics collection has not been set
195			# do not try to save there anything
196			return
197			for key in metrics_by_name:
198			query = {"run_id": self.run_entry['_id'],
199			"name": key}
200			push = {"steps": {"$each": metrics_by_name[key]["steps"]},
201			"values": {"$each": metrics_by_name[key]["values"]},
202			"timestamps": {"$each": metrics_by_name[key]["timestamps"]}
203			}
204			update = {"$push": push}
205			result = self.metrics.update_one(query, update, upsert=True)
206			if result.upserted_id is not None:
207			# This is the first time we are storing this metric
208			info.setdefault("metrics", []) \
209			.append({"name": key, "id": str(result.upserted_id)})
210
211			def insert(self):
212			if self.overwrite:
213			return self.save()
214
215			autoinc_key = self.run_entry.get('_id') is None
216			while True:
217			if autoinc_key:
218			c = self.runs.find({}, {'_id': 1})
219			c = c.sort('_id', pymongo.DESCENDING).limit(1)
220			self.run_entry['_id'] = c.next()['_id'] + 1 if c.count() else 1
221			try:
222			self.runs.insert_one(self.run_entry)
223			except InvalidDocument:
224			raise ObserverError('Run contained an unserializable entry.'
225			'(most likely in the info)')
226			except DuplicateKeyError:
227			if not autoinc_key:
228			raise
229			return
230
231			def save(self):
232			try:
233			self.runs.replace_one({'_id': self.run_entry['_id']},
234			self.run_entry)
235			except AutoReconnect:
236			pass # just wait for the next save
237			except InvalidDocument:
238			raise ObserverError('Run contained an unserializable entry.'
239			'(most likely in the info)')
240
241			def final_save(self, attempts):
242			for i in range(attempts):
243			try:
244			self.runs.save(self.run_entry)
245			return
246			except AutoReconnect:
247			if i < attempts - 1:
248			time.sleep(1)
249			except InvalidDocument:
250			self.run_entry = force_bson_encodeable(self.run_entry)
251			print("Warning: Some of the entries of the run were not "
252			"BSON-serializable!\n They have been altered such that "
253			"they can be stored, but you should fix your experiment!"
254			"Most likely it is either the 'info' or the 'result'.",
255			file=sys.stderr)
256
257			from tempfile import NamedTemporaryFile
258			with NamedTemporaryFile(suffix='.pickle', delete=False,
259			prefix='sacred_mongo_fail_') as f:
260			pickle.dump(self.run_entry, f)
261			print("Warning: saving to MongoDB failed! "
262			"Stored experiment entry in '{}'".format(f.name),
263			file=sys.stderr)
264
265			def save_sources(self, ex_info):
266			base_dir = ex_info['base_dir']
267			source_info = []
268			for source_name, md5 in ex_info['sources']:
269			abs_path = os.path.join(base_dir, source_name)
270			file = self.fs.find_one({'filename': abs_path, 'md5': md5})
271			if file:
272			_id = file._id
273			else:
274			with open(abs_path, 'rb') as f:
275			_id = self.fs.put(f, filename=abs_path)
276			source_info.append([source_name, _id])
277			return source_info
278
279			def __eq__(self, other):
280			if isinstance(other, MongoObserver):
281			return self.runs == other.runs
282			return False
283
284			def __ne__(self, other):
285			return not self.__eq__(other)
286
287
288			class MongoDbOption(CommandLineOption):
289			"""Add a MongoDB Observer to the experiment."""
290
291			arg = 'DB'
292			arg_description = "Database specification. Can be " \
293			"[host:port:]db_name[.collection][!priority]"
294
295			DB_NAME_PATTERN = r"[_A-Za-z][0-9A-Za-z#%&'()+\-;=@\[\]^_{}.]{0,63}"
296			HOSTNAME_PATTERN = \
297			r"(?=.{1,255}$)" \
298			r"[0-9A-Za-z](?:(?:[0-9A-Za-z]\|-){0,61}[0-9A-Za-z])?" \
299			r"(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]\|-){0,61}[0-9A-Za-z])?)*" \
300			r"\.?"
301			URL_PATTERN = "(?:" + HOSTNAME_PATTERN + ")" + ":" + "(?:[0-9]{1,5})"
302			PRIORITY_PATTERN = "(?P<priority>!-?\d+)?"
303			DB_NAME = re.compile("^" + DB_NAME_PATTERN + PRIORITY_PATTERN + "$")
304			URL = re.compile("^" + URL_PATTERN + PRIORITY_PATTERN + "$")
305			URL_DB_NAME = re.compile("^(?P<url>" + URL_PATTERN + ")" + ":" +
306			"(?P<db_name>" + DB_NAME_PATTERN + ")" +
307			PRIORITY_PATTERN + "$")
308
309			@classmethod
310			def apply(cls, args, run):
311			url, db_name, collection, priority = cls.parse_mongo_db_arg(args)
312			if collection:
313			mongo = MongoObserver.create(db_name=db_name, url=url,
314			collection=collection,
315			priority=priority)
316			else:
317			mongo = MongoObserver.create(db_name=db_name, url=url,
318			priority=priority)
319
320			run.observers.append(mongo)
321
322			@classmethod
323			def parse_mongo_db_arg(cls, mongo_db):
324			def get_priority(pattern):
325			prio_str = pattern.match(mongo_db).group('priority')
326			if prio_str is None:
327			return DEFAULT_MONGO_PRIORITY
328			else:
329			return int(prio_str[1:])
330
331			if cls.DB_NAME.match(mongo_db):
332			db_name, _, collection = mongo_db.partition('.')
333			return ('localhost:27017', db_name, collection,
334			get_priority(cls.DB_NAME))
335			elif cls.URL.match(mongo_db):
336			return mongo_db, 'sacred', '', get_priority(cls.URL)
337			elif cls.URL_DB_NAME.match(mongo_db):
338			match = cls.URL_DB_NAME.match(mongo_db)
339			db_name, _, collection = match.group('db_name').partition('.')
340			return (match.group('url'), db_name, collection,
341			get_priority(cls.URL_DB_NAME))
342			else:
343			raise ValueError('mongo_db argument must have the form "db_name" '
344			'or "host:port[:db_name]" but was {}'
345			.format(mongo_db))
346

IDSIA / sacred

Pull Request — master (#184)

MongoObserver.log_metrics() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like