mirumee__ariadne-24

The user wants to extend `add_resolve_functions_to_schema` (or `add_resolve_functions_to_scalar` as mentioned in the problem description) to support `parse_value` and `parse_literal` for Scalars in Ariadne.

Let's start by locating where these functions are defined.

{
  "command": "grep -rn --include=\"*.py\" \"add_resolve_functions_to_schema\" /workspace"
}

{
  "status": "ok",
  "stdout": "/workspace/ariadne/executable_schema.py:6:from .resolvers import add_resolve_functions_to_schema\n/workspace/ariadne/executable_schema.py:13:    add_resolve_functions_to_schema(schema, resolvers)\n/workspace/ariadne/__init__.py:3:from .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\n/workspace/ariadne/__init__.py:6:    \"add_resolve_functions_to_schema\",\n/workspace/ariadne/resolvers.py:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n",
  "stderr": "",
  "exit_code": 0
}

The problem statement mentions `add_resolve_functions_to_scalar`, but the grep for `add_resolve_functions_to_schema` pointed to `ariadne/resolvers.py`. Let's search for `add_resolve_functions_to_scalar` as well.

{
  "command": "grep -rn --include=\"*.py\" \"add_resolve_functions_to_scalar\" /workspace"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

It seems `add_resolve_functions_to_scalar` is not actually in the codebase, or maybe it's a conceptual name used in the issue description. Let's look at `ariadne/resolvers.py` and `add_resolve_functions_to_schema`.

{
  "filepath": "ariadne/resolvers.py"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "content": "from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema\nfrom graphql.execution.base import ResolveInfo\n\n\ndef resolve_parent_field(parent, name: str):\n    if isinstance(parent, dict):\n        return parent.get(name)\n    return getattr(parent, name, None)\n\n\ndef default_resolver(parent, info: ResolveInfo):\n    return resolve_parent_field(parent, info.field_name)\n\n\ndef resolve_to(name: str):\n    def resolver(parent, *_):\n        return resolve_parent_field(parent, name)\n\n    return resolver\n\n\ndef add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n    for type_name, type_object in schema.get_type_map().items():\n        if isinstance(type_object, GraphQLObjectType):\n            add_resolve_functions_to_object(type_name, type_object, resolvers)\n        if isinstance(type_object, GraphQLScalarType):\n            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n\n\ndef add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n    type_resolver = resolvers.get(name, {})\n    for field_name, field_object in obj.fields.items():\n        field_resolver = type_resolver.get(field_name, default_resolver)\n        field_object.resolver = field_resolver\n\n\ndef add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n    serializer = resolvers.get(name, obj.serialize)\n    obj.serialize = serializer",
  "start_line": 1,
  "end_line": 39,
  "total_lines": 39,
  "is_truncated": false
}

Wait, I see `add_resolve_function_to_scalar` (singular) in `ariadne/resolvers.py` at line 36.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

Wait, look at the type hint for `obj` in `add_resolve_function_to_scalar`: it says `GraphQLObjectType`, but it's called when `type_object` is `GraphQLScalarType` in `add_resolve_functions_to_schema`.

```python
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
```

So `add_resolve_function_to_scalar` is actually handling `GraphQLScalarType` objects.

The current implementation only handles `serialize`. The requirement is to also support `parse_value` and `parse_literal`.

In `graphql-core` (which `ariadne` uses), `GraphQLScalarType` has `serialize`, `parse_value`, and `parse_literal` attributes.

If `resolvers` contains a dict for a scalar, like:
`resolvers = {'MyScalar': {'serialize': ser, 'parse_value': pv, 'parse_literal': pl}}`

The current implementation does:
`serializer = resolvers.get(name, obj.serialize)`
If `resolvers.get(name)` returns the dict `{'serialize': ser, 'parse_value': pv, 'parse_literal': pl}`, then `serializer` becomes that dict, and `obj.serialize` is set to that dict. This is definitely wrong if the user provided a dict of functions.

Wait, if `resolvers` is `{'MyScalar': ser}`, where `ser` is a callable, then `serializer` becomes `ser`, and `obj.serialize` becomes `ser`. That works for the one-way case if they just pass the function.

But the problem statement says:
`type_defs = {'Scalar': {'serialize': callable}}`
And `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

Wait, let's re-read the problem statement carefully.
"Our `add_resolve_functions_to_scalar` utility could support following use-cases:"

Actually, the problem statement says `type_defs = ...`, but it probably means `resolvers = ...` passed to `add_resolve_functions_to_schema`.

Let's check how `add_resolve_function_to_scalar` is currently implemented:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

If `resolvers = {'MyScalar': some_func}`, then `serializer = some_func`, and `obj.serialize = some_func`.
If `resolvers = {'MyScalar': {'serialize': some_func}}`, then `serializer = {'serialize': some_func}`, and `obj.serialize = {'serialize': some_func}`. This is probably not what's intended if they pass a dict.

Wait, let's look at `add_resolve_functions_to_object`:
```python
def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):
    type_resolver = resolvers.get(name, {})\n    for field_name, field_object in obj.fields.items():\n        field_resolver = type_resolver.get(field_name, default_resolver)\n        field_object.resolver = field_resolver
