internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: pydantic/pydantic

Issue:
BUG: Const validator is not called when there are class validators
The issue is on this line:
https://github.com/samuelcolvin/pydantic/blob/bf9cc4a5e7903ada2e819a63fe2da011f292a143/pydantic/fields.py#L542

Unlike the line above, post_validators are not appended to but overwritten. This removes the const validator...


Discussion:

Resolving patch:
diff --git a/pydantic/fields.py b/pydantic/fields.py
--- a/pydantic/fields.py
+++ b/pydantic/fields.py
@@ -539,7 +539,7 @@ def populate_validators(self) -> None:
 
         if class_validators_:
             self.pre_validators += prep_validators(v.func for v in class_validators_ if not v.each_item and v.pre)
-            self.post_validators = prep_validators(v.func for v in class_validators_ if not v.each_item and not v.pre)
+            self.post_validators += prep_validators(v.func for v in class_validators_ if not v.each_item and not v.pre)
 
         if self.parse_json:
             self.pre_validators.append(make_generic_validator(validate_json))


Test patch:
diff --git a/tests/test_main.py b/tests/test_main.py
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -5,7 +5,18 @@
 
 import pytest
 
-from pydantic import BaseModel, ConfigError, Extra, Field, NoneBytes, NoneStr, Required, ValidationError, constr
+from pydantic import (
+    BaseModel,
+    ConfigError,
+    Extra,
+    Field,
+    NoneBytes,
+    NoneStr,
+    Required,
+    ValidationError,
+    constr,
+    validator,
+)
 
 
 def test_success():
@@ -415,6 +426,27 @@ class Model(BaseModel):
     ]
 
 
+def test_const_with_validator():
+    class Model(BaseModel):
+        a: int = Field(3, const=True)
+
+        @validator('a')
+        def validate(v):
+            return v
+
+    with pytest.raises(ValidationError) as exc_info:
+        Model(a=4)
+
+    assert exc_info.value.errors() == [
+        {
+            'loc': ('a',),
+            'msg': 'unexpected value; permitted: 3',
+            'type': 'value_error.const',
+            'ctx': {'given': 4, 'permitted': [3]},
+        }
+    ]
+
+
 def test_const_list():
     class SubModel(BaseModel):
         b: int
Repository: pydantic/pydantic

Issue:
data.json file appears after `make docs`
# Step to reproduce

