Run pre-commit

Author: smokestacklightnin

setup.py

@@ -88,8 +88,8 @@ def select_constraint(default, nightly=None, git_master=None):
         "pyarrow>=10,<11",
     ],
     extras_require={
-        'lint': [
-            'pre-commit',
+        "lint": [
+            "pre-commit",
         ]
     },
     # Add in any packaged data.

struct2tensor/calculate.py

@@ -260,11 +260,7 @@ def __str__(self) -> str:
     def _create_value_error(self) -> ValueError:
         """Creates a ValueError, assuming there should be one for this node."""
         return ValueError(
-            "Expression {} returned the wrong type: expected: {} actual: {}.".format(
-                self.expression,
-                _fancy_type_str(self.expression.is_repeated, self.expression.type),
-                _node_type_str(self.value),
-            )
+            f"Expression {self.expression} returned the wrong type: expected: {_fancy_type_str(self.expression.is_repeated, self.expression.type)} actual: {_node_type_str(self.value)}."
         )
 
     def calculate(

struct2tensor/expression_impl/broadcast.py

@@ -139,17 +139,17 @@ def calculation_equal(self, expr: expression.Expression) -> bool:
 class _RecalculateExpression(expression.Expression):
     r"""Expression for recalculating a broadcasted subtree's parent indices.
 
-  This is needed because when a subtree is broadcasted, the nested fields
-  could be duplicated. Their parent indices need to be updated.
+    This is needed because when a subtree is broadcasted, the nested fields
+    could be duplicated. Their parent indices need to be updated.
 
-  For example, given the expression tree:
+    For example, given the expression tree:
                     _DirectExpression(root)
                     /                      \
       _DirectExpression(parent)     _DirectExpression(sibling)
                   /
-  _DirectExpression(submessage)
+    _DirectExpression(submessage)
 
-  If we broadcast (parent) into (sibling), then we get:
+    If we broadcast (parent) into (sibling), then we get:
                     _DirectExpression(root)
                     /                      \
       _DirectExpression(parent)     _DirectExpression(sibling)
@@ -158,19 +158,19 @@ class _RecalculateExpression(expression.Expression):
                                                \
                                       _RecalculateExpression(new_submessage)
 
-  This tree represents a field `parent` broadcasted into `sibling`. In this case
-  the `origin` of `_RecalculateExpression(new_submessage)` would be
-  `_DirectExpression(submessage)` and the `parent` of
-  `_RecalculateExpression(new_submessage)` would be
-  `_BroadcastChildExpression(new_parent)`
+    This tree represents a field `parent` broadcasted into `sibling`. In this case
+    the `origin` of `_RecalculateExpression(new_submessage)` would be
+    `_DirectExpression(submessage)` and the `parent` of
+    `_RecalculateExpression(new_submessage)` would be
+    `_BroadcastChildExpression(new_parent)`
 
-  Attributes:
+    Attributes:
     origin: The origin expression should be a _DirectExpression that represents
       the original subtree's field. It can represent a Child or Leaf NodeTensor.
     parent: The parent expression should be a _BroadcastChildExpression or
       _RecalculateExpression that represents the 'broadcasted' parent's
       ChildNodeTensor.
-  """
+    """
 
     def __init__(self, origin: expression.Expression, parent: expression.Expression):
         super().__init__(

struct2tensor/expression_impl/filter_expression_test.py

@@ -33,7 +33,7 @@
 def _create_slice_and_project_example():
     r"""Creates an example for test_slice_and_project.
 
-  Returns:
+    Returns:
                ------*-----------------
               /                        \
         ---session0----             session1
@@ -44,8 +44,8 @@ def _create_slice_and_project_example():
     |   |     |        |    |     |      |    |   |
     a   b     c        e    f     g      h    i   j
 
-  This also adds an action_mask that is false for the zeroeth action.
-  """
+    This also adds an action_mask that is false for the zeroeth action.
+    """
     return proto_test_util.text_to_expression(
         [
             """
@@ -107,17 +107,17 @@ def _create_nested_prensor():
    root0                    root1-----------------------      root2 (empty)
     /   \                   /    \               \      \
     |  keep_my_sib0:False  |  keep_my_sib1:True   | keep_my_sib2:False
-  doc0-----               doc1---------------    doc2--------
-   |       \                \           \    \               \
+    doc0-----               doc1---------------    doc2--------
+    |       \                \           \    \               \
   bar:"a"  keep_me:False    bar:"b" bar:"c" keep_me:True      bar:"d"
 
-  Returns:
+    Returns:
     a prensor expression representing:
     {doc:[{bar:["a"], keep_me:False}], keep_my_sib:False}
     {doc:[{bar:["b","c"], keeo}, {bar:["d"]}],
      keep_me:True}
     {}
-  """
+    """
     return prensor.create_prensor_from_descendant_nodes(
         {
             path.Path([]): prensor_test_util.create_root_node(3),
@@ -138,24 +138,24 @@ def _create_nested_prensor():
 def _create_nested_prensor_2():
     r"""Creates a prensor representing a list of nested protocol buffers.
 
-  keep_me no longer has a value in doc0.
+    keep_me no longer has a value in doc0.
 
        -----*----------------------------------------------------
       /                       \                                  \
    root0                    root1-----------------------      root2 (empty)
     /   \                   /    \               \      \
     |  keep_my_sib0:False  |  keep_my_sib1:True   | keep_my_sib2:False
-  doc0                    doc1---------------    doc2--------
-   |                        \           \    \               \
+    doc0                    doc1---------------    doc2--------
+    |                        \           \    \               \
   bar:"a"                   bar:"b" bar:"c" keep_me:True      bar:"d"
 
-  Returns:
+    Returns:
     a prensor expression representing:
     {doc:[{bar:["a"], keep_me:False}], keep_my_sib:False}
     {doc:[{bar:["b","c"], keeo}, {bar:["d"]}],
      keep_me:True}
     {}
-  """
+    """
     return prensor.create_prensor_from_descendant_nodes(
         {
             path.Path([]): prensor_test_util.create_root_node(3),
@@ -290,19 +290,19 @@ def test_filter_by_child_create_nested_prensor_2(self):
     def test_filter_by_sibling(self):
         r"""Tests filter_by_sibling.
 
-    Beginning with the struct:
+        Beginning with the struct:
          -----*----------------------------------------------------
         /                       \                                  \
      root0                    root1-----------------------      root2 (empty)
-      /   \                   /    \               \      \
+        /   \                   /    \               \      \
       |  keep_my_sib0:False  |  keep_my_sib1:True   | keep_my_sib2:False
-    doc0-----               doc1---------------    doc2--------
-     |       \                \           \    \               \
+        doc0-----               doc1---------------    doc2--------
+        |       \                \           \    \               \
     bar:"a"  keep_me:False    bar:"b" bar:"c" keep_me:True      bar:"d"
 
-    Filter doc with keep_my_sib:
+        Filter doc with keep_my_sib:
 
-    End with the struct (suppressing original doc):
+        End with the struct (suppressing original doc):
          -----*----------------------------------------------------
         /                       \                                  \
     root0                    root1------------------        root2 (empty)
@@ -312,7 +312,7 @@ def test_filter_by_sibling(self):
                              \           \    \
                              bar:"b" bar:"c" keep_me:True
 
-    """
+        """
         root = create_expression.create_expression_from_prensor(
             _create_nested_prensor()
         )

struct2tensor/expression_impl/map_prensor_to_prensor.py

@@ -208,50 +208,50 @@ def map_prensor_to_prensor(
 ) -> expression.Expression:
     r"""Maps an expression to a prensor, and merges that prensor.
 
-  For example, suppose you have an op my_op, that takes a prensor of the form:
+    For example, suppose you have an op my_op, that takes a prensor of the form:
 
     event
      / \
    foo   bar
 
-  and produces a prensor of the form my_result_schema:
+    and produces a prensor of the form my_result_schema:
 
      event
       / \
    foo2 bar2
 
-  If you give it an expression original with the schema:
+    If you give it an expression original with the schema:
 
-   session
+    session
       |
     event
     /  \
   foo   bar
 
-  result = map_prensor_to_prensor(
+    result = map_prensor_to_prensor(
     original,
     path.Path(["session","event"]),
     my_op,
     my_output_schema)
 
-  Result will have the schema:
+    Result will have the schema:
 
-   session
+    session
       |
     event--------
     /  \    \    \
   foo   bar foo2 bar2
 
-  Args:
+    Args:
     root_expr: the root expression
     source: the path where the prensor op is applied.
     paths_needed: the paths needed for the op.
     prensor_op: the prensor op
     output_schema: the output schema of the op.
 
-  Returns:
+    Returns:
     A new expression where the prensor is merged.
-  """
+    """
     original_child = root_expr.get_descendant_or_error(source).project(paths_needed)
     prensor_child = _PrensorOpExpression(original_child, prensor_op, output_schema)
     paths_map = {

struct2tensor/expression_impl/proto_test_util.py

@@ -36,9 +36,9 @@ def text_to_expression(text_list, example_proto_clz):
 def _get_expression_from_session_empty_user_info():
     r"""Run create_root_prensor on a very deep tree.
 
-  In addition, the user_info is empty.
+    In addition, the user_info is empty.
 
-  ```
+    ```
                ------*-----------------
               /                        \
         ---session0----             session1
@@ -49,11 +49,11 @@ def _get_expression_from_session_empty_user_info():
     |   |     |        |    |     |      |    |   |
     a   b     c        e    f     g      h    i   j
 
-  ```
+    ```
 
-  Returns:
+    Returns:
     A RootPrensor with the above structure.
-  """
+    """
     return text_to_expression(
         [
             """

struct2tensor/ops/struct2tensor_ops.py

@@ -173,9 +173,9 @@ def parse_message_level(
         for field_descriptor in field_descriptors
     ]
     if tf.is_tensor(backing_str_tensor):
-        assert message_format == "binary", (
-            "message_format must be 'binary' if a backing_str_tensor is provided"
-        )
+        assert (
+            message_format == "binary"
+        ), "message_format must be 'binary' if a backing_str_tensor is provided"
         backing_str_tensor = [backing_str_tensor]
     else:
         backing_str_tensor = []