```
Here, `resolvers.get(name, {})` handles the case where the type is not in `resolvers`.

For scalars, the problem description suggests that we want to be able to pass a dictionary of functions for a scalar.

Let's try to reproduce this. I'll create a test case that uses a custom scalar and checks if `serialize`, `parse_value`, and `parse_literal` are correctly assigned.

First, I need to see if there are any existing tests for scalars.

{
  "command": "find tests -name \"*scalar*\""
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "",
  "exit_code": 0
}

No tests with "scalar" in the name. Let's look at the tests directory.

{
  "command": "ls -R tests"
}

{
  "status": "ok",
  "stdout": "tests:\n__init__.py\ntest_modularization.py\ntest_mutations.py\ntest_queries.py\n",
  "stderr": "",
  "exit_code": 0
}

The tests seem very sparse.

Let's create a reproduction script `repro.py` to see how it currently behaves and how it should behave.

I need `GraphQLSchema`, `GraphQLScalarType`, `GraphQLObjectType` from `graphql`.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLString\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\ndef dummy_resolver(parent, info):\n    return \"hello\"\n\n# Setup a simple schema with a scalar\n# We can't easily create a full schema without type_defs, so we'll build it manually\nscalar = GraphQLScalarType(name=\"MyScalar\", serialize=lambda v: v)\nobj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": {\"type\": scalar}})\nschema = GraphQLSchema(query=obj_type)\n\nresolvers = {\n    \"MyScalar\": {\n        \"serialize\": mock_serialize,\n        \"parse_value\": mock_parse_value,\n        \"parse_literal\": mock_parse_literal,\n    }\n}\n\n# This should set the scalar's methods\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Serialize: {scalar.serialize}\")\nprint(f\"Parse Value: {scalar.parse_value}\")\nprint(f\"Parse Literal: {scalar.parse_literal}\")\n\nassert scalar.serialize == mock_serialize\nassert scalar.parse_value == mock_parse_value\nassert scalar.parse_literal == mock_parse_literal\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 20, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/schema.py\", line 106, in __init__\n    self._type_map = GraphQLTypeMap(initial_types)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/typemap.py\", line 31, in __init__\n    self.update(reduce(self.reducer, types, OrderedDict()))  # type: ignore\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/typemap.py\", line 109, in reducer\n    field_map = type_.fields\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/pyutils/cached_property.py\", line 22, in __get__\n    value = obj.__dict__[self.func.__name__] = self.func(obj)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 198, in fields\n    return define_field_map(self, self._fields)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 223, in define_field_map\n    ), \"{}.{} must be an instance of GraphQLField.\".format(type_, field_name)\nAssertionError: Query.foo must be an instance of GraphQLField.\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 20, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/schema.py\", line 106, in __init__\n    self._type_map = GraphQLTypeMap(initial_types)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/typemap.py\", line 31, in __init__\n    self.update(reduce(self.reducer, types, OrderedDict()))  # type: ignore\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/typemap.py\", line 109, in reducer\n    field_map = type_.fields\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/pyutils/cached_property.py\", line 22, in __get__\n    value = obj.__dict__[self.func.__name__] = self.func(obj)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 198, in fields\n    return define_field_map(self, self._fields)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 223, in define_field_map\n    ), \"{}.{} must be an instance of GraphQLField.\".format(type_, field_name)\nAssertionError: Query.foo must be an instance of GraphQLField.\n",
    "exit_code": 1
  }
}

The error `AssertionError: Query.foo must be an instance of GraphQLField.` is because I passed a simple dict to `fields` in `GraphQLObjectType`. I need to use `GraphQLField`.

Let's correct the reproduction script.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\n# Setup a simple schema with a scalar\nscalar = GraphQLScalarType(name=\"MyScalar\", serialize=lambda v: v)\nobj_type = GraphQLObjectType(\n    name=\"Query\", \n    fields={\n        \"foo\": GraphQLField(scalar)\n    }\n)\nschema = GraphQLSchema(query=obj_type)\n\nresolvers = {\n    \"MyScalar\": {\n        \"serialize\": mock_serialize,\n        \"parse_value\": mock_parse_value,\n        \"parse_literal\": mock_parse_literal,\n    }\n}\n\n# This should set the scalar's methods\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Serialize: {scalar.serialize}\")\nprint(f\"Parse Value: {scalar.parse_value}\")\nprint(f\"Parse Literal: {scalar.parse_literal}\")\n\n# We expect these to fail currently\ntry:\n    assert scalar.serialize == mock_serialize\n    assert scalar.parse_value == mock_parse_value\n    assert scalar.parse_literal == mock_parse_literal\n    print(\"Success!\")\nexcept AssertionError as e:\n    print(\"Failed as expected\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Serialize: {'serialize': <function mock_serialize at 0x78c6414dc200>, 'parse_value': <function mock_parse_value at 0x78c6425dd0e0>, 'parse_literal': <function mock_parse_literal at 0x78c6425dd440>}\nParse Value: <function none_func at 0x78c6418274d0>\nParse Literal: <function none_func at 0x78c6418274d0>\nFailed as expected\n",
  "stderr": "",
  "exit_code": 0
}

As expected, `scalar.serialize` became the entire dictionary, and `parse_value` and `parse_literal` remained unchanged.

Now let's check the case where `resolvers` has just a function for the scalar.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\nscalar = GraphQLScalarType(name=\"MyScalar\", serialize=lambda v: v)\nobj_type = GraphQLObjectType(\n    name=\"Query\", \n    fields={\n        \"foo\": GraphQLField(scalar)\n    }\n)\nschema = GraphQLSchema(query=obj_type)\n\nresolvers = {\n    \"MyScalar\": mock_serialize,\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Serialize: {scalar.serialize}\")\nassert scalar.serialize == mock_serialize\nprint(\"Success for single function!\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Serialize: <function mock_serialize at 0x7e83ba63c950>\nSuccess for single function!\n",
  "stderr": "",
  "exit_code": 0
}

So it currently supports:
- `resolvers = {"MyScalar": mock_serialize}` -> `scalar.serialize = mock_serialize`

But we want to support:
- `resolvers = {"MyScalar": { "serialize": mock_serialize }}` -> `scalar.serialize = mock_serialize`
- `resolvers = {"MyScalar": { "serialize": mock_serialize, "parse_value": mock_pv, "parse_literal": mock_pl }}` -> `scalar.serialize=mock_serialize, scalar.parse_value=mock_pv, scalar.parse_literal=mock_pl`

Let's analyze `add_resolve_function_to_scalar` again.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

(Note: `obj` is actually a `GraphQLScalarType` here)

We should change it to handle both a callable and a dictionary of callables.

Proposed implementation:

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if scalar_resolvers is None:
        return

    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    else:
        obj.serialize = scalar_resolvers
```

