def test_style_type_adapter(logger, handler, args, kwargs, type_, default_type, extra):
"""Make sure that if you have both a TypeAdapter and a StyleAdapter the
type you provide ends up in the right place, and that it doesn't interfere
with keyword formatting."""
def test(record):
"""Make sure the type attribute is as expected"""
rectype = getattr(record, 'type', None)
if rectype is None:
assert False, "No type for record!"
if type_ is None:
assert rectype == default_type
else:
assert rectype == type_
if extra is not None:
for key, val in extra.items():
assert getattr(record, key, None) == val
logger.addHandler(handler)
logger = TypeAdapter(logger, default_type=default_type)
logger = StyleAdapter(logger, extra=extra)
handler.set_test(test)
fmt = ['{}']*len(args) + ['{' + name + '}' for name in kwargs]
fmt = ' '.join(fmt)
print('-' * 60)
note('fmt={}'.format(fmt))
if type_ is None:
logger.info(fmt, *args, **kwargs)
event('type is None')
else:
logger.info(fmt, *args, type=type_, **kwargs)
def test_style_adapter(logger, handler, args, kwargs, extra):
"""Make sure the StyleAdapter can do keyword formatting"""
def test(record):
"""Make sure the formatting worked"""
assert record.getMessage() == expected
if extra is not None:
for key, val in extra.items():
assert getattr(record, key, None) == val
logger.addHandler(handler)
logger = StyleAdapter(logger, extra=extra)
handler.set_test(test)
fmt = ['{}']*len(args) + ['{' + name + '}' for name in kwargs]
fmt = ' '.join(fmt)
note('fmt={}'.format(fmt))
expected = fmt.format(*args, **kwargs)
logger.info(fmt, *args, **kwargs)
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from collections import defaultdict, namedtuple
import numpy as np
from vermouth.parser_utils import SectionLineParser
from vermouth.log_helpers import StyleAdapter, get_logger
LOGGER = StyleAdapter(get_logger(__name__))
PersistenceSpecs = namedtuple("persistence",
["model", "lp", "start", "stop", "mol_idxs"])
class BuildDirector(SectionLineParser):
"""
Parser for the build file which dictates additional information
about how to generate the system in the random-walk.
"""
COMMENT_CHAR = ';'
def __init__(self, molecules, topology):
super().__init__()
self.topology = topology
StyleAdapter,
BipolarFormatter,
CountingHandler,
TypeAdapter,
)
# Implement Logger
LOGGER = TypeAdapter(logging.getLogger('polyply'))
PRETTY_FORMATTER = logging.Formatter(fmt='{levelname:} - {type} - {message}',
style='{')
DETAILED_FORMATTER = logging.Formatter(
fmt='{levelname:} - {type} - {name} - {message}', style='{')
COUNTER = CountingHandler()
# Control above what level message we want to count
COUNTER.setLevel(logging.WARNING)
CONSOLE_HANDLER = logging.StreamHandler()
FORMATTER = BipolarFormatter(DETAILED_FORMATTER,
PRETTY_FORMATTER,
logging.DEBUG,
logger=LOGGER)
CONSOLE_HANDLER.setFormatter(FORMATTER)
LOGGER.addHandler(CONSOLE_HANDLER)
LOGGER.addHandler(COUNTER)
LOGGER = StyleAdapter(LOGGER)
LOGLEVELS = {0: logging.INFO, 1: logging.DEBUG, 2: 5}