arcaflow-plugin-sdk 0.14.0.dev1__tar.gz → 0.14.1__tar.gz

{arcaflow_plugin_sdk-0.14.0.dev1 → arcaflow_plugin_sdk-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arcaflow-plugin-sdk
-Version: 0.14.0.dev1
+Version: 0.14.1
 Summary: Plugin SDK for Python for the Arcaflow workflow engine
 Home-page: https://github.com/arcalot/arcaflow-plugin-sdk-python
 License: Apache-2.0

{arcaflow_plugin_sdk-0.14.0.dev1 → arcaflow_plugin_sdk-0.14.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "arcaflow-plugin-sdk"
 # Do not change, the version is automatically updated in CI.
-version = "v0.14.0-dev1"
+version = "0.14.1"
 description = "Plugin SDK for Python for the Arcaflow workflow engine"
 authors = ["Arcalot Contributors"]
 license = "Apache-2.0"

{arcaflow_plugin_sdk-0.14.0.dev1 → arcaflow_plugin_sdk-0.14.1}/src/arcaflow_plugin_sdk/schema.py

@@ -2578,7 +2578,114 @@ class ObjectSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
 
 
 @dataclass
-class OneOfStringSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
+class OneOfSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
+    types: typing.Union[
+        Dict[str, typing.Annotated[_OBJECT_LIKE, discriminator("type_id")]],
+        Dict[int, typing.Annotated[_OBJECT_LIKE, discriminator("type_id")]],
+    ]
+    discriminator_inlined: typing.Annotated[
+        bool,
+        _name("Discriminator field inlined"),
+        _description(
+            "Whether or not the discriminator is inlined in the underlying"
+            " objects' schema"
+        ),
+    ]
+    oneof_type: typing.Annotated[str, _name("One Of Type Schema Name")] = None
+    discriminator_type: typing.Annotated[str, _name("Discriminator Type")] = (
+        None
+    )
+    discriminator_field_name: typing.Annotated[
+        str,
+        _name("Discriminator field name"),
+        _description(
+            "Name of the field used to discriminate between possible values."
+        ),
+    ] = "_type"
+
+    def _insert_discriminator(
+        self,
+        discriminated_object: typing.Dict[str, typing.Any],
+        discriminator_val: str,
+    ) -> typing.Dict[str, typing.Any]:
+        """Add a discriminator field as a property of a member type.
+
+        This function adds a member type's discriminator field as a property
+        with a constant value equal to its discriminated value. The
+        discriminator field is moved to the zeroth index of the list of
+        required fields in a data packet.
+
+        :param discriminated_object: A Python dict which represents the
+            relevant fragment of the scope's JSON definition.
+        :param discriminator_val: The value that represents the given object in
+            its discriminated union.
+        """
+        if self.discriminator_inlined:
+            # update the object's schema to show the only valid value
+            # for this object's discriminator
+            discriminated_object["properties"][
+                self.discriminator_field_name
+            ] = {
+                "type": self.discriminator_type,
+                "const": discriminator_val,
+            }
+            # discriminator field is already present in the required
+            # list when the discriminator is inlined
+            discriminated_object["required"].remove(
+                self.discriminator_field_name
+            )
+        # discriminator must have the first position
+        discriminated_object["required"].insert(
+            0, self.discriminator_field_name
+        )
+
+    def _to_jsonschema_fragment(
+        self, scope: typing.ForwardRef("ScopeSchema"), defs: _JSONSchemaDefs
+    ) -> any:
+        one_of = []
+        for k, v in self.types.items():
+            # noinspection PyProtectedMember
+            _ = scope.objects[v.id]._to_jsonschema_fragment(scope, defs)
+            self._insert_discriminator(defs.defs[v.id], str(k))
+            if v.display is not None:
+                if v.display.name is not None:
+                    defs.defs[v.id]["title"] = v.display.name
+                if v.display.description is not None:
+                    defs.defs[v.id]["description"] = v.display.description
+            name = v.id + self.oneof_type + str(k)
+            defs.defs[name] = defs.defs[v.id]
+            one_of.append({"$ref": "#/$defs/" + name})
+        return {"oneOf": one_of}
+
+    def _to_openapi_fragment(
+        self, scope: typing.ForwardRef("ScopeSchema"), defs: _OpenAPIComponents
+    ) -> any:
+        one_of = []
+        discriminator_mapping = {}
+        for k, v in self.types.items():
+            # noinspection PyProtectedMember
+            _ = scope.objects[v.id]._to_openapi_fragment(scope, defs)
+            name = v.id + self.oneof_type + str(k)
+            discriminator_mapping[k] = "#/components/schemas/" + name
+            self._insert_discriminator(defs.defs[v.id], str(k))
+            if v.display is not None:
+                if v.display.name is not None:
+                    defs.defs[v.id]["title"] = v.display.name
+                if v.display.description is not None:
+                    defs.defs[v.id]["description"] = v.display.description
+            defs.components[name] = defs.defs[v.id]
+            one_of.append({"$ref": "#/components/schemas/" + name})
+        return {
+            "oneOf": one_of,
+            "discriminator": {
+                "propertyName": self.discriminator_field_name,
+                "mapping": discriminator_mapping,
+            },
+        }
+
+
+@dataclass
+class OneOfStringSchema(OneOfSchema):
     """This class holds the definition of variable types with a string
     discriminator. This type acts as a split for a case where multiple possible
     object types can be present in a field. This type requires that there be a
@@ -2701,112 +2808,14 @@ class OneOfStringSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
     """  # noqa: E501
 
     types: Dict[str, typing.Annotated[_OBJECT_LIKE, discriminator("type_id")]]
-    discriminator_inlined: typing.Annotated[
-        bool,
-        _name("Discriminator field inlined"),
-        _description(
-            "True if the discriminator is a field in each schema of the"
-            " underlying objects"
-        ),
-    ]
-    discriminator_field_name: typing.Annotated[
-        str,
-        _name("Discriminator field name"),
-        _description(
-            "Name of the field whose value is used to discriminate between"
-            " possible subobject types. If this field is present in any of the"
-            " subobjects it must have a type of string."
-        ),
-    ] = "_type"
 
-    def _insert_discriminator(
-        self,
-        discriminated_object: typing.Dict[str, typing.Any],
-        discriminator_val: str,
-    ) -> typing.Dict[str, typing.Any]:
-        """Add a discriminator field as a property of a member type.
-
-        This function adds a member type's discriminator field as a property
-        with a constant value equal to its discriminated value. The
-        discriminator field is moved to the zeroth index of the list of
-        required fields in a data packet.
-
-        :param discriminated_object: A Python dict which represents the
-            relevant fragment of the scope's JSON definition.
-        :param discriminator_val: The value that represents the given object in
-            its discriminated union.
-        """
-        if self.discriminator_inlined:
-            # update the object's schema to show the only valid value
-            # for this object's discriminator
-            discriminated_object["properties"][
-                self.discriminator_field_name
-            ] = {
-                "type": "string",
-                "const": discriminator_val,
-            }
-            # discriminator field is already present in the required
-            # list when the discriminator is inlined
-            discriminated_object["required"].remove(
-                self.discriminator_field_name
-            )
-        # discriminator must have the first position
-        discriminated_object["required"].insert(
-            0, self.discriminator_field_name
-        )
-
-    def _to_jsonschema_fragment(
-        self, scope: typing.ForwardRef("ScopeSchema"), defs: _JSONSchemaDefs
-    ) -> any:
-        one_of = []
-        for k, v in self.types.items():
-            # noinspection PyProtectedMember
-            scope.objects[v.id]._to_jsonschema_fragment(scope, defs)
-
-            self._insert_discriminator(defs.defs[v.id], k)
-
-            if v.display is not None:
-                if v.display.name is not None:
-                    defs.defs[v.id]["title"] = v.display.name
-                if v.display.description is not None:
-                    defs.defs[v.id]["description"] = v.display.description
-
-            name = v.id + "_discriminated_string_" + _id_typeize(k)
-            defs.defs[name] = defs.defs[v.id]
-            one_of.append({"$ref": "#/$defs/" + name})
-        return {"oneOf": one_of}
-
-    def _to_openapi_fragment(
-        self, scope: typing.ForwardRef("ScopeSchema"), defs: _OpenAPIComponents
-    ) -> any:
-        one_of = []
-        discriminator_mapping = {}
-        for k, v in self.types.items():
-            # noinspection PyProtectedMember
-            scope.objects[v.id]._to_openapi_fragment(scope, defs)
-
-            name = v.id + "_discriminated_string_" + _id_typeize(k)
-            discriminator_mapping[k] = "#/components/schemas/" + name
-            self._insert_discriminator(defs.defs[v.id], k)
-            if v.display is not None:
-                if v.display.name is not None:
-                    defs.defs[v.id]["title"] = v.display.name
-                if v.display.description is not None:
-                    defs.defs[v.id]["description"] = v.display.description
-
-            defs.components[name] = defs.defs[v.id]
-            one_of.append({"$ref": "#/components/schemas/" + name})
-        return {
-            "oneOf": one_of,
-            "discriminator": {
-                "propertyName": self.discriminator_field_name,
-                "mapping": discriminator_mapping,
-            },
-        }
+    def __post_init__(self):
+        self.oneof_type = "_discriminated_string_"
+        self.discriminator_type = "string"
 
 
 @dataclass
-class OneOfIntSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
+class OneOfIntSchema(OneOfSchema):
     """This class holds the definition of variable types with an integer
     discriminator. This type acts as a split for a case where multiple possible
     object types can be present in a field. This type requires that there be a
@@ -2912,106 +2921,10 @@ class OneOfIntSchema(_JSONSchemaGenerator, _OpenAPIGenerator):
     """  # noqa: E501
 
     types: Dict[int, typing.Annotated[_OBJECT_LIKE, discriminator("type_id")]]
-    discriminator_inlined: typing.Annotated[
-        bool,
-        _name("Discriminator field inlined"),
-        _description(
-            "Whether or not the discriminator is inlined in the underlying"
-            " objects' schema"
-        ),
-    ]
-    discriminator_field_name: typing.Annotated[
-        str,
-        _name("Discriminator field name"),
-        _description(
-            "Name of the field used to discriminate between possible values."
-            " If this field ispresent on any of the component objects it must"
-            " also be an int."
-        ),
-    ] = "_type"
-
-    def _insert_discriminator(
-        self,
-        discriminated_object: typing.Dict[str, typing.Any],
-        discriminator_val: str,
-    ) -> typing.Dict[str, typing.Any]:
-        """Add a discriminator field as a property of a member type.
-
-        This function adds a member type's discriminator field as a property
-        with a constant value equal to its discriminated value. The
-        discriminator field is moved to the zeroth index of the list of
-        required fields in a data packet.
-
-        :param discriminated_object: A Python dict which represents the
-            relevant fragment of the scope's JSON definition.
-        :param discriminator_val: The value that represents the given object in
-            its discriminated union.
-        """
-        if self.discriminator_inlined:
-            # update the object's schema to show the only valid value
-            # for this object's discriminator
-            discriminated_object["properties"][
-                self.discriminator_field_name
-            ] = {
-                "type": "string",
-                "const": discriminator_val,
-            }
-            # discriminator field is already present in the required
-            # list when the discriminator is inlined
-            discriminated_object["required"].remove(
-                self.discriminator_field_name
-            )
-        # discriminator must have the first position
-        discriminated_object["required"].insert(
-            0, self.discriminator_field_name
-        )
 
-    def _to_jsonschema_fragment(
-        self, scope: typing.ForwardRef("ScopeSchema"), defs: _JSONSchemaDefs
-    ) -> any:
-        one_of = []
-        for k, v in self.types.items():
-            # noinspection PyProtectedMember
-            scope.objects[v.id]._to_jsonschema_fragment(scope, defs)
-
-            self._insert_discriminator(defs.defs[v.id], str(k))
-            if v.display is not None:
-                if v.display.name is not None:
-                    defs.defs[v.id]["title"] = v.display.name
-                if v.display.description is not None:
-                    defs.defs[v.id]["description"] = v.display.description
-            name = v.id + "_discriminated_int_" + str(k)
-            defs.defs[name] = defs.defs[v.id]
-            one_of.append({"$ref": "#/$defs/" + name})
-        return {"oneOf": one_of}
-
-    def _to_openapi_fragment(
-        self, scope: typing.ForwardRef("ScopeSchema"), defs: _OpenAPIComponents
-    ) -> any:
-        one_of = []
-        discriminator_mapping = {}
-        for k, v in self.types.items():
-            # noinspection PyProtectedMember
-            scope.objects[v.id]._to_openapi_fragment(scope, defs)
-            name = v.id + "_discriminated_int_" + str(k)
-            discriminator_mapping[k] = "#/components/schemas/" + name
-
-            self._insert_discriminator(defs.defs[v.id], str(k))
-            if v.display is not None:
-                if v.display.name is not None:
-                    defs.defs[v.id]["title"] = v.display.name
-                if v.display.description is not None:
-                    defs.defs[v.id]["description"] = v.display.description
-
-            defs.components[name] = defs.defs[v.id]
-            one_of.append({"$ref": "#/components/schemas/" + name})
-        return {
-            "oneOf": one_of,
-            "discriminator": {
-                "propertyName": self.discriminator_field_name,
-                "mapping": discriminator_mapping,
-            },
-        }
+    def __post_init__(self):
+        self.oneof_type = "_discriminated_int_"
+        self.discriminator_type = "integer"
 
 
 @dataclass
@@ -5621,7 +5534,10 @@ class OneOfStringType(
     ):
         # noinspection PyArgumentList
         OneOfStringSchema.__init__(
-            self, types, discriminator_inlined, discriminator_field_name
+            self,
+            types=types,
+            discriminator_inlined=discriminator_inlined,
+            discriminator_field_name=discriminator_field_name,
         )
         _OneOfType.__init__(
             self,
@@ -5659,7 +5575,10 @@ class OneOfIntType(OneOfIntSchema, _OneOfType[OneOfT, int], Generic[OneOfT]):
     ):
         # noinspection PyArgumentList
         OneOfIntSchema.__init__(
-            self, types, discriminator_inlined, discriminator_field_name
+            self,
+            types=types,
+            discriminator_inlined=discriminator_inlined,
+            discriminator_field_name=discriminator_field_name,
         )
         _OneOfType.__init__(
             self,
@@ -6070,10 +5989,17 @@ class StepType(StepSchema):
             input.validate(params, tuple(["input"]))
         # Run the step
         result = self._handler(step_local_data.initialized_object, params)
+        if not isinstance(result, tuple):
+            raise BadArgumentException(
+                f"The implementation of step {run_id}/{self.id} returned"
+                f" type {type(result)}; expected a tuple with two"
+                " values: output ID string and a step-specific value."
+                f"\nValue returned: {result}"
+            )
         if len(result) != 2:
             raise BadArgumentException(
-                "The step returned {} results instead of 2. Did your step"
-                " return the correct results?".format(len(result))
+                f"The implementation of step {run_id}/{self.id} returned"
+                f"{len(result)} results instead of 2. Got {result}."
             )
         output_id, output_data = result
         if output_id not in self.outputs:
@@ -6867,8 +6793,12 @@ class _SchemaBuilder:
     ) -> AbstractType:
         t: typing.ForwardRef
         # TODO is there a better way to directly evaluate a forward ref?
-        # noinspection PyArgumentList,PyProtectedMember
-        resolved = t._evaluate(None, None, frozenset())
+        # Note: This is an unstable API.
+        # noinspection PyProtectedMember
+        resolved = t._evaluate(
+            globalns=None,
+            localns=None,
+            recursive_guard=frozenset())
         return cls._resolve(resolved, resolved, path, scope)
 
     @classmethod
@@ -7019,12 +6949,14 @@ class _SchemaBuilder:
             types[discriminator_value] = f.type
         if discriminator_type is str:
             return OneOfStringType(
-                types,
-                scope,
+                types=types,
+                scope=scope,
                 discriminator_inlined=False,
             )
         else:
-            return OneOfIntType(types, scope, discriminator_inlined=False)
+            return OneOfIntType(
+                types=types, scope=scope, discriminator_inlined=False
+            )
 
     @classmethod
     def _resolve_pattern(cls, t, type_hints: type, path, scope: ScopeType):

{arcaflow_plugin_sdk-0.14.0.dev1 → arcaflow_plugin_sdk-0.14.1}/src/arcaflow_plugin_sdk/test_plugin.py

@@ -4,16 +4,16 @@ import tempfile
 import typing
 import unittest
 
-from arcaflow_plugin_sdk import plugin
+from arcaflow_plugin_sdk import plugin, schema
 
 
 @dataclasses.dataclass
-class StdoutTestInput:
+class EmptyTestInput:
     pass
 
 
 @dataclasses.dataclass
-class StdoutTestOutput:
+class EmptyTestOutput:
     pass
 
 
@@ -21,13 +21,13 @@ class StdoutTestOutput:
     "stdout-test",
     "Stdout test",
     "A test for writing to stdout.",
-    {"success": StdoutTestOutput},
+    {"success": EmptyTestOutput},
 )
 def stdout_test_step(
-    input: StdoutTestInput,
-) -> typing.Tuple[str, StdoutTestOutput]:
+    _: EmptyTestInput,
+) -> typing.Tuple[str, EmptyTestOutput]:
     print("Hello world!")
-    return "success", StdoutTestOutput()
+    return "success", EmptyTestOutput()
 
 
 class StdoutTest(unittest.TestCase):
@@ -52,5 +52,26 @@ class StdoutTest(unittest.TestCase):
         self.assertEqual("Hello world!\n", e.getvalue())
 
 
+@plugin.step(
+    "incorrect-return",
+    "Incorrect Return",
+    "A step that returns a bad output which omits the output ID.",
+    {"success": EmptyTestOutput},
+)
+def incorrect_return_step(
+    _: EmptyTestInput,
+) -> typing.Tuple[str, EmptyTestOutput]:
+    # noinspection PyTypeChecker
+    return EmptyTestOutput()
+
+
+class CallStepTest(unittest.TestCase):
+    def test_incorrect_return_args_count(self):
+        s = plugin.build_schema(incorrect_return_step)
+
+        with self.assertRaises(schema.BadArgumentException):
+            s.call_step(self.id(), "incorrect-return", EmptyTestInput())
+
+
 if __name__ == "__main__":
     unittest.main()

{arcaflow_plugin_sdk-0.14.0.dev1 → arcaflow_plugin_sdk-0.14.1}/src/arcaflow_plugin_sdk/test_schema.py

@@ -56,6 +56,7 @@ class InlineStr2:
 class InlineInt:
     type_: int
     msg: str