Wait, if it's a dictionary, we should probably only update the fields that are actually present in the dictionary. The `get(key, default)` approach does exactly that.

Let's refine the type hint for `obj` as well, since it's clearly a `GraphQLScalarType`.

Wait, let's check if `GraphQLScalarType` attributes are mutable. In my reproduction script, `scalar.serialize = mock_serialize` worked.

One more thing: the problem statement says:
`- type_defs = {'Scalar': {'serialize': callable}}`
`- type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

Wait, they said `type_defs`. But in `ariadne`, `type_defs` usually refers to the SDL string. They probably meant the `resolvers` dict.

Let's verify the implementation with a more comprehensive reproduction script.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\ndef test_scalar_resolution(resolver_config, expected_serialize, expected_pv, expected_pl):\n    scalar = GraphQLScalarType(name=\"MyScalar\", serialize=lambda v: v, parse_value=lambda v: v, parse_literal=lambda v: v)\n    obj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": GraphQLField(scalar)})\n    schema = GraphQLSchema(query=obj_type)\n    \n    resolvers = {\"MyScalar\": resolver_config}\n    add_resolve_functions_to_schema(schema, resolvers)\n    \n    assert scalar.serialize == expected_serialize\n    assert scalar.parse_value == expected_pv\n    assert scalar.parse_literal == expected_pl\n    print(f\"Passed for config: {resolver_config}\")\n\n# Case 1: No resolver\ntest_scalar_resolution(None, None, None, None) # This case is slightly different because we don't put it in the dict\n\n# Wait, if resolver_config is None, resolvers = {\"MyScalar\": None}. \n# resolvers.get(\"MyScalar\") will return None.\n\n# Let's refine the test function.\n\ndef test_scalar_resolution_refined(resolvers, expected_serialize_relative, expected_pv_relative, expected_pl_relative):\n    def initial_ser(v): return \"ser\"\n    def initial_pv(v): return \"pv\"\n    def initial_pl(v): return \"pl\"\n    \n    scalar = GraphQLScalarType(name=\"MyScalar\", serialize=initial_ser, parse_value=initial_pv, parse_literal=initial_pl)\n    obj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": GraphQLField(scalar)})\n    schema = GraphQLSchema(query=obj_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers)\n    \n    # relative means: if it's a function, match that function; if it's \"initial\", match the initial one.\n    def check(actual, expected, initial):\n        if expected == \"initial\":\n            assert actual == initial\n        else:\n            assert actual == expected\n\n    check(scalar.serialize, expected_serialize_relative, initial_ser)\n    check(scalar.parse_value, expected_pv_relative, initial_pv)\n    check(scalar.parse_literal, expected_pl_relative, initial_pl)\n\n# Case 1: No resolver for this scalar\ntest_scalar_resolution_refined({}, \"initial\", \"initial\", \"initial\")\n\n# Case 2: Single function resolver (should only affect serialize)\ntest_scalar_resolution_refined({\"MyScalar\": mock_serialize}, mock_serialize, \"initial\", \"initial\")\n\n# Case 3: Dict with only serialize\ntest_scalar_resolution_refined({\"MyScalar\": {\"serialize\": mock_serialize}}, mock_serialize, \"initial\", \"initial\")\n\n# Case 4: Dict with all three\ntest_scalar_resolution_refined(\n    {\"MyScalar\": {\"serialize\": mock_serialize, \"parse_value\": mock_parse_value, \"parse_literal\": mock_parse_literal}},\n    mock_serialize, mock_parse_value, mock_parse_literal\n)\n\n# Case 5: Dict with only parse_value\ntest_scalar_resolution_refined({\"MyScalar\": {\"parse_value\": mock_parse_value}}, \"initial\", mock_parse_value, \"initial\")\n\nprint(\"All refined tests passed!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 27, in <module>\n  File \"<stdin>\", line 22, in test_scalar_resolution\nAssertionError\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 27, in <module>\n  File \"<stdin>\", line 22, in test_scalar_resolution\nAssertionError\n",
    "exit_code": 1
  }
}

Wait, I mixed up `test_scalar_resolution` and `test_scalar_resolution_refined` in my head when I wrote the script? No, I see `test_scalar_resolution` being called at line 27, but I only defined `test_scalar_resolution_refined`.

Actually, the output says:
```
  File "<stdin>", line 27, in <module>
  File "<stdin>", line 22, in test_scalar_resolution
AssertionError
```

Wait, I see what happened. I probably forgot to clean up the script or I'm misreading. Let's look at the `run_command` call again.

Ah, I see. I used `test_scalar_resolution` in the call but I had defined `test_scalar_resolution_refined`. But wait, the script I sent did NOT have `test_scalar_resolution` called at line 27.

Let me re-examine the script I sent in the previous turn.
Lines 1-15: imports and mock functions
Lines 17-31: `test_scalar_resolution_refined`
Lines 33-48: calls to `test_scalar_resolution_refined`

Wait, if I look at my previous turn's `run_command` content... I see where the mistake might be. I actually wrote `test_scalar_resolution` in the first attempt at the script but then I wrote `test_scalar_resolution_refined`.

Wait, the `run_command` output says line 27 in `<module>` and line 22 in `test_scalar_resolution`.

Ah! I see! I am probably miscounting lines or the agent's memory is confusing me. Let's just look at the actual script I sent in the `run_command` call.

The script I sent was:
```python
python3 - <<'PY'
...
def test_scalar_resolution_refined(resolvers, expected_serialize_relative, expected_pv_relative, expected_pl_relative):
...
# Case 1: No resolver for this scalar
test_scalar_resolution_refined({}, "initial", "initial", "initial")
...
```
Wait, if I check the `run_command` call again... it's exactly as I wrote. Why did it fail?

Wait, did I accidentally send the previous version of the script too? No.

Wait, I see the problem. The `test_scalar_resolution` function might have been defined earlier in the same session? No, `python3 - <<'PY'` starts a new process.

Let me re-run the reproduction script, ensuring it's clean and consistent.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\ndef test_scalar_resolution_refined(resolvers, expected_serialize_relative, expected_pv_relative, expected_pl_relative):\n    def initial_ser(v): return \"ser\"\n    def initial_pv(v): return \"pv\"\n    def initial_pl(v): return \"pl\"\n    \n    scalar = GraphQLScalarType(name=\"MyScalar\", serialize=initial_ser, parse_value=initial_pv, parse_literal=initial_pl)\n    obj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": GraphQLField(scalar)})\n    schema = GraphQLSchema(query=obj_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers)\n    \n    def check(actual, expected, initial):\n        if expected == \"initial\":\n            assert actual == initial\n        else:\n            assert actual == expected\n\n    check(scalar.serialize, expected_serialize_relative, initial_ser)\n    check(scalar.parse_value, expected_pv_relative, initial_pv)\n    check(scalar.parse_literal, expected_pl_relative, initial_pl)\n\n# Case 1: No resolver for this scalar\ntest_scalar_resolution_refined({}, \"initial\", \"initial\", \"initial\")\n\n# Case 2: Single function resolver (should only affect serialize)\ntest_scalar_resolution_refined({\"MyScalar\": mock_serialize}, mock_serialize, \"initial\", \"initial\")\n\n# Case 3: Dict with only serialize\ntest_scalar_resolution_refined({\"MyScalar\": {\"serialize\": mock_serialize}}, mock_serialize, \"initial\", \"initial\")\n\n# Case 4: Dict with all three\ntest_scalar_resolution_refined(\n    {\"MyScalar\": {\"serialize\": mock_serialize, \"parse_value\": mock_parse_value, \"parse_literal\": mock_parse_literal}},\n    mock_serialize, mock_parse_value, mock_parse_literal\n)\n\n# Case 5: Dict with only parse_value\ntest_scalar_resolution_refined({\"MyScalar\": {\"parse_value\": mock_parse_value}}, \"initial\", mock_parse_value, \"initial\")\n\nprint(\"All refined tests passed!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 41, in <module>\n  File \"<stdin>\", line 30, in test_scalar_resolution_refined\n  File \"<stdin>\", line 28, in check\nAssertionError\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 41, in <module>\n  File \"<stdin>\", line 30, in test_scalar_resolution_refined\n  File \"<stdin>\", line 28, in check\nAssertionError\n",
    "exit_code": 1
  }
}

Okay, it's failing at line 41, which is Case 2: `test_scalar_resolution_refined({"MyScalar": mock_serialize}, mock_serialize, "initial", "initial")`.
And line 30: `check(scalar.serialize, expected_serialize_relative, initial_ser)`.

Wait, why does it fail Case 2?
In Case 2, `resolvers = {"MyScalar": mock_serialize}`.
`add_resolve_functions_to_schema` calls `add_resolve_function_to_scalar("MyScalar", scalar, resolvers)`.
Existing `add_resolve_function_to_scalar`:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
`resolvers.get("MyScalar", obj.serialize)` returns `mock_serialize`.
`obj.serialize = mock_serialize`.
Then `check(scalar.serialize, mock_serialize, initial_ser)` should pass because `scalar.serialize` is `mock_serialize`.

Wait, why did it fail?

Let's print the values in the reproduction script to see what's happening.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\ndef test_scalar_resolution_refined(resolvers, expected_serialize_relative, expected_pv_relative, expected_pl_relative):\n    def initial_ser(v): return \"ser\"\n    def initial_pv(v): return \"pv\"\n    def initial_pl(v): return \"pl\"\n    \n    scalar = GraphQLScalarType(name=\"MyScalar\", serialize=initial_ser, parse_value=initial_pv, parse_literal=initial_pl)\n    obj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": GraphQLField(scalar)})\n    schema = GraphQLSchema(query=obj_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers)\n    \n    print(f\"Actual serialize: {scalar.serialize}\")\n    print(f\"Expected serialize: {expected_serialize_relative}\")\n\n    def check(actual, expected, initial):\n        if expected == \"initial\":\n            assert actual == initial\n        else:\n            assert actual == expected\n\n    check(scalar.serialize, expected_serialize_relative, initial_ser)\n    check(scalar.parse_value, expected_pv_relative, initial_pv)\n    check(scalar.parse_literal, expected_pl_relative, initial_pl)\n\ntest_scalar_resolution_refined({\"MyScalar\": mock_serialize}, mock_serialize, \"initial\", \"initial\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Actual serialize: <function mock_serialize at 0x7b6684dcd8c0>\nExpected serialize: <function mock_serialize at 0x7b6684dcd8c0>\n",
  "stderr": "",
  "exit_code": 0
}

Wait, it passed! So my previous `run_command` failed on Case 2?

Wait, let's look at the previous failure again.
`File "<stdin>", line 41, in <module>`
`File "<stdin>", line 30, in test_scalar_resolution_refined`
`File "<stdin>", line 28, in check`
`AssertionError`

Wait, I see what happened. I might have miscounted lines or the `run_command` output was truncated/shifted.

Let's re-examine the script I sent in the previous turn.
Line 41 was Case 5: `test_scalar_resolution_refined({"MyScalar": {"parse_value": mock_parse_value}}, "initial", mock_parse_value, "initial")`.

Ah! Case 5 should fail because currently `add_resolve_function_to_scalar` only sets `serialize`.
In Case 5: `resolvers = {"MyScalar": {"parse_value": mock_parse_value}}`.
`add_resolve_function_to_scalar` does:
`serializer = resolvers.get("MyScalar", obj.serialize)` which returns `{"parse_value": mock_parse_value}`.
`obj.serialize = {"parse_value": mock_parse_value}`.
Then `check(scalar.serialize, "initial", initial_ser)` fails because `scalar.serialize` is now a dict, not `initial_ser`.
Then `check(scalar.parse_value, mock_parse_value, initial_pv)` fails because `scalar.parse_value` is still `initial_pv`.

So actually, everything is failing as expected for the current implementation when a dict is passed.

Now I can proceed with the fix.

In `ariadne/resolvers.py`:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

Wait, the type hint `GraphQLObjectType` is wrong for `obj`. It should be `GraphQLScalarType`.

Let's implement the fix.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if scalar_resolvers is None:
        return

    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    else:
        obj.serialize = scalar_resolvers
```

Let's double check if there are any other places where scalars are handled.
`add_resolve_functions_to_schema` calls it.

```python
def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):
    for type_name, type_object in schema.get_type_map().items():
        if isinstance(type_object, GraphQLObjectType):
            add_resolve_functions_to_object(type_name, type_object, resolvers)
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
```

Wait, I should check if `GraphQLScalarType` is imported in `ariadne/resolvers.py`. Yes it is.

Let's apply the edit.

{
  "filepath": "ariadne/resolvers.py",
  "new_string": "def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n    scalar_resolvers = resolvers.get(name)\n    if scalar_resolvers is None:\n        return\n\n    if isinstance(scalar_resolvers, dict):\n        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n    else:\n        obj.serialize = scalar_resolvers",
  "old_string": "def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n    serializer = resolvers.get(name, obj.serialize)\n    obj.serialize = serializer"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -34,6 +34,14 @@\n         field_object.resolver = field_resolver\n \n \n-def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n-    serializer = resolvers.get(name, obj.serialize)\n-    obj.serialize = serializer\n+def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n+    scalar_resolvers = resolvers.get(name)\n+    if scalar_resolvers is None:\n+        return\n+\n+    if isinstance(scalar_resolvers, dict):\n+        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n+        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n+        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n+    else:\n+        obj.serialize = scalar_resolvers\n",
  "is_truncated": false
}

Now let's run the comprehensive reproduction script again to make sure everything is correct.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef mock_serialize(value):\n    return f\"serialized({value})\"\n\ndef mock_parse_value(value):\n    return f\"parsed_value({value})\"\n\ndef mock_parse_literal(node):\n    return f\"parsed_literal({node})\"\n\ndef test_scalar_resolution_refined(resolvers, expected_serialize_relative, expected_pv_relative, expected_pl_relative):\n    def initial_ser(v): return \"ser\"\n    def initial_pv(v): return \"pv\"\n    def initial_pl(v): return \"pl\"\n    \n    scalar = GraphQLScalarType(name=\"MyScalar\", serialize=initial_ser, parse_value=initial_pv, parse_literal=initial_pl)\n    obj_type = GraphQLObjectType(name=\"Query\", fields={\"foo\": GraphQLField(scalar)})\n    schema = GraphQLSchema(query=obj_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers)\n    \n    def check(actual, expected, initial):\n        if expected == \"initial\":\n            assert actual == initial\n        else:\n            assert actual == expected\n\n    check(scalar.serialize, expected_serialize_relative, initial_ser)\n    check(scalar.parse_value, expected_pv_relative, initial_pv)\n    check(scalar.parse_literal, expected_pl_relative, initial_pl)\n\n# Case 1: No resolver for this scalar\ntest_scalar_resolution_refined({}, \"initial\", \"initial\", \"initial\")\n\n# Case 2: Single function resolver (should only affect serialize)\ntest_scalar_resolution_refined({\"MyScalar\": mock_serialize}, mock_serialize, \"initial\", \"initial\")\n\n# Case 3: Dict with only serialize\ntest_scalar_resolution_refined({\"MyScalar\": {\"serialize\": mock_serialize}}, mock_serialize, \"initial\", \"initial\")\n\n# Case 4: Dict with all three\ntest_scalar_resolution_refined(\n    {\"MyScalar\": {\"serialize\": mock_serialize, \"parse_value\": mock_parse_value, \"parse_literal\": mock_parse_literal}},\n    mock_serialize, mock_parse_value, mock_parse_literal\n)\n\n# Case 5: Dict with only parse_value\ntest_scalar_resolution_refined({\"MyScalar\": {\"parse_value\": mock_parse_value}}, \"initial\", mock_parse_value, \"initial\")\n\n# Case 6: Dict with only parse_literal\ntest_scalar_resolution_refined({\"MyScalar\": {\"parse_literal\": mock_parse_literal}}, \"initial\", \"initial\", mock_parse_literal)\n\nprint(\"All refined tests passed!\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "All refined tests passed!\n",
  "stderr": "",
  "exit_code": 0
}

