Clean up unnecessary logging

yorm/base.py

@@ -15,18 +15,12 @@ def __getattribute__(self, name):
         if name in ('yorm_mapper', 'yorm_attrs'):
             return object.__getattribute__(self, name)
 
-        log.trace("getting attribute '{}'...".format(name))
-
         if name in self.yorm_attrs:
             self.yorm_mapper.retrieve(self)
-        else:
-            log.trace("unmapped: {}".format(name))
 
         return object.__getattribute__(self, name)
 
     def __setattr__(self, name, value):
-        log.trace("setting attribute '{}' to {}...".format(name, repr(value)))
-
         if hasattr(self, 'yorm_attrs') and name in self.yorm_attrs:
             converter = self.yorm_attrs[name]
             value = converter.to_value(value)
@@ -38,8 +32,6 @@ def __setattr__(self, name, value):
                 self.yorm_mapper.store(self)
             else:
                 log.trace("automatic storage is off")
-        else:
-            log.trace("unmapped: {}".format(name))
 
     def __enter__(self):
         log.debug("turning off automatic storage...")
@@ -97,12 +89,12 @@ def to_value(cls, obj):  # pylint: disable=E0213
                 converter = yorm_attrs.pop(name)
             except KeyError:
                 from . import standard
-                converter = standard.match(name, data)
+                converter = standard.match(name, data, nested=True)
                 cls.yorm_attrs[name] = converter
             value[name] = converter.to_value(data)
 
         for name, converter in yorm_attrs.items():
-            log.debug("adding deleted '{}'...".format(name))
+            log.trace("adding missing nested key '{}'...".format(name))
             value[name] = converter.to_value(None)
 
         return value

yorm/common.py

@@ -77,7 +77,7 @@ def create_dirname(path):
     """Ensure a parent directory exists for a path."""
     dirpath = os.path.dirname(path)
     if dirpath and not os.path.isdir(dirpath):
-        log.trace("creating directory {}...".format(dirpath))
+        log.trace("creating directory '{}'...".format(dirpath))
         os.makedirs(dirpath)
 
 

yorm/mapper.py

@@ -60,7 +60,7 @@ def __str__(self):
     def create(self, obj):
         """Create a new file for the object."""
         if not os.path.exists(self.path):
-            log.debug("creating '{}' for {}...".format(self, repr(obj)))
+            log.info("mapping {} to '{}'...".format(repr(obj), self))
             common.create_dirname(self.path)
             common.touch(self.path)
             self.exists = True
@@ -69,10 +69,9 @@ def create(self, obj):
     def retrieve(self, obj):
         """Load the object's properties from its file."""
         if self.storing:
-            log.trace("storing in process...")
             return
         self.retrieving = True
-        log.debug("retrieving {} from {}...".format(repr(obj), self))
+        log.debug("retrieving {} from '{}'...".format(repr(obj), self.path))
 
         # Parse data from file
         text = self.read()
@@ -89,7 +88,7 @@ def retrieve(self, obj):
                 converter = standard.match(name, data)
                 obj.yorm_attrs[name] = converter
             value = converter.to_value(data)
-            log.trace("value retrieved: {} = {}".format(name, repr(value)))
+            log.trace("value retrieved: '{}' = {}".format(name, repr(value)))
             setattr(obj, name, value)
 
         # Set meta attributes
@@ -123,17 +122,16 @@ def load(text, path):
     def store(self, obj):
         """Format and save the object's properties to its file."""
         if self.retrieving:
-            log.trace("retrieving in process...")
             return
         self.storing = True
-        log.debug("storing {} to {}...".format(repr(obj), self))
+        log.debug("storing {} to '{}'...".format(repr(obj), self.path))
 
         # Format the data items
         data = {}
         for name, converter in obj.yorm_attrs.items():
             value = getattr(obj, name, None)
             data2 = converter.to_data(value)
-            log.debug("data to store: {} = {}".format(name, repr(data2)))
+            log.trace("data to store: '{}' = {}".format(name, repr(data2)))
             data[name] = data2
 
         # Dump data to file
@@ -168,7 +166,7 @@ def write(self, text):
     def delete(self):
         """Delete the object's file from the file system."""
         if self.exists:
-            log.info("deleting '{}'...".format(self))
+            log.info("deleting '{}'...".format(self.path))
             common.delete(self.path)
             self.retrieved = False
             self.exists = False

yorm/standard.py

@@ -95,22 +95,24 @@ def to_value(cls, obj):
             return cls.DEFAULT
 
 
-def match(name, data):
+def match(name, data, nested=False):
     """Determine the appropriate converter for new data."""
-    log.debug("determining '{}' converter: {}".format(name, repr(data)))
+    nested = " nested" if nested else ""
+    msg = "determining converter for new{}: '{}' = {}"
+    log.debug(msg.format(nested, name, repr(data)))
 
     converters = Object.__subclasses__()
     log.trace("converter options: {}".format(converters))
 
     for converter in converters:
-        if converter.TYPE and isinstance(data, converter.TYPE):
+        if converter.TYPE and type(data) == converter.TYPE:
             log.debug("matched converter: {}".format(converter))
-            log.info("new attribute: {}".format(name))
+            log.info("new{} attribute: {}".format(nested, name))
             return converter
 
     if data is None or isinstance(data, (dict, list)):
         log.info("default converter: {}".format(Object))
-        log.warn("new attribute with unknown type: {}".format(name))
+        log.warn("new{} attribute with unknown type: {}".format(nested, name))
         return Object
 
     raise common.ConversionError("no converter available for: {}".format(data))