+    code: int
 
 
 @dataclasses.dataclass
@@ -81,6 +82,11 @@ class InlineUnion:
     union: typing.Union[InlineStr, InlineStr2, DoubleInlineStr]
 
 
+@dataclasses.dataclass
+class IntInlineUnion:
+    union: typing.Union[InlineInt, InlineInt2]
+
+
 class Color(enum.Enum):
     GREEN = "green"
     RED = "red"
@@ -584,6 +590,30 @@ class OneOfTest(unittest.TestCase):
             },
             "a",
         )
+        self.scope_inlined_int = schema.ScopeType(
+            {
+                "a": schema.ObjectType(
+                    InlineInt,
+                    {
+                        discriminator_field_name: PropertyType(
+                            schema.IntType(),
+                        ),
+                        "msg": PropertyType(schema.StringType()),
+                        "code": PropertyType(schema.IntType()),
+                    },
+                ),
+                "b": schema.ObjectType(
+                    InlineInt2,
+                    {
+                        discriminator_field_name: PropertyType(
+                            schema.IntType(),
+                        ),
+                        "msg2": PropertyType(schema.StringType()),
+                    },
+                ),
+            },
+            "a",
+        )
 
     def test_inline_discriminator_missing(self):
         with self.assertRaises(BadArgumentException) as cm:
