ansys-fluent-core 0.31.dev1__py3-none-any.whl → 0.31.1__py3-none-any.whl

ansys/fluent/core/services/field_data.py

@@ -51,6 +51,7 @@ from ansys.fluent.core.field_data_interfaces import (
     _AllowedSurfaceNames,
     _AllowedVectorFieldNames,
     _ReturnFieldData,
+    _to_field_name_str,
 )
 from ansys.fluent.core.pyfluent_warnings import PyFluentDeprecationWarning
 from ansys.fluent.core.services.interceptors import (
@@ -60,7 +61,7 @@ from ansys.fluent.core.services.interceptors import (
     TracingInterceptor,
 )
 from ansys.fluent.core.services.streaming import StreamingService
-from ansys.fluent.core.utils.deprecate import deprecate_argument, deprecate_arguments
+from ansys.fluent.core.utils.deprecate import all_deprecators
 
 logger = logging.getLogger("pyfluent.field_data")
 
@@ -428,7 +429,7 @@ class BaseFieldData:
             )
         ]
         return self._returned_data._scalar_data(
-            kwargs.get("field_name"),
+            _to_field_name_str(kwargs.get("field_name")),
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             scalar_field_data,
@@ -452,7 +453,7 @@ class BaseFieldData:
     ) -> Dict[int | str, np.array]:
         vector_field_data = self.data[(("type", "vector-field"),)]
         return self._returned_data._vector_data(
-            kwargs.get("field_name"),
+            _to_field_name_str(kwargs.get("field_name")),
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             vector_field_data,
@@ -465,11 +466,10 @@ class BaseFieldData:
         if kwargs.get("zones") is None:
             zones = []
         del zones
-        pathlines_data = self.data[
-            (("type", "pathlines-field"), ("field", kwargs.get("field_name")))
-        ]
+        field_name = _to_field_name_str(kwargs.get("field_name"))
+        pathlines_data = self.data[(("type", "pathlines-field"), ("field", field_name))]
         return self._returned_data._pathlines_data(
-            kwargs.get("field_name"),
+            field_name,
             kwargs.get("surfaces"),
             self.get_surface_ids(kwargs.get("surfaces")),
             pathlines_data,
@@ -637,11 +637,16 @@ class Transaction(FieldTransaction):
             raise ValueError("For 'path-lines' `field_name` should be unique.")
         else:
             self._pathline_field_data.append(field_name)
+        additional_field_name = kwargs.get("additional_field_name")
+        if additional_field_name:
+            additional_field_name = self._allowed_scalar_field_names.valid_name(
+                additional_field_name
+            )
         self._fields_request.pathlinesFieldRequest.extend(
             self._fetched_data._pathlines_data(
                 field_name,
                 kwargs.get("surfaces"),
-                additionalField=kwargs.get("additional_field_name"),
+                additionalField=additional_field_name,
                 provideParticleTimeField=kwargs.get("provide_particle_time_field"),
                 dataLocation=(
                     FieldDataProtoModule.DataLocation.Nodes
@@ -660,17 +665,24 @@ class Transaction(FieldTransaction):
             )
         )
 
-    @deprecate_argument(
-        old_arg="surface_names",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
-    )
-    @deprecate_argument(
-        old_arg="surface_ids",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
+    @all_deprecators(
+        deprecate_arg_mappings=[
+            {
+                "old_arg": "surface_names",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+            {
+                "old_arg": "surface_ids",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+        ],
+        data_type_converter=_data_type_convertor,
+        deprecated_version="v0.23.dev0",
+        deprecated_reason="Old arguments 'surface_ids' and 'surface_names' are deprecated. Use 'surfaces' instead.",
+        warn_message="'add_surfaces_request' is deprecated, use 'add_requests' instead",
     )
-    @deprecate_arguments(converter=_data_type_convertor)
     def add_surfaces_request(
         self,
         data_types: List[SurfaceDataType] | List[str],
@@ -679,25 +691,29 @@ class Transaction(FieldTransaction):
     ) -> None:
         """Add request to get surface data (vertices, face connectivity, centroids, and
         normals)."""
-        warnings.warn(
-            "'add_surfaces_request' is deprecated, use 'add_requests' instead",
-            PyFluentDeprecationWarning,
-        )
         self._add_surfaces_request(
             data_types=data_types,
             surfaces=self.get_surface_ids(surfaces),
             overset_mesh=overset_mesh,
         )
 
-    @deprecate_argument(
-        old_arg="surface_names",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
-    )
-    @deprecate_argument(
-        old_arg="surface_ids",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
+    @all_deprecators(
+        deprecate_arg_mappings=[
+            {
+                "old_arg": "surface_names",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+            {
+                "old_arg": "surface_ids",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+        ],
+        data_type_converter=None,
+        deprecated_version="v0.23.dev0",
+        deprecated_reason="Old arguments 'surface_ids' and 'surface_names' are deprecated. Use 'surfaces' instead.",
+        warn_message="'add_scalar_fields_request' is deprecated, use 'add_requests' instead",
     )
     def add_scalar_fields_request(
         self,
@@ -707,10 +723,6 @@ class Transaction(FieldTransaction):
         boundary_value: bool | None = True,
     ) -> None:
         """Add request to get scalar field data on surfaces."""
-        warnings.warn(
-            "'add_scalar_fields_request' is deprecated, use 'add_requests' instead",
-            PyFluentDeprecationWarning,
-        )
         self._add_scalar_fields_request(
             field_name=field_name,
             surfaces=self.get_surface_ids(surfaces),
@@ -718,15 +730,23 @@ class Transaction(FieldTransaction):
             boundary_value=boundary_value,
         )
 
-    @deprecate_argument(
-        old_arg="surface_names",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
-    )
-    @deprecate_argument(
-        old_arg="surface_ids",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
+    @all_deprecators(
+        deprecate_arg_mappings=[
+            {
+                "old_arg": "surface_names",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+            {
+                "old_arg": "surface_ids",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+        ],
+        data_type_converter=None,
+        deprecated_version="v0.23.dev0",
+        deprecated_reason="Old arguments 'surface_ids' and 'surface_names' are deprecated. Use 'surfaces' instead.",
+        warn_message="'add_vector_fields_request' is deprecated, use 'add_requests' instead",
     )
     def add_vector_fields_request(
         self,
@@ -734,23 +754,27 @@ class Transaction(FieldTransaction):
         surfaces: List[int | str],
     ) -> None:
         """Add request to get vector field data on surfaces."""
-        warnings.warn(
-            "'add_vector_fields_request' is deprecated, use 'add_requests' instead",
-            PyFluentDeprecationWarning,
-        )
         self._add_vector_fields_request(
             field_name=field_name, surfaces=self.get_surface_ids(surfaces)
         )
 
-    @deprecate_argument(
-        old_arg="surface_names",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
-    )
-    @deprecate_argument(
-        old_arg="surface_ids",
-        new_arg="surfaces",
-        converter=lambda old_arg_val: old_arg_val or [],
+    @all_deprecators(
+        deprecate_arg_mappings=[
+            {
+                "old_arg": "surface_names",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+            {
+                "old_arg": "surface_ids",
+                "new_arg": "surfaces",
+                "converter": lambda old_arg_val: old_arg_val or [],
+            },
+        ],
+        data_type_converter=None,
+        deprecated_version="v0.23.dev0",
+        deprecated_reason="Old arguments 'surface_ids' and 'surface_names' are deprecated. Use 'surfaces' instead.",
+        warn_message="'add_pathlines_fields_request' is deprecated, use 'add_requests' instead",
     )
     def add_pathlines_fields_request(
         self,
@@ -770,10 +794,6 @@ class Transaction(FieldTransaction):
         zones: list | None = None,
     ) -> None:
         """Add request to get path-lines field on surfaces."""
-        warnings.warn(
-            "'add_pathlines_fields_request' is deprecated, use 'add_requests' instead",
-            PyFluentDeprecationWarning,
-        )
         self._add_pathlines_fields_request(
             field_name=field_name,
             surfaces=self.get_surface_ids(surfaces),
@@ -1247,6 +1267,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         self._field_info = field_info
         self.is_data_valid = is_data_valid
         self.scheme_eval = scheme_eval
+
         self.get_zones_info = lambda: get_zones_info()()
 
         self._allowed_surface_names = _AllowedSurfaceNames(field_info)
@@ -1324,9 +1345,12 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         surfaces = kwargs.get("surfaces")
         surface_ids = self.get_surface_ids(surfaces)
         fields_request = get_fields_request()
+        field_name = self._allowed_scalar_field_names.valid_name(
+            kwargs.get("field_name")
+        )
         fields_request.scalarFieldRequest.extend(
             self._fetched_data._scalar_data(
-                self._allowed_scalar_field_names.valid_name(kwargs.get("field_name")),
+                field_name,
                 self.get_surface_ids(surfaces),
                 kwargs.get("node_value"),
                 kwargs.get("boundary_value"),
@@ -1335,7 +1359,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         fields = ChunkParser().extract_fields(self._service.get_fields(fields_request))
         scalar_field_data = next(iter(fields.values()))
         return self._returned_data._scalar_data(
-            kwargs.get("field_name"), surfaces, surface_ids, scalar_field_data
+            field_name, surfaces, surface_ids, scalar_field_data
         )
 
     def _get_surface_data(
@@ -1372,12 +1396,15 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         **kwargs,
     ) -> Dict[int | str, np.array]:
         surface_ids = self.get_surface_ids(kwargs.get("surfaces"))
+        field_name = self._allowed_vector_field_names.valid_name(
+            kwargs.get("field_name")
+        )
         for surface_id in surface_ids:
             self.scheme_eval.string_eval(f"(surface? {surface_id})")
         fields_request = get_fields_request()
         fields_request.vectorFieldRequest.extend(
             self._fetched_data._vector_data(
-                self._allowed_vector_field_names.valid_name(kwargs.get("field_name")),
+                field_name,
                 surface_ids,
             )
         )
@@ -1385,7 +1412,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         vector_field_data = next(iter(fields.values()))
 
         return self._returned_data._vector_data(
-            kwargs.get("field_name"),
+            field_name,
             kwargs.get("surfaces"),
             surface_ids,
             vector_field_data,
@@ -1398,12 +1425,20 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         if kwargs.get("zones") is None:
             zones = []
         surface_ids = self.get_surface_ids(kwargs.get("surfaces"))
+        field_name = self._allowed_scalar_field_names.valid_name(
+            kwargs.get("field_name")
+        )
         fields_request = get_fields_request()
+        additional_field_name = kwargs.get("additional_field_name")
+        if additional_field_name:
+            additional_field_name = self._allowed_scalar_field_names.valid_name(
+                additional_field_name
+            )
         fields_request.pathlinesFieldRequest.extend(
             self._fetched_data._pathlines_data(
-                self._allowed_scalar_field_names.valid_name(kwargs.get("field_name")),
+                field_name,
                 surface_ids,
-                additionalField=kwargs.get("additional_field_name"),
+                additionalField=kwargs.get(additional_field_name),
                 provideParticleTimeField=kwargs.get("provide_particle_time_field"),
                 dataLocation=(
                     FieldDataProtoModule.DataLocation.Nodes
@@ -1427,7 +1462,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
         if self._deprecated_flag:
             self._deprecated_flag = False
             return self._returned_data._pathlines_data(
-                kwargs.get("field_name"),
+                field_name,
                 kwargs.get("surfaces"),
                 surface_ids,
                 pathlines_data,
@@ -1435,7 +1470,7 @@ class LiveFieldData(BaseFieldData, FieldDataSource):
             )
 
         return self._returned_data._pathlines_data(
-            kwargs.get("field_name"),
+            field_name,
             kwargs.get("surfaces"),
             surface_ids,
             pathlines_data,

ansys/fluent/core/services/reduction.py

@@ -36,6 +36,9 @@ from ansys.fluent.core.services.interceptors import (
     GrpcErrorInterceptor,
     TracingInterceptor,
 )
+from ansys.fluent.core.variable_strategies import (
+    FluentExprNamingStrategy as naming_strategy,
+)
 
 Path = List[Tuple[str, str]]
 
@@ -273,6 +276,7 @@ class Reduction:
         """__init__ method of Reduction class."""
         self.service = service
         self.ctxt = weakref.proxy(ctxt)
+        self._to_str = naming_strategy().to_string if naming_strategy else lambda s: s
 
     def _validate_str_location(self, loc: str):
         if all(
@@ -295,174 +299,159 @@ class Reduction:
         except BadReductionRequest:
             return locations
 
+    def _make_request(
+        self,
+        requestName,
+        locations,
+        ctxt=None,
+        expression=None,
+        weight=None,
+        condition=None,
+    ) -> Any:
+        request = getattr(ReductionProtoModule, requestName)()
+        if expression is not None:
+            request.expression = self._to_str(expression)
+        if weight is not None:
+            request.weight = weight
+        if condition is not None:
+            request.condition = condition
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        return request
+
     def area(self, locations, ctxt=None) -> Any:
         """Get area."""
-        request = ReductionProtoModule.AreaRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaRequest", locations, ctxt)
         response = self.service.area(request)
         return _convert_variant_to_value(response.value)
 
     def area_average(self, expression, locations, ctxt=None) -> Any:
         """Get area average."""
-        request = ReductionProtoModule.AreaAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaAveRequest", locations, ctxt, expression)
         response = self.service.area_average(request)
         return _convert_variant_to_value(response.value)
 
     def area_integral(self, expression, locations, ctxt=None) -> Any:
         """Get area integral."""
-        request = ReductionProtoModule.AreaIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaIntRequest", locations, ctxt, expression)
         response = self.service.area_integral(request)
         return _convert_variant_to_value(response.value)
 
     def centroid(self, locations, ctxt=None) -> Any:
         """Get centroid."""
-        request = ReductionProtoModule.CentroidRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("CentroidRequest", locations, ctxt)
         response = self.service.centroid(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def count(self, locations, ctxt=None) -> Any:
-        """Get count."""
-        request = ReductionProtoModule.CountRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Count the number of faces or cells within the locations."""
+        request = self._make_request("CountRequest", locations, ctxt)
         response = self.service.count(request)
         return _convert_variant_to_value(response.value)
 
     def count_if(self, condition, locations, ctxt=None) -> Any:
-        """Get count if a particular condition satisfies."""
-        request = ReductionProtoModule.CountIfRequest()
-        request.expression = condition
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Count the number of faces or cells where the specified condition is satisfied."""
+        request = self._make_request(
+            "CountIfRequest", locations, ctxt, condition=condition
+        )
         response = self.service.count_if(request)
         return _convert_variant_to_value(response.value)
 
     def force(self, locations, ctxt=None) -> Any:
         """Get force."""
-        request = ReductionProtoModule.ForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("ForceRequest", locations, ctxt)
         response = self.service.force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def mass_average(self, expression, locations, ctxt=None) -> Any:
         """Get mass average."""
-        request = ReductionProtoModule.MassAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassAveRequest", locations, ctxt, expression)
         response = self.service.mass_average(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_average(self, expression, locations, ctxt=None) -> Any:
         """Get mass flow average."""
-        request = ReductionProtoModule.MassFlowAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassFlowAveRequest", locations, ctxt, expression)
         response = self.service.mass_flow_average(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_average_absolute(self, expression, locations, ctxt=None) -> Any:
-        """Get absolute mass flow average."""
-        request = ReductionProtoModule.MassFlowAveAbsRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Compute the mass flow average of the absolute value of the given expression."""
+        request = self._make_request(
+            "MassFlowAveAbsRequest", locations, ctxt, expression
+        )
         response = self.service.mass_flow_average_absolute(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_integral(self, expression, locations, ctxt=None) -> Any:
         """Get mass flow integral."""
-        request = ReductionProtoModule.MassFlowIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassFlowIntRequest", locations, ctxt, expression)
         response = self.service.mass_flow_integral(request)
         return _convert_variant_to_value(response.value)
 
     def mass_integral(self, expression, locations, ctxt=None) -> Any:
         """Get mass integral."""
-        request = ReductionProtoModule.MassIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassIntRequest", locations, ctxt, expression)
         response = self.service.mass_integral(request)
         return _convert_variant_to_value(response.value)
 
     def maximum(self, expression, locations, ctxt=None) -> Any:
         """Get maximum."""
-        request = ReductionProtoModule.MaximumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MaximumRequest", locations, ctxt, expression)
         response = self.service.maximum(request)
         return _convert_variant_to_value(response.value)
 
     def minimum(self, expression, locations, ctxt=None) -> Any:
         """Get minimum."""
-        request = ReductionProtoModule.MinimumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MinimumRequest", locations, ctxt, expression)
         response = self.service.minimum(request)
         return _convert_variant_to_value(response.value)
 
     def pressure_force(self, locations, ctxt=None) -> Any:
         """Get pressure force."""
-        request = ReductionProtoModule.PressureForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("PressureForceRequest", locations, ctxt)
         response = self.service.pressure_force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def viscous_force(self, locations, ctxt=None) -> Any:
         """Get viscous force."""
-        request = ReductionProtoModule.ViscousForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("ViscousForceRequest", locations, ctxt)
         response = self.service.viscous_force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def volume(self, locations, ctxt=None) -> Any:
         """Get volume."""
-        request = ReductionProtoModule.VolumeRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeRequest", locations, ctxt)
         response = self.service.volume(request)
         return _convert_variant_to_value(response.value)
 
     def volume_average(self, expression, locations, ctxt=None) -> Any:
         """Get volume average."""
-        request = ReductionProtoModule.VolumeAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeRequest", locations, ctxt, expression)
         response = self.service.volume_average(request)
         return _convert_variant_to_value(response.value)
 
     def volume_integral(self, expression, locations, ctxt=None) -> Any:
         """Get volume integral."""
-        request = ReductionProtoModule.VolumeIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeIntRequest", locations, ctxt, expression)
         response = self.service.volume_integral(request)
         return _convert_variant_to_value(response.value)
 
     def moment(self, expression, locations, ctxt=None) -> Any:
         """Get moment."""
-        request = ReductionProtoModule.MomentRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MomentRequest", locations, ctxt, expression)
         response = self.service.moment(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def sum(self, expression, locations, weight, ctxt=None) -> Any:
         """Get sum."""
-        request = ReductionProtoModule.SumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
-        request.weight = weight
+        request = self._make_request("SumRequest", locations, ctxt, expression, weight)
         response = self.service.sum(request)
         return _convert_variant_to_value(response.value)
 
     def sum_if(self, expression, condition, locations, weight, ctxt=None) -> Any:
-        """Get sum if a particular condition satisfies."""
-        request = ReductionProtoModule.SumIfRequest()
-        request.expression = expression
-        request.condition = condition
-        request.locations.extend(self._get_location_string(locations, ctxt))
-        request.weight = weight
+        """Compute the weighted sum of the expression at locations where the given condition is satisfied."""
+        request = self._make_request(
+            "SumIfRequest", locations, ctxt, expression, weight, condition
+        )
         response = self.service.sum_if(request)
         return _convert_variant_to_value(response.value)

ansys/fluent/core/services/solution_variables.py

@@ -42,6 +42,11 @@ from ansys.fluent.core.services.interceptors import (
     TracingInterceptor,
 )
 from ansys.fluent.core.solver.error_message import allowed_name_error_message
+from ansys.fluent.core.variable_strategies import (
+    FluentSVarNamingStrategy as naming_strategy,
+)
+
+_to_field_name_str = naming_strategy().to_string if naming_strategy else lambda s: s
 
 
 class SolutionVariableService:
@@ -354,6 +359,7 @@ class _AllowedSvarNames:
         SvarError
             If the given solution variable name is invalid.
         """
+        solution_variable_name = _to_field_name_str(solution_variable_name)
         if not self.is_valid(
             solution_variable_name, zone_names=zone_names, domain_name=domain_name
         ):
@@ -613,7 +619,9 @@ class SolutionVariableData:
         )
         svars_request.domainId = self._allowed_domain_names.valid_name(domain_name)
         svars_request.name = self._allowed_solution_variable_names.valid_name(
-            solution_variable_name, zone_names, domain_name
+            solution_variable_name,
+            zone_names,
+            domain_name,
         )
         zone_id_name_map = {}
         for zone_name in zone_names: