# In string concatenation, support for f-strings' inline concatenation method
# Finally we can concatenate strings as conveniently as JS
name = "ackerr"
precision = 2
height = 183.2
assert f"{name} is {height:0.{precision}f}cm tall." == "ackerr is 183.20cm tall."

# In constant definitions, you can use underscores to improve readability
number = 3_735_928_559
magic = 0xDEAD_BEEF
assert number == magic

# In variable definitions, type annotations are supported
# Worth noting that Python is still not strongly typed, just written in this __annotations__ variable
import typing
numbers: typing.List[int] = [1,1,4,5,1,4]
complex_data: typing.Dict[int, typing.Set[int]] = {}
assert "complex_data" in __annotations__

# Added enum.auto function, developers no longer have to bother with auto-increment
import enum
class Colors(enum.Enum):
    R = enum.auto()
    G = enum.auto()
    B = enum.auto()

assert Colors.B.value == 3

# The type system supports lazy evaluation, no need to use a string to refer to yourself anymore
from __future__ import annotations
class QuerySet:
    def filter(self, **params) -> QuerySet:
        """some database filter"""


# Added the dataclass standard package
# Compared to dict argument passing, greatly improves readability
import dataclasses as dc
@dc.dataclass
class Person:
    name: str
    age: int
    gender: str = 'Unknown'

assert Person('me', '24').gender == 'Unknown'

# Added assignment-judgment syntax (also vividly called the walrus operator)
import re
if match := re.search(r"(\d+)%", "Total coverage: 80%"):
    print("Coverage is {match.group(1)}")

# Functions support using `/` to restrict non-keyword arguments
def calculate_data_length(data, /):
    pass

# Officially noted that in this case `calculate_data_length(data=data)` is clearly less readable, you can ban it when defining the function
# Plus this syntax avoids `**kwargs` argument-passing conflicts
def get_values(data, /, **kwargs):
    print(data, kwargs)

get_values({}, data='some_data')

# f-strings support self-explanatory syntax
name = "ackerr"
assert f"Debug: {name=}" == "Debug: name='ackerr'"

# Added `functools.cached_property` method, supports property caching
import functools
class DB:
    @functools.cached_property
    def connection(self):
        print(1)

db = DB()
assert db.connection == None
assert db.connection == None

# dict supports the union operator `|`
x = {"a": 1, "b": 2}
y = {"b": 3, "c": 4}
assert x | y == {"a": 1, "b": 3, "c": 4}
assert y | x == {"a": 1, "b": 2, "c": 4}

# Support for native types like `list`/`dict`/`set` as type annotations
def occurance(names: list[str]) -> dict[str, int]:
    return {name: names.count(name) for name in names}

# Added match+case syntax similar to switch+case
def check(status_code: int, message: str):
    match status_code:
        case 200 if message:
            return message
        case 200:
            return "ok"
        case 400:
            return "bad request"
        case 500 | 502 | 503:
            return "something wrong"
        case _:
            return "not implemented"

# `typing.Union` can be written more elegantly as `|`
def add_all(*numbers: int | float) -> int | float:
    return sum(numbers)

assert isinstance(42, int | float)

# `dataclass` supports keyword-only mode
import dataclasses as dc
@dc.dataclass(kw_only=True)
class Person:
    name: str
    age: int
    gender: str = 'Unknown'