@@ -779,6 +809,20 @@ class OneOfTest(unittest.TestCase):
         self.assertIsInstance(unserialized_data2, DoubleInlineStr)
         self.assertEqual(unserialized_data2.msg, "Hi again")
 
+        s = schema.OneOfIntType(
+            {
+                1: schema.RefType("a", self.scope_inlined_int),
+                2: schema.RefType("b", self.scope_inlined_int),
+            },
+            scope=self.scope_inlined_int,
+            discriminator_field_name=discriminator_field_name,
+            discriminator_inlined=True,
+        )
+        unserialized_data: InlineInt = s.unserialize(
+            {discriminator_field_name: 1, "msg": "Hi again", "code": 101}
+        )
+        self.assertIsInstance(unserialized_data, InlineInt)
+
     def test_validation(self):
         s = schema.OneOfStringType[Basic](
             {
@@ -2117,6 +2161,172 @@ class JSONSchemaTest(unittest.TestCase):
             json_schema,
         )
 
+    def test_oneof_int_inline(self):
+        scope = schema.ScopeType(
+            {},
+            IntInlineUnion.__name__,
+        )
+        inline_int_key = 1
+        inline_int2_key = 2
+
+        scope.objects = {
+            IntInlineUnion.__name__: schema.ObjectType(
+                IntInlineUnion,
+                {
+                    "union": schema.PropertyType(
+                        schema.OneOfIntType(
+                            {
+                                inline_int_key: schema.RefType(
+                                    InlineInt.__name__, scope
+                                ),
+                                inline_int2_key: schema.RefType(
+                                    InlineInt2.__name__, scope
+                                ),
+                            },
+                            scope,
+                            discriminator_inlined=True,
+                            discriminator_field_name=discriminator_field_name,
+                        )
+                    )
+                },
+            ),
+            InlineInt.__name__: schema.ObjectType(
+                InlineInt,
+                {
+                    "msg": schema.PropertyType(schema.StringType()),
+                    "code": schema.PropertyType(schema.IntType()),
+                    discriminator_field_name: schema.PropertyType(
+                        schema.IntType()
+                    ),
+                },
+            ),
+            InlineInt2.__name__: schema.ObjectType(
+                InlineInt2,
+                {
+                    "msg2": schema.PropertyType(schema.StringType()),
+                    discriminator_field_name: schema.PropertyType(
+                        schema.IntType()
+                    ),
+                },
+            ),
+        }
+
+        defs = schema._JSONSchemaDefs()
+        json_schema = scope._to_jsonschema_fragment(scope, defs)
+        self.assertEqual(
+            {
+                "$defs": {
+                    IntInlineUnion.__name__: {
+                        "type": "object",
+                        "properties": {
+                            "union": {
+                                "oneOf": [
+                                    {
+                                        "$ref": (
+                                            f"#/$defs/{InlineInt.__name__}"
+                                            "_discriminated_int_"
+                                            f"{inline_int_key}"
+                                        )
+                                    },
+                                    {
+                                        "$ref": (
+                                            f"#/$defs/{InlineInt2.__name__}"
+                                            "_discriminated_int_"
+                                            f"{inline_int2_key}"
+                                        )
+                                    },
+                                ]
+                            }
+                        },
+                        "required": ["union"],
+                        "additionalProperties": False,
+                        "dependentRequired": {},
+                    },
+                    InlineInt.__name__: {
+                        "type": "object",
+                        "properties": {
+                            "msg": {"type": "string"},
+                            "code": {"type": "integer"},
+                            discriminator_field_name: {
+                                "type": "integer",
+                                "const": str(inline_int_key),
+                            },
+                        },
+                        "required": [discriminator_field_name, "msg", "code"],
+                        "additionalProperties": False,
+                        "dependentRequired": {},
+                    },
+                    InlineInt.__name__
+                    + f"_discriminated_int_{inline_int_key}": {
+                        "type": "object",
+                        "properties": {
+                            "msg": {"type": "string"},
+                            "code": {"type": "integer"},
+                            discriminator_field_name: {
+                                "type": "integer",
+                                "const": str(inline_int_key),
+                            },
+                        },
+                        "required": [discriminator_field_name, "msg", "code"],
+                        "additionalProperties": False,
+                        "dependentRequired": {},
+                    },
+                    InlineInt2.__name__: {
+                        "type": "object",
+                        "properties": {
+                            "msg2": {"type": "string"},
+                            discriminator_field_name: {
+                                "type": "integer",
+                                "const": str(inline_int2_key),
+                            },
+                        },
+                        "required": [discriminator_field_name, "msg2"],
+                        "additionalProperties": False,
+                        "dependentRequired": {},
+                    },
+                    InlineInt2.__name__
+                    + f"_discriminated_int_{inline_int2_key}": {
+                        "type": "object",
+                        "properties": {
+                            "msg2": {"type": "string"},
+                            discriminator_field_name: {
+                                "type": "integer",
+                                "const": str(inline_int2_key),
+                            },
+                        },
+                        "required": [discriminator_field_name, "msg2"],
+                        "additionalProperties": False,
+                        "dependentRequired": {},
+                    },
+                },
+                "type": "object",
+                "properties": {
+                    "union": {
+                        "oneOf": [
+                            {
+                                "$ref": (
+                                    f"#/$defs/{InlineInt.__name__}"
+                                    "_discriminated_int_"
+                                    f"{inline_int_key}"
+                                )
+                            },
+                            {
+                                "$ref": (
+                                    f"#/$defs/{InlineInt2.__name__}"
+                                    "_discriminated_int_"
+                                    f"{inline_int2_key}"
+                                )
+                            },
+                        ]
+                    }
+                },
+                "required": ["union"],
+                "additionalProperties": False,
+                "dependentRequired": {},
+            },
+            json_schema,
+        )
+
 
 def load_tests(loader, tests, ignore):
     """This function adds the doctests to the discovery process."""