The tests passed. Now I should check for any other parallel paths.
The structure of Ariadne seems to be that `add_resolve_functions_to_schema` is the main entry point for assigning resolvers.

Let's check if there are any other similar functions.
I saw `add_resolve_functions_to_object`, and we just fixed `add_resolve_function_to_scalar`.

Wait, let's check if I missed any other part of the request.
"Our `add_resolve_functions_to_scalar` utility could support following use-cases:"

I have implemented support for both:
- `resolvers = {'Scalar': callable}` (one-way, serialize only)
- `resolvers = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}` (two-way)

And also partial cases like only providing `parse_value`.

One more thing: `GraphQLScalarType` in `graphql-core` (depending on version) might be immutable for some attributes. But in my reproduction script, it worked fine. In Ariadne's environment (which uses `graphql-core` 3.x likely), it should be fine.

Let's verify if there are any other files I should look at.
`ariadne/executable_schema.py` uses `add_resolve_functions_to_schema`.

```python
from .resolvers import add_resolve_functions_to_schema
...
    add_resolve_functions_to_schema(schema, resolvers)
```

I've already tested `add_resolve_functions_to_schema` via my reproduction script.

Let's do one last check on `ariadne/resolvers.py` to make sure I didn't leave any mistakes.

{
  "filepath": "ariadne/resolvers.py"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "content": "from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema\nfrom graphql.execution.base import ResolveInfo\n\n\ndef resolve_parent_field(parent, name: str):\n    if isinstance(parent, dict):\n        return parent.get(name)\n    return getattr(parent, name, None)\n\n\ndef default_resolver(parent, info: ResolveInfo):\n    return resolve_parent_field(parent, info.field_name)\n\n\ndef resolve_to(name: str):\n    def resolver(parent, *_):\n        return resolve_parent_field(parent, name)\n\n    return resolver\n\n\ndef add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n    for type_name, type_object in schema.get_type_map().items():\n        if isinstance(type_object, GraphQLObjectType):\n            add_resolve_functions_to_object(type_name, type_object, resolvers)\n        if isinstance(type_object, GraphQLScalarType):\n            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n\n\ndef add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n    type_resolver = resolvers.get(name, {})\n    for field_name, field_object in obj.fields.items():\n        field_resolver = type_resolver.get(field_name, default_resolver)\n        field_object.resolver = field_resolver\n\n\ndef add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n    scalar_resolvers = resolvers.get(name)\n    if scalar_resolvers is None:\n        return\n\n    if isinstance(scalar_resolvers, dict):\n        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n    else:\n        obj.serialize = scalar_resolvers",
  "start_line": 1,
  "end_line": 47,
  "total_lines": 47,
  "is_truncated": false
}