Follow the steps [here](https://pydantic-docs.helpmanual.io/contributing/).

When running `make docs`, a new file `data.json` appears at `/`. This should not appear there, or should already be committed there, or should be excluded by `.gitignore`.

For context, see [this comment](https://github.com/samuelcolvin/pydantic/pull/1987/files#r502764774).


Discussion:

Resolving patch:
diff --git a/docs/build/exec_examples.py b/docs/build/exec_examples.py
--- a/docs/build/exec_examples.py
+++ b/docs/build/exec_examples.py
@@ -207,6 +207,13 @@ def error(desc: str):
         else:
             lines = lines[ignore_above + 1 :]
 
+        try:
+            ignore_below = lines.index('# ignore-below')
+        except ValueError:
+            pass
+        else:
+            lines = lines[:ignore_below]
+
         lines = '\n'.join(lines).split('\n')
         if any(len(l) > MAX_LINE_LENGTH for l in lines):
             error(f'lines longer than {MAX_LINE_LENGTH} characters')
diff --git a/docs/examples/models_parse.py b/docs/examples/models_parse.py
--- a/docs/examples/models_parse.py
+++ b/docs/examples/models_parse.py
@@ -1,5 +1,7 @@
 import pickle
 from datetime import datetime
+from pathlib import Path
+
 from pydantic import BaseModel, ValidationError
 
 
@@ -31,8 +33,10 @@ class User(BaseModel):
 )
 print(m)
 
-path = 'data.json'
-with open(path, 'w') as f:
-    f.write('{"id": 123, "name": "James"}')
+path = Path('data.json')
+path.write_text('{"id": 123, "name": "James"}')
 m = User.parse_file(path)
 print(m)
+# ignore-below
+if path.exists():
+    path.unlink()


Test patch:
Repository: pydantic/pydantic

Issue:
validate_assignment with side effect validators 
# Bug

Output of `python -c "import pydantic.utils; print(pydantic.utils.version_info())"`:
```
             pydantic version: 1.7.2
            pydantic compiled: True
                 install path: /home/arthur/Documents/odmantic/.venv/lib/python3.8/site-packages/pydantic
               python version: 3.8.1 (default, Jan  5 2020, 23:12:00)  [GCC 7.3.0]
                     platform: Linux-4.17.14-041714-generic-x86_64-with-glibc2.27
     optional deps. installed: ['typing-extensions']
```

```py
from pydantic import root_validator, BaseModel

class Rectangle(BaseModel):
    width: float
    height: float
    area: float = None

    class Config:
        validate_assignment = True

    @root_validator()
    def set_ts_now(cls, v):
        v["area"] = v["width"] * v["height"]
        return v

r = Rectangle(width=1, height=1)
assert r.area == 1
r.height = 5
assert r.area == 5 # AssertionError, r.area has not been modified
```
I don't know if it should be allowed to use validators this way or if it's a real bug.
I'd be happy to try to implement a fix :smile: 


Discussion:
Hi @art049 
Yes you're right. Since #1971 has been solved, this is the expected behaviour but it seems we update only the current field and not all. I can make a quick fix if you want should take couple of minutes

Resolving patch:
diff --git a/pydantic/main.py b/pydantic/main.py
--- a/pydantic/main.py
+++ b/pydantic/main.py
@@ -406,7 +406,12 @@ def __setattr__(self, name, value):  # noqa: C901 (ignore complexity)
             if errors:
                 raise ValidationError(errors, self.__class__)
 
-        self.__dict__[name] = value
+            # update the whole __dict__ as other values than just `value`
+            # may be changed (e.g. with `root_validator`)
+            object_setattr(self, '__dict__', new_values)
+        else:
+            self.__dict__[name] = value
+
         self.__fields_set__.add(name)
 
     def __getstate__(self) -> 'DictAny':


Test patch:
diff --git a/tests/test_main.py b/tests/test_main.py
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -666,6 +666,28 @@ def current_lessequal_500(cls, values):
     ]
 
 
+def test_root_validator_many_values_change():
+    """It should run root_validator on assignment and update ALL concerned fields"""
+
+    class Rectangle(BaseModel):
+        width: float
+        height: float
+        area: float = None
+
+        class Config:
+            validate_assignment = True
+
+        @root_validator
+        def set_area(cls, values):
+            values['area'] = values['width'] * values['height']
+            return values
+
+    r = Rectangle(width=1, height=1)
+    assert r.area == 1
+    r.height = 5
+    assert r.area == 5
+
+
 def test_enum_values():
     FooEnum = Enum('FooEnum', {'foo': 'foo', 'bar': 'bar'})
Repository: pydantic/pydantic

Issue:
BaseModel.copy(update=…) does not update __fields_set__
### Checks

* [x] I added a descriptive title to this issue
* [x] I have searched (google, github) for similar issues and couldn't find anything
* [x] I have read and followed [the docs](https://pydantic-docs.helpmanual.io/) and still think this is a bug

# Bug

Output of `python -c "import pydantic.utils; print(pydantic.utils.version_info())"`:
```
             pydantic version: 1.7.2
            pydantic compiled: False
                 install path: /usr/local/lib/python3.6/dist-packages/pydantic
               python version: 3.6.9 (default, Oct  8 2020, 12:12:24)  [GCC 8.4.0]
                     platform: Linux-4.15.0-112-generic-x86_64-with-Ubuntu-18.04-bionic
     optional deps. installed: ['typing-extensions', 'email-validator']
```

```py
from typing import Optional
import pydantic

class Foo(pydantic.BaseModel):
    foo: Optional[str]
    bar: Optional[str]

print(Foo(foo='hello')
      .copy(update={'bar': 'world'})
      .json(exclude_unset=True))
# Observed: {"foo": "hello"}
# Expected: {"foo": "hello", "bar": "world"}
```


Discussion:

Resolving patch:
diff --git a/pydantic/main.py b/pydantic/main.py
--- a/pydantic/main.py
+++ b/pydantic/main.py
@@ -627,7 +627,12 @@ def copy(
         cls = self.__class__
         m = cls.__new__(cls)
         object_setattr(m, '__dict__', v)
-        object_setattr(m, '__fields_set__', self.__fields_set__.copy())
+        # new `__fields_set__` can have unset optional fields with a set value in `update` kwarg
+        if update:
+            fields_set = self.__fields_set__ | update.keys()
+        else:
+            fields_set = set(self.__fields_set__)
+        object_setattr(m, '__fields_set__', fields_set)
         for name in self.__private_attributes__:
             value = getattr(self, name, Undefined)
             if value is not Undefined:


Test patch:
diff --git a/tests/test_construction.py b/tests/test_construction.py
--- a/tests/test_construction.py
+++ b/tests/test_construction.py
@@ -1,5 +1,5 @@
 import pickle
-from typing import Any, List
+from typing import Any, List, Optional
 
 import pytest
 
@@ -191,6 +191,14 @@ def test_copy_update():
     assert m != m2
 
 
+def test_copy_update_unset():
+    class Foo(BaseModel):
+        foo: Optional[str]
+        bar: Optional[str]
+
+    assert Foo(foo='hello').copy(update={'bar': 'world'}).json(exclude_unset=True) == '{"foo": "hello", "bar": "world"}'
+
+
 def test_copy_set_fields():
     m = ModelTwo(a=24, d=Model(a='12'))
     m2 = m.copy()
Repository: pydantic/pydantic

Issue:
Document GetterDict for ORM mode properly properly
As per #1726 and #1689 we need to document `GetterDict` and how to use it properly.



Discussion:
Docs also say GetterDict can be modified, but how is that the case? Any attempt just raises.

Resolving patch:
diff --git a/docs/examples/models_orm_mode_data_binding.py b/docs/examples/models_orm_mode_data_binding.py
new file mode 100644
--- /dev/null
+++ b/docs/examples/models_orm_mode_data_binding.py
@@ -0,0 +1,43 @@
+from pydantic import BaseModel
+from typing import Any, Optional
+from pydantic.utils import GetterDict
+from xml.etree.ElementTree import fromstring
+
+
+xmlstring = """
+<User Id="2138">
+    <FirstName />
+    <LoggedIn Value="true" />
+</User>
+"""
+
+
+class UserGetter(GetterDict):
+
+    def get(self, key: str, default: Any) -> Any:
+
+        # element attributes
+        if key in {'Id', 'Status'}:
+            return self._obj.attrib.get(key, default)
+
+        # element children
+        else:
+            try:
+                return self._obj.find(key).attrib['Value']
+            except (AttributeError, KeyError):
+                return default
+
+
+class User(BaseModel):
+    Id: int
+    Status: Optional[str]
+    FirstName: Optional[str]
+    LastName: Optional[str]
+    LoggedIn: bool
+
+    class Config:
+        orm_mode = True
+        getter_dict = UserGetter
+
+
+user = User.from_orm(fromstring(xmlstring))


Test patch:
Repository: pydantic/pydantic

Issue:
when extra is allowed, representation is break
### Checks

* [x] I added a descriptive title to this issue
* [x] I have searched (google, github) for similar issues and couldn't find anything
* [x] I have read and followed [the docs](https://pydantic-docs.helpmanual.io/) and still think this is a bug

<!-- Sorry to sound so draconian, but every second saved replying to issues is time spend improving pydantic :-) -->

# Bug

Output of `python -c "import pydantic.utils; print(pydantic.utils.version_info())"`:
```
python -c "import pydantic.utils; print(pydantic.utils.version_info())"
             pydantic version: 1.8.2
            pydantic compiled: False
                 install path: /Users/Sol/Project/pydantic/pydantic
               python version: 3.9.5 (default, Jun 23 2021, 22:47:04)  [Clang 11.0.3 (clang-1103.0.32.62)]
                     platform: macOS-10.15.6-x86_64-i386-64bit
     optional deps. installed: ['devtools', 'dotenv', 'email-validator', 'typing-extensions']
```
<!-- or if you're using pydantic prior to v1.3, manually include: OS, python version and pydantic version -->

<!-- Please read the [docs](https://pydantic-docs.helpmanual.io/) and search through issues to
confirm your bug hasn't already been reported. -->

<!-- Where possible please include a self-contained code snippet describing your bug: -->

```py
from pydantic import BaseModel
from pydantic import Extra



class Foo(BaseModel):
    a: int

    class Config:
        extra = Extra.allow


f = Foo(a=1, b=2)
breakpoint()
print(f) # << raise error. not only 'print', also str(Model), breakpoint().. etc

```

because

field b that allowed is not in Model.fields


in `main.BaseModel`

```
class BaseModel(Representation, metaclass=ModelMetaclass):

    ...

    def __repr_args__(self) -> 'ReprArgs':
        return [(k, v) for k, v in self.__dict__.items() if self.__fields__[k].field_info.repr] # KeyError
```





Discussion:

Resolving patch:
diff --git a/pydantic/main.py b/pydantic/main.py
--- a/pydantic/main.py
+++ b/pydantic/main.py
@@ -853,7 +853,9 @@ def __eq__(self, other: Any) -> bool:
             return self.dict() == other
 
     def __repr_args__(self) -> 'ReprArgs':
-        return [(k, v) for k, v in self.__dict__.items() if self.__fields__[k].field_info.repr]
+        return [
+            (k, v) for k, v in self.__dict__.items() if k not in self.__fields__ or self.__fields__[k].field_info.repr
+        ]
 
 
 _is_base_model_class_defined = True


Test patch:
diff --git a/tests/test_main.py b/tests/test_main.py
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -194,6 +194,16 @@ class Config:
     assert Model(a='10.2', b=12).dict() == {'a': 10.2, 'b': 12}
 
 
+def test_allow_extra_repr():
+    class Model(BaseModel):
+        a: float = ...
+
+        class Config:
+            extra = Extra.allow
+
+    assert str(Model(a='10.2', b=12)) == 'a=10.2 b=12'
+
+
 def test_forbidden_extra_success():
     class ForbiddenExtra(BaseModel):
         foo = 'whatever'
Repository: pydantic/pydantic

Issue:
Color comparison is always false
# Bug

Output of `python -c "import pydantic.utils; print(pydantic.utils.version_info())"`:
```
             pydantic version: 1.9.0
            pydantic compiled: True
                 install path: /home/xxxxxxx/xxxxxxx/xxxxxxx/venv310/lib/python3.10/site-packages/pydantic
               python version: 3.10.1 (main, Dec 21 2021, 17:46:38) [GCC 9.3.0]
                     platform: Linux-5.11.0-44-generic-x86_64-with-glibc2.31
     optional deps. installed: ['dotenv', 'typing-extensions']

```
<!-- or if you're using pydantic prior to v1.3, manually include: OS, python version and pydantic version -->

<!-- Please read the [docs](https://pydantic-docs.helpmanual.io/) and search through issues to
confirm your bug hasn't already been reported. -->

<!-- Where possible please include a self-contained code snippet describing your bug: -->
How to reproduce:

```py
>>> from pydantic.color import Color
>>> Color("red") == Color("red")
False
```
As a consequence, when using Color fields, the comparison of equal models is always false.


Discussion:
This is not a bug. It's a feature request.

We don't currently implement special equals methods.

PR welcome. 

Resolving patch:
diff --git a/pydantic/color.py b/pydantic/color.py
--- a/pydantic/color.py
+++ b/pydantic/color.py
@@ -198,6 +198,9 @@ def __str__(self) -> str:
     def __repr_args__(self) -> 'ReprArgs':
         return [(None, self.as_named(fallback=True))] + [('rgb', self.as_rgb_tuple())]  # type: ignore
 
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, Color) and self.as_rgb_tuple() == other.as_rgb_tuple()
+
 
 def parse_tuple(value: Tuple[Any, ...]) -> RGBA:
     """


Test patch:
diff --git a/tests/test_color.py b/tests/test_color.py
--- a/tests/test_color.py
+++ b/tests/test_color.py
@@ -184,3 +184,12 @@ def test_str_repr():
     assert repr(Color('red')) == "Color('red', rgb=(255, 0, 0))"
     assert str(Color((1, 2, 3))) == '#010203'
     assert repr(Color((1, 2, 3))) == "Color('#010203', rgb=(1, 2, 3))"
+
+
+def test_eq():
+    assert Color('red') == Color('red')
+    assert Color('red') != Color('blue')
+    assert Color('red') != 'red'
+
+    assert Color('red') == Color((255, 0, 0))
+    assert Color('red') != Color((0, 0, 255))
Repository: pydantic/pydantic

Issue:
subclasses of bytes converted to bytes
See https://github.com/duo-labs/py_webauthn/issues/113#issuecomment-1017816575

In short (I think) cython is converting subclasses of bytes to raw bytes in here:

https://github.com/samuelcolvin/pydantic/blob/9d631a3429a66f30742c1a52c94ac18ec6ba848d/pydantic/validators.py#L79

Fix should be as simple as changing the type hint.


Discussion:

Resolving patch:
diff --git a/pydantic/validators.py b/pydantic/validators.py
--- a/pydantic/validators.py
+++ b/pydantic/validators.py
@@ -76,7 +76,7 @@ def strict_str_validator(v: Any) -> Union[str]:
     raise errors.StrError()
 
 
-def bytes_validator(v: Any) -> bytes:
+def bytes_validator(v: Any) -> Union[bytes]:
     if isinstance(v, bytes):
         return v
     elif isinstance(v, bytearray):


Test patch:
diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
--- a/tests/test_edge_cases.py
+++ b/tests/test_edge_cases.py
@@ -1906,3 +1906,29 @@ class Config:
             arbitrary_types_allowed = True
 
     assert Model().x == Foo()
+
+
+def test_bytes_subclass():
+    class MyModel(BaseModel):
+        my_bytes: bytes
+
+    class BytesSubclass(bytes):
+        def __new__(cls, data: bytes):
+            self = bytes.__new__(cls, data)
+            return self
+
+    m = MyModel(my_bytes=BytesSubclass(b'foobar'))
+    assert m.my_bytes.__class__ == BytesSubclass
+
+
+def test_int_subclass():
+    class MyModel(BaseModel):
+        my_int: int
+
+    class IntSubclass(int):
+        def __new__(cls, data: int):
+            self = int.__new__(cls, data)
+            return self
+
+    m = MyModel(my_int=IntSubclass(123))
+    assert m.my_int.__class__ == IntSubclass
Repository: pydantic/pydantic

Issue:
create_model not support generics model
### Checks

* [x] I added a descriptive title to this issue
* [x] I have searched (google, github) for similar issues and couldn't find anything
* [x] I have read and followed [the docs](https://pydantic-docs.helpmanual.io/) and still think this is a bug

# Bug

```
from typing import Generic, TypeVar

from pydantic import Field, create_model
from pydantic.generics import GenericModel

T = TypeVar("T")


class TestGenericModel(GenericModel):
    pass


AAModel = create_model("AAModel", __base__=(TestGenericModel, Generic[T]), aa=(int, Field(0)))

AAModel[int](aa=1)
```

output
```py
Traceback (most recent call last):
  File "test.py", line 13, in <module>
    AAModel = create_model("AAModel", __base__=(TestGenericModel, Generic[T]), aa=(int, Field(0)))
  File "pydantic/main.py", line 972, in pydantic.main.create_model
TypeError: type() doesn't support MRO entry resolution; use types.new_class()
```



Discussion:

Resolving patch:
diff --git a/pydantic/main.py b/pydantic/main.py
--- a/pydantic/main.py
+++ b/pydantic/main.py
@@ -4,7 +4,7 @@
 from enum import Enum
 from functools import partial
 from pathlib import Path
-from types import FunctionType
+from types import FunctionType, prepare_class, resolve_bases
 from typing import (
     TYPE_CHECKING,
     AbstractSet,
@@ -996,8 +996,12 @@ def create_model(
     namespace.update(fields)
     if __config__:
         namespace['Config'] = inherit_config(__config__, BaseConfig)
-
-    return type(__model_name, __base__, namespace, **__cls_kwargs__)
+    resolved_bases = resolve_bases(__base__)
+    meta, ns, kwds = prepare_class(__model_name, resolved_bases, kwds=__cls_kwargs__)
+    if resolved_bases is not __base__:
+        ns['__orig_bases__'] = __base__
+    namespace.update(ns)
+    return meta(__model_name, resolved_bases, namespace, **kwds)
 
 
 _missing = object()


Test patch:
diff --git a/tests/test_create_model.py b/tests/test_create_model.py
--- a/tests/test_create_model.py
+++ b/tests/test_create_model.py
@@ -1,6 +1,9 @@
+from typing import Generic, TypeVar
+
 import pytest
 
 from pydantic import BaseModel, Extra, Field, ValidationError, create_model, errors, validator
+from pydantic.generics import GenericModel
 
 
 def test_create_model():
@@ -205,3 +208,17 @@ class Config:
 
     m2 = create_model('M2', __config__=Config, a=(str, Field(...)))
     assert m2.schema()['properties'] == {'a': {'title': 'A', 'description': 'descr', 'type': 'string'}}
+
+
+def test_generics_model():
+    T = TypeVar('T')
+
+    class TestGenericModel(GenericModel):
+        pass
+
+    AAModel = create_model(
+        'AAModel', __base__=(TestGenericModel, Generic[T]), __cls_kwargs__={'orm_mode': True}, aa=(int, Field(0))
+    )
+    result = AAModel[int](aa=1)
+    assert result.aa == 1
+    assert result.__config__.orm_mode is True
Repository: pydantic/pydantic

Issue:
Validation decorator docs depend on system files in `/etc`
### Checks

* [x] I added a descriptive title to this issue
* [x] I have searched (google, github) for similar issues and couldn't find anything
* [x] I have read and followed [the docs](https://pydantic-docs.helpmanual.io/) and still think this is a bug

<!-- Sorry to sound so draconian, but every second saved replying to issues is time spend improving pydantic :-) -->

# Bug

The [validation decorator docs](https://github.com/samuelcolvin/pydantic/blob/master/docs/usage/validation_decorator.md?plain=1#L27) depend on [system installed files](https://github.com/samuelcolvin/pydantic/blob/master/docs/examples/validation_decorator_types.py#L16-L17), which may not be accessible when building from source:
```
> make docs
python docs/build/main.py
error in validation_decorator_types.py: Traceback (most recent call last):
PermissionError: [Errno 1] Operation not permitted: '/etc/'
1 errors, not writing files
```


Discussion:
Fair point, PR welcome to use a relative path that does exist.

Resolving patch:
diff --git a/docs/examples/validation_decorator_types.py b/docs/examples/validation_decorator_types.py
--- a/docs/examples/validation_decorator_types.py
+++ b/docs/examples/validation_decorator_types.py
@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import Pattern, Optional
 
@@ -13,5 +14,8 @@ def find_file(path: DirectoryPath, regex: Pattern, max=None) -> Optional[Path]:
             return f
 
 
-print(find_file('/etc/', '^sys.*'))
-print(find_file('/etc/', '^foobar.*', max=3))
+# note: this_dir is a string here
+this_dir = os.path.dirname(__file__)
+
+print(find_file(this_dir, '^validation.*'))
+print(find_file(this_dir, '^foobar.*', max=3))


Test patch:
Repository: pydantic/pydantic

Issue:
V1.10 release
To do/decide:
* [x] #2557 - **merged**
* [x] #2745 - needs some tweaks, but we need to decide if it's a good idea before V2
* [x] #2190 - **deferred**
* [x] cherry pick stuff from v1.9 branch, maybe just history #4350
* [x] #3346
* [x] #3593 -  **deferred**
* [x] #3946
* [x] #4028 - **API will change in v2**
* [x] #4354
* [x] #4216
* [x] #4191
* [x] #3941 - revert or fix
* [x] #4339
* [x] #4356


Discussion:
Ideally I'd like to get a pre-release of V1.10 out early next week.

If you have a change you'd like to be included in V1.10, please make sure your PRs are ready to merge and use the magic comment "please review" to assign us.
#4356 is ready to go i think
#4165 is ready to go i think
#3674 would be amazing 🙏
> #3674 would be amazing pray

this is already merged, so will be included.
so are #4165 and #4356.

Resolving patch:
diff --git a/pydantic/version.py b/pydantic/version.py
--- a/pydantic/version.py
+++ b/pydantic/version.py
@@ -1,6 +1,6 @@
 __all__ = 'compiled', 'VERSION', 'version_info'
 
-VERSION = '1.9.2'
+VERSION = '1.10.0a1'
 
 try:
     import cython  # type: ignore


Test patch: