def testTypes(self): """Test that types are correctly derived and enforced.""" with self.assertRaises(TypeError): repeated.repeated(1, "foo") with self.assertRaises(TypeError): repeated.meld(1, "foo")
def testTypes(self): """Test that types are correctly derived and enforced.""" with self.assertRaises(TypeError): repeated.repeated(1, "foo") with self.assertRaises(TypeError): repeated.meld(1, "foo")
def testMaterialize(self): self.__generator_has_run = False def _gen(): if self.__generator_has_run: raise ValueError("This should only run once.") self.__generator_has_run = True yield 1 yield 2 yield 3 lazyseq = repeated.lazy(_gen) self.assertValuesEqual(lazyseq, repeated.repeated(1, 2, 3)) # Accessing this for a second time should blow up. with self.assertRaises(ValueError): core.Materialize()(lazyseq) # So let's reset and do this with a materialized seq. self.__generator_has_run = False materialized = core.Materialize()(lazyseq) self.assertEqual(materialized, repeated.repeated(1, 2, 3)) # And a second time. self.assertEqual(materialized, repeated.repeated(1, 2, 3))
def testMaterialize(self): self.__generator_has_run = False def _gen(): if self.__generator_has_run: raise ValueError("This should only run once.") self.__generator_has_run = True yield 1 yield 2 yield 3 lazyseq = repeated.lazy(_gen) self.assertValuesEqual(lazyseq, repeated.repeated(1, 2, 3)) # Accessing this for a second time should blow up. with self.assertRaises(ValueError): core.Materialize()(lazyseq) # So let's reset and do this with a materialized seq. self.__generator_has_run = False materialized = core.Materialize()(lazyseq) self.assertEqual(materialized, repeated.repeated(1, 2, 3)) # And a second time. self.assertEqual(materialized, repeated.repeated(1, 2, 3))
def testApplication(self): """Test function application across values.""" self.assertEqual( repeated.repeated(2, 4), repeated.value_apply(repeated.repeated(1, 2), lambda x: x * 2)) # As everything working on values, this should also work on scalars. applied = repeated.value_apply(5, lambda x: x * 2) self.assertValueEq(10, applied)
def testApplication(self): """Test function application across values.""" self.assertEqual( repeated.repeated(2, 4), repeated.value_apply( repeated.repeated(1, 2), lambda x: x * 2)) # As everything working on values, this should also work on scalars. applied = repeated.value_apply(5, lambda x: x * 2) self.assertValueEq(10, applied)
def testSuperpositions(self): """Superpositions can be manipulated using IRepeated.""" s = superposition.superposition("foo", "bar") r = repeated.repeated("foo", "bar") # Comparison should work in both directions. self.assertValueEq(r, s) self.assertValueEq(s, r) # Application should preserve container type. s = superposition.superposition(1, 2) applied = repeated.value_apply(s, lambda x: x * 2) self.assertValueEq(applied, repeated.repeated(2, 4)) self.assertIsInstance(applied, superposition.ISuperposition)
def _generate_rows(self, args, kwargs): # instantiate the plugin with arguments. self.plugin_obj = self.plugin_cls(session=self.session, *args, **kwargs) output_header = getattr(self.plugin_cls, "table_header", None) collector = getattr(self.plugin_obj, "collect_as_dicts", None) if callable(collector) and output_header is not None: # The plugin supports the collect API and declares its output ahead # of time. This is the ideal case. self.columns = output_header return repeated.lazy( lambda: self._order_columns(output_header, collector)) else: # TODO: Should we not support these kind of plugins? # We don't know enough about the plugin to do the easy thing. We # need to create a shim renderer that will cache the plugin output # and then use that. renderer = identity_renderer.IdentityRenderer(session=self.session) with renderer.start(): self.session.RunPlugin(self.plugin_cls.name, format=renderer, *args, **kwargs) # The identity renderer will now contain the plugin output and # columns. self.columns = renderer.columns return repeated.repeated(*list(renderer.rows))
def apply(self, args, kwargs): """Instantiate the plugin with given args and run it. This caches the output of the plugin. Subsequently, table_header, rows and columns will be populated. The CommmandWrapper must not be applied twice with different arguments - each instance represents a unique application. Arguments: args, kwargs: Arguments to the plugin. """ if self._applied_args is not None: # Called before. Return what we cached. if self._applied_args != (args, kwargs): raise ValueError( "%r was previously called with %r but is now being called" " with %r. This should never happen." % (self, self._applied_args, (args, kwargs))) return self.rows kwargs = kwargs.copy() kwargs.pop("vars", None) self._applied_args = (args, kwargs) # First time - instantiate the plugin with arguments. plugin_curry = getattr(self.session.plugins, self.plugin_cls.name) self.plugin_obj = plugin_curry(session=self.session, *args, **kwargs) output_header = getattr(self.plugin_cls, "table_header", None) collector = getattr(self.plugin_obj, "collect_as_dicts", None) if callable(collector) and output_header is not None: # The plugin supports the collect API and declares its output ahead # of time. This is the ideal case. self.columns = output_header self.rows = repeated.lazy(collector) else: # We don't know enough about the plugin to do the easy thing. We # need to create a shim renderer that will cache the plugin output # and then use that. renderer = identity_renderer.IdentityRenderer(session=self.session) with renderer.start(): self.session.RunPlugin(self.plugin_cls.name, format=renderer, *args, **kwargs) # The identity renderer will now contain the plugin output and # columns. self.columns = renderer.columns self.rows = repeated.repeated(*list(renderer.rows)) return self.rows
def apply(self, args, kwargs): """Instantiate the plugin with given args and run it. This caches the output of the plugin. Subsequently, table_header, rows and columns will be populated. The CommmandWrapper must not be applied twice with different arguments - each instance represents a unique application. Arguments: args, kwargs: Arguments to the plugin. """ if self._applied_args is not None: # Called before. Return what we cached. if self._applied_args != (args, kwargs): raise ValueError( "%r was previously called with %r but is now being called" " with %r. This should never happen." % (self, self._applied_args, (args, kwargs))) return self.rows kwargs = kwargs.copy() kwargs.pop("vars", None) self._applied_args = (args, kwargs) # First time - instantiate the plugin with arguments. plugin_curry = getattr(self.session.plugins, self.plugin_cls.name) self.plugin_obj = plugin_curry(session=self.session, *args, **kwargs) output_header = getattr(self.plugin_cls, "table_header", None) collector = getattr(self.plugin_obj, "collect_as_dicts", None) if callable(collector) and output_header is not None: # The plugin supports the collect API and declares its output ahead # of time. This is the ideal case. self.columns = output_header self.rows = repeated.lazy(collector) else: # We don't know enough about the plugin to do the easy thing. We # need to create a shim renderer that will cache the plugin output # and then use that. renderer = identity_renderer.IdentityRenderer(session=self.session) with renderer.start(): self.session.RunPlugin(self.plugin_cls.name, format=renderer, *args, **kwargs) # The identity renderer will now contain the plugin output and # columns. self.columns = renderer.columns self.rows = repeated.repeated(*list(renderer.rows)) return self.rows
def testCreation(self): """Test that creation is reasonable.""" # This should make a repeated var of two values. r = repeated.repeated("foo", "bar") # It should be a repeated var. self.assertIsInstance(r, repeated.IRepeated) # And also have more than one value. self.assertTrue(repeated.isrepeating(r)) # Repeating a single value will still create a repeated var. r = repeated.repeated("foo") self.assertIsInstance(r, repeated.IRepeated) # But it won't be repeating (have more than one value). self.assertFalse(repeated.isrepeating(r)) # Using meld will just return a scalar on one value. r = repeated.meld("foo") self.assertIsInstance(r, six.string_types) # Meld on two values has the same behavior as repeated. r = repeated.meld("foo", "foo") self.assertIsInstance(r, repeated.IRepeated)
def testCreation(self): """Test that creation is reasonable.""" # This should make a repeated var of two values. r = repeated.repeated("foo", "bar") # It should be a repeated var. self.assertIsInstance(r, repeated.IRepeated) # And also have more than one value. self.assertTrue(repeated.isrepeating(r)) # Repeating a single value will still create a repeated var. r = repeated.repeated("foo") self.assertIsInstance(r, repeated.IRepeated) # But it won't be repeating (have more than one value). self.assertFalse(repeated.isrepeating(r)) # Using meld will just return a scalar on one value. r = repeated.meld("foo") self.assertIsInstance(r, six.string_types) # Meld on two values has the same behavior as repeated. r = repeated.meld("foo", "foo") self.assertIsInstance(r, repeated.IRepeated)
def testNesting(self): """Test that repeated vars remain flat.""" r = repeated.repeated("foo", "bar") r = repeated.repeated(r, "baz") self.assertValueEq(repeated.repeated("foo", "bar", "baz"), r) r = repeated.repeated("zoo", r) self.assertValueEq(repeated.repeated("zoo", "foo", "bar", "baz"), r) # value_eq should ignore order. self.assertValueEq(repeated.repeated("bar", "foo", "baz", "zoo"), r) # Order should be preserved for getvalues, though. self.assertEqual(repeated.getvalues(r), ["zoo", "foo", "bar", "baz"]) self.assertEqual(repeated.value_type(r), type("foo"))
def testNesting(self): """Test that repeated vars remain flat.""" r = repeated.repeated("foo", "bar") r = repeated.repeated(r, "baz") self.assertValueEq(repeated.repeated("foo", "bar", "baz"), r) r = repeated.repeated("zoo", r) self.assertValueEq(repeated.repeated("zoo", "foo", "bar", "baz"), r) # value_eq should ignore order. self.assertValueEq(repeated.repeated("bar", "foo", "baz", "zoo"), r) # Order should be preserved for getvalues, though. self.assertEqual(repeated.getvalues(r), ["zoo", "foo", "bar", "baz"]) self.assertEqual(repeated.value_type(r), type("foo"))
def __call__(self, rv): return repeated.repeated(*list(rv))
def value_apply(self, f): return repeated.repeated(*[f(x) for x in self.getvalues()])
def __call__(self, rv): return repeated.repeated(*list(rv))