Version 2.1.2

 * Add in duplex module for dual instancemethod/classmethod definition
 * Update contextlog to allow for 'anonymous' logging (i.e. calling Log.output without having a reference to current log item)

Author: stestagg

setup.py

@@ -6,7 +6,7 @@
 if __name__ == "__main__":
     setup(
         name="fin",
-        version="2.1.1",
+        version="2.1.2",
         license="BSD",
 
         description="A small, useful python utility library",

src/fin/__init__.py

@@ -2,4 +2,4 @@
 A utility library
 """
 
-VERSION = "2.1.1"
+VERSION = "2.1.2"

src/fin/contextlog.py

@@ -2,13 +2,16 @@
 # -*- coding: utf-8 -*-
 
 import collections
+import functools
 import pprint
 import sys
-import functools
 import textwrap
+import types
 
 import fin.terminal
 import fin.color
+import fin.duplex
+
 
 THEMES = {
     "default": {
@@ -51,6 +54,13 @@ def __init__(self, msg):
         self.exit_msg = msg
 
 
+def find_open_log(cls):
+    for stack in cls.LOGS.viewvalues():
+        if len(stack) > 0:
+            return stack[-1]
+    raise ValueError("Cannot find a suitable context log to output to")
+
+
 class Log(object):
 
     """A logging context manager"""
@@ -128,7 +138,15 @@ def __exit__(self, exc_type, exc_value, tb):
         self.on_exit(exc_type is not None, msg)
         return rv
 
+    @fin.duplex.method(inst_lookup_fun=find_open_log)
     def output(self, msg):
+        if isinstance(self, types.TypeType) and issubclass(self, Log):
+            for stack in self.LOGS.viewvalues():
+                if len(stack) > 0:
+                    self = stack[-1]
+                    break
+            else:
+                raise ValueError("Cannot find a suitable context log to output to")
         if not self.open:
             raise ValueError("Cannot log output from outside log context.")
         self.child_added(None)
@@ -143,6 +161,7 @@ def output(self, msg):
             self.stream.write(full)
         self.stream.flush()
 
+    @fin.duplex.method(inst_lookup_fun=find_open_log)
     def format(self, msg, **kwargs):
         if not self.open:
             raise ValueError("Cannot log output from outside log context.")

src/fin/contextlog_test.py

@@ -106,6 +106,26 @@ def test_log_output_format(self):
             l.format({1: "2"})
         self.assertEqual(self.lines, ["Foo: ", "| + {1: '2'}", "`- OK"])
 
+    def test_anonymous_output(self):
+        with fin.contextlog.Log("Foo", stream=self):
+            fin.contextlog.Log.output("Test")
+        self.assertEqual(self.lines, ['Foo: ', '| + Test', '`- OK'])
+
+    def test_anonymous_nested_output(self):
+        with fin.contextlog.Log("Foo", stream=self):
+            with fin.contextlog.Log("Bar", stream=self):
+                fin.contextlog.Log.output("Test")
+        self.assertEqual(self.lines, ['Foo: ', '| Bar: ', '| | + Test', '| `- OK', '`- OK'])
+
+    def test_anonymous_output_noleak(self):
+        with fin.contextlog.Log("Foo", stream=self):
+            with fin.contextlog.Log("Bar", stream=self):
+                fin.contextlog.Log.output("ONE")
+            fin.contextlog.Log.output("TWO")
+        self.assertEqual(self.lines, ['Foo: ', '| Bar: ', '| | + ONE', '| `- OK', '| + TWO', '`- OK'])
+
+
+
 
 if __name__ == "__main__":
     unittest.main()

src/fin/duplex.py

@@ -0,0 +1,52 @@
+import functools
+
+
+_property = property
+
+
+class DuplexMethod(object):
+
+	def __init__(self, func, class_method=None, inst_lookup_fun=None):
+		self.func = func
+		self.class_method = class_method
+		self.inst_lookup_fun = inst_lookup_fun
+
+	def __get__(self, obj, cls=None):
+		if obj is None:
+			if self.class_method is not None:
+				return self.class_method.__get__(cls, cls)
+			elif self.inst_lookup_fun is not None:
+				obj = self.inst_lookup_fun(cls)
+			else:
+				obj = cls
+		return self.func.__get__(obj, cls)
+
+	def classmethod(self, func):
+		self.class_method = func
+		return self
+
+
+def method(*args, **kwargs):
+	"""
+	Create a duplex method.  Duplex methods can be called as an instance OR a classmethod using the same
+	function name.  Usage is similar to @classmethod, but the first (self) argument to the function, when called,
+	will be bound to either an instance OR a class object depending on how it is called.
+
+	Example:
+
+	class A(object):
+		@fin.dumplex.method
+		def me(obj):
+			return obj
+
+	>>>  A.me() == <class 'A'>
+	>>>  A().me() == <A object at 0x1006cf350>
+
+	"""
+
+	if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+		func, = args
+		return DuplexMethod(func)
+	def wrapper(func):
+		return DuplexMethod(func, *args, **kwargs)
+	return wrapper

src/fin/duplex_test.py

@@ -0,0 +1,87 @@
+
+from __future__ import with_statement
+
+import os
+import shutil
+import tempfile
+
+import fin.testing
+import fin.duplex
+
+
+class DuplexTest(fin.testing.TestCase):
+
+    def test_duplex_definition(self):
+        class A(object):
+            def abc(self):
+                return self
+
+            @fin.duplex.method
+            def xyz(self):
+                return self
+
+        a = A()
+        self.assertIs(A.xyz(), A)
+        self.assertIs(a.xyz(), a)
+
+    def test_duplex_definition_call(self):
+        class A(object):
+            def abc(self):
+                return self
+
+            @fin.duplex.method()
+            def xyz(self):
+                return self
+
+        a = A()
+        self.assertIs(A.xyz(), A)
+        self.assertIs(a.xyz(), a)
+
+    def test_custom_lookup_func(self):
+        def find_a(cls):
+            return cls.INST
+
+        class A(object):
+            INST = None
+            @fin.duplex.method(inst_lookup_fun=find_a)
+            def me(self):
+                return self
+
+        a = A()
+        A.INST = a
+        self.assertIs(A.me(), a)
+        self.assertIs(a.me(), a)
+
+        class B(A):
+            pass
+        b = B()
+        self.assertIs(B.me(), a)
+        self.assertIs(b.me(), b)
+
+        B.INST = b
+        self.assertIs(A.me(), a)
+        self.assertIs(a.me(), a)
+        self.assertIs(B.me(), b)
+        self.assertIs(b.me(), b)
+        A.INST = None
+        B.INST = None
+
+    def test_different_classmethod(self):
+        INST = object()
+        CLS = object()
+        class A(object):
+            @fin.duplex.method
+            def thefunc(self):
+                return INST, self
+
+            @thefunc.classmethod
+            def thefunc(cls):
+                return CLS, cls
+
+        a = A()
+        self.assertEqual(A.thefunc(), (CLS, A))
+        self.assertEqual(a.thefunc(), (INST, a))
+
+
+if __name__ == "__main__":
+    fin.testing.main()