langfun 0.1.2.dev202509020804__py3-none-any.whl → 0.1.2.dev202511110805__py3-none-any.whl

langfun/core/structured/querying_test.py

@@ -249,35 +249,60 @@ class QueryTest(unittest.TestCase):
 
   def test_root_modality_to_structure_render(self):
     lm = fake.StaticResponse('1')
+    image = modalities.Image.from_bytes(b'mock_image')
     self.assert_render(
-        modalities.Image.from_bytes(b'mock_image'),
+        image,
         int,
         lm=lm,
-        expected_snippet='\n\nREQUEST:\n  <<[[input]]>>\n\n',
+        expected_snippet=f'\n\nREQUEST:\n  <<[[{image.id}]]>>\n\n',
         expected_modalities=1,
     )
 
   def test_root_modality_to_str_render(self):
     lm = fake.StaticResponse('1')
+    modality = modalities.Image.from_bytes(b'mock_image')
     self.assert_render(
-        modalities.Image.from_bytes(b'mock_image'),
+        modality,
         None,
         lm=lm,
-        expected_snippet='<<[[input]]>>',
+        expected_snippet=f'<<[[{modality.id}]]>>',
         exact_match=True,
         expected_modalities=1,
     )
 
   def test_str_with_modality_to_str_render(self):
     lm = fake.StaticResponse('A cat and a mouse.')
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    mouse_image = modalities.Image.from_bytes(b'mouse_image')
     self.assert_render(
         'What are these? {{this_image}} and {{that_image}}',
         None,
-        this_image=modalities.Image.from_bytes(b'cat_image'),
-        that_image=modalities.Image.from_bytes(b'mouse_image'),
+        this_image=cat_image,
+        that_image=mouse_image,
         lm=lm,
         expected_snippet=(
-            'What are these? <<[[this_image]]>> and <<[[that_image]]>>'
+            f'What are these? <<[[{cat_image.id}]]>> and '
+            f'<<[[{mouse_image.id}]]>>'
+        ),
+        exact_match=True,
+        expected_modalities=2,
+    )
+
+  def test_message_with_modality_to_str_render(self):
+    lm = fake.StaticResponse('A cat and a mouse.')
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    mouse_image = modalities.Image.from_bytes(b'mouse_image')
+    self.assert_render(
+        lf.Template(
+            'What are these? {{this_image}} and {{that_image}}',
+            this_image=cat_image,
+            that_image=mouse_image,
+        ).render(),
+        None,
+        lm=lm,
+        expected_snippet=(
+            f'What are these? <<[[{cat_image.id}]]>> and '
+            f'<<[[{mouse_image.id}]]>>'
         ),
         exact_match=True,
         expected_modalities=2,
@@ -285,33 +310,33 @@ class QueryTest(unittest.TestCase):
 
   def test_structure_with_modality_to_str_render(self):
     lm = fake.StaticResponse('A cat and a mouse.')
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    mouse_image = modalities.Image.from_bytes(b'mouse_image')
     self.assert_render(
-        [
-            modalities.Image.from_bytes(b'cat_image'),
-            modalities.Image.from_bytes(b'mouse_image'),
-        ],
+        [cat_image, mouse_image],
         None,
         lm=lm,
-        expected_snippet='`[<<[[input[0]]]>>, <<[[input[1]]]>>]`',
+        expected_snippet=(
+            f'`[<<[[{cat_image.id}]]>>, <<[[{mouse_image.id}]]>>]`'
+        ),
         exact_match=True,
         expected_modalities=2,
     )
 
   def test_structure_with_modality_to_structure_render(self):
     lm = fake.StaticResponse('["cat", "mouse"]')
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    mouse_image = modalities.Image.from_bytes(b'mouse_image')
     self.assert_render(
-        [
-            modalities.Image.from_bytes(b'cat_image'),
-            modalities.Image.from_bytes(b'mouse_image'),
-        ],
+        [cat_image, mouse_image],
         list[str],
         lm=lm,
-        expected_snippet=inspect.cleandoc("""
+        expected_snippet=inspect.cleandoc(f"""
             REQUEST:
               ```python
               [
-                <<[[input[0]]]>>,
-                <<[[input[1]]]>>
+                <<[[{cat_image.id}]]>>,
+                <<[[{mouse_image.id}]]>>
               ]
               ```
             """),
@@ -320,25 +345,25 @@ class QueryTest(unittest.TestCase):
 
   def test_structure_with_modality_and_examples_to_structure_render(self):
     lm = fake.StaticResponse('["cat", "mouse"]')
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    mouse_image = modalities.Image.from_bytes(b'mouse_image')
+    dog_image = modalities.Image.from_bytes(b'dog_image')
     self.assert_render(
-        [
-            modalities.Image.from_bytes(b'cat_image'),
-            modalities.Image.from_bytes(b'mouse_image'),
-        ],
+        [cat_image, mouse_image],
         list[str],
         examples=[
             mapping.MappingExample(
-                input=[modalities.Image.from_bytes(b'dog_image')],
+                input=[dog_image],
                 schema=list[str],
                 output=['dog'],
             ),
         ],
         lm=lm,
-        expected_snippet=inspect.cleandoc("""
+        expected_snippet=inspect.cleandoc(f"""
             REQUEST:
               ```python
               [
-                <<[[examples[0].input[0]]]>>
+                <<[[{dog_image.id}]]>>
               ]
               ```
 
@@ -356,8 +381,8 @@ class QueryTest(unittest.TestCase):
             REQUEST:
               ```python
               [
-                <<[[input[0]]]>>,
-                <<[[input[1]]]>>
+                <<[[{cat_image.id}]]>>,
+                <<[[{mouse_image.id}]]>>
               ]
               ```
 
@@ -369,6 +394,17 @@ class QueryTest(unittest.TestCase):
         expected_modalities=3,
     )
 
+  def test_query_with_modality_output(self):
+    cat_image = modalities.Image.from_bytes(b'cat_image')
+    lm = fake.StaticResponse(
+        lf.Template('Here you go: {{image}}', image=cat_image).render(
+            message_cls=lf.AIMessage
+        )
+    )
+    response = querying.query('Generate a cat image', lm=lm)
+    self.assertIsInstance(response, lf.AIMessage)
+    self.assertEqual(response.modalities(), [cat_image])
+
   def test_multiple_queries(self):
     self.assertEqual(
         querying.query(
@@ -545,7 +581,7 @@ class QueryTest(unittest.TestCase):
             )
         ).input,
     )
-    self.assertIsNotNone(output.get_modality('image'))
+    self.assertEqual(len(output.referred_modalities), 1)
 
   def test_query_and_reduce(self):
     self.assertEqual(
@@ -991,15 +1027,11 @@ class LfQueryPythonV2Test(unittest.TestCase):
     )
 
   def test_bad_response(self):
-    with lf.context(
-        lm=fake.StaticSequence(['a2']),
-        override_attrs=True,
+    with self.assertRaisesRegex(
+        mapping.MappingError,
+        'name .* is not defined',
     ):
-      with self.assertRaisesRegex(
-          mapping.MappingError,
-          'name .* is not defined',
-      ):
-        querying.query('Compute 1 + 2', int)
+      querying.query('Compute 1 + 2', int, lm=fake.StaticSequence(['a2']))
 
   def test_not_allowed_code(self):
     lm = fake.StaticResponse(
@@ -1026,21 +1058,20 @@ class LfQueryPythonV2Test(unittest.TestCase):
     self.assertEqual(querying.query('what is 1 + 0', int, lm=lm, autofix=3), 1)
 
   def test_response_postprocess(self):
-    with lf.context(
-        lm=fake.StaticResponse('<!-- some comment-->\n3'),
-        override_attrs=True,
-    ):
-      self.assertEqual(
-          querying.query(
-              'Compute 1 + 2', response_postprocess=lambda x: x.split('\n')[1]),
-          '3'
-      )
-      self.assertEqual(
-          querying.query(
-              'Compute 1 + 2', int,
-              response_postprocess=lambda x: x.split('\n')[1]),
-          3
-      )
+    self.assertEqual(
+        querying.query(
+            'Compute 1 + 2',
+            lm=fake.StaticResponse('<!-- some comment-->\n3'),
+            response_postprocess=lambda x: x.split('\n')[1]),
+        '3'
+    )
+    self.assertEqual(
+        querying.query(
+            'Compute 1 + 2', int,
+            lm=fake.StaticResponse('<!-- some comment-->\n3'),
+            response_postprocess=lambda x: x.split('\n')[1]),
+        3
+    )
 
   def test_render(self):
     l = querying.LfQuery.from_protocol('python:2.0')(
@@ -1312,15 +1343,15 @@ class LfQueryJsonV1Test(unittest.TestCase):
 
   def test_bad_transform(self):
     with in_memory.lm_cache() as cache:
-      with lf.context(
-          lm=fake.StaticSequence(['3']),
-          override_attrs=True,
+      with self.assertRaisesRegex(
+          mapping.MappingError,
+          'No JSON dict in the output',
       ):
-        with self.assertRaisesRegex(
-            mapping.MappingError,
-            'No JSON dict in the output',
-        ):
-          querying.query('Compute 1 + 2', int, protocol='json', cache_seed=1)
+        querying.query(
+            'Compute 1 + 2', int, 
+            lm=fake.StaticSequence(['3']),
+            protocol='json', cache_seed=1
+        )
       # Make sure bad mapping does not impact cache.
       self.assertEqual(len(cache), 0)
 
@@ -1595,7 +1626,7 @@ class TrackQueriesTest(unittest.TestCase):
         'bar',
     ])
     state = {}
-    def start_callabck(query):
+    def start_callback(query):
       self.assertFalse(query.is_completed)
       self.assertIsNone(query.end_time)
       elapse1 = query.elapse
@@ -1620,7 +1651,7 @@ class TrackQueriesTest(unittest.TestCase):
       state['end'] = query
 
     with querying.track_queries(
-        start_callabck=start_callabck, end_callabck=end_callback
+        start_callback=start_callback, end_callback=end_callback
     ) as queries:
       querying.query('foo', lm=lm)
     self.assertIs(state['start'], queries[0])
@@ -1631,7 +1662,7 @@ class TrackQueriesTest(unittest.TestCase):
         'bar',
     ])
     state = {}
-    def start_callabck(query):
+    def start_callback(query):
       self.assertFalse(query.is_completed)
       self.assertIsNone(query.end_time)
       self.assertIsNotNone(query.usage_summary)
@@ -1653,7 +1684,7 @@ class TrackQueriesTest(unittest.TestCase):
 
     with self.assertRaises(mapping.MappingError):
       with querying.track_queries(
-          start_callabck=start_callabck, end_callabck=end_callback
+          start_callback=start_callback, end_callback=end_callback
       ) as queries:
         querying.query('foo', int, lm=lm)
     self.assertIs(state['start'], queries[0])

langfun/core/structured/schema.py

@@ -33,12 +33,12 @@ def include_method_in_prompt(method):
 
 
 def should_include_method_in_prompt(method):
-  """Returns true if the method should be shown in the prompt."""
+  """Returns True if the method should be shown in the prompt."""
   return getattr(method, '__show_in_prompt__', False)
 
 
 def parse_value_spec(value) -> pg.typing.ValueSpec:
-  """Parses a PyGlove ValueSpec equivalence into a ValueSpec."""
+  """Parses a PyGlove ValueSpec equivalent into a ValueSpec."""
   if isinstance(value, pg.typing.ValueSpec):
     return value
 
@@ -121,7 +121,67 @@ class Schema(
     pg.Object,
     pg.views.HtmlTreeView.Extension
 ):
-  """Base class for structured data schema."""
+  """Schema for structured inputs and outputs.
+
+  `lf.Schema` provides a unified representation for defining the output schema
+  used in Langfun's structured operations like `lf.query`, `lf.parse`,
+  `lf.complete`, and `lf.describe`. It acts as an abstraction layer,
+  allowing schemas to be defined using Python type annotations, `pg.Object`
+  classes, or dictionaries, and then converting them into a format that
+  language models can understand.
+
+  `lf.Schema` can be created from various types using `lf.Schema.from_value`:
+  *   Built-in types: `int`, `str`, `bool`, `float`
+  *   Typing constructs: `list`, `dict`, `typing.Union`, `typing.Literal`,
+      `typing.Optional`
+  *   PyGlove classes: `pg.Object` subclasses
+
+  **1. Creating a Schema:**
+
+  ```python
+  import langfun as lf
+  import pyglove as pg
+  from typing import Literal, Union
+
+  # From a basic type
+  int_schema = lf.Schema.from_value(int)
+
+  # From a list type
+  list_schema = lf.Schema.from_value(list[int])
+
+  # From a dictionary
+  dict_schema = lf.Schema.from_value(dict(a=int, b=str))
+
+  # From pg.Object
+  class Point(pg.Object):
+    x: int
+    y: int
+  point_schema = lf.Schema.from_value(Point)
+
+  # From Union or Literal
+  union_schema = lf.Schema.from_value(Union[int, str])
+  literal_schema = lf.Schema.from_value(Literal['A', 'B'])
+  ```
+
+  **2. Schema Representation:**
+  Once created, a schema object can represent itself in different formats,
+  such as Python-like syntax or JSON, which is used in prompts to LLMs.
+
+  ```python
+  print(point_schema.repr('python'))
+  # Output:
+  # class Point:
+  #   x: int
+  #   y: int
+
+  print(dict_schema.repr('json'))
+  # Output:
+  # {
+  #   "a": "int",
+  #   "b": "str"
+  # }
+  ```
+  """
 
   spec: pg.typing.Annotated[
       pg.typing.Object(pg.typing.ValueSpec, transform=parse_value_spec),
@@ -144,7 +204,7 @@ class Schema(
   def parse(
       self, text: str, protocol: SchemaProtocol = 'json', **kwargs
   ) -> Any:
-    """Parse a LM generated text into a structured value."""
+    """Parses a LM generated text into a structured value."""
     value = value_repr(protocol).parse(text, self, **kwargs)
 
     # TODO(daiyip): support autofix for schema error.
@@ -157,7 +217,7 @@ class Schema(
     return self.schema_str()
 
   def schema_dict(self) -> dict[str, Any]:
-    """Returns the dict representation of the schema."""
+    """Returns the dictionary representation of the schema."""
 
     def _node(vs: pg.typing.ValueSpec) -> Any:
       if isinstance(vs, pg.typing.PrimitiveType):
@@ -406,7 +466,7 @@ def class_definitions(
     strict: bool = False,
     markdown: bool = False,
 ) -> str | None:
-  """Returns a str for class definitions."""
+  """Returns a string for class definitions."""
   if not classes:
     return None
   def_str = io.StringIO()
@@ -683,7 +743,7 @@ class ValueRepr(metaclass=abc.ABCMeta):
 
   @abc.abstractmethod
   def parse(self, text: str, schema: Schema | None = None, **kwargs) -> Any:
-    """Parse a LM generated text into a structured value."""
+    """Parses a LM generated text into a structured value."""
 
 
 class ValuePythonRepr(ValueRepr):
@@ -739,7 +799,7 @@ class ValuePythonRepr(ValueRepr):
       autofix_lm: lf.LanguageModel = lf.contextual(),
       **kwargs,
   ) -> Any:
-    """Parse a Python string into a structured object."""
+    """Parses a Python string into a structured object."""
     del kwargs
     global_vars = additional_context or {}
     if schema is not None:
@@ -820,7 +880,7 @@ class ValueJsonRepr(ValueRepr):
     return pg.to_json_str(dict(result=value))
 
   def parse(self, text: str, schema: Schema | None = None, **kwargs) -> Any:
-    """Parse a JSON string into a structured object."""
+    """Parses a JSON string into a structured object."""
     del schema
     try:
       text = cleanup_json(text)
@@ -837,7 +897,7 @@ class ValueJsonRepr(ValueRepr):
 
 
 def cleanup_json(json_str: str) -> str:
-  """Clean up the LM responded JSON string."""
+  """Cleans up the LM responded JSON string."""
   # Treatments:
   # 1. Extract the JSON string with a top-level dict from the response.
   #    This prevents the leading and trailing texts in the response to

langfun/core/structured/schema_generation.py

@@ -90,16 +90,35 @@ def generate_class(
     skip_lm: bool = False,
     **kwargs,
 ) -> Type[Any] | lf.Message:
-  """Generate a class with specified name based on the prompt.
-
-  Example:
-    ```
-    trip_cls = lf.classgen(
-        'Trip',
-        'A trip plan to visit {{ city }}, city='San Francisco',
-        lm=lf.llms.GeminiPro()
-    )
-    ```
+  """Generates a Python class dynamically from a prompt using an LLM.
+
+  `lf.structured.generate_class` takes a class name and a natural language
+  description (prompt) and uses a language model to generate a Python class
+  (inheriting from `pg.Object`) that matches the description.
+  This is useful for creating structured data types on-the-fly based on
+  dynamic requirements.
+
+  **Example:**
+
+  ```python
+  import langfun as lf
+  import pyglove as pg
+
+  trip_plan_cls = lf.structured.generate_class(
+      'TripPlan',
+      'A trip plan to visit San Francisco, including a list of destinations,'
+      'start date, end date, and total budget.',
+      lm=lf.llms.Gemini25Flash())
+
+  # This might generate a class like:
+  # class TripPlan(pg.Object):
+  #   destinations: list[str]
+  #   start_date: str
+  #   end_date: str
+  #   total_budget: float
+
+  print(lf.Schema.from_value(trip_plan_cls).schema_str('python'))
+  ```
 
   Args:
     name: Class name to be generated.
@@ -108,17 +127,17 @@ def generate_class(
     lm: The language model to use. If not specified, the language model from
       `lf.context` context manager will be used.
     examples: An optional list of fewshot examples for helping class generation.
-      If None, a default single shot example will be used. Use
-      `lf.structured.classgen_example` to generate example.
+      If None, a default single-shot example will be used. Use
+      `lf.structured.classgen_example` to generate examples.
     returns_message: If True, returns `lf.Message` as the output, instead of
       returning the structured `message.result`.
     skip_lm: If True, returns the rendered prompt as a UserMessage object.
-      otherwise return the LLM response based on the rendered prompt.
+      otherwise returns the LLM response based on the rendered prompt.
     **kwargs: Template variables passed to `prompt` and keyword arguments passed
       to `lf.structured.GenerateClass`.
 
   Returns:
-    Generated class.
+    The generated Python class, or `lf.Message` if `returns_message` is True.
 
   Raises:
     CodeError: if generation failed.

langfun/core/structured/scoring.py

@@ -35,38 +35,50 @@ def score(
     return_scoring_results: bool = False,
     **kwargs,
 ) -> list[float] | list[lf.LMScoringResult]:
-  """Scores the outputs based on the prompt.
-
-  Examples:
-    ```
-    # Example 1: Scoring text output based on the user prompt.
-    scores = lf.score('{{x}} + {{y}} =', ['1', '2', '3'], lm=lm, x=1, y=2)
-    assert len(scores) == 3
-
-    # Example 2: Scoring int output based on the formulated OOP prompt.
-    scores = lf.score('1 + 1 =', [1, 2, 3], lm=lm)
-    assert len(scores) == 3
-
-    class Answer(pg.Object):
-      result: int
-
-    # Example 3: Scoring object output based on the formulated OOP prompt.
-    scores = lf.score('1 + 1 =', [Answer(1), Answer(2), Answer(3)], lm=lm)
-    assert len(scores) == 3
-
-    # Example 4: Scoring object field value based on the formulated OOP prompt
-    # and the generated tokens before the first `pg.oneof`.
-    scores = lf.score('1 + 1 =', [Answer(pg.oneof([1, 2, 3]))], lm=lm)
-    assert len(scores) == 3
-
-    # Example 5: Scoring multiple prompt/completion pairs.
-    scores = lf.score(
-        ['1 + 1=', '2 + 3='],
-        ['2', '4'],
-        lm=lm
-    )
-    assert len(scores) == 2
-    ```
+  """Scores completions based on a prompt using a language model.
+
+  `lf.score` computes the likelihood of each completion being generated given
+  a prompt, according to the specified language model. It can score text
+  completions or structured objects. If `schema` is provided, Langfun
+  formats the prompt and completions appropriately before scoring.
+
+  **Example 1: Score text completions**
+  ```python
+  import langfun as lf
+  scores = lf.score(
+      '1 + 1 =',
+      ['2', '3', '4'],
+      lm=lf.llms.Gemini25Flash())
+  print([f'{s:.3f}' for s in scores])
+  # Output: ['-0.001', '-2.345', '-3.456']
+  ```
+
+  **Example 2: Score structured completions**
+  ```python
+  import langfun as lf
+  import pyglove as pg
+
+  class Answer(pg.Object):
+    result: int
+
+  scores = lf.score(
+      '1 + 1 =',
+      [Answer(result=2), Answer(result=3), Answer(result=4)],
+      lm=lf.llms.Gemini25Flash())
+  print([f'{s:.3f}' for s in scores])
+  # Output: ['-0.001', '-2.345', '-3.456']
+  ```
+
+  **Example 3: Score multiple prompt/completion pairs**
+  ```python
+  import langfun as lf
+  scores = lf.score(
+      ['1 + 1 =', '2 + 2 ='],
+      ['2', '4'],
+      lm=lf.llms.Gemini25Flash())
+  print([f'{s:.3f}' for s in scores])
+  # Output: ['-0.001', '-0.002']
+  ```
 
   Args:
     prompt: The prompt(s) based on which each completion will be scored.
@@ -74,8 +86,7 @@ def score(
     schema: The schema as the output type. If None, it will be inferred from
       the completions.
     lm: The language model used for scoring.
-    examples: Fewshot exemplars used together with the prompt in getting the
-      completions.
+    examples: Few-shot examples used to construct the prompt for scoring.
     protocol: The protocol for formulating the prompt based on objects.
     return_scoring_results: If True, returns a list of `lf.LMScoringResult`,
       otherwise returns a list of floats as the scores of each completion.

langfun/core/structured/tokenization.py

@@ -23,7 +23,7 @@ import pyglove as pg
 
 
 def tokenize(
-    prompt: Union[str, pg.Symbolic] | list[str | pg.Symbolic],
+    prompt: Union[str, pg.Symbolic, list[str | pg.Symbolic]],
     schema: Union[
         schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
     ] = None,
@@ -33,20 +33,35 @@ def tokenize(
     protocol: schema_lib.SchemaProtocol = 'python',
     **kwargs,
 ) -> list[tuple[str | bytes, int]]:
-  """Tokenize the prompt for `lf.query`.
+  """Renders a prompt and tokenizes it using a language model.
+
+  `lf.tokenize` first renders a prompt based on the provided `prompt`,
+  `schema`, and `examples`, similar to `lf.query`, and then uses the
+  specified language model (`lm`) to tokenize the resulting message.
+  This is useful for understanding how a prompt is seen by the model or
+  for estimating token counts before sending requests.
+
+  **Example:**
+
+  ```python
+  import langfun as lf
+  tokens = lf.tokenize('Hello world!', lm=lf.llms.Gpt4())
+  print(tokens)
+  # Output might look like: [('Hello', 15339), (' world', 1917), ('!', 0)]
+  ```
 
   Args:
-    prompt: The prompt(s) based on which each completion will be scored.
-    schema: The schema as the output type. If None, it will be inferred from
-      the completions.
-    lm: The language model used for scoring.
-    examples: Fewshot exemplars used together with the prompt in getting the
-      completions.
+    prompt: The prompt to render and tokenize. Can be a string, `pg.Symbolic`,
+      or `lf.Template`.
+    schema: The schema for formatting the prompt, if `prompt` is structured or
+      if schema-based formatting is needed.
+    lm: The language model to use for tokenization.
+    examples: Few-shot examples to include in the rendered prompt.
     protocol: The protocol for formulating the prompt based on objects.
     **kwargs: Keyword arguments that are referred by the prompt.
 
   Returns:
-    A list of (text, token_id) tuples.
+    A list of (token_str, token_id) tuples representing the tokenized prompt.
   """
   input_message = querying.query_prompt(
       prompt,

langfun/core/subscription.py

@@ -35,7 +35,7 @@ EventType = TypeVar('EventType')
 
 
 class EventHandler(Generic[EventType], metaclass=abc.ABCMeta):
-  """Interface for event subscriber."""
+  """Interface for event handler."""
 
   @classmethod
   @functools.cache
@@ -51,7 +51,7 @@ class EventHandler(Generic[EventType], metaclass=abc.ABCMeta):
 
   @classmethod
   def accepts(cls, event: Event[Any]) -> bool:
-    """Returns True if current event handler class can accepts an event."""
+    """Returns True if current event handler class can accept an event."""
     return isinstance(event, cls.event_type())
 
   @abc.abstractmethod