The implementation looks clean and correct.

I will now check for any untracked files in `/workspace`.

{
  "command": "git status --short"
}

{
  "status": "ok",
  "stdout": " M ariadne/resolvers.py\n",
  "stderr": "",
  "exit_code": 0
}

No untracked files.

I will now check the diff.

{
  "command": "git diff"
}

{
  "status": "ok",
  "stdout": "diff --git a/ariadne/resolvers.py b/ariadne/resolvers.py\nindex 388e3ad..31a0cef 100644\n--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -34,6 +34,14 @@ def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers\n         field_object.resolver = field_resolver\n \n \n-def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n-    serializer = resolvers.get(name, obj.serialize)\n-    obj.serialize = serializer\n+def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n+    scalar_resolvers = resolvers.get(name)\n+    if scalar_resolvers is None:\n+        return\n+\n+    if isinstance(scalar_resolvers, dict):\n+        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n+        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n+        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n+    else:\n+        obj.serialize = scalar_resolvers\n",
  "stderr": "",
  "exit_code": 0
}

Everything looks good. I'll submit the patch.

{
  "status": "ok",
  "patch_size": 989,
  "files_changed": 1
}

The patch has been submitted.

The `add_resolve_function_to_scalar` function in `ariadne/resolvers.py` was updated to support both single callable resolvers (affecting only `serialize`) and dictionaries of resolver functions (supporting `serialize`, `parse_value`, and `parse_literal`). This enables two-way custom scalar support in Ariadne when using `add_resolve_functions_to_schema`.