diff --git a/.github/workflows/ci-core.yml b/.github/workflows/ci-core.yml index a77c106224..2d2910ad35 100644 --- a/.github/workflows/ci-core.yml +++ b/.github/workflows/ci-core.yml @@ -23,7 +23,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" diff --git a/.github/workflows/ci-lockfile.yml b/.github/workflows/ci-lockfile.yml index 9a17891c9d..0ce7c29b3f 100644 --- a/.github/workflows/ci-lockfile.yml +++ b/.github/workflows/ci-lockfile.yml @@ -23,7 +23,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" @@ -35,4 +35,4 @@ jobs: run: | # Install all default extras. # Fail if the lockfile dependencies are out of date with pyproject.toml. - XDSL_VERSION_OVERRIDE="0+dynamic" uv sync --extra gui --extra dev --extra jax --extra riscv --locked + uv sync --extra gui --extra dev --extra jax --extra riscv --locked diff --git a/.github/workflows/ci-notebooks.yml b/.github/workflows/ci-notebooks.yml index 315ecaab2d..772dbb5641 100644 --- a/.github/workflows/ci-notebooks.yml +++ b/.github/workflows/ci-notebooks.yml @@ -23,7 +23,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" diff --git a/.github/workflows/ci-pyright-fails.yml b/.github/workflows/ci-pyright-fails.yml index 242ef950bb..ac40df4cfc 100644 --- a/.github/workflows/ci-pyright-fails.yml +++ b/.github/workflows/ci-pyright-fails.yml @@ -25,7 +25,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" diff --git a/.github/workflows/code-formatting.yml b/.github/workflows/code-formatting.yml index b078349aef..a3ffe2fd54 100644 --- a/.github/workflows/code-formatting.yml +++ b/.github/workflows/code-formatting.yml @@ -22,7 +22,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" diff --git a/.github/workflows/jupyterlite.yml b/.github/workflows/jupyterlite.yml index 06639560a9..99a89eaf5b 100644 --- a/.github/workflows/jupyterlite.yml +++ b/.github/workflows/jupyterlite.yml @@ -15,7 +15,7 @@ jobs: path: xdsl - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 - name: Set up Python run: uv python install 3.11 diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index bdf6cd9ce6..5a42a071b1 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -11,7 +11,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 - name: Set up Python run: uv python install 3.11 diff --git a/.github/workflows/remake-lockfile.yml b/.github/workflows/remake-lockfile.yml index 3795e06a34..1e349f66b4 100644 --- a/.github/workflows/remake-lockfile.yml +++ b/.github/workflows/remake-lockfile.yml @@ -16,7 +16,7 @@ jobs: steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v3 + - uses: astral-sh/setup-uv@v5 - run: | rm uv.lock diff --git a/.github/workflows/update-lockfile-bot.yml b/.github/workflows/update-lockfile-bot.yml index 22dfee2748..5331a86681 100644 --- a/.github/workflows/update-lockfile-bot.yml +++ b/.github/workflows/update-lockfile-bot.yml @@ -17,7 +17,7 @@ jobs: - uses: actions/checkout@v4 - name: Install uv - uses: astral-sh/setup-uv@v3 + uses: astral-sh/setup-uv@v5 with: enable-cache: true cache-dependency-glob: "uv.lock" @@ -28,7 +28,7 @@ jobs: - name: Install the package locally and update lockfile run: | # Install all default extras. - XDSL_VERSION_OVERRIDE="0+dynamic" make venv + make venv - uses: EndBug/add-and-commit@v9 with: diff --git a/Makefile b/Makefile index 026a193278..d6106f268b 100644 --- a/Makefile +++ b/Makefile @@ -11,7 +11,7 @@ VENV_DIR ?= .venv export UV_PROJECT_ENVIRONMENT=$(if $(VIRTUAL_ENV),$(VIRTUAL_ENV),$(VENV_DIR)) # allow overriding which extras are installed -VENV_EXTRAS ?= --extra gui --extra dev --extra jax --extra riscv +VENV_EXTRAS ?= --extra gui --extra dev --extra jax --extra riscv --extra docs # default lit options LIT_OPTIONS ?= -v --order=smart @@ -28,7 +28,7 @@ uv-installed: # set up the venv with all dependencies for development .PHONY: ${VENV_DIR}/ ${VENV_DIR}/: uv-installed - XDSL_VERSION_OVERRIDE="0+dynamic" uv sync ${VENV_EXTRAS} + uv sync ${VENV_EXTRAS} @if [ ! -z "$(XDSL_MLIR_OPT_PATH)" ]; then \ ln -sf $(XDSL_MLIR_OPT_PATH) ${VENV_DIR}/bin/mlir-opt; \ fi @@ -163,3 +163,13 @@ coverage-report: uv-installed .PHONY: coverage-clean coverage-clean: uv-installed uv run coverage erase + +# docs + +.PHONY: docs-serve +docs-serve: uv-installed + uv run mkdocs serve + +.PHONY: docs-build +docs-build: uv-installed + uv run mkdocs build diff --git a/docs/api/index.md b/docs/api/index.md new file mode 100644 index 0000000000..ab70f677ac --- /dev/null +++ b/docs/api/index.md @@ -0,0 +1,5 @@ +# Api Reference + +| Module | Name | +|----------------------|--------------------------| +| [`ir`](ir/index.md) | IR Data Structures | diff --git a/docs/api/ir/attribute.md b/docs/api/ir/attribute.md new file mode 100644 index 0000000000..31ee4ac9ad --- /dev/null +++ b/docs/api/ir/attribute.md @@ -0,0 +1,38 @@ +# Attribute + +## ::: xdsl.ir.Attribute + + options: + members: + - name + - verify + show_root_heading: true + +## ::: xdsl.ir.Data + + options: + members: + - data + - print_parameter + - parse_parameter + show_root_heading: true + +## ::: xdsl.ir.ParametrizedAttribute + + options: + members: + - parameters + - print_parameters + - parse_parameters + - get_irdl_definition + show_root_heading: true + +## ::: xdsl.ir.TypedAttribute + + options: + members: + - parameters + - print_parameters + - parse_parameters + - get_irdl_definition + show_root_heading: true diff --git a/docs/api/ir/block.md b/docs/api/ir/block.md new file mode 100644 index 0000000000..e69de29bb2 diff --git a/docs/api/ir/dialect.md b/docs/api/ir/dialect.md new file mode 100644 index 0000000000..2d21e1bd59 --- /dev/null +++ b/docs/api/ir/dialect.md @@ -0,0 +1,8 @@ + +# ::: xdsl.ir.Dialect + + options: + members: + - attributes + - operations + show_root_heading: true diff --git a/docs/api/ir/index.md b/docs/api/ir/index.md new file mode 100644 index 0000000000..8a78bdbfe9 --- /dev/null +++ b/docs/api/ir/index.md @@ -0,0 +1,34 @@ +# IR Data Structures + +## [Attribute](attribute.md) + +Attributes represent compile-time information in xDSL. +All attributes are immutable, equatable, and hashable. + +## [SSAValue](ssa_value.md) + +Run-time information is represented as SSAValue. +SSA stands for [static single-assignment](https://en.wikipedia.org/wiki/Static_single-assignment_form), meaning that each value is only ever assigned once, and never reassigned. +This property is useful when performing transformations such as dead-code elimination, constant folding, and other compiler transformations. + +## [IRNode](ir_node.md) + +Code is represented as a recursive data structure, where [operations](operation.md) contain a doubly-linked list of [regions](region.md), which contain a doubly linked list of [blocks](block.md), which contain operations. + +## [Operation](operation.md) + +Operations are rich objects that carry some meaning in their IR. +They can be used to represent integer addition (`arith.addi`), a module of code (`builtin.module`), a function declaration or definition (`func.func`), and many more. + +## [Block](block.md) + +Blocks are a list of operations. +They have a (possibly empty) list of operands, that can be used to model function arguments for use in the function body, or loop arguments. + +## [Region](region.md) + +Regions are a list of blocks. + +## [Dialect](dialect.md) + +A dialect is a grouping of [attributes](attribute.md) and [operations](operation.md). diff --git a/docs/api/ir/ir_node.md b/docs/api/ir/ir_node.md new file mode 100644 index 0000000000..388c3bbcec --- /dev/null +++ b/docs/api/ir/ir_node.md @@ -0,0 +1,6 @@ +# IRNode + +## ::: xdsl.ir.IRNode + + options: + show_root_heading: true diff --git a/docs/api/ir/operation.md b/docs/api/ir/operation.md new file mode 100644 index 0000000000..38bee668de --- /dev/null +++ b/docs/api/ir/operation.md @@ -0,0 +1,28 @@ +# Operation + +## ::: xdsl.ir.Operation + + options: + members: + - name + - operands + - results + - successors + - properties + - attributes + - regions + - parent + - next_op + - prev_op + - traits + show_root_heading: true + +## ::: xdsl.ir.OpOperands + + options: + show_root_heading: true + +## ::: xdsl.ir.OpTraits + + options: + show_root_heading: true diff --git a/docs/api/ir/region.md b/docs/api/ir/region.md new file mode 100644 index 0000000000..e69de29bb2 diff --git a/docs/api/ir/ssa_value.md b/docs/api/ir/ssa_value.md new file mode 100644 index 0000000000..9ea5298811 --- /dev/null +++ b/docs/api/ir/ssa_value.md @@ -0,0 +1,12 @@ + +# SSAValue + +## ::: xdsl.ir.SSAValue + + options: + show_root_heading: true + +## ::: xdsl.ir.Use + + options: + show_root_heading: true diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000000..57a92d9fb4 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,5 @@ +# xDSL + +[xDSL](https://xdsl.dev/) is a compiler framework designed to be approachable, productive, and fun to use. + +[API Reference](api/index.md) diff --git a/flake.lock b/flake.lock index 0ecbc95bb0..3064cabe04 100644 --- a/flake.lock +++ b/flake.lock @@ -20,11 +20,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1732238832, - "narHash": "sha256-sQxuJm8rHY20xq6Ah+GwIUkF95tWjGRd1X8xF+Pkk38=", + "lastModified": 1737264083, + "narHash": "sha256-6QqSrHPN+ZD+7HuadVLuFNUaM8XnmZF3EO7QViM1b80=", "owner": "nixos", "repo": "nixpkgs", - "rev": "8edf06bea5bcbee082df1b7369ff973b91618b8d", + "rev": "aa6ae0afa6adeb5c202a168e51eda1d3da571117", "type": "github" }, "original": { diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000000..b2a6c1aed3 --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,15 @@ +site_name: xDSL + +theme: + name: "material" + +plugins: +- search +- mkdocstrings + + +# nav: +# - xDSL: index.md +# - API Reference: +# - API Reference: api/index.md +# - Core IR Data Structures: api/ir/index.md diff --git a/pyproject.toml b/pyproject.toml index 0384b532ec..91003c44d5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,17 +24,22 @@ dev = [ "nbval<0.12", "filecheck==1.0.1", "lit<19.0.0", - "marimo==0.10.12", + "marimo==0.10.14", "pre-commit==4.0.1", - "ruff==0.9.1", + "ruff==0.9.2", "asv<0.7", "nbconvert>=7.7.2,<8.0.0", "textual-dev==1.7.0", "pytest-asyncio==0.25.2", - "pyright==1.1.391", + "pyright==1.1.392.post0", +] +docs = [ + "mkdocs>=1.6.1", + "mkdocs-material>=9.5.49", + "mkdocstrings[python]>=0.27.0", ] gui = ["textual==1.0.0", "pyclip==0.7"] -jax = ["jax==0.4.38", "numpy==2.2.1"] +jax = ["jax==0.5.0", "numpy==2.2.2"] riscv = ["riscemu==2.2.7"] [project.urls] diff --git a/setup.py b/setup.py index 41cc20d3e1..92b8cfb0f5 100644 --- a/setup.py +++ b/setup.py @@ -1,4 +1,3 @@ -import os from collections.abc import Mapping from typing import cast @@ -6,10 +5,7 @@ import versioneer -if "XDSL_VERSION_OVERRIDE" in os.environ: - version = os.environ["XDSL_VERSION_OVERRIDE"] -else: - version = versioneer.get_version() +version = versioneer.get_version() setup( diff --git a/tests/dialects/test_math.py b/tests/dialects/test_math.py index 78286e0b29..4ca92d9577 100644 --- a/tests/dialects/test_math.py +++ b/tests/dialects/test_math.py @@ -1,5 +1,3 @@ -from typing import TypeVar - import pytest from xdsl.dialects.arith import ConstantOp, FloatingPointLikeBinaryOperation @@ -10,7 +8,7 @@ f32, i32, ) -from xdsl.dialects.experimental.math import ( +from xdsl.dialects.math import ( AbsFOp, AbsIOp, Atan2Op, @@ -45,12 +43,9 @@ TruncOp, ) from xdsl.dialects.test import TestOp -from xdsl.ir import Attribute from xdsl.utils.exceptions import VerifyException from xdsl.utils.test_value import TestSSAValue -_BinOpArgT = TypeVar("_BinOpArgT", bound=Attribute) - class Test_float_math_binary_construction: operand_type = f32 @@ -81,11 +76,9 @@ class Test_float_math_binary_construction: PowFOp, ], ) - @pytest.mark.parametrize("return_type", [None, operand_type]) def test_float_binary_ops_constant_math_init( self, OpClass: type[FloatingPointLikeBinaryOperation], - return_type: Attribute, ): op = OpClass(self.a, self.b) assert isinstance(op, OpClass) @@ -102,9 +95,9 @@ def test_float_binary_ops_constant_math_init( PowFOp, ], ) - @pytest.mark.parametrize("return_type", [None, f32_vector_type]) - def test_flaot_binary_vector_ops_init( - self, OpClass: type[FloatingPointLikeBinaryOperation], return_type: Attribute + def test_float_binary_vector_ops_init( + self, + OpClass: type[FloatingPointLikeBinaryOperation], ): op = OpClass(self.lhs_vector, self.rhs_vector) assert isinstance(op, OpClass) @@ -121,9 +114,9 @@ def test_flaot_binary_vector_ops_init( PowFOp, ], ) - @pytest.mark.parametrize("return_type", [None, f32_tensor_type]) def test_float_binary_ops_tensor_math_init( - self, OpClass: type[FloatingPointLikeBinaryOperation], return_type: Attribute + self, + OpClass: type[FloatingPointLikeBinaryOperation], ): op = OpClass(self.lhs_tensor, self.rhs_tensor) assert isinstance(op, OpClass) @@ -172,11 +165,9 @@ class Test_float_math_unary_constructions: TruncOp, ], ) - @pytest.mark.parametrize("return_type", [operand_type]) def test_float_math_constant_ops_init( self, OpClass: type, - return_type: Attribute, # FIXME ): op = OpClass(self.a) assert op.result.type == f32 @@ -211,8 +202,7 @@ def test_float_math_constant_ops_init( TruncOp, ], ) - @pytest.mark.parametrize("return_type", [f32_tensor_type]) - def test_float_math_ops_vector_init(self, OpClass: type, return_type: Attribute): + def test_float_math_ops_vector_init(self, OpClass: type): op = OpClass(self.test_vec) assert op.result.type == self.f32_vector_type assert op.operand.type == self.f32_vector_type @@ -246,8 +236,10 @@ def test_float_math_ops_vector_init(self, OpClass: type, return_type: Attribute) TruncOp, ], ) - @pytest.mark.parametrize("return_type", [f32_tensor_type]) - def test_float_math_ops_tensor_init(self, OpClass: type, return_type: Attribute): + def test_float_math_ops_tensor_init( + self, + OpClass: type, + ): op = OpClass(self.test_tensor) assert op.result.type == self.f32_tensor_type assert op.operand.type == self.f32_tensor_type @@ -351,11 +343,9 @@ class Test_int_math_unary_constructions: CtPopOp, ], ) - @pytest.mark.parametrize("return_type", [operand_type]) def test_int_math_ops_init( self, OpClass: type, - return_type: Attribute, # FIXME use something other than `type` ): op = OpClass(self.a) assert op.result.type == i32 @@ -372,11 +362,9 @@ def test_int_math_ops_init( CtPopOp, ], ) - @pytest.mark.parametrize("return_type", [i32_vector_type]) def test_int_math_ops_vec_init( self, OpClass: type, - return_type: Attribute, # FIXME use something other than `type` ): op = OpClass(self.test_vec) assert op.result.type == self.i32_vector_type @@ -393,11 +381,9 @@ def test_int_math_ops_vec_init( CtPopOp, ], ) - @pytest.mark.parametrize("return_type", [i32_vector_type]) def test_int_math_ops_tensor_init( self, OpClass: type, - return_type: Attribute, ): op = OpClass(self.test_tensor) assert op.result.type == self.i32_tensor_type @@ -420,8 +406,8 @@ class Test_Trunci: def test_trunci_incorrect_bitwidth(self): with pytest.raises(VerifyException): - _trunci_op = TruncOp(self.a).verify() + TruncOp(self.a).verify() with pytest.raises(VerifyException): - _trunci_op_vec = TruncOp(self.test_vec).verify() + TruncOp(self.test_vec).verify() with pytest.raises(VerifyException): - _trunci_op_tensor = TruncOp(self.test_tensor).verify() + TruncOp(self.test_tensor).verify() diff --git a/tests/filecheck/dialects/arm/test_ops.mlir b/tests/filecheck/dialects/arm/test_ops.mlir index 0f3f0a5e86..970ef5a3de 100644 --- a/tests/filecheck/dialects/arm/test_ops.mlir +++ b/tests/filecheck/dialects/arm/test_ops.mlir @@ -17,6 +17,16 @@ // CHECK-ASM: mul x3, x1, x2 # multiply s1 by s2 %dss_mul = arm.dss.mul %x1, %x2 {"comment" = "multiply s1 by s2"} : (!arm.reg, !arm.reg) -> !arm.reg +// CHECK-NEXT: arm.label "testlabel" {comment = "this is a label"} +// CHECK-ASM: testlabel: # this is a label +arm.label "testlabel" {comment = "this is a label"} + +// CHECK-NEXT: arm.cmp %x2, %x1 {comment = "compare values in x2 and x1"} +// CHECK-ASM: cmp x2, x1 # compare values in x2 and x1 +arm.cmp %x2, %x1 {comment = "compare values in x2 and x1"} : (!arm.reg, !arm.reg) + // CHECK-GENERIC: %x1 = "arm.get_register"() : () -> !arm.reg // CHECK-GENERIC: %ds_mov = "arm.ds.mov"(%x1) {comment = "move contents of s to d"} : (!arm.reg) -> !arm.reg // CHECK-GENERIC: %dss_mul = "arm.dss.mul"(%x1, %x2) {comment = "multiply s1 by s2"} : (!arm.reg, !arm.reg) -> !arm.reg +// CHECK-GENERIC: "arm.label"() <{label = "testlabel"}> {comment = "this is a label"} : () -> () +// CHECK-GENERIC: "arm.cmp"(%x2, %x1) {comment = "compare values in x2 and x1"} : (!arm.reg, !arm.reg) -> () diff --git a/tests/filecheck/dialects/linalg/linalg_ops.mlir b/tests/filecheck/dialects/linalg/linalg_ops.mlir index dd9a9d3485..95f24552bf 100644 --- a/tests/filecheck/dialects/linalg/linalg_ops.mlir +++ b/tests/filecheck/dialects/linalg/linalg_ops.mlir @@ -150,4 +150,4 @@ linalg.quantized_matmul ins(%5, %6, %7, %8 : tensor<64x9216xi8>, tensor<9216x409 // CHECK-GENERIC-NEXT: %45 = "arith.muli"(%42, %44) <{overflowFlags = #arith.overflow}> : (i32, i32) -> i32 // CHECK-GENERIC-NEXT: %46 = "arith.addi"(%40, %45) <{overflowFlags = #arith.overflow}> : (i32, i32) -> i32 // CHECK-GENERIC-NEXT: "linalg.yield"(%46) : (i32) -> () -// CHECK-GENERIC-NEXT: }) {linalg.memoized_indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> (d0, d1)>]} : (tensor<64x9216xi8>, tensor<9216x4096xi8>, i32, i32, tensor<64x4096xi32>) -> tensor<64x4096xi32> +// CHECK-GENERIC-NEXT: }) {linalg.memoized_indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> ()>, affine_map<(d0, d1, d2) -> ()>, affine_map<(d0, d1, d2) -> (d0, d1)>]} : (tensor<64x9216xi8>, tensor<9216x4096xi8>, i32, i32, tensor<64x4096xi32>) -> tensor<64x4096xi32> diff --git a/tests/pattern_rewriter/test_pattern_rewriter.py b/tests/pattern_rewriter/test_pattern_rewriter.py index 0cb0495585..0cca22bd38 100644 --- a/tests/pattern_rewriter/test_pattern_rewriter.py +++ b/tests/pattern_rewriter/test_pattern_rewriter.py @@ -33,7 +33,7 @@ attr_type_rewrite_pattern, op_type_rewrite_pattern, ) -from xdsl.rewriter import InsertPoint +from xdsl.rewriter import BlockInsertPoint, InsertPoint def rewrite_and_compare( @@ -1225,7 +1225,7 @@ def match_and_rewrite(self, op: test.TestOp, rewriter: PatternRewriter): if op.parent is None: return - rewriter.inline_region_before(op.regions[0], op.parent) + rewriter.inline_region(op.regions[0], BlockInsertPoint.before(op.parent)) rewriter.erase_matched_op() rewrite_and_compare( @@ -1272,7 +1272,7 @@ def match_and_rewrite(self, op: test.TestOp, rewriter: PatternRewriter): if op.parent is None: return - rewriter.inline_region_after(op.regions[0], op.parent) + rewriter.inline_region(op.regions[0], BlockInsertPoint.after(op.parent)) rewriter.erase_matched_op() rewrite_and_compare( @@ -1320,7 +1320,9 @@ def match_and_rewrite(self, op: test.TestOp, rewriter: PatternRewriter): if parent_region is None: return - rewriter.inline_region_at_start(op.regions[0], parent_region) + rewriter.inline_region( + op.regions[0], BlockInsertPoint.at_start(parent_region) + ) rewriter.erase_matched_op() rewrite_and_compare( @@ -1368,7 +1370,9 @@ def match_and_rewrite(self, op: test.TestOp, rewriter: PatternRewriter): if parent_region is None: return - rewriter.inline_region_at_end(op.regions[0], parent_region) + rewriter.inline_region( + op.regions[0], BlockInsertPoint.at_end(parent_region) + ) rewriter.erase_matched_op() rewrite_and_compare( diff --git a/tests/test_op_builder.py b/tests/test_op_builder.py index 95bd0761e1..69caea5eb8 100644 --- a/tests/test_op_builder.py +++ b/tests/test_op_builder.py @@ -5,7 +5,7 @@ from xdsl.dialects.builtin import IntAttr, i32, i64 from xdsl.dialects.scf import IfOp from xdsl.ir import Block, BlockArgument, Operation, Region -from xdsl.rewriter import InsertPoint +from xdsl.rewriter import BlockInsertPoint, InsertPoint def test_insertion_point_constructors(): @@ -24,6 +24,46 @@ def test_insertion_point_constructors(): assert InsertPoint.after(op2) == InsertPoint(target, None) +def test_block_insertion_point_constructors(): + target = Region( + [ + (block1 := Block()), + (block2 := Block()), + ] + ) + + assert BlockInsertPoint.at_start(target) == BlockInsertPoint(target, block1) + assert BlockInsertPoint.at_end(target) == BlockInsertPoint(target, None) + assert BlockInsertPoint.before(block1) == BlockInsertPoint(target, block1) + assert BlockInsertPoint.after(block1) == BlockInsertPoint(target, block2) + assert BlockInsertPoint.before(block2) == BlockInsertPoint(target, block2) + assert BlockInsertPoint.after(block2) == BlockInsertPoint(target, None) + + assert BlockInsertPoint.at_start(target) != BlockInsertPoint.at_end(target) + + +def test_block_insertion_init_incorrect(): + region = Region() + block = Block() + with pytest.raises( + ValueError, match="Insertion point must be in the builder's `region`" + ): + BlockInsertPoint(region, block) + + +def test_block_insertion_point_orphan(): + block = Block() + with pytest.raises( + ValueError, match="Block insertion point must have a parent region" + ): + BlockInsertPoint.before(block) + + with pytest.raises( + ValueError, match="Block insertion point must have a parent region" + ): + BlockInsertPoint.after(block) + + def test_builder(): target = Block( [ @@ -76,21 +116,21 @@ def test_builder_create_block(): target = Region([block1, block2]) builder = Builder(InsertPoint.at_start(block1)) - new_block1 = builder.create_block_at_start(target, (i32,)) + new_block1 = builder.create_block(BlockInsertPoint.at_start(target), (i32,)) assert len(new_block1.args) == 1 assert new_block1.args[0].type == i32 assert len(target.blocks) == 3 assert target.blocks[0] == new_block1 assert builder.insertion_point == InsertPoint.at_start(new_block1) - new_block2 = builder.create_block_at_end(target, (i64,)) + new_block2 = builder.create_block(BlockInsertPoint.at_end(target), (i64,)) assert len(new_block2.args) == 1 assert new_block2.args[0].type == i64 assert len(target.blocks) == 4 assert target.blocks[3] == new_block2 assert builder.insertion_point == InsertPoint.at_start(new_block2) - new_block3 = builder.create_block_before(block2, (i32, i64)) + new_block3 = builder.create_block(BlockInsertPoint.before(block2), (i32, i64)) assert len(new_block3.args) == 2 assert new_block3.args[0].type == i32 assert new_block3.args[1].type == i64 @@ -98,7 +138,7 @@ def test_builder_create_block(): assert target.blocks[2] == new_block3 assert builder.insertion_point == InsertPoint.at_start(new_block3) - new_block4 = builder.create_block_after(block2, (i64, i32)) + new_block4 = builder.create_block(BlockInsertPoint.after(block2), (i64, i32)) assert len(new_block4.args) == 2 assert new_block4.args[0].type == i64 assert new_block4.args[1].type == i32 @@ -142,10 +182,10 @@ def add_block_on_create(b: Block): b.block_creation_handler = [add_block_on_create] - b1 = b.create_block_at_start(region) - b2 = b.create_block_at_end(region) - b3 = b.create_block_before(block) - b4 = b.create_block_after(block) + b1 = b.create_block(BlockInsertPoint.at_start(region)) + b2 = b.create_block(BlockInsertPoint.at_end(region)) + b3 = b.create_block(BlockInsertPoint.before(block)) + b4 = b.create_block(BlockInsertPoint.after(block)) assert created_blocks == [b1, b2, b3, b4] diff --git a/tests/test_rewriter.py b/tests/test_rewriter.py index 38cca8a129..b4f6af7c4e 100644 --- a/tests/test_rewriter.py +++ b/tests/test_rewriter.py @@ -9,7 +9,7 @@ from xdsl.dialects.builtin import Builtin, Float32Type, Float64Type, ModuleOp, i32, i64 from xdsl.ir import Block, Region from xdsl.parser import Parser -from xdsl.rewriter import InsertPoint, Rewriter +from xdsl.rewriter import BlockInsertPoint, InsertPoint, Rewriter def rewrite_and_compare( @@ -289,7 +289,9 @@ def test_insert_block_before(): """ def insert_empty_block_before(module: ModuleOp, rewriter: Rewriter) -> None: - rewriter.insert_block_before(Block(), module.regions[0].blocks[0]) + rewriter.insert_block( + Block(), BlockInsertPoint.before(module.regions[0].blocks[0]) + ) rewrite_and_compare(prog, expected, insert_empty_block_before) @@ -312,7 +314,9 @@ def test_insert_block_after(): """ def insert_empty_block_after(module: ModuleOp, rewriter: Rewriter) -> None: - rewriter.insert_block_after(Block(), module.regions[0].blocks[0]) + rewriter.insert_block( + Block(), BlockInsertPoint.after(module.regions[0].blocks[0]) + ) rewrite_and_compare(prog, expected, insert_empty_block_after) @@ -510,7 +514,7 @@ def transformation(module: ModuleOp, rewriter: Rewriter) -> None: Block((test.TestOp(result_types=(Float64Type(),)),)), ) ) - rewriter.inline_region_before(region, module.body.blocks[1]) + rewriter.inline_region(region, BlockInsertPoint.before(module.body.blocks[1])) rewrite_and_compare(prog, expected, transformation) @@ -544,7 +548,7 @@ def transformation(module: ModuleOp, rewriter: Rewriter) -> None: Block((test.TestOp(result_types=(Float64Type(),)),)), ) ) - rewriter.inline_region_after(region, module.body.blocks[0]) + rewriter.inline_region(region, BlockInsertPoint.after(module.body.blocks[0])) rewrite_and_compare(prog, expected, transformation) @@ -578,7 +582,7 @@ def transformation(module: ModuleOp, rewriter: Rewriter) -> None: Block((test.TestOp(result_types=(Float64Type(),)),)), ) ) - rewriter.inline_region_at_start(region, module.body) + rewriter.inline_region(region, BlockInsertPoint.at_start(module.body)) rewrite_and_compare(prog, expected, transformation) @@ -612,33 +616,22 @@ def transformation(module: ModuleOp, rewriter: Rewriter) -> None: Block((test.TestOp(result_types=(Float64Type(),)),)), ) ) - rewriter.inline_region_at_end(region, module.body) + rewriter.inline_region(region, BlockInsertPoint.at_end(module.body)) rewrite_and_compare(prog, expected, transformation) def test_verify_inline_region(): - block = Block() region = Region(Block()) - with pytest.raises( - ValueError, match="Cannot inline region before a block with no parent" - ): - Rewriter.inline_region_before(region, block) - with pytest.raises(ValueError, match="Cannot move region into itself."): - Rewriter.inline_region_before(region, region.block) - - with pytest.raises( - ValueError, match="Cannot inline region before a block with no parent" - ): - Rewriter.inline_region_after(region, block) + Rewriter.inline_region(region, BlockInsertPoint.before(region.block)) with pytest.raises(ValueError, match="Cannot move region into itself."): - Rewriter.inline_region_after(region, region.block) + Rewriter.inline_region(region, BlockInsertPoint.after(region.block)) with pytest.raises(ValueError, match="Cannot move region into itself."): - Rewriter.inline_region_at_start(region, region) + Rewriter.inline_region(region, BlockInsertPoint.at_start(region)) with pytest.raises(ValueError, match="Cannot move region into itself."): - Rewriter.inline_region_at_end(region, region) + Rewriter.inline_region(region, BlockInsertPoint.at_end(region)) diff --git a/tests/test_traits.py b/tests/test_traits.py index 39191add09..f06fbcb98e 100644 --- a/tests/test_traits.py +++ b/tests/test_traits.py @@ -7,21 +7,31 @@ from abc import ABC from collections.abc import Sequence from dataclasses import dataclass +from typing import Any import pytest from xdsl.dialects import test from xdsl.dialects.builtin import ( + DYNAMIC_INDEX, AnyIntegerAttr, + AnyMemRefTypeConstr, + AnyTensorTypeConstr, + AnyUnrankedMemrefTypeConstr, + AnyUnrankedTensorTypeConstr, IntegerAttr, IntegerType, + MemRefType, + NoneAttr, StringAttr, SymbolRefAttr, + TensorType, + UnrankedTensorType, i1, i32, i64, ) -from xdsl.ir import Operation, OpTrait, OpTraits +from xdsl.ir import Attribute, Operation, OpTrait, OpTraits, SSAValue from xdsl.irdl import ( Block, IRDLOperation, @@ -36,6 +46,8 @@ region_def, result_def, traits_def, + var_operand_def, + var_result_def, ) from xdsl.traits import ( AlwaysSpeculatable, @@ -44,6 +56,7 @@ HasParent, OptionalSymbolOpInterface, RecursivelySpeculatable, + SameOperandsAndResultType, SymbolOpInterface, SymbolTable, is_speculatable, @@ -549,6 +562,428 @@ class SupeculatabilityTestOp(IRDLOperation): assert is_speculatable(op) is speculatability +@pytest.mark.parametrize( + ("operands", "result_types"), + [ + ([()], [()]), + ([()], (test.TestType("foo"),)), + ((TestSSAValue(test.TestType("foo")),), [()]), + ], +) +def test_same_operands_and_result_type_trait_for_scalar_types( + operands: tuple[SSAValue] | tuple[()], + result_types: tuple[test.TestType] | tuple[()], +): + @irdl_op_definition + class SameOperandsAndResultTypeOp(IRDLOperation): + name = "test.same_operand_and_result_type" + + ops = var_operand_def(test.TestType("foo")) + res = var_result_def(test.TestType("foo")) + + traits = traits_def(SameOperandsAndResultType()) + + op = SameOperandsAndResultTypeOp(operands=operands, result_types=result_types) + + with pytest.raises( + VerifyException, match="requires at least one result or operand" + ): + op.verify() + + +@irdl_op_definition +class SameOperandsAndResultTypeOp(IRDLOperation): + name = "test.same_operand_and_result_type" + + ops = var_operand_def( + AnyMemRefTypeConstr + | AnyUnrankedMemrefTypeConstr + | AnyUnrankedTensorTypeConstr + | AnyTensorTypeConstr + ) + + res = var_result_def( + AnyMemRefTypeConstr + | AnyUnrankedMemrefTypeConstr + | AnyUnrankedTensorTypeConstr + | AnyTensorTypeConstr + ) + + traits = traits_def(SameOperandsAndResultType()) + + +@pytest.mark.parametrize( + ( + "operand1_and_result_element_type", + "operand_and_result_shape1", + "result_element_type2", + "result_shape2", + ), + [ + ( + test.TestType("foo"), + [2, 3], + test.TestType("qux"), + [2, 3], + ), + ( + test.TestType("foo"), + [2, 3], + test.TestType("foo"), + [2, 4], + ), + ( + test.TestType("qux"), + [2, 3], + test.TestType("foo"), + [2, 3], + ), + ( + test.TestType("foo"), + [2, 4], + test.TestType("foo"), + [2, 3], + ), + ], +) +def test_same_operands_and_result_type_trait_for_result_element_type_of_shaped_types( + operand1_and_result_element_type: Attribute, + operand_and_result_shape1: tuple[int], + result_element_type2: Attribute, + result_shape2: tuple[int], +): + op = SameOperandsAndResultTypeOp( + operands=[ + TestSSAValue( + TensorType(operand1_and_result_element_type, operand_and_result_shape1) + ) + ], + result_types=[ + [ + TensorType(operand1_and_result_element_type, operand_and_result_shape1), + TensorType(result_element_type2, result_shape2), + ], + ], + ) + + with pytest.raises( + VerifyException, + match="requires the same type for all operands and results", + ): + op.verify() + + +@pytest.mark.parametrize( + "operands_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + "results_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + ( + "operand_type", + "result_type", + ), + [ + ( + TensorType(test.TestType("foo"), [2, 3]), + TensorType(test.TestType("qux"), [2, 3]), + ), + ( + TensorType(test.TestType("foo"), [2, 3]), + TensorType(test.TestType("foo"), [2, 4]), + ), + ( + TensorType(test.TestType("qux"), [2, 3]), + TensorType(test.TestType("foo"), [2, 3]), + ), + ( + TensorType(test.TestType("foo"), [2, 4]), + TensorType(test.TestType("foo"), [2, 3]), + ), + ( + MemRefType(test.TestType("foo"), [2, 3]), + MemRefType(test.TestType("qux"), [2, 3]), + ), + ( + MemRefType(test.TestType("foo"), [2, 3]), + MemRefType(test.TestType("foo"), [2, 4]), + ), + ( + MemRefType(test.TestType("qux"), [2, 3]), + MemRefType(test.TestType("foo"), [2, 3]), + ), + ( + MemRefType(test.TestType("foo"), [2, 4]), + MemRefType(test.TestType("foo"), [2, 3]), + ), + ], +) +def test_same_operands_and_result_type_trait_for_element_type_of_shaped_types( + operand_type: TensorType[Any], + result_type: TensorType[Any], + operands_num: int, + results_num: int, +): + op = SameOperandsAndResultTypeOp( + operands=[ + [ + TestSSAValue(operand_type), + ] + * operands_num, + ], + result_types=[[result_type] * results_num], + ) + + with pytest.raises( + VerifyException, + match="requires the same type for all operands and results", + ): + op.verify() + + +@pytest.mark.parametrize( + ( + "element_type", + "shape", + "operand1_and_result_encoding", + "result_encoding2", + ), + [ + ( + test.TestType("foo"), + [2, 3], + StringAttr("bar"), + StringAttr("baz"), + ), + ( + test.TestType("foo"), + [2, 3], + StringAttr("baz"), + StringAttr("bar"), + ), + ( + test.TestType("foo"), + [2, 3], + StringAttr("bar"), + NoneAttr(), + ), + ( + test.TestType("foo"), + [2, 3], + NoneAttr(), + StringAttr("bar"), + ), + ], +) +def test_same_operands_and_result_type_trait_for_result_encoding_of_shaped_types( + element_type: Attribute, + shape: tuple[int], + operand1_and_result_encoding: Attribute, + result_encoding2: Attribute, +): + op = SameOperandsAndResultTypeOp( + operands=[ + [ + TestSSAValue( + TensorType( + element_type, + shape, + operand1_and_result_encoding, + ) + ), + ], + ], + result_types=[ + [ + TensorType(element_type, shape, operand1_and_result_encoding), + TensorType(element_type, shape, result_encoding2), + ] + ], + ) + + with pytest.raises( + VerifyException, + match="requires the same encoding for all operands and results", + ): + op.verify() + + +@pytest.mark.parametrize( + "operands_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + "results_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + ( + "element_type", + "shape", + "operand_encoding", + "result_encoding", + ), + [ + ( + test.TestType("foo"), + [2, 3], + StringAttr("bar"), + StringAttr("baz"), + ), + ( + test.TestType("foo"), + [2, 3], + StringAttr("baz"), + StringAttr("bar"), + ), + ( + test.TestType("foo"), + [2, 3], + StringAttr("bar"), + NoneAttr(), + ), + ( + test.TestType("foo"), + [2, 3], + NoneAttr(), + StringAttr("bar"), + ), + ], +) +def test_same_operands_and_result_type_trait_for_encoding_of_shaped_types( + element_type: Attribute, + shape: tuple[int], + operand_encoding: Attribute, + result_encoding: Attribute, + operands_num: int, + results_num: int, +): + op = SameOperandsAndResultTypeOp( + operands=[ + [ + TestSSAValue( + TensorType( + element_type, + shape, + operand_encoding, + ) + ), + ] + * operands_num, + ], + result_types=[[TensorType(element_type, shape, result_encoding)] * results_num], + ) + + with pytest.raises( + VerifyException, + match="requires the same encoding for all operands and results", + ): + op.verify() + + +@pytest.mark.parametrize( + "operands_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + "results_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + ( + "operand1_and_result_shape", + "operand2_shape", + ), + [ + ( + [1], + [1], + ), + ( + [2, 3], + [2, 3], + ), + ( + [2, 3], + [2, DYNAMIC_INDEX], + ), + ( + [2, 4], + [2, DYNAMIC_INDEX], + ), + ( + [2, DYNAMIC_INDEX], + [2, DYNAMIC_INDEX], + ), + ], +) +def test_same_operands_and_result_type_trait_for_ranked_mixed_shapes( + operand1_and_result_shape: tuple[int], + operand2_shape: tuple[int], + operands_num: int, + results_num: int, +): + op = SameOperandsAndResultTypeOp( + operands=[ + [ + TestSSAValue( + TensorType(test.TestType("foo"), operand1_and_result_shape) + ), + TestSSAValue(TensorType(test.TestType("foo"), operand2_shape)), + ] + * operands_num, + ], + result_types=[ + [TensorType(test.TestType("foo"), operand1_and_result_shape)] * results_num + ], + ) + + op.verify() + + +@pytest.mark.parametrize( + "operands_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + "results_num", + [1, 2, 3], +) +@pytest.mark.parametrize( + ("operand1_and_result_shape",), + [ + ([1],), + ([2, 3],), + ([2, DYNAMIC_INDEX],), + ([DYNAMIC_INDEX, DYNAMIC_INDEX],), + ], +) +def test_same_operands_and_result_type_trait_for_mixed_rank_and_mixed_shapes( + operand1_and_result_shape: tuple[int], + operands_num: int, + results_num: int, +): + op = SameOperandsAndResultTypeOp( + operands=[ + [ + TestSSAValue( + TensorType(test.TestType("foo"), operand1_and_result_shape) + ), + TestSSAValue(UnrankedTensorType(test.TestType("foo"))), + ] + * operands_num, + ], + result_types=[ + [TensorType(test.TestType("foo"), operand1_and_result_shape)] * results_num + ], + ) + + op.verify() + + @irdl_op_definition class TestModifyTraitsOp(IRDLOperation): name = "test.test_modify_traits" diff --git a/tests/utils/test_type.py b/tests/utils/test_type.py new file mode 100644 index 0000000000..f13b1deeb8 --- /dev/null +++ b/tests/utils/test_type.py @@ -0,0 +1,89 @@ +from xdsl.dialects import test +from xdsl.dialects.builtin import ( + DYNAMIC_INDEX, + MemRefType, + NoneAttr, + TensorType, + UnrankedTensorType, +) +from xdsl.utils.type import ( + get_element_type_or_self, + get_encoding, + have_compatible_shape, +) + + +def test_get_element_type_or_self(): + scalar_type1 = test.TestType("foo") + assert scalar_type1 == get_element_type_or_self(scalar_type1) + + shaped_type1 = TensorType(scalar_type1, [4]) + assert scalar_type1 == get_element_type_or_self(shaped_type1) + + unranked_shaped_type1 = UnrankedTensorType(scalar_type1) + assert scalar_type1 == get_element_type_or_self(unranked_shaped_type1) + + +def test_get_encoding(): + scalar_type1 = test.TestType("foo") + + assert get_encoding(scalar_type1) == NoneAttr() + + shaped_type1 = TensorType(scalar_type1, [4]) + + assert get_encoding(shaped_type1) == NoneAttr() + + shaped_type2 = TensorType(scalar_type1, [4], scalar_type1) + + assert get_encoding(shaped_type2) == scalar_type1 + + shaped_type3 = MemRefType(scalar_type1, [4]) + + assert get_encoding(shaped_type3) == NoneAttr() + + +def test_have_compatible_shape(): + scalar_type1 = test.TestType("foo") + scalar_type2 = test.TestType("foo") + + assert have_compatible_shape(scalar_type1, scalar_type2) + + shaped_type1 = TensorType(scalar_type1, [4]) + + assert not have_compatible_shape(scalar_type1, shaped_type1) + assert not have_compatible_shape(shaped_type1, scalar_type1) + + unranked_shaped_type1 = UnrankedTensorType(scalar_type1) + unranked_shaped_type2 = UnrankedTensorType(scalar_type2) + + assert have_compatible_shape(shaped_type1, unranked_shaped_type1) + assert have_compatible_shape(unranked_shaped_type1, shaped_type1) + assert have_compatible_shape(unranked_shaped_type1, unranked_shaped_type2) + + shaped_type2 = TensorType(scalar_type2, [1, 2]) + + assert not have_compatible_shape(shaped_type1, shaped_type2) + + shaped_type3 = TensorType(scalar_type2, [5]) + + assert not have_compatible_shape(shaped_type1, shaped_type3) + + shaped_type4 = TensorType(scalar_type2, [1, 3]) + + assert not have_compatible_shape(shaped_type2, shaped_type4) + + shaped_type5 = TensorType(scalar_type2, [DYNAMIC_INDEX, 3]) + shaped_type6 = TensorType(scalar_type2, [1, DYNAMIC_INDEX]) + shaped_type7 = TensorType(scalar_type2, [DYNAMIC_INDEX, DYNAMIC_INDEX]) + + assert have_compatible_shape(shaped_type4, shaped_type5) + assert have_compatible_shape(shaped_type4, shaped_type6) + + assert have_compatible_shape(shaped_type5, shaped_type6) + assert have_compatible_shape(shaped_type5, shaped_type7) + + assert have_compatible_shape(shaped_type6, shaped_type7) + + shaped_type8 = TensorType(scalar_type2, [2, DYNAMIC_INDEX]) + + assert not have_compatible_shape(shaped_type4, shaped_type8) diff --git a/uv.lock b/uv.lock index c7a8751286..331e321a89 100644 --- a/uv.lock +++ b/uv.lock @@ -226,6 +226,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 }, ] +[[package]] +name = "babel" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/74/f1bc80f23eeba13393b7222b11d95ca3af2c1e28edca18af487137eefed9/babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316", size = 9348104 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", size = 9587599 }, +] + [[package]] name = "beautifulsoup4" version = "4.12.3" @@ -271,6 +280,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/84/c2/80633736cd183ee4a62107413def345f7e6e3c01563dbca1417363cf957e/build-1.2.2.post1-py3-none-any.whl", hash = "sha256:1d61c0887fa860c01971625baae8bdd338e517b836a2f70dd1f7aa3a6b2fc5b5", size = 22950 }, ] +[[package]] +name = "certifi" +version = "2024.12.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/bd/1d41ee578ce09523c81a15426705dd20969f5abf006d1afe8aeff0dd776a/certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db", size = 166010 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/32/8f6669fc4798494966bf446c8c4a162e0b5d893dff088afddf76414f70e1/certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56", size = 164927 }, +] + [[package]] name = "cffi" version = "1.17.1" @@ -337,6 +355,67 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249 }, ] +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, + { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, + { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, + { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, + { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, + { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, + { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, + { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, + { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, + { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, + { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, + { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, + { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, +] + [[package]] name = "click" version = "8.1.8" @@ -436,27 +515,27 @@ toml = [ [[package]] name = "debugpy" -version = "1.8.11" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/bc/e7/666f4c9b0e24796af50aadc28d36d21c2e01e831a934535f956e09b3650c/debugpy-1.8.11.tar.gz", hash = "sha256:6ad2688b69235c43b020e04fecccdf6a96c8943ca9c2fb340b8adc103c655e57", size = 1640124 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/26/e6/4cf7422eaa591b4c7d6a9fde224095dac25283fdd99d90164f28714242b0/debugpy-1.8.11-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:2b26fefc4e31ff85593d68b9022e35e8925714a10ab4858fb1b577a8a48cb8cd", size = 2075100 }, - { url = "https://files.pythonhosted.org/packages/83/3a/e163de1df5995d95760a4d748b02fbefb1c1bf19e915b664017c40435dbf/debugpy-1.8.11-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61bc8b3b265e6949855300e84dc93d02d7a3a637f2aec6d382afd4ceb9120c9f", size = 3559724 }, - { url = "https://files.pythonhosted.org/packages/27/6c/327e19fd1bf428a1efe1a6f97b306689c54c2cebcf871b66674ead718756/debugpy-1.8.11-cp310-cp310-win32.whl", hash = "sha256:c928bbf47f65288574b78518449edaa46c82572d340e2750889bbf8cd92f3737", size = 5178068 }, - { url = "https://files.pythonhosted.org/packages/49/80/359ff8aa388f0bd4a48f0fa9ce3606396d576657ac149c6fba3cc7de8adb/debugpy-1.8.11-cp310-cp310-win_amd64.whl", hash = "sha256:8da1db4ca4f22583e834dcabdc7832e56fe16275253ee53ba66627b86e304da1", size = 5210109 }, - { url = "https://files.pythonhosted.org/packages/7c/58/8e3f7ec86c1b7985a232667b5df8f3b1b1c8401028d8f4d75e025c9556cd/debugpy-1.8.11-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:85de8474ad53ad546ff1c7c7c89230db215b9b8a02754d41cb5a76f70d0be296", size = 2173656 }, - { url = "https://files.pythonhosted.org/packages/d2/03/95738a68ade2358e5a4d63a2fd8e7ed9ad911001cfabbbb33a7f81343945/debugpy-1.8.11-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ffc382e4afa4aee367bf413f55ed17bd91b191dcaf979890af239dda435f2a1", size = 3132464 }, - { url = "https://files.pythonhosted.org/packages/ca/f4/18204891ab67300950615a6ad09b9de236203a9138f52b3b596fa17628ca/debugpy-1.8.11-cp311-cp311-win32.whl", hash = "sha256:40499a9979c55f72f4eb2fc38695419546b62594f8af194b879d2a18439c97a9", size = 5103637 }, - { url = "https://files.pythonhosted.org/packages/3b/90/3775e301cfa573b51eb8a108285681f43f5441dc4c3916feed9f386ef861/debugpy-1.8.11-cp311-cp311-win_amd64.whl", hash = "sha256:987bce16e86efa86f747d5151c54e91b3c1e36acc03ce1ddb50f9d09d16ded0e", size = 5127862 }, - { url = "https://files.pythonhosted.org/packages/c6/ae/2cf26f3111e9d94384d9c01e9d6170188b0aeda15b60a4ac6457f7c8a26f/debugpy-1.8.11-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:84e511a7545d11683d32cdb8f809ef63fc17ea2a00455cc62d0a4dbb4ed1c308", size = 2498756 }, - { url = "https://files.pythonhosted.org/packages/b0/16/ec551789d547541a46831a19aa15c147741133da188e7e6acf77510545a7/debugpy-1.8.11-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce291a5aca4985d82875d6779f61375e959208cdf09fcec40001e65fb0a54768", size = 4219136 }, - { url = "https://files.pythonhosted.org/packages/72/6f/b2b3ce673c55f882d27a6eb04a5f0c68bcad6b742ac08a86d8392ae58030/debugpy-1.8.11-cp312-cp312-win32.whl", hash = "sha256:28e45b3f827d3bf2592f3cf7ae63282e859f3259db44ed2b129093ca0ac7940b", size = 5224440 }, - { url = "https://files.pythonhosted.org/packages/77/09/b1f05be802c1caef5b3efc042fc6a7cadd13d8118b072afd04a9b9e91e06/debugpy-1.8.11-cp312-cp312-win_amd64.whl", hash = "sha256:44b1b8e6253bceada11f714acf4309ffb98bfa9ac55e4fce14f9e5d4484287a1", size = 5264578 }, - { url = "https://files.pythonhosted.org/packages/2e/66/931dc2479aa8fbf362dc6dcee707d895a84b0b2d7b64020135f20b8db1ed/debugpy-1.8.11-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:8988f7163e4381b0da7696f37eec7aca19deb02e500245df68a7159739bbd0d3", size = 2483651 }, - { url = "https://files.pythonhosted.org/packages/10/07/6c171d0fe6b8d237e35598b742f20ba062511b3a4631938cc78eefbbf847/debugpy-1.8.11-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c1f6a173d1140e557347419767d2b14ac1c9cd847e0b4c5444c7f3144697e4e", size = 4213770 }, - { url = "https://files.pythonhosted.org/packages/89/f1/0711da6ac250d4fe3bf7b3e9b14b4a86e82a98b7825075c07e19bab8da3d/debugpy-1.8.11-cp313-cp313-win32.whl", hash = "sha256:bb3b15e25891f38da3ca0740271e63ab9db61f41d4d8541745cfc1824252cb28", size = 5223911 }, - { url = "https://files.pythonhosted.org/packages/56/98/5e27fa39050749ed460025bcd0034a0a5e78a580a14079b164cc3abdeb98/debugpy-1.8.11-cp313-cp313-win_amd64.whl", hash = "sha256:d8768edcbeb34da9e11bcb8b5c2e0958d25218df7a6e56adf415ef262cd7b6d1", size = 5264166 }, - { url = "https://files.pythonhosted.org/packages/77/0a/d29a5aacf47b4383ed569b8478c02d59ee3a01ad91224d2cff8562410e43/debugpy-1.8.11-py2.py3-none-any.whl", hash = "sha256:0e22f846f4211383e6a416d04b4c13ed174d24cc5d43f5fd52e7821d0ebc8920", size = 5226874 }, +version = "1.8.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/25/c74e337134edf55c4dfc9af579eccb45af2393c40960e2795a94351e8140/debugpy-1.8.12.tar.gz", hash = "sha256:646530b04f45c830ceae8e491ca1c9320a2d2f0efea3141487c82130aba70dce", size = 1641122 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/19/dd58334c0a1ec07babf80bf29fb8daf1a7ca4c1a3bbe61548e40616ac087/debugpy-1.8.12-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:a2ba7ffe58efeae5b8fad1165357edfe01464f9aef25e814e891ec690e7dd82a", size = 2076091 }, + { url = "https://files.pythonhosted.org/packages/4c/37/bde1737da15f9617d11ab7b8d5267165f1b7dae116b2585a6643e89e1fa2/debugpy-1.8.12-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbbd4149c4fc5e7d508ece083e78c17442ee13b0e69bfa6bd63003e486770f45", size = 3560717 }, + { url = "https://files.pythonhosted.org/packages/d9/ca/bc67f5a36a7de072908bc9e1156c0f0b272a9a2224cf21540ab1ffd71a1f/debugpy-1.8.12-cp310-cp310-win32.whl", hash = "sha256:b202f591204023b3ce62ff9a47baa555dc00bb092219abf5caf0e3718ac20e7c", size = 5180672 }, + { url = "https://files.pythonhosted.org/packages/c1/b9/e899c0a80dfa674dbc992f36f2b1453cd1ee879143cdb455bc04fce999da/debugpy-1.8.12-cp310-cp310-win_amd64.whl", hash = "sha256:9649eced17a98ce816756ce50433b2dd85dfa7bc92ceb60579d68c053f98dff9", size = 5212702 }, + { url = "https://files.pythonhosted.org/packages/af/9f/5b8af282253615296264d4ef62d14a8686f0dcdebb31a669374e22fff0a4/debugpy-1.8.12-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:36f4829839ef0afdfdd208bb54f4c3d0eea86106d719811681a8627ae2e53dd5", size = 2174643 }, + { url = "https://files.pythonhosted.org/packages/ef/31/f9274dcd3b0f9f7d1e60373c3fa4696a585c55acb30729d313bb9d3bcbd1/debugpy-1.8.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a28ed481d530e3138553be60991d2d61103ce6da254e51547b79549675f539b7", size = 3133457 }, + { url = "https://files.pythonhosted.org/packages/ab/ca/6ee59e9892e424477e0c76e3798046f1fd1288040b927319c7a7b0baa484/debugpy-1.8.12-cp311-cp311-win32.whl", hash = "sha256:4ad9a94d8f5c9b954e0e3b137cc64ef3f579d0df3c3698fe9c3734ee397e4abb", size = 5106220 }, + { url = "https://files.pythonhosted.org/packages/d5/1a/8ab508ab05ede8a4eae3b139bbc06ea3ca6234f9e8c02713a044f253be5e/debugpy-1.8.12-cp311-cp311-win_amd64.whl", hash = "sha256:4703575b78dd697b294f8c65588dc86874ed787b7348c65da70cfc885efdf1e1", size = 5130481 }, + { url = "https://files.pythonhosted.org/packages/ba/e6/0f876ecfe5831ebe4762b19214364753c8bc2b357d28c5d739a1e88325c7/debugpy-1.8.12-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:7e94b643b19e8feb5215fa508aee531387494bf668b2eca27fa769ea11d9f498", size = 2500846 }, + { url = "https://files.pythonhosted.org/packages/19/64/33f41653a701f3cd2cbff8b41ebaad59885b3428b5afd0d93d16012ecf17/debugpy-1.8.12-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:086b32e233e89a2740c1615c2f775c34ae951508b28b308681dbbb87bba97d06", size = 4222181 }, + { url = "https://files.pythonhosted.org/packages/32/a6/02646cfe50bfacc9b71321c47dc19a46e35f4e0aceea227b6d205e900e34/debugpy-1.8.12-cp312-cp312-win32.whl", hash = "sha256:2ae5df899732a6051b49ea2632a9ea67f929604fd2b036613a9f12bc3163b92d", size = 5227017 }, + { url = "https://files.pythonhosted.org/packages/da/a6/10056431b5c47103474312cf4a2ec1001f73e0b63b1216706d5fef2531eb/debugpy-1.8.12-cp312-cp312-win_amd64.whl", hash = "sha256:39dfbb6fa09f12fae32639e3286112fc35ae976114f1f3d37375f3130a820969", size = 5267555 }, + { url = "https://files.pythonhosted.org/packages/cf/4d/7c3896619a8791effd5d8c31f0834471fc8f8fb3047ec4f5fc69dd1393dd/debugpy-1.8.12-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:696d8ae4dff4cbd06bf6b10d671e088b66669f110c7c4e18a44c43cf75ce966f", size = 2485246 }, + { url = "https://files.pythonhosted.org/packages/99/46/bc6dcfd7eb8cc969a5716d858e32485eb40c72c6a8dc88d1e3a4d5e95813/debugpy-1.8.12-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:898fba72b81a654e74412a67c7e0a81e89723cfe2a3ea6fcd3feaa3395138ca9", size = 4218616 }, + { url = "https://files.pythonhosted.org/packages/03/dd/d7fcdf0381a9b8094da1f6a1c9f19fed493a4f8576a2682349b3a8b20ec7/debugpy-1.8.12-cp313-cp313-win32.whl", hash = "sha256:22a11c493c70413a01ed03f01c3c3a2fc4478fc6ee186e340487b2edcd6f4180", size = 5226540 }, + { url = "https://files.pythonhosted.org/packages/25/bd/ecb98f5b5fc7ea0bfbb3c355bc1dd57c198a28780beadd1e19915bf7b4d9/debugpy-1.8.12-cp313-cp313-win_amd64.whl", hash = "sha256:fdb3c6d342825ea10b90e43d7f20f01535a72b3a1997850c0c3cefa5c27a4a2c", size = 5267134 }, + { url = "https://files.pythonhosted.org/packages/38/c4/5120ad36405c3008f451f94b8f92ef1805b1e516f6ff870f331ccb3c4cc0/debugpy-1.8.12-py2.py3-none-any.whl", hash = "sha256:274b6a2040349b5c9864e475284bce5bb062e63dce368a394b8cc865ae3b00c6", size = 5229490 }, ] [[package]] @@ -609,6 +688,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c6/c8/a5be5b7550c10858fcf9b0ea054baccab474da77d37f1e828ce043a3a5d4/frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3", size = 11901 }, ] +[[package]] +name = "ghp-import" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034 }, +] + +[[package]] +name = "griffe" +version = "1.5.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/74/cd35a98cb11f79de0581e8e1e6fbd738aeeed1f2d90e9b5106728b63f5f7/griffe-1.5.5.tar.gz", hash = "sha256:35ee5b38b93d6a839098aad0f92207e6ad6b70c3e8866c08ca669275b8cba585", size = 391124 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/88/52c9422bc853cd7c2b6122090e887d17b5fad29b67f930e4277c9c557357/griffe-1.5.5-py3-none-any.whl", hash = "sha256:2761b1e8876c6f1f9ab1af274df93ea6bbadd65090de5f38f4cb5cc84897c7dd", size = 128221 }, +] + [[package]] name = "h11" version = "0.14.0" @@ -732,7 +835,7 @@ wheels = [ [[package]] name = "jax" -version = "0.4.38" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jaxlib" }, @@ -741,14 +844,14 @@ dependencies = [ { name = "opt-einsum" }, { name = "scipy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fb/e5/c4aa9644bb96b7f6747bd7c9f8cda7665ca5e194fa2542b2dea3ff730701/jax-0.4.38.tar.gz", hash = "sha256:43bae65881628319e0a2148e8f81a202fbc2b8d048e35c7cb1df2416672fa4a8", size = 1930034 } +sdist = { url = "https://files.pythonhosted.org/packages/4a/cb/22d62b26284f08e62d6eb64603d3b010004cfdb7a97ce6cca5c6cf86edab/jax-0.5.0.tar.gz", hash = "sha256:49df70bf293a345a7fb519f71193506d37a024c4f850b358042eb32d502c81c8", size = 1959707 } wheels = [ - { url = "https://files.pythonhosted.org/packages/22/49/b4418a7a892c0dd64442bbbeef54e1cdfe722dfc5a7bf0d611d3f5f90e99/jax-0.4.38-py3-none-any.whl", hash = "sha256:78987306f7041ea8500d99df1a17c33ed92620c2268c4c3677fb24e06712be64", size = 2236864 }, + { url = "https://files.pythonhosted.org/packages/f4/58/cc0721a1030fcbab0984beea0bf3c4610ec103f738423cdfa9c4ceb40598/jax-0.5.0-py3-none-any.whl", hash = "sha256:b3907aa87ae2c340b39cdbf80c07a74550369cafcaf7398fb60ba58d167345ab", size = 2270365 }, ] [[package]] name = "jaxlib" -version = "0.4.38" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "ml-dtypes" }, @@ -756,26 +859,22 @@ dependencies = [ { name = "scipy" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/d4/e6a0881a88b8f17491c2ee271fd77c348b0221d9e2ec92dad23a2c9e41bc/jaxlib-0.4.38-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:55c19b9d3f33a6fc59f644aa5a21fba02639ccdd776cb4a9b5526625f57839ff", size = 99663603 }, - { url = "https://files.pythonhosted.org/packages/b6/6d/11569ce873f04c82ec22e58d822f4187dccae1d400c0d6dd05ed314d5328/jaxlib-0.4.38-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:30b2f52cb50d74734af2f477c2533a7a583e3bb7b2c8acdeb361ee77d940577a", size = 79475708 }, - { url = "https://files.pythonhosted.org/packages/72/61/1de2405d13089c83b1ad87ec0266479c9d00080659dae2474892ae356306/jaxlib-0.4.38-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:ee19c163a8fdf0839d4c18b88a5fbfb4e731ba7c437416d3e5483e570bb764e4", size = 93219045 }, - { url = "https://files.pythonhosted.org/packages/9c/24/0829decf233c6af9efe7c53888ae8ac72395e0979869cd9cee487e35dac3/jaxlib-0.4.38-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:61aeccb9a27c67fdb8450f6357240019cd4511cb9d62a44e4764756d384853ad", size = 101732107 }, - { url = "https://files.pythonhosted.org/packages/0d/04/120c4caac6151f7297fedf9dd776362aa2d417d3f87bda826050b4da45e8/jaxlib-0.4.38-cp310-cp310-win_amd64.whl", hash = "sha256:d6ab745a89d0fb737a36fe1d8b86659e3fffe6ee8303b20651b26193d5edc0ef", size = 64223924 }, - { url = "https://files.pythonhosted.org/packages/b0/6a/b9fba73eb5e758e40a514919e096a039d27dc0ab4776a6cc977f5153a55f/jaxlib-0.4.38-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:b67fdeabd6dfed08b7768f3bdffb521160085f8305669bd197beef61d08de08b", size = 99679916 }, - { url = "https://files.pythonhosted.org/packages/44/2a/3458130d44d44038fd6974e7c43948f68408f685063203b82229b9b72c1a/jaxlib-0.4.38-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3fb0eaae7369157afecbead50aaf29e73ffddfa77a2335d721bd9794f3c510e4", size = 79488377 }, - { url = "https://files.pythonhosted.org/packages/94/96/7d9a0b9f35af4727df44b68ade4c6f15163840727d1cb47251b1ea515e30/jaxlib-0.4.38-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:43db58c4c427627296366a56c10318e1f00f503690e17f94bb4344293e1995e0", size = 93241543 }, - { url = "https://files.pythonhosted.org/packages/a3/2d/68f85037e60c981b37b18b23ace458c677199dea4722ddce541b48ddfc63/jaxlib-0.4.38-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:2751ff7037d6a997d0be0e77cc4be381c5a9f9bb8b314edb755c13a6fd969f45", size = 101751923 }, - { url = "https://files.pythonhosted.org/packages/cc/24/a9c571c8a189f58e0b54b14d53fc7f5a0a06e4f1d7ab9edcf8d1d91d07e7/jaxlib-0.4.38-cp311-cp311-win_amd64.whl", hash = "sha256:35226968fc9de6873d1571670eac4117f5ed80e955f7a1775204d1044abe16c6", size = 64255189 }, - { url = "https://files.pythonhosted.org/packages/49/df/08b94c593c0867c7eaa334592807ba74495de4be90580f360db8b96221dc/jaxlib-0.4.38-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:3fefea985f0415816f3bbafd3f03a437050275ef9bac9a72c1314e1644ac57c1", size = 99737849 }, - { url = "https://files.pythonhosted.org/packages/ab/b1/c9d2a7ba9ebeabb7ac37082f4c466364f475dc7550a79358c0f0aa89fdf2/jaxlib-0.4.38-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f33bcafe32c97a562ecf6894d7c41674c80c0acdedfa5423d49af51147149874", size = 79509242 }, - { url = "https://files.pythonhosted.org/packages/53/25/dd670d8bdf3799ece76d12cfe6a6a250ea256057aa4b0fcace4753a99d2d/jaxlib-0.4.38-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:496f45b0e001a2341309cd0c74af0b670537dced79c168cb230cfcc773f0aa86", size = 93251503 }, - { url = "https://files.pythonhosted.org/packages/f9/cc/37fce5162f6b9070203fd76cc0f298d9b3bfdf01939a78935a6078d63621/jaxlib-0.4.38-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:dad6c0a96567c06d083c0469fec40f201210b099365bd698be31a6d2ec88fd59", size = 101792792 }, - { url = "https://files.pythonhosted.org/packages/6f/7a/8515950a60a4ea5b13cc98fc0a42e36553b2db5a6eedc00d3bd7836f77b5/jaxlib-0.4.38-cp312-cp312-win_amd64.whl", hash = "sha256:966cdec36cfa978f5b4582bcb4147fe511725b94c1a752dac3a5f52ce46b6fa3", size = 64288223 }, - { url = "https://files.pythonhosted.org/packages/91/03/aee503c7077c6dbbd568842303426c6ec1cef9bff330c418c9e71906cccd/jaxlib-0.4.38-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:41e55ae5818a882e5789e848f6f16687ac132bcfbb5a5fa114a5d18b78d05f2d", size = 99739026 }, - { url = "https://files.pythonhosted.org/packages/cb/bf/fbbf61da319611d88e11c691d5a2077039208ded05e1731dea940f824a59/jaxlib-0.4.38-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6fe326b8af366387dd47ccf312583b2b17fed12712c9b74a648b18a13cbdbabf", size = 79508735 }, - { url = "https://files.pythonhosted.org/packages/e4/0b/8cbff0b6d62a4694351c49baf53b7ed8deb8a6854d129408c38158e11676/jaxlib-0.4.38-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:248cca3771ebf24b070f49701364ceada33e6139445b06c782cca5ac5ad92bf4", size = 93251882 }, - { url = "https://files.pythonhosted.org/packages/15/57/7f0283273b69c417071bcd2f4c2ed076479ec5ffc22a647f13c21da8d071/jaxlib-0.4.38-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:2ce77ba8cda9259a4bca97afc1c722e4291a6c463a63f8d372c6edc85117d625", size = 101791137 }, - { url = "https://files.pythonhosted.org/packages/de/de/d6c4d234cd426b97459cb070af90792b48643967a0d28641379ee9e10fc9/jaxlib-0.4.38-cp313-cp313-win_amd64.whl", hash = "sha256:4103db0b3a38a5dc132741237453c24d8547290a22079ba1b577d6c88c95300a", size = 64288459 }, + { url = "https://files.pythonhosted.org/packages/c8/41/3e4ac64df72c4da126df3fd66a2214025a46b6263f7be266728e7b8e473e/jaxlib-0.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1b8a6c4345f137f387650de2dbc488c20251b7412b55dd648e1a4f13bcf507fb", size = 79248968 }, + { url = "https://files.pythonhosted.org/packages/1e/5f/2a16e61f1d54ae5f55fbf3cb3e22ef5bb01bf9d7d6474e0d34fedba19c4d/jaxlib-0.5.0-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:5b2efe3dfebf18a84c451d3803ac884ee242021c1113b279c13f4bbc378c3dc0", size = 93181077 }, + { url = "https://files.pythonhosted.org/packages/08/c3/573e2f01b99f1247e8fbe1aa46b95a0faa68ef208f9a8e8ef775d607b3e6/jaxlib-0.5.0-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:74440b632107336400d4f97a16481d767f13ea914c53ba14e544c6fda54819b3", size = 101969119 }, + { url = "https://files.pythonhosted.org/packages/6e/38/512f61ea13da41ca47f2411d7c05af0cf74a37f225e16725ed0e6fb58893/jaxlib-0.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:53478a28eee6c2ef01759b05a9491702daef9268c3ed013d6f8e2e5f5cae0887", size = 63883394 }, + { url = "https://files.pythonhosted.org/packages/92/4b/8875870ff52ad3fbea876c905228f691f05c8dc8556b226cbfaf0fba7f62/jaxlib-0.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6cd762ed1623132499fa701c4203446102e0a9c82ca23194b87288f746d12a29", size = 79242870 }, + { url = "https://files.pythonhosted.org/packages/a0/0f/00cdfa411d7218e4696c10c5867f7d3c396219adbcaeb02e95108ca802de/jaxlib-0.5.0-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:63088dbfaa85bb56cd521a925a3472fd7328b18ec93c2d8ffa85af331095c995", size = 93181807 }, + { url = "https://files.pythonhosted.org/packages/58/8e/a5c29db03d5a93b0326e297b556d0e0a9805e9c9c1ae5f82f69557273faa/jaxlib-0.5.0-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:09113ef1582ba34d7cbc440fedb318f4855b59b776711a8aba2473c9727d3025", size = 101969212 }, + { url = "https://files.pythonhosted.org/packages/70/86/ceae20e4f37fa07f1cc95551cc0f49170d0db46d2e82fdf511d26bffd801/jaxlib-0.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:78289fc3ddc1e4e9510de2536a6375df9fe1c50de0ac60826c286b7a5c5090fe", size = 63881994 }, + { url = "https://files.pythonhosted.org/packages/57/d6/d971b40cb156e0637aa3c1522a1e803b641142e9a8f3ade6a574711bb073/jaxlib-0.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73e335715760c56e635109d61426435a5d7f46f3363a115daea09427d5cd0efd", size = 79246087 }, + { url = "https://files.pythonhosted.org/packages/41/2e/ba9770330077c3e4082cd0353e6a61419f79bff3e2197f904ce70167b9ad/jaxlib-0.5.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:4b4b01afb0ddec96c08356bff2bb685ddbe97fdffe4ed6e2d834b30aba972f22", size = 93179593 }, + { url = "https://files.pythonhosted.org/packages/66/e9/211ba3e46ec22c722c4d61a739cfccf79b0618006d6f5fa53eb4eb93ed6d/jaxlib-0.5.0-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:f980c733e98c998a8da87c9a8cc61b6726d0be667a58bd664c1d717b4b4eae75", size = 101984785 }, + { url = "https://files.pythonhosted.org/packages/2d/cb/11bb92324afb6ba678f388e10b78d6b02196bc8887eb5aa0d85ce398edf9/jaxlib-0.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:5baedbeeb60fa493c7528783254f04c6e986a2826266b198ed37e9336af2ef8c", size = 63899871 }, + { url = "https://files.pythonhosted.org/packages/22/ac/e400473e6a2f405fd6e4dc40a713bb9a3868a3f76a8ffc5eb66f6e686002/jaxlib-0.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed18ea7161d03aa8fd4d1b55494882f21420efdfea68e5f298c4aebcf2ac3f34", size = 79245359 }, + { url = "https://files.pythonhosted.org/packages/44/2d/c210abf4a9b2ce2e0858fcd3567c8773a739114e37d751af6c228901af57/jaxlib-0.5.0-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:7d9b17a7ea19355d45ecdb2ff0db5d707a86f0c5a862d94b89b4568d6c45311a", size = 93180025 }, + { url = "https://files.pythonhosted.org/packages/30/f8/316f7b4797c5eb50c6d70e461724a7cbe08b4505ca4da1bfd260c135895a/jaxlib-0.5.0-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:11eef01d37c0f1c5306265b76f207f1002d13480ded2e31fd63ec76912c93ca2", size = 101982281 }, + { url = "https://files.pythonhosted.org/packages/4c/f2/cfa012a0417c9b13b44c8e1d3ebf5fd04e8bb738b5c93e20c9fc97919880/jaxlib-0.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:61b4d26cd6a0c49ba0b1e4340c7d29198913ee2dc70b65ee90752717d22305bb", size = 63900219 }, ] [[package]] @@ -900,7 +999,7 @@ wheels = [ [[package]] name = "marimo" -version = "0.10.12" +version = "0.10.14" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -922,9 +1021,9 @@ dependencies = [ { name = "uvicorn" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/7e/e0/e8f6a5a71495972f723dac82a0b45503968e389171c06a6cec6424463a39/marimo-0.10.12.tar.gz", hash = "sha256:ccb6682f7645ac812445bb7e71c7e5c6b94d1bc8505e19c33b542482756768ce", size = 11853043 } +sdist = { url = "https://files.pythonhosted.org/packages/7f/5e/e68abb8d0d990834c61c213265b798a8b3dcd32973bc9107d9acaf73a6d6/marimo-0.10.14.tar.gz", hash = "sha256:01ff0a3602818609b60300ab0ab491616bad6ab9b867e7ed76dd2616002972c9", size = 11859210 } wheels = [ - { url = "https://files.pythonhosted.org/packages/97/7b/ad89d703508d3393bcabb340785bef352a4e53d65b068c614ee8752a7772/marimo-0.10.12-py3-none-any.whl", hash = "sha256:915ff89dc557a3a7dc9008fbff1efe55ca7caa8dc714e6d784ef55087490fa97", size = 12148616 }, + { url = "https://files.pythonhosted.org/packages/5a/7b/13054f5cf3da24a61321425d606844c493ac18c6aad6967bd24029631a02/marimo-0.10.14-py3-none-any.whl", hash = "sha256:3b87fd71a551a1f32330d30ac519f52d56baff2f80330e4b41f3560860587858", size = 12157959 }, ] [[package]] @@ -1047,6 +1146,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, ] +[[package]] +name = "mergedeep" +version = "1.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354 }, +] + [[package]] name = "mistune" version = "3.1.0" @@ -1059,6 +1167,127 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b4/b3/743ffc3f59da380da504d84ccd1faf9a857a1445991ff19bf2ec754163c2/mistune-3.1.0-py3-none-any.whl", hash = "sha256:b05198cf6d671b3deba6c87ec6cf0d4eb7b72c524636eddb6dbf13823b52cee1", size = 53694 }, ] +[[package]] +name = "mkdocs" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ghp-import" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mergedeep" }, + { name = "mkdocs-get-deps" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "pyyaml" }, + { name = "pyyaml-env-tag" }, + { name = "watchdog" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451 }, +] + +[[package]] +name = "mkdocs-autorefs" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mkdocs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/18/fb1e17fb705228b51bf7b2f791adaf83c0fa708e51bbc003411ba48ae21e/mkdocs_autorefs-1.3.0.tar.gz", hash = "sha256:6867764c099ace9025d6ac24fd07b85a98335fbd30107ef01053697c8f46db61", size = 42597 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/4a/960c441950f98becfa5dd419adab20274939fd575ab848aee2c87e3599ac/mkdocs_autorefs-1.3.0-py3-none-any.whl", hash = "sha256:d180f9778a04e78b7134e31418f238bba56f56d6a8af97873946ff661befffb3", size = 17642 }, +] + +[[package]] +name = "mkdocs-get-deps" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mergedeep" }, + { name = "platformdirs" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521 }, +] + +[[package]] +name = "mkdocs-material" +version = "9.5.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "colorama" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "mkdocs" }, + { name = "mkdocs-material-extensions" }, + { name = "paginate" }, + { name = "pygments" }, + { name = "pymdown-extensions" }, + { name = "regex" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/16/c48d5a28bc4a67c49808180b6009d4d1b4c0753739ffee3cc37046ab29d7/mkdocs_material-9.5.50.tar.gz", hash = "sha256:ae5fe16f3d7c9ccd05bb6916a7da7420cf99a9ce5e33debd9d40403a090d5825", size = 3923354 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/b5/1bf29cd744896ae83bd38c72970782c843ba13e0240b1a85277bd3928637/mkdocs_material-9.5.50-py3-none-any.whl", hash = "sha256:f24100f234741f4d423a9d672a909d859668a4f404796be3cf035f10d6050385", size = 8645274 }, +] + +[[package]] +name = "mkdocs-material-extensions" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728 }, +] + +[[package]] +name = "mkdocstrings" +version = "0.27.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mkdocs" }, + { name = "mkdocs-autorefs" }, + { name = "platformdirs" }, + { name = "pymdown-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/5a/5de70538c2cefae7ac3a15b5601e306ef3717290cb2aab11d51cbbc2d1c0/mkdocstrings-0.27.0.tar.gz", hash = "sha256:16adca6d6b0a1f9e0c07ff0b02ced8e16f228a9d65a37c063ec4c14d7b76a657", size = 94830 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/10/4c27c3063c2b3681a4b7942f8dbdeb4fa34fecb2c19b594e7345ebf4f86f/mkdocstrings-0.27.0-py3-none-any.whl", hash = "sha256:6ceaa7ea830770959b55a16203ac63da24badd71325b96af950e59fd37366332", size = 30658 }, +] + +[package.optional-dependencies] +python = [ + { name = "mkdocstrings-python" }, +] + +[[package]] +name = "mkdocstrings-python" +version = "1.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "griffe" }, + { name = "mkdocs-autorefs" }, + { name = "mkdocstrings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/ae/32703e35d74040051c672400fd9f5f2b48a6ea094f5071dd8a0e3be35322/mkdocstrings_python-1.13.0.tar.gz", hash = "sha256:2dbd5757e8375b9720e81db16f52f1856bf59905428fd7ef88005d1370e2f64c", size = 185697 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/23/d02d86553327296c3bf369d444194ea83410cce8f0e690565264f37f3261/mkdocstrings_python-1.13.0-py3-none-any.whl", hash = "sha256:b88bbb207bab4086434743849f8e796788b373bd32e7bfefbf8560ac45d88f97", size = 112254 }, +] + [[package]] name = "ml-dtypes" version = "0.5.1" @@ -1215,11 +1444,11 @@ wheels = [ [[package]] name = "narwhals" -version = "1.21.1" +version = "1.22.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ad/6d/1a3a84b2c3186465aa5e95146e96610b875b7a5bb899f6dd1206f0444c0e/narwhals-1.21.1.tar.gz", hash = "sha256:44082c6273fd0125a2bde5baae6ddb7465e185c24fd6e1c5e71cab1d746c89cc", size = 242809 } +sdist = { url = "https://files.pythonhosted.org/packages/26/2d/3047f817d6a1290b96851950101776d40671c309bed36429537b5cab5b94/narwhals-1.22.0.tar.gz", hash = "sha256:8e257c5af70a82382796706f39d681290f2c482812474524087f36cb69f9d2f1", size = 241780 } wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/4f/7c482d8fe70bc19e1e121ccd205fedac936bbb2ff3b789775294fdbe525b/narwhals-1.21.1-py3-none-any.whl", hash = "sha256:f5f2cd33a6fa636de74067f4050d6dd9a9343b39a5a911dc97810d55d8f24cdd", size = 282702 }, + { url = "https://files.pythonhosted.org/packages/17/d9/00a937201a3ca6e8b2ca29226935be53dd7bc9bee27cb8ba5b27efe11ccf/narwhals-1.22.0-py3-none-any.whl", hash = "sha256:5c931bf8696b6dec276f590f1bc5043080606b16ce86d85c9b550312c981970f", size = 297474 }, ] [[package]] @@ -1313,64 +1542,64 @@ wheels = [ [[package]] name = "numpy" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/fdbf6a7871703df6160b5cf3dd774074b086d278172285c52c2758b76305/numpy-2.2.1.tar.gz", hash = "sha256:45681fd7128c8ad1c379f0ca0776a8b0c6583d2f69889ddac01559dfe4390918", size = 20227662 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/c4/5588367dc9f91e1a813beb77de46ea8cab13f778e1b3a0e661ab031aba44/numpy-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5edb4e4caf751c1518e6a26a83501fda79bff41cc59dac48d70e6d65d4ec4440", size = 21213214 }, - { url = "https://files.pythonhosted.org/packages/d8/8b/32dd9f08419023a4cf856c5ad0b4eba9b830da85eafdef841a104c4fc05a/numpy-2.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa3017c40d513ccac9621a2364f939d39e550c542eb2a894b4c8da92b38896ab", size = 14352248 }, - { url = "https://files.pythonhosted.org/packages/84/2d/0e895d02940ba6e12389f0ab5cac5afcf8dc2dc0ade4e8cad33288a721bd/numpy-2.2.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:61048b4a49b1c93fe13426e04e04fdf5a03f456616f6e98c7576144677598675", size = 5391007 }, - { url = "https://files.pythonhosted.org/packages/11/b9/7f1e64a0d46d9c2af6d17966f641fb12d5b8ea3003f31b2308f3e3b9a6aa/numpy-2.2.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:7671dc19c7019103ca44e8d94917eba8534c76133523ca8406822efdd19c9308", size = 6926174 }, - { url = "https://files.pythonhosted.org/packages/2e/8c/043fa4418bc9364e364ab7aba8ff6ef5f6b9171ade22de8fbcf0e2fa4165/numpy-2.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4250888bcb96617e00bfa28ac24850a83c9f3a16db471eca2ee1f1714df0f957", size = 14330914 }, - { url = "https://files.pythonhosted.org/packages/f7/b6/d8110985501ca8912dfc1c3bbef99d66e62d487f72e46b2337494df77364/numpy-2.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7746f235c47abc72b102d3bce9977714c2444bdfaea7888d241b4c4bb6a78bf", size = 16379607 }, - { url = "https://files.pythonhosted.org/packages/e2/57/bdca9fb8bdaa810c3a4ff2eb3231379b77f618a7c0d24be9f7070db50775/numpy-2.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:059e6a747ae84fce488c3ee397cee7e5f905fd1bda5fb18c66bc41807ff119b2", size = 15541760 }, - { url = "https://files.pythonhosted.org/packages/97/55/3b9147b3cbc3b6b1abc2a411dec5337a46c873deca0dd0bf5bef9d0579cc/numpy-2.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f62aa6ee4eb43b024b0e5a01cf65a0bb078ef8c395e8713c6e8a12a697144528", size = 18168476 }, - { url = "https://files.pythonhosted.org/packages/00/e7/7c2cde16c9b87a8e14fdd262ca7849c4681cf48c8a774505f7e6f5e3b643/numpy-2.2.1-cp310-cp310-win32.whl", hash = "sha256:48fd472630715e1c1c89bf1feab55c29098cb403cc184b4859f9c86d4fcb6a95", size = 6570985 }, - { url = "https://files.pythonhosted.org/packages/a1/a8/554b0e99fc4ac11ec481254781a10da180d0559c2ebf2c324232317349ee/numpy-2.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:b541032178a718c165a49638d28272b771053f628382d5e9d1c93df23ff58dbf", size = 12913384 }, - { url = "https://files.pythonhosted.org/packages/59/14/645887347124e101d983e1daf95b48dc3e136bf8525cb4257bf9eab1b768/numpy-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40f9e544c1c56ba8f1cf7686a8c9b5bb249e665d40d626a23899ba6d5d9e1484", size = 21217379 }, - { url = "https://files.pythonhosted.org/packages/9f/fd/2279000cf29f58ccfd3778cbf4670dfe3f7ce772df5e198c5abe9e88b7d7/numpy-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f9b57eaa3b0cd8db52049ed0330747b0364e899e8a606a624813452b8203d5f7", size = 14388520 }, - { url = "https://files.pythonhosted.org/packages/58/b0/034eb5d5ba12d66ab658ff3455a31f20add0b78df8203c6a7451bd1bee21/numpy-2.2.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bc8a37ad5b22c08e2dbd27df2b3ef7e5c0864235805b1e718a235bcb200cf1cb", size = 5389286 }, - { url = "https://files.pythonhosted.org/packages/5d/69/6f3cccde92e82e7835fdb475c2bf439761cbf8a1daa7c07338e1e132dfec/numpy-2.2.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:9036d6365d13b6cbe8f27a0eaf73ddcc070cae584e5ff94bb45e3e9d729feab5", size = 6930345 }, - { url = "https://files.pythonhosted.org/packages/d1/72/1cd38e91ab563e67f584293fcc6aca855c9ae46dba42e6b5ff4600022899/numpy-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51faf345324db860b515d3f364eaa93d0e0551a88d6218a7d61286554d190d73", size = 14335748 }, - { url = "https://files.pythonhosted.org/packages/f2/d4/f999444e86986f3533e7151c272bd8186c55dda554284def18557e013a2a/numpy-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38efc1e56b73cc9b182fe55e56e63b044dd26a72128fd2fbd502f75555d92591", size = 16391057 }, - { url = "https://files.pythonhosted.org/packages/99/7b/85cef6a3ae1b19542b7afd97d0b296526b6ef9e3c43ea0c4d9c4404fb2d0/numpy-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:31b89fa67a8042e96715c68e071a1200c4e172f93b0fbe01a14c0ff3ff820fc8", size = 15556943 }, - { url = "https://files.pythonhosted.org/packages/69/7e/b83cc884c3508e91af78760f6b17ab46ad649831b1fa35acb3eb26d9e6d2/numpy-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c86e2a209199ead7ee0af65e1d9992d1dce7e1f63c4b9a616500f93820658d0", size = 18180785 }, - { url = "https://files.pythonhosted.org/packages/b2/9f/eb4a9a38867de059dcd4b6e18d47c3867fbd3795d4c9557bb49278f94087/numpy-2.2.1-cp311-cp311-win32.whl", hash = "sha256:b34d87e8a3090ea626003f87f9392b3929a7bbf4104a05b6667348b6bd4bf1cd", size = 6568983 }, - { url = "https://files.pythonhosted.org/packages/6d/1e/be3b9f3073da2f8c7fa361fcdc231b548266b0781029fdbaf75eeab997fd/numpy-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:360137f8fb1b753c5cde3ac388597ad680eccbbbb3865ab65efea062c4a1fd16", size = 12917260 }, - { url = "https://files.pythonhosted.org/packages/62/12/b928871c570d4a87ab13d2cc19f8817f17e340d5481621930e76b80ffb7d/numpy-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:694f9e921a0c8f252980e85bce61ebbd07ed2b7d4fa72d0e4246f2f8aa6642ab", size = 20909861 }, - { url = "https://files.pythonhosted.org/packages/3d/c3/59df91ae1d8ad7c5e03efd63fd785dec62d96b0fe56d1f9ab600b55009af/numpy-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3683a8d166f2692664262fd4900f207791d005fb088d7fdb973cc8d663626faa", size = 14095776 }, - { url = "https://files.pythonhosted.org/packages/af/4e/8ed5868efc8e601fb69419644a280e9c482b75691466b73bfaab7d86922c/numpy-2.2.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:780077d95eafc2ccc3ced969db22377b3864e5b9a0ea5eb347cc93b3ea900315", size = 5126239 }, - { url = "https://files.pythonhosted.org/packages/1a/74/dd0bbe650d7bc0014b051f092f2de65e34a8155aabb1287698919d124d7f/numpy-2.2.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:55ba24ebe208344aa7a00e4482f65742969a039c2acfcb910bc6fcd776eb4355", size = 6659296 }, - { url = "https://files.pythonhosted.org/packages/7f/11/4ebd7a3f4a655764dc98481f97bd0a662fb340d1001be6050606be13e162/numpy-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b1d07b53b78bf84a96898c1bc139ad7f10fda7423f5fd158fd0f47ec5e01ac7", size = 14047121 }, - { url = "https://files.pythonhosted.org/packages/7f/a7/c1f1d978166eb6b98ad009503e4d93a8c1962d0eb14a885c352ee0276a54/numpy-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5062dc1a4e32a10dc2b8b13cedd58988261416e811c1dc4dbdea4f57eea61b0d", size = 16096599 }, - { url = "https://files.pythonhosted.org/packages/3d/6d/0e22afd5fcbb4d8d0091f3f46bf4e8906399c458d4293da23292c0ba5022/numpy-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fce4f615f8ca31b2e61aa0eb5865a21e14f5629515c9151850aa936c02a1ee51", size = 15243932 }, - { url = "https://files.pythonhosted.org/packages/03/39/e4e5832820131ba424092b9610d996b37e5557180f8e2d6aebb05c31ae54/numpy-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:67d4cda6fa6ffa073b08c8372aa5fa767ceb10c9a0587c707505a6d426f4e046", size = 17861032 }, - { url = "https://files.pythonhosted.org/packages/5f/8a/3794313acbf5e70df2d5c7d2aba8718676f8d054a05abe59e48417fb2981/numpy-2.2.1-cp312-cp312-win32.whl", hash = "sha256:32cb94448be47c500d2c7a95f93e2f21a01f1fd05dd2beea1ccd049bb6001cd2", size = 6274018 }, - { url = "https://files.pythonhosted.org/packages/17/c1/c31d3637f2641e25c7a19adf2ae822fdaf4ddd198b05d79a92a9ce7cb63e/numpy-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:ba5511d8f31c033a5fcbda22dd5c813630af98c70b2661f2d2c654ae3cdfcfc8", size = 12613843 }, - { url = "https://files.pythonhosted.org/packages/20/d6/91a26e671c396e0c10e327b763485ee295f5a5a7a48c553f18417e5a0ed5/numpy-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f1d09e520217618e76396377c81fba6f290d5f926f50c35f3a5f72b01a0da780", size = 20896464 }, - { url = "https://files.pythonhosted.org/packages/8c/40/5792ccccd91d45e87d9e00033abc4f6ca8a828467b193f711139ff1f1cd9/numpy-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ecc47cd7f6ea0336042be87d9e7da378e5c7e9b3c8ad0f7c966f714fc10d821", size = 14111350 }, - { url = "https://files.pythonhosted.org/packages/c0/2a/fb0a27f846cb857cef0c4c92bef89f133a3a1abb4e16bba1c4dace2e9b49/numpy-2.2.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f419290bc8968a46c4933158c91a0012b7a99bb2e465d5ef5293879742f8797e", size = 5111629 }, - { url = "https://files.pythonhosted.org/packages/eb/e5/8e81bb9d84db88b047baf4e8b681a3e48d6390bc4d4e4453eca428ecbb49/numpy-2.2.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b6c390bfaef8c45a260554888966618328d30e72173697e5cabe6b285fb2348", size = 6645865 }, - { url = "https://files.pythonhosted.org/packages/7a/1a/a90ceb191dd2f9e2897c69dde93ccc2d57dd21ce2acbd7b0333e8eea4e8d/numpy-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:526fc406ab991a340744aad7e25251dd47a6720a685fa3331e5c59fef5282a59", size = 14043508 }, - { url = "https://files.pythonhosted.org/packages/f1/5a/e572284c86a59dec0871a49cd4e5351e20b9c751399d5f1d79628c0542cb/numpy-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f74e6fdeb9a265624ec3a3918430205dff1df7e95a230779746a6af78bc615af", size = 16094100 }, - { url = "https://files.pythonhosted.org/packages/0c/2c/a79d24f364788386d85899dd280a94f30b0950be4b4a545f4fa4ed1d4ca7/numpy-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:53c09385ff0b72ba79d8715683c1168c12e0b6e84fb0372e97553d1ea91efe51", size = 15239691 }, - { url = "https://files.pythonhosted.org/packages/cf/79/1e20fd1c9ce5a932111f964b544facc5bb9bde7865f5b42f00b4a6a9192b/numpy-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3eac17d9ec51be534685ba877b6ab5edc3ab7ec95c8f163e5d7b39859524716", size = 17856571 }, - { url = "https://files.pythonhosted.org/packages/be/5b/cc155e107f75d694f562bdc84a26cc930569f3dfdfbccb3420b626065777/numpy-2.2.1-cp313-cp313-win32.whl", hash = "sha256:9ad014faa93dbb52c80d8f4d3dcf855865c876c9660cb9bd7553843dd03a4b1e", size = 6270841 }, - { url = "https://files.pythonhosted.org/packages/44/be/0e5cd009d2162e4138d79a5afb3b5d2341f0fe4777ab6e675aa3d4a42e21/numpy-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:164a829b6aacf79ca47ba4814b130c4020b202522a93d7bff2202bfb33b61c60", size = 12606618 }, - { url = "https://files.pythonhosted.org/packages/a8/87/04ddf02dd86fb17c7485a5f87b605c4437966d53de1e3745d450343a6f56/numpy-2.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4dfda918a13cc4f81e9118dea249e192ab167a0bb1966272d5503e39234d694e", size = 20921004 }, - { url = "https://files.pythonhosted.org/packages/6e/3e/d0e9e32ab14005425d180ef950badf31b862f3839c5b927796648b11f88a/numpy-2.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:733585f9f4b62e9b3528dd1070ec4f52b8acf64215b60a845fa13ebd73cd0712", size = 14119910 }, - { url = "https://files.pythonhosted.org/packages/b5/5b/aa2d1905b04a8fb681e08742bb79a7bddfc160c7ce8e1ff6d5c821be0236/numpy-2.2.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:89b16a18e7bba224ce5114db863e7029803c179979e1af6ad6a6b11f70545008", size = 5153612 }, - { url = "https://files.pythonhosted.org/packages/ce/35/6831808028df0648d9b43c5df7e1051129aa0d562525bacb70019c5f5030/numpy-2.2.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:676f4eebf6b2d430300f1f4f4c2461685f8269f94c89698d832cdf9277f30b84", size = 6668401 }, - { url = "https://files.pythonhosted.org/packages/b1/38/10ef509ad63a5946cc042f98d838daebfe7eaf45b9daaf13df2086b15ff9/numpy-2.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f5cdf9f493b35f7e41e8368e7d7b4bbafaf9660cba53fb21d2cd174ec09631", size = 14014198 }, - { url = "https://files.pythonhosted.org/packages/df/f8/c80968ae01df23e249ee0a4487fae55a4c0fe2f838dfe9cc907aa8aea0fa/numpy-2.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1ad395cf254c4fbb5b2132fee391f361a6e8c1adbd28f2cd8e79308a615fe9d", size = 16076211 }, - { url = "https://files.pythonhosted.org/packages/09/69/05c169376016a0b614b432967ac46ff14269eaffab80040ec03ae1ae8e2c/numpy-2.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:08ef779aed40dbc52729d6ffe7dd51df85796a702afbf68a4f4e41fafdc8bda5", size = 15220266 }, - { url = "https://files.pythonhosted.org/packages/f1/ff/94a4ce67ea909f41cf7ea712aebbe832dc67decad22944a1020bb398a5ee/numpy-2.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:26c9c4382b19fcfbbed3238a14abf7ff223890ea1936b8890f058e7ba35e8d71", size = 17852844 }, - { url = "https://files.pythonhosted.org/packages/46/72/8a5dbce4020dfc595592333ef2fbb0a187d084ca243b67766d29d03e0096/numpy-2.2.1-cp313-cp313t-win32.whl", hash = "sha256:93cf4e045bae74c90ca833cba583c14b62cb4ba2cba0abd2b141ab52548247e2", size = 6326007 }, - { url = "https://files.pythonhosted.org/packages/7b/9c/4fce9cf39dde2562584e4cfd351a0140240f82c0e3569ce25a250f47037d/numpy-2.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bff7d8ec20f5f42607599f9994770fa65d76edca264a87b5e4ea5629bce12268", size = 12693107 }, - { url = "https://files.pythonhosted.org/packages/f1/65/d36a76b811ffe0a4515e290cb05cb0e22171b1b0f0db6bee9141cf023545/numpy-2.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7ba9cc93a91d86365a5d270dee221fdc04fb68d7478e6bf6af650de78a8339e3", size = 21044672 }, - { url = "https://files.pythonhosted.org/packages/aa/3f/b644199f165063154df486d95198d814578f13dd4d8c1651e075bf1cb8af/numpy-2.2.1-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3d03883435a19794e41f147612a77a8f56d4e52822337844fff3d4040a142964", size = 6789873 }, - { url = "https://files.pythonhosted.org/packages/d7/df/2adb0bb98a3cbe8a6c3c6d1019aede1f1d8b83927ced228a46cc56c7a206/numpy-2.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4511d9e6071452b944207c8ce46ad2f897307910b402ea5fa975da32e0102800", size = 16194933 }, - { url = "https://files.pythonhosted.org/packages/13/3e/1959d5219a9e6d200638d924cedda6a606392f7186a4ed56478252e70d55/numpy-2.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5c5cc0cbabe9452038ed984d05ac87910f89370b9242371bd9079cb4af61811e", size = 12820057 }, +version = "2.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/d0/c12ddfd3a02274be06ffc71f3efc6d0e457b0409c4481596881e748cb264/numpy-2.2.2.tar.gz", hash = "sha256:ed6906f61834d687738d25988ae117683705636936cc605be0bb208b23df4d8f", size = 20233295 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/2a/69033dc22d981ad21325314f8357438078f5c28310a6d89fb3833030ec8a/numpy-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7079129b64cb78bdc8d611d1fd7e8002c0a2565da6a47c4df8062349fee90e3e", size = 21215825 }, + { url = "https://files.pythonhosted.org/packages/31/2c/39f91e00bbd3d5639b027ac48c55dc5f2992bd2b305412d26be4c830862a/numpy-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2ec6c689c61df613b783aeb21f945c4cbe6c51c28cb70aae8430577ab39f163e", size = 14354996 }, + { url = "https://files.pythonhosted.org/packages/0a/2c/d468ebd253851af10de5b3e8f3418ebabfaab5f0337a75299fbeb8b8c17a/numpy-2.2.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:40c7ff5da22cd391944a28c6a9c638a5eef77fcf71d6e3a79e1d9d9e82752715", size = 5393621 }, + { url = "https://files.pythonhosted.org/packages/7f/f4/3d8a5a0da297034106c5de92be881aca7079cde6058934215a1de91334f6/numpy-2.2.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:995f9e8181723852ca458e22de5d9b7d3ba4da3f11cc1cb113f093b271d7965a", size = 6928931 }, + { url = "https://files.pythonhosted.org/packages/47/a7/029354ab56edd43dd3f5efbfad292b8844f98b93174f322f82353fa46efa/numpy-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b78ea78450fd96a498f50ee096f69c75379af5138f7881a51355ab0e11286c97", size = 14333157 }, + { url = "https://files.pythonhosted.org/packages/e3/d7/11fc594838d35c43519763310c316d4fd56f8600d3fc80a8e13e325b5c5c/numpy-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fbe72d347fbc59f94124125e73fc4976a06927ebc503ec5afbfb35f193cd957", size = 16381794 }, + { url = "https://files.pythonhosted.org/packages/af/d4/dd9b19cd4aff9c79d3f54d17f8be815407520d3116004bc574948336981b/numpy-2.2.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8e6da5cffbbe571f93588f562ed130ea63ee206d12851b60819512dd3e1ba50d", size = 15543990 }, + { url = "https://files.pythonhosted.org/packages/30/97/ab96b7650f27f684a9b1e46757a7294ecc50cab27701d05f146e9f779627/numpy-2.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09d6a2032faf25e8d0cadde7fd6145118ac55d2740132c1d845f98721b5ebcfd", size = 18170896 }, + { url = "https://files.pythonhosted.org/packages/81/9b/bae9618cab20db67a2ca9d711795cad29b2ca4b73034dd3b5d05b962070a/numpy-2.2.2-cp310-cp310-win32.whl", hash = "sha256:159ff6ee4c4a36a23fe01b7c3d07bd8c14cc433d9720f977fcd52c13c0098160", size = 6573458 }, + { url = "https://files.pythonhosted.org/packages/92/9b/95678092febd14070cfb7906ea7932e71e9dd5a6ab3ee948f9ed975e905d/numpy-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:64bd6e1762cd7f0986a740fee4dff927b9ec2c5e4d9a28d056eb17d332158014", size = 12915812 }, + { url = "https://files.pythonhosted.org/packages/21/67/32c68756eed84df181c06528ff57e09138f893c4653448c4967311e0f992/numpy-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:642199e98af1bd2b6aeb8ecf726972d238c9877b0f6e8221ee5ab945ec8a2189", size = 21220002 }, + { url = "https://files.pythonhosted.org/packages/3b/89/f43bcad18f2b2e5814457b1c7f7b0e671d0db12c8c0e43397ab8cb1831ed/numpy-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6d9fc9d812c81e6168b6d405bf00b8d6739a7f72ef22a9214c4241e0dc70b323", size = 14391215 }, + { url = "https://files.pythonhosted.org/packages/9c/e6/efb8cd6122bf25e86e3dd89d9dbfec9e6861c50e8810eed77d4be59b51c6/numpy-2.2.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:c7d1fd447e33ee20c1f33f2c8e6634211124a9aabde3c617687d8b739aa69eac", size = 5391918 }, + { url = "https://files.pythonhosted.org/packages/47/e2/fccf89d64d9b47ffb242823d4e851fc9d36fa751908c9aac2807924d9b4e/numpy-2.2.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:451e854cfae0febe723077bd0cf0a4302a5d84ff25f0bfece8f29206c7bed02e", size = 6933133 }, + { url = "https://files.pythonhosted.org/packages/34/22/5ece749c0e5420a9380eef6fbf83d16a50010bd18fef77b9193d80a6760e/numpy-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd249bc894af67cbd8bad2c22e7cbcd46cf87ddfca1f1289d1e7e54868cc785c", size = 14338187 }, + { url = "https://files.pythonhosted.org/packages/5b/86/caec78829311f62afa6fa334c8dfcd79cffb4d24bcf96ee02ae4840d462b/numpy-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02935e2c3c0c6cbe9c7955a8efa8908dd4221d7755644c59d1bba28b94fd334f", size = 16393429 }, + { url = "https://files.pythonhosted.org/packages/c8/4e/0c25f74c88239a37924577d6ad780f3212a50f4b4b5f54f5e8c918d726bd/numpy-2.2.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a972cec723e0563aa0823ee2ab1df0cb196ed0778f173b381c871a03719d4826", size = 15559103 }, + { url = "https://files.pythonhosted.org/packages/d4/bd/d557f10fa50dc4d5871fb9606af563249b66af2fc6f99041a10e8757c6f1/numpy-2.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6d6a0910c3b4368d89dde073e630882cdb266755565155bc33520283b2d9df8", size = 18182967 }, + { url = "https://files.pythonhosted.org/packages/30/e9/66cc0f66386d78ed89e45a56e2a1d051e177b6e04477c4a41cd590ef4017/numpy-2.2.2-cp311-cp311-win32.whl", hash = "sha256:860fd59990c37c3ef913c3ae390b3929d005243acca1a86facb0773e2d8d9e50", size = 6571499 }, + { url = "https://files.pythonhosted.org/packages/66/a3/4139296b481ae7304a43581046b8f0a20da6a0dfe0ee47a044cade796603/numpy-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:da1eeb460ecce8d5b8608826595c777728cdf28ce7b5a5a8c8ac8d949beadcf2", size = 12919805 }, + { url = "https://files.pythonhosted.org/packages/0c/e6/847d15770ab7a01e807bdfcd4ead5bdae57c0092b7dc83878171b6af97bb/numpy-2.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ac9bea18d6d58a995fac1b2cb4488e17eceeac413af014b1dd26170b766d8467", size = 20912636 }, + { url = "https://files.pythonhosted.org/packages/d1/af/f83580891577b13bd7e261416120e036d0d8fb508c8a43a73e38928b794b/numpy-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23ae9f0c2d889b7b2d88a3791f6c09e2ef827c2446f1c4a3e3e76328ee4afd9a", size = 14098403 }, + { url = "https://files.pythonhosted.org/packages/2b/86/d019fb60a9d0f1d4cf04b014fe88a9135090adfadcc31c1fadbb071d7fa7/numpy-2.2.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3074634ea4d6df66be04f6728ee1d173cfded75d002c75fac79503a880bf3825", size = 5128938 }, + { url = "https://files.pythonhosted.org/packages/7a/1b/50985edb6f1ec495a1c36452e860476f5b7ecdc3fc59ea89ccad3c4926c5/numpy-2.2.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ec0636d3f7d68520afc6ac2dc4b8341ddb725039de042faf0e311599f54eb37", size = 6661937 }, + { url = "https://files.pythonhosted.org/packages/f4/1b/17efd94cad1b9d605c3f8907fb06bcffc4ce4d1d14d46b95316cccccf2b9/numpy-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ffbb1acd69fdf8e89dd60ef6182ca90a743620957afb7066385a7bbe88dc748", size = 14049518 }, + { url = "https://files.pythonhosted.org/packages/5b/73/65d2f0b698df1731e851e3295eb29a5ab8aa06f763f7e4188647a809578d/numpy-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0349b025e15ea9d05c3d63f9657707a4e1d471128a3b1d876c095f328f8ff7f0", size = 16099146 }, + { url = "https://files.pythonhosted.org/packages/d5/69/308f55c0e19d4b5057b5df286c5433822e3c8039ede06d4051d96f1c2c4e/numpy-2.2.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:463247edcee4a5537841d5350bc87fe8e92d7dd0e8c71c995d2c6eecb8208278", size = 15246336 }, + { url = "https://files.pythonhosted.org/packages/f0/d8/d8d333ad0d8518d077a21aeea7b7c826eff766a2b1ce1194dea95ca0bacf/numpy-2.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9dd47ff0cb2a656ad69c38da850df3454da88ee9a6fde0ba79acceee0e79daba", size = 17863507 }, + { url = "https://files.pythonhosted.org/packages/82/6e/0b84ad3103ffc16d6673e63b5acbe7901b2af96c2837174c6318c98e27ab/numpy-2.2.2-cp312-cp312-win32.whl", hash = "sha256:4525b88c11906d5ab1b0ec1f290996c0020dd318af8b49acaa46f198b1ffc283", size = 6276491 }, + { url = "https://files.pythonhosted.org/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:5acea83b801e98541619af398cc0109ff48016955cc0818f478ee9ef1c5c3dcb", size = 12616372 }, + { url = "https://files.pythonhosted.org/packages/e1/fe/df5624001f4f5c3e0b78e9017bfab7fdc18a8d3b3d3161da3d64924dd659/numpy-2.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b208cfd4f5fe34e1535c08983a1a6803fdbc7a1e86cf13dd0c61de0b51a0aadc", size = 20899188 }, + { url = "https://files.pythonhosted.org/packages/a9/80/d349c3b5ed66bd3cb0214be60c27e32b90a506946857b866838adbe84040/numpy-2.2.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d0bbe7dd86dca64854f4b6ce2ea5c60b51e36dfd597300057cf473d3615f2369", size = 14113972 }, + { url = "https://files.pythonhosted.org/packages/9d/50/949ec9cbb28c4b751edfa64503f0913cbfa8d795b4a251e7980f13a8a655/numpy-2.2.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:22ea3bb552ade325530e72a0c557cdf2dea8914d3a5e1fecf58fa5dbcc6f43cd", size = 5114294 }, + { url = "https://files.pythonhosted.org/packages/8d/f3/399c15629d5a0c68ef2aa7621d430b2be22034f01dd7f3c65a9c9666c445/numpy-2.2.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:128c41c085cab8a85dc29e66ed88c05613dccf6bc28b3866cd16050a2f5448be", size = 6648426 }, + { url = "https://files.pythonhosted.org/packages/2c/03/c72474c13772e30e1bc2e558cdffd9123c7872b731263d5648b5c49dd459/numpy-2.2.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:250c16b277e3b809ac20d1f590716597481061b514223c7badb7a0f9993c7f84", size = 14045990 }, + { url = "https://files.pythonhosted.org/packages/83/9c/96a9ab62274ffafb023f8ee08c88d3d31ee74ca58869f859db6845494fa6/numpy-2.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c8854b09bc4de7b041148d8550d3bd712b5c21ff6a8ed308085f190235d7ff", size = 16096614 }, + { url = "https://files.pythonhosted.org/packages/d5/34/cd0a735534c29bec7093544b3a509febc9b0df77718a9b41ffb0809c9f46/numpy-2.2.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b6fb9c32a91ec32a689ec6410def76443e3c750e7cfc3fb2206b985ffb2b85f0", size = 15242123 }, + { url = "https://files.pythonhosted.org/packages/5e/6d/541717a554a8f56fa75e91886d9b79ade2e595918690eb5d0d3dbd3accb9/numpy-2.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57b4012e04cc12b78590a334907e01b3a85efb2107df2b8733ff1ed05fce71de", size = 17859160 }, + { url = "https://files.pythonhosted.org/packages/b9/a5/fbf1f2b54adab31510728edd06a05c1b30839f37cf8c9747cb85831aaf1b/numpy-2.2.2-cp313-cp313-win32.whl", hash = "sha256:4dbd80e453bd34bd003b16bd802fac70ad76bd463f81f0c518d1245b1c55e3d9", size = 6273337 }, + { url = "https://files.pythonhosted.org/packages/56/e5/01106b9291ef1d680f82bc47d0c5b5e26dfed15b0754928e8f856c82c881/numpy-2.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:5a8c863ceacae696aff37d1fd636121f1a512117652e5dfb86031c8d84836369", size = 12609010 }, + { url = "https://files.pythonhosted.org/packages/9f/30/f23d9876de0f08dceb707c4dcf7f8dd7588266745029debb12a3cdd40be6/numpy-2.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b3482cb7b3325faa5f6bc179649406058253d91ceda359c104dac0ad320e1391", size = 20924451 }, + { url = "https://files.pythonhosted.org/packages/6a/ec/6ea85b2da9d5dfa1dbb4cb3c76587fc8ddcae580cb1262303ab21c0926c4/numpy-2.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9491100aba630910489c1d0158034e1c9a6546f0b1340f716d522dc103788e39", size = 14122390 }, + { url = "https://files.pythonhosted.org/packages/68/05/bfbdf490414a7dbaf65b10c78bc243f312c4553234b6d91c94eb7c4b53c2/numpy-2.2.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:41184c416143defa34cc8eb9d070b0a5ba4f13a0fa96a709e20584638254b317", size = 5156590 }, + { url = "https://files.pythonhosted.org/packages/f7/ec/fe2e91b2642b9d6544518388a441bcd65c904cea38d9ff998e2e8ebf808e/numpy-2.2.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7dca87ca328f5ea7dafc907c5ec100d187911f94825f8700caac0b3f4c384b49", size = 6671958 }, + { url = "https://files.pythonhosted.org/packages/b1/6f/6531a78e182f194d33ee17e59d67d03d0d5a1ce7f6be7343787828d1bd4a/numpy-2.2.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bc61b307655d1a7f9f4b043628b9f2b721e80839914ede634e3d485913e1fb2", size = 14019950 }, + { url = "https://files.pythonhosted.org/packages/e1/fb/13c58591d0b6294a08cc40fcc6b9552d239d773d520858ae27f39997f2ae/numpy-2.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fad446ad0bc886855ddf5909cbf8cb5d0faa637aaa6277fb4b19ade134ab3c7", size = 16079759 }, + { url = "https://files.pythonhosted.org/packages/2c/f2/f2f8edd62abb4b289f65a7f6d1f3650273af00b91b7267a2431be7f1aec6/numpy-2.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:149d1113ac15005652e8d0d3f6fd599360e1a708a4f98e43c9c77834a28238cb", size = 15226139 }, + { url = "https://files.pythonhosted.org/packages/aa/29/14a177f1a90b8ad8a592ca32124ac06af5eff32889874e53a308f850290f/numpy-2.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:106397dbbb1896f99e044efc90360d098b3335060375c26aa89c0d8a97c5f648", size = 17856316 }, + { url = "https://files.pythonhosted.org/packages/95/03/242ae8d7b97f4e0e4ab8dd51231465fb23ed5e802680d629149722e3faf1/numpy-2.2.2-cp313-cp313t-win32.whl", hash = "sha256:0eec19f8af947a61e968d5429f0bd92fec46d92b0008d0a6685b40d6adf8a4f4", size = 6329134 }, + { url = "https://files.pythonhosted.org/packages/80/94/cd9e9b04012c015cb6320ab3bf43bc615e248dddfeb163728e800a5d96f0/numpy-2.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:97b974d3ba0fb4612b77ed35d7627490e8e3dff56ab41454d9e8b23448940576", size = 12696208 }, + { url = "https://files.pythonhosted.org/packages/96/7e/1dd770ee68916ed358991ab62c2cc353ffd98d0b75b901d52183ca28e8bb/numpy-2.2.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b0531f0b0e07643eb089df4c509d30d72c9ef40defa53e41363eca8a8cc61495", size = 21047291 }, + { url = "https://files.pythonhosted.org/packages/d1/3c/ccd08578dc532a8e6927952339d4a02682b776d5e85be49ed0760308433e/numpy-2.2.2-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:e9e82dcb3f2ebbc8cb5ce1102d5f1c5ed236bf8a11730fb45ba82e2841ec21df", size = 6792494 }, + { url = "https://files.pythonhosted.org/packages/7c/28/8754b9aee4f97199f9a047f73bb644b5a2014994a6d7b061ba67134a42de/numpy-2.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0d4142eb40ca6f94539e4db929410f2a46052a0fe7a2c1c59f6179c39938d2a", size = 16197312 }, + { url = "https://files.pythonhosted.org/packages/26/96/deb93f871f401045a684ca08a009382b247d14996d7a94fea6aa43c67b94/numpy-2.2.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:356ca982c188acbfa6af0d694284d8cf20e95b1c3d0aefa8929376fea9146f60", size = 12822674 }, ] [[package]] @@ -1400,6 +1629,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, ] +[[package]] +name = "paginate" +version = "0.5.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746 }, +] + [[package]] name = "pandocfilters" version = "1.5.1" @@ -1424,6 +1662,15 @@ version = "0.3.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/06/43/adc39246de74e9c482c11fbe6a50e8bc7f9dc367fdc261f6f767de5b1419/pasteboard-0.3.3.tar.gz", hash = "sha256:d80275e76ff1eaaa5ca3d0e0fd8aecd5ea1298523dfd51f3774b5aaebdde02cf", size = 13540 } +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 }, +] + [[package]] name = "pexpect" version = "4.9.0" @@ -1727,15 +1974,15 @@ wheels = [ [[package]] name = "pyright" -version = "1.1.391" +version = "1.1.392.post0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "nodeenv" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/11/05/4ea52a8a45cc28897edb485b4102d37cbfd5fce8445d679cdeb62bfad221/pyright-1.1.391.tar.gz", hash = "sha256:66b2d42cdf5c3cbab05f2f4b76e8bec8aa78e679bfa0b6ad7b923d9e027cadb2", size = 21965 } +sdist = { url = "https://files.pythonhosted.org/packages/66/df/3c6f6b08fba7ccf49b114dfc4bb33e25c299883fd763f93fad47ef8bc58d/pyright-1.1.392.post0.tar.gz", hash = "sha256:3b7f88de74a28dcfa90c7d90c782b6569a48c2be5f9d4add38472bdaac247ebd", size = 3789911 } wheels = [ - { url = "https://files.pythonhosted.org/packages/ad/89/66f49552fbeb21944c8077d11834b2201514a56fd1b7747ffff9630f1bd9/pyright-1.1.391-py3-none-any.whl", hash = "sha256:54fa186f8b3e8a55a44ebfa842636635688670c6896dcf6cf4a7fc75062f4d15", size = 18579 }, + { url = "https://files.pythonhosted.org/packages/e7/b1/a18de17f40e4f61ca58856b9ef9b0febf74ff88978c3f7776f910071f567/pyright-1.1.392.post0-py3-none-any.whl", hash = "sha256:252f84458a46fa2f0fd4e2f91fc74f50b9ca52c757062e93f6c250c0d8329eb2", size = 5595487 }, ] [[package]] @@ -1855,6 +2102,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, ] +[[package]] +name = "pyyaml-env-tag" +version = "0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/8e/da1c6c58f751b70f8ceb1eb25bc25d524e8f14fe16edcce3f4e3ba08629c/pyyaml_env_tag-0.1.tar.gz", hash = "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb", size = 5631 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/66/bbb1dd374f5c870f59c5bb1db0e18cbe7fa739415a24cbd95b2d1f5ae0c4/pyyaml_env_tag-0.1-py3-none-any.whl", hash = "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069", size = 3911 }, +] + [[package]] name = "pyzmq" version = "26.2.0" @@ -1930,15 +2189,100 @@ wheels = [ [[package]] name = "referencing" -version = "0.35.1" +version = "0.36.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "attrs" }, { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/99/5b/73ca1f8e72fff6fa52119dbd185f73a907b1989428917b24cff660129b6d/referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c", size = 62991 } +sdist = { url = "https://files.pythonhosted.org/packages/27/32/fd98246df7a0f309b58cae68b10b6b219ef2eb66747f00dfb34422687087/referencing-0.36.1.tar.gz", hash = "sha256:ca2e6492769e3602957e9b831b94211599d2aade9477f5d44110d2530cf9aade", size = 74661 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/fa/9f193ef0c9074b659009f06d7cbacc6f25b072044815bcf799b76533dbb8/referencing-0.36.1-py3-none-any.whl", hash = "sha256:363d9c65f080d0d70bc41c721dce3c7f3e77fc09f269cd5c8813da18069a6794", size = 26777 }, +] + +[[package]] +name = "regex" +version = "2024.11.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/5f/bd69653fbfb76cf8604468d3b4ec4c403197144c7bfe0e6a5fc9e02a07cb/regex-2024.11.6.tar.gz", hash = "sha256:7ab159b063c52a0333c884e4679f8d7a85112ee3078fe3d9004b2dd875585519", size = 399494 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/3c/4651f6b130c6842a8f3df82461a8950f923925db8b6961063e82744bddcc/regex-2024.11.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff590880083d60acc0433f9c3f713c51f7ac6ebb9adf889c79a261ecf541aa91", size = 482674 }, + { url = "https://files.pythonhosted.org/packages/15/51/9f35d12da8434b489c7b7bffc205c474a0a9432a889457026e9bc06a297a/regex-2024.11.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:658f90550f38270639e83ce492f27d2c8d2cd63805c65a13a14d36ca126753f0", size = 287684 }, + { url = "https://files.pythonhosted.org/packages/bd/18/b731f5510d1b8fb63c6b6d3484bfa9a59b84cc578ac8b5172970e05ae07c/regex-2024.11.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:164d8b7b3b4bcb2068b97428060b2a53be050085ef94eca7f240e7947f1b080e", size = 284589 }, + { url = "https://files.pythonhosted.org/packages/78/a2/6dd36e16341ab95e4c6073426561b9bfdeb1a9c9b63ab1b579c2e96cb105/regex-2024.11.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3660c82f209655a06b587d55e723f0b813d3a7db2e32e5e7dc64ac2a9e86fde", size = 782511 }, + { url = "https://files.pythonhosted.org/packages/1b/2b/323e72d5d2fd8de0d9baa443e1ed70363ed7e7b2fb526f5950c5cb99c364/regex-2024.11.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d22326fcdef5e08c154280b71163ced384b428343ae16a5ab2b3354aed12436e", size = 821149 }, + { url = "https://files.pythonhosted.org/packages/90/30/63373b9ea468fbef8a907fd273e5c329b8c9535fee36fc8dba5fecac475d/regex-2024.11.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1ac758ef6aebfc8943560194e9fd0fa18bcb34d89fd8bd2af18183afd8da3a2", size = 809707 }, + { url = "https://files.pythonhosted.org/packages/f2/98/26d3830875b53071f1f0ae6d547f1d98e964dd29ad35cbf94439120bb67a/regex-2024.11.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:997d6a487ff00807ba810e0f8332c18b4eb8d29463cfb7c820dc4b6e7562d0cf", size = 781702 }, + { url = "https://files.pythonhosted.org/packages/87/55/eb2a068334274db86208ab9d5599ffa63631b9f0f67ed70ea7c82a69bbc8/regex-2024.11.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02a02d2bb04fec86ad61f3ea7f49c015a0681bf76abb9857f945d26159d2968c", size = 771976 }, + { url = "https://files.pythonhosted.org/packages/74/c0/be707bcfe98254d8f9d2cff55d216e946f4ea48ad2fd8cf1428f8c5332ba/regex-2024.11.6-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f02f93b92358ee3f78660e43b4b0091229260c5d5c408d17d60bf26b6c900e86", size = 697397 }, + { url = "https://files.pythonhosted.org/packages/49/dc/bb45572ceb49e0f6509f7596e4ba7031f6819ecb26bc7610979af5a77f45/regex-2024.11.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:06eb1be98df10e81ebaded73fcd51989dcf534e3c753466e4b60c4697a003b67", size = 768726 }, + { url = "https://files.pythonhosted.org/packages/5a/db/f43fd75dc4c0c2d96d0881967897926942e935d700863666f3c844a72ce6/regex-2024.11.6-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:040df6fe1a5504eb0f04f048e6d09cd7c7110fef851d7c567a6b6e09942feb7d", size = 775098 }, + { url = "https://files.pythonhosted.org/packages/99/d7/f94154db29ab5a89d69ff893159b19ada89e76b915c1293e98603d39838c/regex-2024.11.6-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabbfc59f2c6edba2a6622c647b716e34e8e3867e0ab975412c5c2f79b82da2", size = 839325 }, + { url = "https://files.pythonhosted.org/packages/f7/17/3cbfab1f23356fbbf07708220ab438a7efa1e0f34195bf857433f79f1788/regex-2024.11.6-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8447d2d39b5abe381419319f942de20b7ecd60ce86f16a23b0698f22e1b70008", size = 843277 }, + { url = "https://files.pythonhosted.org/packages/7e/f2/48b393b51900456155de3ad001900f94298965e1cad1c772b87f9cfea011/regex-2024.11.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:da8f5fc57d1933de22a9e23eec290a0d8a5927a5370d24bda9a6abe50683fe62", size = 773197 }, + { url = "https://files.pythonhosted.org/packages/45/3f/ef9589aba93e084cd3f8471fded352826dcae8489b650d0b9b27bc5bba8a/regex-2024.11.6-cp310-cp310-win32.whl", hash = "sha256:b489578720afb782f6ccf2840920f3a32e31ba28a4b162e13900c3e6bd3f930e", size = 261714 }, + { url = "https://files.pythonhosted.org/packages/42/7e/5f1b92c8468290c465fd50c5318da64319133231415a8aa6ea5ab995a815/regex-2024.11.6-cp310-cp310-win_amd64.whl", hash = "sha256:5071b2093e793357c9d8b2929dfc13ac5f0a6c650559503bb81189d0a3814519", size = 274042 }, + { url = "https://files.pythonhosted.org/packages/58/58/7e4d9493a66c88a7da6d205768119f51af0f684fe7be7bac8328e217a52c/regex-2024.11.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5478c6962ad548b54a591778e93cd7c456a7a29f8eca9c49e4f9a806dcc5d638", size = 482669 }, + { url = "https://files.pythonhosted.org/packages/34/4c/8f8e631fcdc2ff978609eaeef1d6994bf2f028b59d9ac67640ed051f1218/regex-2024.11.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2c89a8cc122b25ce6945f0423dc1352cb9593c68abd19223eebbd4e56612c5b7", size = 287684 }, + { url = "https://files.pythonhosted.org/packages/c5/1b/f0e4d13e6adf866ce9b069e191f303a30ab1277e037037a365c3aad5cc9c/regex-2024.11.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:94d87b689cdd831934fa3ce16cc15cd65748e6d689f5d2b8f4f4df2065c9fa20", size = 284589 }, + { url = "https://files.pythonhosted.org/packages/25/4d/ab21047f446693887f25510887e6820b93f791992994f6498b0318904d4a/regex-2024.11.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1062b39a0a2b75a9c694f7a08e7183a80c63c0d62b301418ffd9c35f55aaa114", size = 792121 }, + { url = "https://files.pythonhosted.org/packages/45/ee/c867e15cd894985cb32b731d89576c41a4642a57850c162490ea34b78c3b/regex-2024.11.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:167ed4852351d8a750da48712c3930b031f6efdaa0f22fa1933716bfcd6bf4a3", size = 831275 }, + { url = "https://files.pythonhosted.org/packages/b3/12/b0f480726cf1c60f6536fa5e1c95275a77624f3ac8fdccf79e6727499e28/regex-2024.11.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d548dafee61f06ebdb584080621f3e0c23fff312f0de1afc776e2a2ba99a74f", size = 818257 }, + { url = "https://files.pythonhosted.org/packages/bf/ce/0d0e61429f603bac433910d99ef1a02ce45a8967ffbe3cbee48599e62d88/regex-2024.11.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2a19f302cd1ce5dd01a9099aaa19cae6173306d1302a43b627f62e21cf18ac0", size = 792727 }, + { url = "https://files.pythonhosted.org/packages/e4/c1/243c83c53d4a419c1556f43777ccb552bccdf79d08fda3980e4e77dd9137/regex-2024.11.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bec9931dfb61ddd8ef2ebc05646293812cb6b16b60cf7c9511a832b6f1854b55", size = 780667 }, + { url = "https://files.pythonhosted.org/packages/c5/f4/75eb0dd4ce4b37f04928987f1d22547ddaf6c4bae697623c1b05da67a8aa/regex-2024.11.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9714398225f299aa85267fd222f7142fcb5c769e73d7733344efc46f2ef5cf89", size = 776963 }, + { url = "https://files.pythonhosted.org/packages/16/5d/95c568574e630e141a69ff8a254c2f188b4398e813c40d49228c9bbd9875/regex-2024.11.6-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:202eb32e89f60fc147a41e55cb086db2a3f8cb82f9a9a88440dcfc5d37faae8d", size = 784700 }, + { url = "https://files.pythonhosted.org/packages/8e/b5/f8495c7917f15cc6fee1e7f395e324ec3e00ab3c665a7dc9d27562fd5290/regex-2024.11.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4181b814e56078e9b00427ca358ec44333765f5ca1b45597ec7446d3a1ef6e34", size = 848592 }, + { url = "https://files.pythonhosted.org/packages/1c/80/6dd7118e8cb212c3c60b191b932dc57db93fb2e36fb9e0e92f72a5909af9/regex-2024.11.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:068376da5a7e4da51968ce4c122a7cd31afaaec4fccc7856c92f63876e57b51d", size = 852929 }, + { url = "https://files.pythonhosted.org/packages/11/9b/5a05d2040297d2d254baf95eeeb6df83554e5e1df03bc1a6687fc4ba1f66/regex-2024.11.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ac10f2c4184420d881a3475fb2c6f4d95d53a8d50209a2500723d831036f7c45", size = 781213 }, + { url = "https://files.pythonhosted.org/packages/26/b7/b14e2440156ab39e0177506c08c18accaf2b8932e39fb092074de733d868/regex-2024.11.6-cp311-cp311-win32.whl", hash = "sha256:c36f9b6f5f8649bb251a5f3f66564438977b7ef8386a52460ae77e6070d309d9", size = 261734 }, + { url = "https://files.pythonhosted.org/packages/80/32/763a6cc01d21fb3819227a1cc3f60fd251c13c37c27a73b8ff4315433a8e/regex-2024.11.6-cp311-cp311-win_amd64.whl", hash = "sha256:02e28184be537f0e75c1f9b2f8847dc51e08e6e171c6bde130b2687e0c33cf60", size = 274052 }, + { url = "https://files.pythonhosted.org/packages/ba/30/9a87ce8336b172cc232a0db89a3af97929d06c11ceaa19d97d84fa90a8f8/regex-2024.11.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:52fb28f528778f184f870b7cf8f225f5eef0a8f6e3778529bdd40c7b3920796a", size = 483781 }, + { url = "https://files.pythonhosted.org/packages/01/e8/00008ad4ff4be8b1844786ba6636035f7ef926db5686e4c0f98093612add/regex-2024.11.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdd6028445d2460f33136c55eeb1f601ab06d74cb3347132e1c24250187500d9", size = 288455 }, + { url = "https://files.pythonhosted.org/packages/60/85/cebcc0aff603ea0a201667b203f13ba75d9fc8668fab917ac5b2de3967bc/regex-2024.11.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805e6b60c54bf766b251e94526ebad60b7de0c70f70a4e6210ee2891acb70bf2", size = 284759 }, + { url = "https://files.pythonhosted.org/packages/94/2b/701a4b0585cb05472a4da28ee28fdfe155f3638f5e1ec92306d924e5faf0/regex-2024.11.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b85c2530be953a890eaffde05485238f07029600e8f098cdf1848d414a8b45e4", size = 794976 }, + { url = "https://files.pythonhosted.org/packages/4b/bf/fa87e563bf5fee75db8915f7352e1887b1249126a1be4813837f5dbec965/regex-2024.11.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb26437975da7dc36b7efad18aa9dd4ea569d2357ae6b783bf1118dabd9ea577", size = 833077 }, + { url = "https://files.pythonhosted.org/packages/a1/56/7295e6bad94b047f4d0834e4779491b81216583c00c288252ef625c01d23/regex-2024.11.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abfa5080c374a76a251ba60683242bc17eeb2c9818d0d30117b4486be10c59d3", size = 823160 }, + { url = "https://files.pythonhosted.org/packages/fb/13/e3b075031a738c9598c51cfbc4c7879e26729c53aa9cca59211c44235314/regex-2024.11.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b7fa6606c2881c1db9479b0eaa11ed5dfa11c8d60a474ff0e095099f39d98e", size = 796896 }, + { url = "https://files.pythonhosted.org/packages/24/56/0b3f1b66d592be6efec23a795b37732682520b47c53da5a32c33ed7d84e3/regex-2024.11.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c32f75920cf99fe6b6c539c399a4a128452eaf1af27f39bce8909c9a3fd8cbe", size = 783997 }, + { url = "https://files.pythonhosted.org/packages/f9/a1/eb378dada8b91c0e4c5f08ffb56f25fcae47bf52ad18f9b2f33b83e6d498/regex-2024.11.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:982e6d21414e78e1f51cf595d7f321dcd14de1f2881c5dc6a6e23bbbbd68435e", size = 781725 }, + { url = "https://files.pythonhosted.org/packages/83/f2/033e7dec0cfd6dda93390089864732a3409246ffe8b042e9554afa9bff4e/regex-2024.11.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a7c2155f790e2fb448faed6dd241386719802296ec588a8b9051c1f5c481bc29", size = 789481 }, + { url = "https://files.pythonhosted.org/packages/83/23/15d4552ea28990a74e7696780c438aadd73a20318c47e527b47a4a5a596d/regex-2024.11.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149f5008d286636e48cd0b1dd65018548944e495b0265b45e1bffecce1ef7f39", size = 852896 }, + { url = "https://files.pythonhosted.org/packages/e3/39/ed4416bc90deedbfdada2568b2cb0bc1fdb98efe11f5378d9892b2a88f8f/regex-2024.11.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e5364a4502efca094731680e80009632ad6624084aff9a23ce8c8c6820de3e51", size = 860138 }, + { url = "https://files.pythonhosted.org/packages/93/2d/dd56bb76bd8e95bbce684326302f287455b56242a4f9c61f1bc76e28360e/regex-2024.11.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0a86e7eeca091c09e021db8eb72d54751e527fa47b8d5787caf96d9831bd02ad", size = 787692 }, + { url = "https://files.pythonhosted.org/packages/0b/55/31877a249ab7a5156758246b9c59539abbeba22461b7d8adc9e8475ff73e/regex-2024.11.6-cp312-cp312-win32.whl", hash = "sha256:32f9a4c643baad4efa81d549c2aadefaeba12249b2adc5af541759237eee1c54", size = 262135 }, + { url = "https://files.pythonhosted.org/packages/38/ec/ad2d7de49a600cdb8dd78434a1aeffe28b9d6fc42eb36afab4a27ad23384/regex-2024.11.6-cp312-cp312-win_amd64.whl", hash = "sha256:a93c194e2df18f7d264092dc8539b8ffb86b45b899ab976aa15d48214138e81b", size = 273567 }, + { url = "https://files.pythonhosted.org/packages/90/73/bcb0e36614601016552fa9344544a3a2ae1809dc1401b100eab02e772e1f/regex-2024.11.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a6ba92c0bcdf96cbf43a12c717eae4bc98325ca3730f6b130ffa2e3c3c723d84", size = 483525 }, + { url = "https://files.pythonhosted.org/packages/0f/3f/f1a082a46b31e25291d830b369b6b0c5576a6f7fb89d3053a354c24b8a83/regex-2024.11.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:525eab0b789891ac3be914d36893bdf972d483fe66551f79d3e27146191a37d4", size = 288324 }, + { url = "https://files.pythonhosted.org/packages/09/c9/4e68181a4a652fb3ef5099e077faf4fd2a694ea6e0f806a7737aff9e758a/regex-2024.11.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:086a27a0b4ca227941700e0b31425e7a28ef1ae8e5e05a33826e17e47fbfdba0", size = 284617 }, + { url = "https://files.pythonhosted.org/packages/fc/fd/37868b75eaf63843165f1d2122ca6cb94bfc0271e4428cf58c0616786dce/regex-2024.11.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bde01f35767c4a7899b7eb6e823b125a64de314a8ee9791367c9a34d56af18d0", size = 795023 }, + { url = "https://files.pythonhosted.org/packages/c4/7c/d4cd9c528502a3dedb5c13c146e7a7a539a3853dc20209c8e75d9ba9d1b2/regex-2024.11.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b583904576650166b3d920d2bcce13971f6f9e9a396c673187f49811b2769dc7", size = 833072 }, + { url = "https://files.pythonhosted.org/packages/4f/db/46f563a08f969159c5a0f0e722260568425363bea43bb7ae370becb66a67/regex-2024.11.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c4de13f06a0d54fa0d5ab1b7138bfa0d883220965a29616e3ea61b35d5f5fc7", size = 823130 }, + { url = "https://files.pythonhosted.org/packages/db/60/1eeca2074f5b87df394fccaa432ae3fc06c9c9bfa97c5051aed70e6e00c2/regex-2024.11.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cde6e9f2580eb1665965ce9bf17ff4952f34f5b126beb509fee8f4e994f143c", size = 796857 }, + { url = "https://files.pythonhosted.org/packages/10/db/ac718a08fcee981554d2f7bb8402f1faa7e868c1345c16ab1ebec54b0d7b/regex-2024.11.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d7f453dca13f40a02b79636a339c5b62b670141e63efd511d3f8f73fba162b3", size = 784006 }, + { url = "https://files.pythonhosted.org/packages/c2/41/7da3fe70216cea93144bf12da2b87367590bcf07db97604edeea55dac9ad/regex-2024.11.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59dfe1ed21aea057a65c6b586afd2a945de04fc7db3de0a6e3ed5397ad491b07", size = 781650 }, + { url = "https://files.pythonhosted.org/packages/a7/d5/880921ee4eec393a4752e6ab9f0fe28009435417c3102fc413f3fe81c4e5/regex-2024.11.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b97c1e0bd37c5cd7902e65f410779d39eeda155800b65fc4d04cc432efa9bc6e", size = 789545 }, + { url = "https://files.pythonhosted.org/packages/dc/96/53770115e507081122beca8899ab7f5ae28ae790bfcc82b5e38976df6a77/regex-2024.11.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d1e379028e0fc2ae3654bac3cbbef81bf3fd571272a42d56c24007979bafb6", size = 853045 }, + { url = "https://files.pythonhosted.org/packages/31/d3/1372add5251cc2d44b451bd94f43b2ec78e15a6e82bff6a290ef9fd8f00a/regex-2024.11.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:13291b39131e2d002a7940fb176e120bec5145f3aeb7621be6534e46251912c4", size = 860182 }, + { url = "https://files.pythonhosted.org/packages/ed/e3/c446a64984ea9f69982ba1a69d4658d5014bc7a0ea468a07e1a1265db6e2/regex-2024.11.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f51f88c126370dcec4908576c5a627220da6c09d0bff31cfa89f2523843316d", size = 787733 }, + { url = "https://files.pythonhosted.org/packages/2b/f1/e40c8373e3480e4f29f2692bd21b3e05f296d3afebc7e5dcf21b9756ca1c/regex-2024.11.6-cp313-cp313-win32.whl", hash = "sha256:63b13cfd72e9601125027202cad74995ab26921d8cd935c25f09c630436348ff", size = 262122 }, + { url = "https://files.pythonhosted.org/packages/45/94/bc295babb3062a731f52621cdc992d123111282e291abaf23faa413443ea/regex-2024.11.6-cp313-cp313-win_amd64.whl", hash = "sha256:2b3361af3198667e99927da8b84c1b010752fa4b1115ee30beaa332cabc3ef1a", size = 273545 }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/59/2056f61236782a2c86b33906c025d4f4a0b17be0161b63b70fd9e8775d36/referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de", size = 26684 }, + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, ] [[package]] @@ -2055,27 +2399,27 @@ wheels = [ [[package]] name = "ruff" -version = "0.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/67/3e/e89f736f01aa9517a97e2e7e0ce8d34a4d8207087b3cfdec95133fee13b5/ruff-0.9.1.tar.gz", hash = "sha256:fd2b25ecaf907d6458fa842675382c8597b3c746a2dde6717fe3415425df0c17", size = 3498844 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/dc/05/c3a2e0feb3d5d394cdfd552de01df9d3ec8a3a3771bbff247fab7e668653/ruff-0.9.1-py3-none-linux_armv6l.whl", hash = "sha256:84330dda7abcc270e6055551aca93fdde1b0685fc4fd358f26410f9349cf1743", size = 10645241 }, - { url = "https://files.pythonhosted.org/packages/dd/da/59f0a40e5f88ee5c054ad175caaa2319fc96571e1d29ab4730728f2aad4f/ruff-0.9.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:3cae39ba5d137054b0e5b472aee3b78a7c884e61591b100aeb544bcd1fc38d4f", size = 10391066 }, - { url = "https://files.pythonhosted.org/packages/b7/fe/85e1c1acf0ba04a3f2d54ae61073da030f7a5dc386194f96f3c6ca444a78/ruff-0.9.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:50c647ff96f4ba288db0ad87048257753733763b409b2faf2ea78b45c8bb7fcb", size = 10012308 }, - { url = "https://files.pythonhosted.org/packages/6f/9b/780aa5d4bdca8dcea4309264b8faa304bac30e1ce0bcc910422bfcadd203/ruff-0.9.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0c8b149e9c7353cace7d698e1656ffcf1e36e50f8ea3b5d5f7f87ff9986a7ca", size = 10881960 }, - { url = "https://files.pythonhosted.org/packages/12/f4/dac4361afbfe520afa7186439e8094e4884ae3b15c8fc75fb2e759c1f267/ruff-0.9.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:beb3298604540c884d8b282fe7625651378e1986c25df51dec5b2f60cafc31ce", size = 10414803 }, - { url = "https://files.pythonhosted.org/packages/f0/a2/057a3cb7999513cb78d6cb33a7d1cc6401c82d7332583786e4dad9e38e44/ruff-0.9.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:39d0174ccc45c439093971cc06ed3ac4dc545f5e8bdacf9f067adf879544d969", size = 11464929 }, - { url = "https://files.pythonhosted.org/packages/eb/c6/1ccfcc209bee465ced4874dcfeaadc88aafcc1ea9c9f31ef66f063c187f0/ruff-0.9.1-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:69572926c0f0c9912288915214ca9b2809525ea263603370b9e00bed2ba56dbd", size = 12170717 }, - { url = "https://files.pythonhosted.org/packages/84/97/4a524027518525c7cf6931e9fd3b2382be5e4b75b2b61bec02681a7685a5/ruff-0.9.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:937267afce0c9170d6d29f01fcd1f4378172dec6760a9f4dface48cdabf9610a", size = 11708921 }, - { url = "https://files.pythonhosted.org/packages/a6/a4/4e77cf6065c700d5593b25fca6cf725b1ab6d70674904f876254d0112ed0/ruff-0.9.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:186c2313de946f2c22bdf5954b8dd083e124bcfb685732cfb0beae0c47233d9b", size = 13058074 }, - { url = "https://files.pythonhosted.org/packages/f9/d6/fcb78e0531e863d0a952c4c5600cc5cd317437f0e5f031cd2288b117bb37/ruff-0.9.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f94942a3bb767675d9a051867c036655fe9f6c8a491539156a6f7e6b5f31831", size = 11281093 }, - { url = "https://files.pythonhosted.org/packages/e4/3b/7235bbeff00c95dc2d073cfdbf2b871b5bbf476754c5d277815d286b4328/ruff-0.9.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:728d791b769cc28c05f12c280f99e8896932e9833fef1dd8756a6af2261fd1ab", size = 10882610 }, - { url = "https://files.pythonhosted.org/packages/2a/66/5599d23257c61cf038137f82999ca8f9d0080d9d5134440a461bef85b461/ruff-0.9.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2f312c86fb40c5c02b44a29a750ee3b21002bd813b5233facdaf63a51d9a85e1", size = 10489273 }, - { url = "https://files.pythonhosted.org/packages/78/85/de4aa057e2532db0f9761e2c2c13834991e087787b93e4aeb5f1cb10d2df/ruff-0.9.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ae017c3a29bee341ba584f3823f805abbe5fe9cd97f87ed07ecbf533c4c88366", size = 11003314 }, - { url = "https://files.pythonhosted.org/packages/00/42/afedcaa089116d81447347f76041ff46025849fedb0ed2b187d24cf70fca/ruff-0.9.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5dc40a378a0e21b4cfe2b8a0f1812a6572fc7b230ef12cd9fac9161aa91d807f", size = 11342982 }, - { url = "https://files.pythonhosted.org/packages/39/c6/fe45f3eb27e3948b41a305d8b768e949bf6a39310e9df73f6c576d7f1d9f/ruff-0.9.1-py3-none-win32.whl", hash = "sha256:46ebf5cc106cf7e7378ca3c28ce4293b61b449cd121b98699be727d40b79ba72", size = 8819750 }, - { url = "https://files.pythonhosted.org/packages/38/8d/580db77c3b9d5c3d9479e55b0b832d279c30c8f00ab0190d4cd8fc67831c/ruff-0.9.1-py3-none-win_amd64.whl", hash = "sha256:342a824b46ddbcdddd3abfbb332fa7fcaac5488bf18073e841236aadf4ad5c19", size = 9701331 }, - { url = "https://files.pythonhosted.org/packages/b2/94/0498cdb7316ed67a1928300dd87d659c933479f44dec51b4f62bfd1f8028/ruff-0.9.1-py3-none-win_arm64.whl", hash = "sha256:1cd76c7f9c679e6e8f2af8f778367dca82b95009bc7b1a85a47f1521ae524fa7", size = 9145708 }, +version = "0.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/80/63/77ecca9d21177600f551d1c58ab0e5a0b260940ea7312195bd2a4798f8a8/ruff-0.9.2.tar.gz", hash = "sha256:b5eceb334d55fae5f316f783437392642ae18e16dcf4f1858d55d3c2a0f8f5d0", size = 3553799 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b9/0e168e4e7fb3af851f739e8f07889b91d1a33a30fca8c29fa3149d6b03ec/ruff-0.9.2-py3-none-linux_armv6l.whl", hash = "sha256:80605a039ba1454d002b32139e4970becf84b5fee3a3c3bf1c2af6f61a784347", size = 11652408 }, + { url = "https://files.pythonhosted.org/packages/2c/22/08ede5db17cf701372a461d1cb8fdde037da1d4fa622b69ac21960e6237e/ruff-0.9.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9aab82bb20afd5f596527045c01e6ae25a718ff1784cb92947bff1f83068b00", size = 11587553 }, + { url = "https://files.pythonhosted.org/packages/42/05/dedfc70f0bf010230229e33dec6e7b2235b2a1b8cbb2a991c710743e343f/ruff-0.9.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fbd337bac1cfa96be615f6efcd4bc4d077edbc127ef30e2b8ba2a27e18c054d4", size = 11020755 }, + { url = "https://files.pythonhosted.org/packages/df/9b/65d87ad9b2e3def67342830bd1af98803af731243da1255537ddb8f22209/ruff-0.9.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82b35259b0cbf8daa22a498018e300b9bb0174c2bbb7bcba593935158a78054d", size = 11826502 }, + { url = "https://files.pythonhosted.org/packages/93/02/f2239f56786479e1a89c3da9bc9391120057fc6f4a8266a5b091314e72ce/ruff-0.9.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b6a9701d1e371bf41dca22015c3f89769da7576884d2add7317ec1ec8cb9c3c", size = 11390562 }, + { url = "https://files.pythonhosted.org/packages/c9/37/d3a854dba9931f8cb1b2a19509bfe59e00875f48ade632e95aefcb7a0aee/ruff-0.9.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cc53e68b3c5ae41e8faf83a3b89f4a5d7b2cb666dff4b366bb86ed2a85b481f", size = 12548968 }, + { url = "https://files.pythonhosted.org/packages/fa/c3/c7b812bb256c7a1d5553433e95980934ffa85396d332401f6b391d3c4569/ruff-0.9.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8efd9da7a1ee314b910da155ca7e8953094a7c10d0c0a39bfde3fcfd2a015684", size = 13187155 }, + { url = "https://files.pythonhosted.org/packages/bd/5a/3c7f9696a7875522b66aa9bba9e326e4e5894b4366bd1dc32aa6791cb1ff/ruff-0.9.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3292c5a22ea9a5f9a185e2d131dc7f98f8534a32fb6d2ee7b9944569239c648d", size = 12704674 }, + { url = "https://files.pythonhosted.org/packages/be/d6/d908762257a96ce5912187ae9ae86792e677ca4f3dc973b71e7508ff6282/ruff-0.9.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a605fdcf6e8b2d39f9436d343d1f0ff70c365a1e681546de0104bef81ce88df", size = 14529328 }, + { url = "https://files.pythonhosted.org/packages/2d/c2/049f1e6755d12d9cd8823242fa105968f34ee4c669d04cac8cea51a50407/ruff-0.9.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c547f7f256aa366834829a08375c297fa63386cbe5f1459efaf174086b564247", size = 12385955 }, + { url = "https://files.pythonhosted.org/packages/91/5a/a9bdb50e39810bd9627074e42743b00e6dc4009d42ae9f9351bc3dbc28e7/ruff-0.9.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d18bba3d3353ed916e882521bc3e0af403949dbada344c20c16ea78f47af965e", size = 11810149 }, + { url = "https://files.pythonhosted.org/packages/e5/fd/57df1a0543182f79a1236e82a79c68ce210efb00e97c30657d5bdb12b478/ruff-0.9.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b338edc4610142355ccf6b87bd356729b62bf1bc152a2fad5b0c7dc04af77bfe", size = 11479141 }, + { url = "https://files.pythonhosted.org/packages/dc/16/bc3fd1d38974f6775fc152a0554f8c210ff80f2764b43777163c3c45d61b/ruff-0.9.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:492a5e44ad9b22a0ea98cf72e40305cbdaf27fac0d927f8bc9e1df316dcc96eb", size = 12014073 }, + { url = "https://files.pythonhosted.org/packages/47/6b/e4ca048a8f2047eb652e1e8c755f384d1b7944f69ed69066a37acd4118b0/ruff-0.9.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:af1e9e9fe7b1f767264d26b1075ac4ad831c7db976911fa362d09b2d0356426a", size = 12435758 }, + { url = "https://files.pythonhosted.org/packages/c2/40/4d3d6c979c67ba24cf183d29f706051a53c36d78358036a9cd21421582ab/ruff-0.9.2-py3-none-win32.whl", hash = "sha256:71cbe22e178c5da20e1514e1e01029c73dc09288a8028a5d3446e6bba87a5145", size = 9796916 }, + { url = "https://files.pythonhosted.org/packages/c3/ef/7f548752bdb6867e6939489c87fe4da489ab36191525fadc5cede2a6e8e2/ruff-0.9.2-py3-none-win_amd64.whl", hash = "sha256:c5e1d6abc798419cf46eed03f54f2e0c3adb1ad4b801119dedf23fcaf69b55b5", size = 10773080 }, + { url = "https://files.pythonhosted.org/packages/0e/4e/33df635528292bd2d18404e4daabcd74ca8a9853b2e1df85ed3d32d24362/ruff-0.9.2-py3-none-win_arm64.whl", hash = "sha256:a1b63fa24149918f8b37cef2ee6fff81f24f0d74b6f0bdc37bc3e1f2143e41c6", size = 10001738 }, ] [[package]] @@ -2352,6 +2696,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229 }, ] +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 }, +] + [[package]] name = "uvicorn" version = "0.34.0" @@ -2368,16 +2721,48 @@ wheels = [ [[package]] name = "virtualenv" -version = "20.28.1" +version = "20.29.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "distlib" }, { name = "filelock" }, { name = "platformdirs" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/50/39/689abee4adc85aad2af8174bb195a819d0be064bf55fcc73b49d2b28ae77/virtualenv-20.28.1.tar.gz", hash = "sha256:5d34ab240fdb5d21549b76f9e8ff3af28252f5499fb6d6f031adac4e5a8c5329", size = 7650532 } +sdist = { url = "https://files.pythonhosted.org/packages/a7/ca/f23dcb02e161a9bba141b1c08aa50e8da6ea25e6d780528f1d385a3efe25/virtualenv-20.29.1.tar.gz", hash = "sha256:b8b8970138d32fb606192cb97f6cd4bb644fa486be9308fb9b63f81091b5dc35", size = 7658028 } wheels = [ - { url = "https://files.pythonhosted.org/packages/51/8f/dfb257ca6b4e27cb990f1631142361e4712badab8e3ca8dc134d96111515/virtualenv-20.28.1-py3-none-any.whl", hash = "sha256:412773c85d4dab0409b83ec36f7a6499e72eaf08c80e81e9576bca61831c71cb", size = 4276719 }, + { url = "https://files.pythonhosted.org/packages/89/9b/599bcfc7064fbe5740919e78c5df18e5dceb0887e676256a1061bb5ae232/virtualenv-20.29.1-py3-none-any.whl", hash = "sha256:4e4cb403c0b0da39e13b46b1b2476e505cb0046b25f242bee80f62bf990b2779", size = 4282379 }, +] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/56/90994d789c61df619bfc5ce2ecdabd5eeff564e1eb47512bd01b5e019569/watchdog-6.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1cdb490583ebd691c012b3d6dae011000fe42edb7a82ece80965b42abd61f26", size = 96390 }, + { url = "https://files.pythonhosted.org/packages/55/46/9a67ee697342ddf3c6daa97e3a587a56d6c4052f881ed926a849fcf7371c/watchdog-6.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bc64ab3bdb6a04d69d4023b29422170b74681784ffb9463ed4870cf2f3e66112", size = 88389 }, + { url = "https://files.pythonhosted.org/packages/44/65/91b0985747c52064d8701e1075eb96f8c40a79df889e59a399453adfb882/watchdog-6.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c897ac1b55c5a1461e16dae288d22bb2e412ba9807df8397a635d88f671d36c3", size = 89020 }, + { url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393 }, + { url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392 }, + { url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019 }, + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471 }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449 }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054 }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480 }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451 }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057 }, + { url = "https://files.pythonhosted.org/packages/30/ad/d17b5d42e28a8b91f8ed01cb949da092827afb9995d4559fd448d0472763/watchdog-6.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c7ac31a19f4545dd92fc25d200694098f42c9a8e391bc00bdd362c5736dbf881", size = 87902 }, + { url = "https://files.pythonhosted.org/packages/5c/ca/c3649991d140ff6ab67bfc85ab42b165ead119c9e12211e08089d763ece5/watchdog-6.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9513f27a1a582d9808cf21a07dae516f0fab1cf2d7683a742c498b93eedabb11", size = 88380 }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079 }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076 }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077 }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078 }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065 }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070 }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067 }, ] [[package]] @@ -2400,66 +2785,65 @@ wheels = [ [[package]] name = "websockets" -version = "14.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f4/1b/380b883ce05bb5f45a905b61790319a28958a9ab1e4b6b95ff5464b60ca1/websockets-14.1.tar.gz", hash = "sha256:398b10c77d471c0aab20a845e7a60076b6390bfdaac7a6d2edb0d2c59d75e8d8", size = 162840 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/91/b1b375dbd856fd5fff3f117de0e520542343ecaf4e8fc60f1ac1e9f5822c/websockets-14.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a0adf84bc2e7c86e8a202537b4fd50e6f7f0e4a6b6bf64d7ccb96c4cd3330b29", size = 161950 }, - { url = "https://files.pythonhosted.org/packages/61/8f/4d52f272d3ebcd35e1325c646e98936099a348374d4a6b83b524bded8116/websockets-14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90b5d9dfbb6d07a84ed3e696012610b6da074d97453bd01e0e30744b472c8179", size = 159601 }, - { url = "https://files.pythonhosted.org/packages/c4/b1/29e87b53eb1937992cdee094a0988aadc94f25cf0b37e90c75eed7123d75/websockets-14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2177ee3901075167f01c5e335a6685e71b162a54a89a56001f1c3e9e3d2ad250", size = 159854 }, - { url = "https://files.pythonhosted.org/packages/3f/e6/752a2f5e8321ae2a613062676c08ff2fccfb37dc837a2ee919178a372e8a/websockets-14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f14a96a0034a27f9d47fd9788913924c89612225878f8078bb9d55f859272b0", size = 168835 }, - { url = "https://files.pythonhosted.org/packages/60/27/ca62de7877596926321b99071639275e94bb2401397130b7cf33dbf2106a/websockets-14.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f874ba705deea77bcf64a9da42c1f5fc2466d8f14daf410bc7d4ceae0a9fcb0", size = 167844 }, - { url = "https://files.pythonhosted.org/packages/7e/db/f556a1d06635c680ef376be626c632e3f2bbdb1a0189d1d1bffb061c3b70/websockets-14.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9607b9a442392e690a57909c362811184ea429585a71061cd5d3c2b98065c199", size = 168157 }, - { url = "https://files.pythonhosted.org/packages/b3/bc/99e5f511838c365ac6ecae19674eb5e94201aa4235bd1af3e6fa92c12905/websockets-14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bea45f19b7ca000380fbd4e02552be86343080120d074b87f25593ce1700ad58", size = 168561 }, - { url = "https://files.pythonhosted.org/packages/c6/e7/251491585bad61c79e525ac60927d96e4e17b18447cc9c3cfab47b2eb1b8/websockets-14.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:219c8187b3ceeadbf2afcf0f25a4918d02da7b944d703b97d12fb01510869078", size = 167979 }, - { url = "https://files.pythonhosted.org/packages/ac/98/7ac2e4eeada19bdbc7a3a66a58e3ebdf33648b9e1c5b3f08c3224df168cf/websockets-14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ad2ab2547761d79926effe63de21479dfaf29834c50f98c4bf5b5480b5838434", size = 167925 }, - { url = "https://files.pythonhosted.org/packages/ab/3d/09e65c47ee2396b7482968068f6e9b516221e1032b12dcf843b9412a5dfb/websockets-14.1-cp310-cp310-win32.whl", hash = "sha256:1288369a6a84e81b90da5dbed48610cd7e5d60af62df9851ed1d1d23a9069f10", size = 162831 }, - { url = "https://files.pythonhosted.org/packages/8a/67/59828a3d09740e6a485acccfbb66600632f2178b6ed1b61388ee96f17d5a/websockets-14.1-cp310-cp310-win_amd64.whl", hash = "sha256:e0744623852f1497d825a49a99bfbec9bea4f3f946df6eb9d8a2f0c37a2fec2e", size = 163266 }, - { url = "https://files.pythonhosted.org/packages/97/ed/c0d03cb607b7fe1f7ff45e2cd4bb5cd0f9e3299ced79c2c303a6fff44524/websockets-14.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:449d77d636f8d9c17952628cc7e3b8faf6e92a17ec581ec0c0256300717e1512", size = 161949 }, - { url = "https://files.pythonhosted.org/packages/06/91/bf0a44e238660d37a2dda1b4896235d20c29a2d0450f3a46cd688f43b239/websockets-14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a35f704be14768cea9790d921c2c1cc4fc52700410b1c10948511039be824aac", size = 159606 }, - { url = "https://files.pythonhosted.org/packages/ff/b8/7185212adad274c2b42b6a24e1ee6b916b7809ed611cbebc33b227e5c215/websockets-14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b1f3628a0510bd58968c0f60447e7a692933589b791a6b572fcef374053ca280", size = 159854 }, - { url = "https://files.pythonhosted.org/packages/5a/8a/0849968d83474be89c183d8ae8dcb7f7ada1a3c24f4d2a0d7333c231a2c3/websockets-14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c3deac3748ec73ef24fc7be0b68220d14d47d6647d2f85b2771cb35ea847aa1", size = 169402 }, - { url = "https://files.pythonhosted.org/packages/bd/4f/ef886e37245ff6b4a736a09b8468dae05d5d5c99de1357f840d54c6f297d/websockets-14.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7048eb4415d46368ef29d32133134c513f507fff7d953c18c91104738a68c3b3", size = 168406 }, - { url = "https://files.pythonhosted.org/packages/11/43/e2dbd4401a63e409cebddedc1b63b9834de42f51b3c84db885469e9bdcef/websockets-14.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6cf0ad281c979306a6a34242b371e90e891bce504509fb6bb5246bbbf31e7b6", size = 168776 }, - { url = "https://files.pythonhosted.org/packages/6d/d6/7063e3f5c1b612e9f70faae20ebaeb2e684ffa36cb959eb0862ee2809b32/websockets-14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cc1fc87428c1d18b643479caa7b15db7d544652e5bf610513d4a3478dbe823d0", size = 169083 }, - { url = "https://files.pythonhosted.org/packages/49/69/e6f3d953f2fa0f8a723cf18cd011d52733bd7f6e045122b24e0e7f49f9b0/websockets-14.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f95ba34d71e2fa0c5d225bde3b3bdb152e957150100e75c86bc7f3964c450d89", size = 168529 }, - { url = "https://files.pythonhosted.org/packages/70/ff/f31fa14561fc1d7b8663b0ed719996cf1f581abee32c8fb2f295a472f268/websockets-14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9481a6de29105d73cf4515f2bef8eb71e17ac184c19d0b9918a3701c6c9c4f23", size = 168475 }, - { url = "https://files.pythonhosted.org/packages/f1/15/b72be0e4bf32ff373aa5baef46a4c7521b8ea93ad8b49ca8c6e8e764c083/websockets-14.1-cp311-cp311-win32.whl", hash = "sha256:368a05465f49c5949e27afd6fbe0a77ce53082185bbb2ac096a3a8afaf4de52e", size = 162833 }, - { url = "https://files.pythonhosted.org/packages/bc/ef/2d81679acbe7057ffe2308d422f744497b52009ea8bab34b6d74a2657d1d/websockets-14.1-cp311-cp311-win_amd64.whl", hash = "sha256:6d24fc337fc055c9e83414c94e1ee0dee902a486d19d2a7f0929e49d7d604b09", size = 163263 }, - { url = "https://files.pythonhosted.org/packages/55/64/55698544ce29e877c9188f1aee9093712411a8fc9732cca14985e49a8e9c/websockets-14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed907449fe5e021933e46a3e65d651f641975a768d0649fee59f10c2985529ed", size = 161957 }, - { url = "https://files.pythonhosted.org/packages/a2/b1/b088f67c2b365f2c86c7b48edb8848ac27e508caf910a9d9d831b2f343cb/websockets-14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:87e31011b5c14a33b29f17eb48932e63e1dcd3fa31d72209848652310d3d1f0d", size = 159620 }, - { url = "https://files.pythonhosted.org/packages/c1/89/2a09db1bbb40ba967a1b8225b07b7df89fea44f06de9365f17f684d0f7e6/websockets-14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bc6ccf7d54c02ae47a48ddf9414c54d48af9c01076a2e1023e3b486b6e72c707", size = 159852 }, - { url = "https://files.pythonhosted.org/packages/ca/c1/f983138cd56e7d3079f1966e81f77ce6643f230cd309f73aa156bb181749/websockets-14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9777564c0a72a1d457f0848977a1cbe15cfa75fa2f67ce267441e465717dcf1a", size = 169675 }, - { url = "https://files.pythonhosted.org/packages/c1/c8/84191455d8660e2a0bdb33878d4ee5dfa4a2cedbcdc88bbd097303b65bfa/websockets-14.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a655bde548ca98f55b43711b0ceefd2a88a71af6350b0c168aa77562104f3f45", size = 168619 }, - { url = "https://files.pythonhosted.org/packages/8d/a7/62e551fdcd7d44ea74a006dc193aba370505278ad76efd938664531ce9d6/websockets-14.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3dfff83ca578cada2d19e665e9c8368e1598d4e787422a460ec70e531dbdd58", size = 169042 }, - { url = "https://files.pythonhosted.org/packages/ad/ed/1532786f55922c1e9c4d329608e36a15fdab186def3ca9eb10d7465bc1cc/websockets-14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6a6c9bcf7cdc0fd41cc7b7944447982e8acfd9f0d560ea6d6845428ed0562058", size = 169345 }, - { url = "https://files.pythonhosted.org/packages/ea/fb/160f66960d495df3de63d9bcff78e1b42545b2a123cc611950ffe6468016/websockets-14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4b6caec8576e760f2c7dd878ba817653144d5f369200b6ddf9771d64385b84d4", size = 168725 }, - { url = "https://files.pythonhosted.org/packages/cf/53/1bf0c06618b5ac35f1d7906444b9958f8485682ab0ea40dee7b17a32da1e/websockets-14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb6d38971c800ff02e4a6afd791bbe3b923a9a57ca9aeab7314c21c84bf9ff05", size = 168712 }, - { url = "https://files.pythonhosted.org/packages/e5/22/5ec2f39fff75f44aa626f86fa7f20594524a447d9c3be94d8482cd5572ef/websockets-14.1-cp312-cp312-win32.whl", hash = "sha256:1d045cbe1358d76b24d5e20e7b1878efe578d9897a25c24e6006eef788c0fdf0", size = 162838 }, - { url = "https://files.pythonhosted.org/packages/74/27/28f07df09f2983178db7bf6c9cccc847205d2b92ced986cd79565d68af4f/websockets-14.1-cp312-cp312-win_amd64.whl", hash = "sha256:90f4c7a069c733d95c308380aae314f2cb45bd8a904fb03eb36d1a4983a4993f", size = 163277 }, - { url = "https://files.pythonhosted.org/packages/34/77/812b3ba5110ed8726eddf9257ab55ce9e85d97d4aa016805fdbecc5e5d48/websockets-14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3630b670d5057cd9e08b9c4dab6493670e8e762a24c2c94ef312783870736ab9", size = 161966 }, - { url = "https://files.pythonhosted.org/packages/8d/24/4fcb7aa6986ae7d9f6d083d9d53d580af1483c5ec24bdec0978307a0f6ac/websockets-14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36ebd71db3b89e1f7b1a5deaa341a654852c3518ea7a8ddfdf69cc66acc2db1b", size = 159625 }, - { url = "https://files.pythonhosted.org/packages/f8/47/2a0a3a2fc4965ff5b9ce9324d63220156bd8bedf7f90824ab92a822e65fd/websockets-14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5b918d288958dc3fa1c5a0b9aa3256cb2b2b84c54407f4813c45d52267600cd3", size = 159857 }, - { url = "https://files.pythonhosted.org/packages/dd/c8/d7b425011a15e35e17757e4df75b25e1d0df64c0c315a44550454eaf88fc/websockets-14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00fe5da3f037041da1ee0cf8e308374e236883f9842c7c465aa65098b1c9af59", size = 169635 }, - { url = "https://files.pythonhosted.org/packages/93/39/6e3b5cffa11036c40bd2f13aba2e8e691ab2e01595532c46437b56575678/websockets-14.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8149a0f5a72ca36720981418eeffeb5c2729ea55fa179091c81a0910a114a5d2", size = 168578 }, - { url = "https://files.pythonhosted.org/packages/cf/03/8faa5c9576299b2adf34dcccf278fc6bbbcda8a3efcc4d817369026be421/websockets-14.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77569d19a13015e840b81550922056acabc25e3f52782625bc6843cfa034e1da", size = 169018 }, - { url = "https://files.pythonhosted.org/packages/8c/05/ea1fec05cc3a60defcdf0bb9f760c3c6bd2dd2710eff7ac7f891864a22ba/websockets-14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cf5201a04550136ef870aa60ad3d29d2a59e452a7f96b94193bee6d73b8ad9a9", size = 169383 }, - { url = "https://files.pythonhosted.org/packages/21/1d/eac1d9ed787f80754e51228e78855f879ede1172c8b6185aca8cef494911/websockets-14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:88cf9163ef674b5be5736a584c999e98daf3aabac6e536e43286eb74c126b9c7", size = 168773 }, - { url = "https://files.pythonhosted.org/packages/0e/1b/e808685530185915299740d82b3a4af3f2b44e56ccf4389397c7a5d95d39/websockets-14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:836bef7ae338a072e9d1863502026f01b14027250a4545672673057997d5c05a", size = 168757 }, - { url = "https://files.pythonhosted.org/packages/b6/19/6ab716d02a3b068fbbeb6face8a7423156e12c446975312f1c7c0f4badab/websockets-14.1-cp313-cp313-win32.whl", hash = "sha256:0d4290d559d68288da9f444089fd82490c8d2744309113fc26e2da6e48b65da6", size = 162834 }, - { url = "https://files.pythonhosted.org/packages/6c/fd/ab6b7676ba712f2fc89d1347a4b5bdc6aa130de10404071f2b2606450209/websockets-14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8621a07991add373c3c5c2cf89e1d277e49dc82ed72c75e3afc74bd0acc446f0", size = 163277 }, - { url = "https://files.pythonhosted.org/packages/fb/cd/382a05a1ba2a93bd9fb807716a660751295df72e77204fb130a102fcdd36/websockets-14.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e5dc25a9dbd1a7f61eca4b7cb04e74ae4b963d658f9e4f9aad9cd00b688692c8", size = 159633 }, - { url = "https://files.pythonhosted.org/packages/b7/a0/fa7c62e2952ef028b422fbf420f9353d9dd4dfaa425de3deae36e98c0784/websockets-14.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:04a97aca96ca2acedf0d1f332c861c5a4486fdcba7bcef35873820f940c4231e", size = 159867 }, - { url = "https://files.pythonhosted.org/packages/c1/94/954b4924f868db31d5f0935893c7a8446515ee4b36bb8ad75a929469e453/websockets-14.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df174ece723b228d3e8734a6f2a6febbd413ddec39b3dc592f5a4aa0aff28098", size = 161121 }, - { url = "https://files.pythonhosted.org/packages/7a/2e/f12bbb41a8f2abb76428ba4fdcd9e67b5b364a3e7fa97c88f4d6950aa2d4/websockets-14.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:034feb9f4286476f273b9a245fb15f02c34d9586a5bc936aff108c3ba1b21beb", size = 160731 }, - { url = "https://files.pythonhosted.org/packages/13/97/b76979401f2373af1fe3e08f960b265cecab112e7dac803446fb98351a52/websockets-14.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:660c308dabd2b380807ab64b62985eaccf923a78ebc572bd485375b9ca2b7dc7", size = 160681 }, - { url = "https://files.pythonhosted.org/packages/39/9c/16916d9a436c109a1d7ba78817e8fee357b78968be3f6e6f517f43afa43d/websockets-14.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5a42d3ecbb2db5080fc578314439b1d79eef71d323dc661aa616fb492436af5d", size = 163316 }, - { url = "https://files.pythonhosted.org/packages/b0/0b/c7e5d11020242984d9d37990310520ed663b942333b83a033c2f20191113/websockets-14.1-py3-none-any.whl", hash = "sha256:4d4fc827a20abe6d544a119896f6b78ee13fe81cbfef416f3f2ddf09a03f0e2e", size = 156277 }, +version = "14.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/54/8359678c726243d19fae38ca14a334e740782336c9f19700858c4eb64a1e/websockets-14.2.tar.gz", hash = "sha256:5059ed9c54945efb321f097084b4c7e52c246f2c869815876a69d1efc4ad6eb5", size = 164394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/fa/76607eb7dcec27b2d18d63f60a32e60e2b8629780f343bb83a4dbb9f4350/websockets-14.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e8179f95323b9ab1c11723e5d91a89403903f7b001828161b480a7810b334885", size = 163089 }, + { url = "https://files.pythonhosted.org/packages/9e/00/ad2246b5030575b79e7af0721810fdaecaf94c4b2625842ef7a756fa06dd/websockets-14.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0d8c3e2cdb38f31d8bd7d9d28908005f6fa9def3324edb9bf336d7e4266fd397", size = 160741 }, + { url = "https://files.pythonhosted.org/packages/72/f7/60f10924d333a28a1ff3fcdec85acf226281331bdabe9ad74947e1b7fc0a/websockets-14.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:714a9b682deb4339d39ffa674f7b674230227d981a37d5d174a4a83e3978a610", size = 160996 }, + { url = "https://files.pythonhosted.org/packages/63/7c/c655789cf78648c01ac6ecbe2d6c18f91b75bdc263ffee4d08ce628d12f0/websockets-14.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2e53c72052f2596fb792a7acd9704cbc549bf70fcde8a99e899311455974ca3", size = 169974 }, + { url = "https://files.pythonhosted.org/packages/fb/5b/013ed8b4611857ac92ac631079c08d9715b388bd1d88ec62e245f87a39df/websockets-14.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e3fbd68850c837e57373d95c8fe352203a512b6e49eaae4c2f4088ef8cf21980", size = 168985 }, + { url = "https://files.pythonhosted.org/packages/cd/33/aa3e32fd0df213a5a442310754fe3f89dd87a0b8e5b4e11e0991dd3bcc50/websockets-14.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b27ece32f63150c268593d5fdb82819584831a83a3f5809b7521df0685cd5d8", size = 169297 }, + { url = "https://files.pythonhosted.org/packages/93/17/dae0174883d6399f57853ac44abf5f228eaba86d98d160f390ffabc19b6e/websockets-14.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4daa0faea5424d8713142b33825fff03c736f781690d90652d2c8b053345b0e7", size = 169677 }, + { url = "https://files.pythonhosted.org/packages/42/e2/0375af7ac00169b98647c804651c515054b34977b6c1354f1458e4116c1e/websockets-14.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:bc63cee8596a6ec84d9753fd0fcfa0452ee12f317afe4beae6b157f0070c6c7f", size = 169089 }, + { url = "https://files.pythonhosted.org/packages/73/8d/80f71d2a351a44b602859af65261d3dde3a0ce4e76cf9383738a949e0cc3/websockets-14.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a570862c325af2111343cc9b0257b7119b904823c675b22d4ac547163088d0d", size = 169026 }, + { url = "https://files.pythonhosted.org/packages/48/97/173b1fa6052223e52bb4054a141433ad74931d94c575e04b654200b98ca4/websockets-14.2-cp310-cp310-win32.whl", hash = "sha256:75862126b3d2d505e895893e3deac0a9339ce750bd27b4ba515f008b5acf832d", size = 163967 }, + { url = "https://files.pythonhosted.org/packages/c0/5b/2fcf60f38252a4562b28b66077e0d2b48f91fef645d5f78874cd1dec807b/websockets-14.2-cp310-cp310-win_amd64.whl", hash = "sha256:cc45afb9c9b2dc0852d5c8b5321759cf825f82a31bfaf506b65bf4668c96f8b2", size = 164413 }, + { url = "https://files.pythonhosted.org/packages/15/b6/504695fb9a33df0ca56d157f5985660b5fc5b4bf8c78f121578d2d653392/websockets-14.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3bdc8c692c866ce5fefcaf07d2b55c91d6922ac397e031ef9b774e5b9ea42166", size = 163088 }, + { url = "https://files.pythonhosted.org/packages/81/26/ebfb8f6abe963c795122439c6433c4ae1e061aaedfc7eff32d09394afbae/websockets-14.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c93215fac5dadc63e51bcc6dceca72e72267c11def401d6668622b47675b097f", size = 160745 }, + { url = "https://files.pythonhosted.org/packages/a1/c6/1435ad6f6dcbff80bb95e8986704c3174da8866ddb751184046f5c139ef6/websockets-14.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1c9b6535c0e2cf8a6bf938064fb754aaceb1e6a4a51a80d884cd5db569886910", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/96/63/900c27cfe8be1a1f2433fc77cd46771cf26ba57e6bdc7cf9e63644a61863/websockets-14.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a52a6d7cf6938e04e9dceb949d35fbdf58ac14deea26e685ab6368e73744e4c", size = 170543 }, + { url = "https://files.pythonhosted.org/packages/00/8b/bec2bdba92af0762d42d4410593c1d7d28e9bfd952c97a3729df603dc6ea/websockets-14.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9f05702e93203a6ff5226e21d9b40c037761b2cfb637187c9802c10f58e40473", size = 169546 }, + { url = "https://files.pythonhosted.org/packages/6b/a9/37531cb5b994f12a57dec3da2200ef7aadffef82d888a4c29a0d781568e4/websockets-14.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22441c81a6748a53bfcb98951d58d1af0661ab47a536af08920d129b4d1c3473", size = 169911 }, + { url = "https://files.pythonhosted.org/packages/60/d5/a6eadba2ed9f7e65d677fec539ab14a9b83de2b484ab5fe15d3d6d208c28/websockets-14.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd9b868d78b194790e6236d9cbc46d68aba4b75b22497eb4ab64fa640c3af56", size = 170183 }, + { url = "https://files.pythonhosted.org/packages/76/57/a338ccb00d1df881c1d1ee1f2a20c9c1b5b29b51e9e0191ee515d254fea6/websockets-14.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1a5a20d5843886d34ff8c57424cc65a1deda4375729cbca4cb6b3353f3ce4142", size = 169623 }, + { url = "https://files.pythonhosted.org/packages/64/22/e5f7c33db0cb2c1d03b79fd60d189a1da044e2661f5fd01d629451e1db89/websockets-14.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:34277a29f5303d54ec6468fb525d99c99938607bc96b8d72d675dee2b9f5bf1d", size = 169583 }, + { url = "https://files.pythonhosted.org/packages/aa/2e/2b4662237060063a22e5fc40d46300a07142afe30302b634b4eebd717c07/websockets-14.2-cp311-cp311-win32.whl", hash = "sha256:02687db35dbc7d25fd541a602b5f8e451a238ffa033030b172ff86a93cb5dc2a", size = 163969 }, + { url = "https://files.pythonhosted.org/packages/94/a5/0cda64e1851e73fc1ecdae6f42487babb06e55cb2f0dc8904b81d8ef6857/websockets-14.2-cp311-cp311-win_amd64.whl", hash = "sha256:862e9967b46c07d4dcd2532e9e8e3c2825e004ffbf91a5ef9dde519ee2effb0b", size = 164408 }, + { url = "https://files.pythonhosted.org/packages/c1/81/04f7a397653dc8bec94ddc071f34833e8b99b13ef1a3804c149d59f92c18/websockets-14.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f20522e624d7ffbdbe259c6b6a65d73c895045f76a93719aa10cd93b3de100c", size = 163096 }, + { url = "https://files.pythonhosted.org/packages/ec/c5/de30e88557e4d70988ed4d2eabd73fd3e1e52456b9f3a4e9564d86353b6d/websockets-14.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:647b573f7d3ada919fd60e64d533409a79dcf1ea21daeb4542d1d996519ca967", size = 160758 }, + { url = "https://files.pythonhosted.org/packages/e5/8c/d130d668781f2c77d106c007b6c6c1d9db68239107c41ba109f09e6c218a/websockets-14.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6af99a38e49f66be5a64b1e890208ad026cda49355661549c507152113049990", size = 160995 }, + { url = "https://files.pythonhosted.org/packages/a6/bc/f6678a0ff17246df4f06765e22fc9d98d1b11a258cc50c5968b33d6742a1/websockets-14.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:091ab63dfc8cea748cc22c1db2814eadb77ccbf82829bac6b2fbe3401d548eda", size = 170815 }, + { url = "https://files.pythonhosted.org/packages/d8/b2/8070cb970c2e4122a6ef38bc5b203415fd46460e025652e1ee3f2f43a9a3/websockets-14.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b374e8953ad477d17e4851cdc66d83fdc2db88d9e73abf755c94510ebddceb95", size = 169759 }, + { url = "https://files.pythonhosted.org/packages/81/da/72f7caabd94652e6eb7e92ed2d3da818626e70b4f2b15a854ef60bf501ec/websockets-14.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a39d7eceeea35db85b85e1169011bb4321c32e673920ae9c1b6e0978590012a3", size = 170178 }, + { url = "https://files.pythonhosted.org/packages/31/e0/812725b6deca8afd3a08a2e81b3c4c120c17f68c9b84522a520b816cda58/websockets-14.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0a6f3efd47ffd0d12080594f434faf1cd2549b31e54870b8470b28cc1d3817d9", size = 170453 }, + { url = "https://files.pythonhosted.org/packages/66/d3/8275dbc231e5ba9bb0c4f93144394b4194402a7a0c8ffaca5307a58ab5e3/websockets-14.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:065ce275e7c4ffb42cb738dd6b20726ac26ac9ad0a2a48e33ca632351a737267", size = 169830 }, + { url = "https://files.pythonhosted.org/packages/a3/ae/e7d1a56755ae15ad5a94e80dd490ad09e345365199600b2629b18ee37bc7/websockets-14.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e9d0e53530ba7b8b5e389c02282f9d2aa47581514bd6049d3a7cffe1385cf5fe", size = 169824 }, + { url = "https://files.pythonhosted.org/packages/b6/32/88ccdd63cb261e77b882e706108d072e4f1c839ed723bf91a3e1f216bf60/websockets-14.2-cp312-cp312-win32.whl", hash = "sha256:20e6dd0984d7ca3037afcb4494e48c74ffb51e8013cac71cf607fffe11df7205", size = 163981 }, + { url = "https://files.pythonhosted.org/packages/b3/7d/32cdb77990b3bdc34a306e0a0f73a1275221e9a66d869f6ff833c95b56ef/websockets-14.2-cp312-cp312-win_amd64.whl", hash = "sha256:44bba1a956c2c9d268bdcdf234d5e5ff4c9b6dc3e300545cbe99af59dda9dcce", size = 164421 }, + { url = "https://files.pythonhosted.org/packages/82/94/4f9b55099a4603ac53c2912e1f043d6c49d23e94dd82a9ce1eb554a90215/websockets-14.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f1372e511c7409a542291bce92d6c83320e02c9cf392223272287ce55bc224e", size = 163102 }, + { url = "https://files.pythonhosted.org/packages/8e/b7/7484905215627909d9a79ae07070057afe477433fdacb59bf608ce86365a/websockets-14.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4da98b72009836179bb596a92297b1a61bb5a830c0e483a7d0766d45070a08ad", size = 160766 }, + { url = "https://files.pythonhosted.org/packages/a3/a4/edb62efc84adb61883c7d2c6ad65181cb087c64252138e12d655989eec05/websockets-14.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8a86a269759026d2bde227652b87be79f8a734e582debf64c9d302faa1e9f03", size = 160998 }, + { url = "https://files.pythonhosted.org/packages/f5/79/036d320dc894b96af14eac2529967a6fc8b74f03b83c487e7a0e9043d842/websockets-14.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86cf1aaeca909bf6815ea714d5c5736c8d6dd3a13770e885aafe062ecbd04f1f", size = 170780 }, + { url = "https://files.pythonhosted.org/packages/63/75/5737d21ee4dd7e4b9d487ee044af24a935e36a9ff1e1419d684feedcba71/websockets-14.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b0f6c3ba3b1240f602ebb3971d45b02cc12bd1845466dd783496b3b05783a5", size = 169717 }, + { url = "https://files.pythonhosted.org/packages/2c/3c/bf9b2c396ed86a0b4a92ff4cdaee09753d3ee389be738e92b9bbd0330b64/websockets-14.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:669c3e101c246aa85bc8534e495952e2ca208bd87994650b90a23d745902db9a", size = 170155 }, + { url = "https://files.pythonhosted.org/packages/75/2d/83a5aca7247a655b1da5eb0ee73413abd5c3a57fc8b92915805e6033359d/websockets-14.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eabdb28b972f3729348e632ab08f2a7b616c7e53d5414c12108c29972e655b20", size = 170495 }, + { url = "https://files.pythonhosted.org/packages/79/dd/699238a92761e2f943885e091486378813ac8f43e3c84990bc394c2be93e/websockets-14.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2066dc4cbcc19f32c12a5a0e8cc1b7ac734e5b64ac0a325ff8353451c4b15ef2", size = 169880 }, + { url = "https://files.pythonhosted.org/packages/c8/c9/67a8f08923cf55ce61aadda72089e3ed4353a95a3a4bc8bf42082810e580/websockets-14.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab95d357cd471df61873dadf66dd05dd4709cae001dd6342edafc8dc6382f307", size = 169856 }, + { url = "https://files.pythonhosted.org/packages/17/b1/1ffdb2680c64e9c3921d99db460546194c40d4acbef999a18c37aa4d58a3/websockets-14.2-cp313-cp313-win32.whl", hash = "sha256:a9e72fb63e5f3feacdcf5b4ff53199ec8c18d66e325c34ee4c551ca748623bbc", size = 163974 }, + { url = "https://files.pythonhosted.org/packages/14/13/8b7fc4cb551b9cfd9890f0fd66e53c18a06240319915533b033a56a3d520/websockets-14.2-cp313-cp313-win_amd64.whl", hash = "sha256:b439ea828c4ba99bb3176dc8d9b933392a2413c0f6b149fdcba48393f573377f", size = 164420 }, + { url = "https://files.pythonhosted.org/packages/10/3d/91d3d2bb1325cd83e8e2c02d0262c7d4426dc8fa0831ef1aa4d6bf2041af/websockets-14.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d7d9cafbccba46e768be8a8ad4635fa3eae1ffac4c6e7cb4eb276ba41297ed29", size = 160773 }, + { url = "https://files.pythonhosted.org/packages/33/7c/cdedadfef7381939577858b1b5718a4ab073adbb584e429dd9d9dc9bfe16/websockets-14.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:c76193c1c044bd1e9b3316dcc34b174bbf9664598791e6fb606d8d29000e070c", size = 161007 }, + { url = "https://files.pythonhosted.org/packages/ca/35/7a20a3c450b27c04e50fbbfc3dfb161ed8e827b2a26ae31c4b59b018b8c6/websockets-14.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd475a974d5352390baf865309fe37dec6831aafc3014ffac1eea99e84e83fc2", size = 162264 }, + { url = "https://files.pythonhosted.org/packages/e8/9c/e3f9600564b0c813f2448375cf28b47dc42c514344faed3a05d71fb527f9/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6c0097a41968b2e2b54ed3424739aab0b762ca92af2379f152c1aef0187e1c", size = 161873 }, + { url = "https://files.pythonhosted.org/packages/3f/37/260f189b16b2b8290d6ae80c9f96d8b34692cf1bb3475df54c38d3deb57d/websockets-14.2-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d7ff794c8b36bc402f2e07c0b2ceb4a2424147ed4785ff03e2a7af03711d60a", size = 161818 }, + { url = "https://files.pythonhosted.org/packages/ff/1e/e47dedac8bf7140e59aa6a679e850c4df9610ae844d71b6015263ddea37b/websockets-14.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dec254fcabc7bd488dab64846f588fc5b6fe0d78f641180030f8ea27b76d72c3", size = 164465 }, + { url = "https://files.pythonhosted.org/packages/7b/c8/d529f8a32ce40d98309f4470780631e971a5a842b60aec864833b3615786/websockets-14.2-py3-none-any.whl", hash = "sha256:7a6ceec4ea84469f15cf15807a747e9efe57e369c384fa86e022b3bea679b79b", size = 157416 }, ] [[package]] name = "xdsl" -version = "0+dynamic" source = { editable = "." } dependencies = [ { name = "immutabledict" }, @@ -2487,6 +2871,11 @@ dev = [ { name = "textual-dev" }, { name = "toml" }, ] +docs = [ + { name = "mkdocs" }, + { name = "mkdocs-material" }, + { name = "mkdocstrings", extra = ["python"] }, +] gui = [ { name = "pyclip" }, { name = "textual" }, @@ -2506,22 +2895,25 @@ requires-dist = [ { name = "filecheck", marker = "extra == 'dev'", specifier = "==1.0.1" }, { name = "immutabledict", specifier = "<4.2.2" }, { name = "ipykernel", marker = "extra == 'dev'" }, - { name = "jax", marker = "extra == 'jax'", specifier = "==0.4.38" }, + { name = "jax", marker = "extra == 'jax'", specifier = "==0.5.0" }, { name = "lit", marker = "extra == 'dev'", specifier = "<19.0.0" }, - { name = "marimo", marker = "extra == 'dev'", specifier = "==0.10.12" }, + { name = "marimo", marker = "extra == 'dev'", specifier = "==0.10.14" }, + { name = "mkdocs", marker = "extra == 'docs'", specifier = ">=1.6.1" }, + { name = "mkdocs-material", marker = "extra == 'docs'", specifier = ">=9.5.49" }, + { name = "mkdocstrings", extras = ["python"], marker = "extra == 'docs'", specifier = ">=0.27.0" }, { name = "nbconvert", marker = "extra == 'dev'", specifier = ">=7.7.2,<8.0.0" }, { name = "nbval", marker = "extra == 'dev'", specifier = "<0.12" }, - { name = "numpy", marker = "extra == 'jax'", specifier = "==2.2.1" }, + { name = "numpy", marker = "extra == 'jax'", specifier = "==2.2.2" }, { name = "ordered-set", specifier = "==4.1.0" }, { name = "pip", marker = "extra == 'dev'", specifier = "<25.0" }, { name = "pre-commit", marker = "extra == 'dev'", specifier = "==4.0.1" }, { name = "pyclip", marker = "extra == 'gui'", specifier = "==0.7" }, - { name = "pyright", marker = "extra == 'dev'", specifier = "==1.1.391" }, + { name = "pyright", marker = "extra == 'dev'", specifier = "==1.1.392.post0" }, { name = "pytest", marker = "extra == 'dev'", specifier = "<8.4" }, { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = "==0.25.2" }, { name = "pytest-cov", marker = "extra == 'dev'" }, { name = "riscemu", marker = "extra == 'riscv'", specifier = "==2.2.7" }, - { name = "ruff", marker = "extra == 'dev'", specifier = "==0.9.1" }, + { name = "ruff", marker = "extra == 'dev'", specifier = "==0.9.2" }, { name = "textual", marker = "extra == 'gui'", specifier = "==1.0.0" }, { name = "textual-dev", marker = "extra == 'dev'", specifier = "==1.7.0" }, { name = "toml", marker = "extra == 'dev'", specifier = "<0.11" }, diff --git a/xdsl/__init__.py b/xdsl/__init__.py index df46b56a94..2044304eee 100644 --- a/xdsl/__init__.py +++ b/xdsl/__init__.py @@ -9,14 +9,9 @@ def __init__(self): def __str__(self): if self._version is None: - import os + from . import _version - if "XDSL_VERSION_OVERRIDE" in os.environ: - self._version = os.environ["XDSL_VERSION_OVERRIDE"] - else: - from . import _version - - self._version = _version.get_versions()["version"] + self._version = _version.get_versions()["version"] return self._version diff --git a/xdsl/backend/riscv/lowering/convert_riscv_scf_to_riscv_cf.py b/xdsl/backend/riscv/lowering/convert_riscv_scf_to_riscv_cf.py index 24abc9f874..c288bffbeb 100644 --- a/xdsl/backend/riscv/lowering/convert_riscv_scf_to_riscv_cf.py +++ b/xdsl/backend/riscv/lowering/convert_riscv_scf_to_riscv_cf.py @@ -7,7 +7,7 @@ RewritePattern, op_type_rewrite_pattern, ) -from xdsl.rewriter import InsertPoint +from xdsl.rewriter import BlockInsertPoint, InsertPoint class LowerRiscvScfForPattern(RewritePattern): @@ -119,7 +119,7 @@ def match_and_rewrite(self, op: riscv_scf.ForOp, rewriter: PatternRewriter, /): ), ) - rewriter.inline_region_before(op.body, end_block) + rewriter.inline_region(op.body, BlockInsertPoint.before(end_block)) # Move lb to new register to initialize the iv. # Skip for loop if condition is not satisfied at start. diff --git a/xdsl/builder.py b/xdsl/builder.py index 50ce855d6e..75f5286c51 100644 --- a/xdsl/builder.py +++ b/xdsl/builder.py @@ -7,9 +7,11 @@ from types import TracebackType from typing import ClassVar, TypeAlias, overload +from typing_extensions import deprecated + from xdsl.dialects.builtin import ArrayAttr from xdsl.ir import Attribute, Block, BlockArgument, Operation, OperationInvT, Region -from xdsl.rewriter import InsertPoint, Rewriter +from xdsl.rewriter import BlockInsertPoint, InsertPoint, Rewriter @dataclass(eq=False) @@ -74,21 +76,36 @@ def insert(self, op: OperationInvT) -> OperationInvT: return op - def create_block_before( - self, insert_before: Block, arg_types: Iterable[Attribute] = () + def create_block( + self, insert_point: BlockInsertPoint, arg_types: Iterable[Attribute] = () ) -> Block: """ - Create a block before `insert_before`, and set - the insertion point at the end of the inserted block. + Create a block at the given location, and set the operation insertion point + at the end of the inserted block. """ block = Block(arg_types=arg_types) - Rewriter.insert_block_before(block, insert_before) + Rewriter.insert_block(block, insert_point) + self.insertion_point = InsertPoint.at_end(block) self.handle_block_creation(block) - return block + @deprecated( + "Use create_block(BlockInsertPoint.before(insert_before), arg_types) instead" + ) + def create_block_before( + self, insert_before: Block, arg_types: Iterable[Attribute] = () + ) -> Block: + """ + Create a block before `insert_before`, and set + the insertion point at the end of the inserted block. + """ + return self.create_block(BlockInsertPoint.before(insert_before), arg_types) + + @deprecated( + "Use create_block(BlockInsertPoint.after(insert_after), arg_types) instead" + ) def create_block_after( self, insert_after: Block, arg_types: Iterable[Attribute] = () ) -> Block: @@ -96,15 +113,11 @@ def create_block_after( Create a block after `insert_after`, and set the insertion point at the end of the inserted block. """ + return self.create_block(BlockInsertPoint.after(insert_after), arg_types) - block = Block(arg_types=arg_types) - Rewriter.insert_block_after(block, insert_after) - self.insertion_point = InsertPoint.at_end(block) - - self.handle_block_creation(block) - - return block - + @deprecated( + "Use create_block(BlockInsertPoint.at_start(region), arg_types) instead" + ) def create_block_at_start( self, region: Region, arg_types: Iterable[Attribute] = () ) -> Block: @@ -112,14 +125,9 @@ def create_block_at_start( Create a block at the start of `region`, and set the insertion point at the end of the inserted block. """ - block = Block(arg_types=arg_types) - region.insert_block(block, 0) - self.insertion_point = InsertPoint.at_end(block) - - self.handle_block_creation(block) - - return block + return self.create_block(BlockInsertPoint.at_start(region), arg_types) + @deprecated("Use create_block(BlockInsertPoint.at_end(region), arg_types) instead") def create_block_at_end( self, region: Region, arg_types: Iterable[Attribute] = () ) -> Block: @@ -127,13 +135,7 @@ def create_block_at_end( Create a block at the end of `region`, and set the insertion point at the end of the inserted block. """ - block = Block(arg_types=arg_types) - region.add_block(block) - self.insertion_point = InsertPoint.at_end(block) - - self.handle_block_creation(block) - - return block + return self.create_block(BlockInsertPoint.at_end(region), arg_types) @staticmethod def _region_no_args(func: Callable[[Builder], None]) -> Region: diff --git a/xdsl/dialects/__init__.py b/xdsl/dialects/__init__.py index 0c8eb9e589..535493544f 100644 --- a/xdsl/dialects/__init__.py +++ b/xdsl/dialects/__init__.py @@ -144,7 +144,7 @@ def get_ltl(): return LTL def get_math(): - from xdsl.dialects.experimental.math import Math + from xdsl.dialects.math import Math return Math diff --git a/xdsl/dialects/arm/__init__.py b/xdsl/dialects/arm/__init__.py index dbb2afbdba..f34ba11c2d 100644 --- a/xdsl/dialects/arm/__init__.py +++ b/xdsl/dialects/arm/__init__.py @@ -8,7 +8,7 @@ from xdsl.dialects.builtin import ModuleOp from xdsl.ir import Dialect -from .ops import ARMOperation, DSMovOp, DSSMulOp, GetRegisterOp +from .ops import ARMOperation, CmpRegOp, DSMovOp, DSSMulOp, GetRegisterOp, LabelOp from .register import IntRegisterType @@ -24,8 +24,10 @@ def print_assembly(module: ModuleOp, output: IO[str]) -> None: "arm", [ GetRegisterOp, + CmpRegOp, DSMovOp, DSSMulOp, + LabelOp, ], [ IntRegisterType, diff --git a/xdsl/dialects/arm/ops.py b/xdsl/dialects/arm/ops.py index d942dc2943..735d9777ea 100644 --- a/xdsl/dialects/arm/ops.py +++ b/xdsl/dialects/arm/ops.py @@ -7,10 +7,16 @@ irdl_op_definition, operand_def, opt_attr_def, + prop_def, result_def, ) -from .assembly import AssemblyInstructionArg, assembly_arg_str, assembly_line +from .assembly import ( + AssemblyInstructionArg, + append_comment, + assembly_arg_str, + assembly_line, +) from .register import IntRegisterType @@ -154,3 +160,74 @@ def __init__( def assembly_line_args(self): return (self.d, self.s1, self.s2) + + +@irdl_op_definition +class LabelOp(ARMOperation): + """ + The label operation is used to emit text labels (e.g. loop:) that are used + as branch, unconditional jump targets and symbol offsets. + https://developer.arm.com/documentation/dui0801/l/Symbols--Literals--Expressions--and-Operators/Labels + """ + + name = "arm.label" + label = prop_def(StringAttr) + comment = opt_attr_def(StringAttr) + + assembly_format = "$label attr-dict" + + def __init__( + self, + label: str | StringAttr, + *, + comment: str | StringAttr | None = None, + ): + if isinstance(label, str): + label = StringAttr(label) + if isinstance(comment, str): + comment = StringAttr(comment) + + super().__init__( + attributes={ + "label": label, + "comment": comment, + }, + ) + + def assembly_line(self) -> str | None: + return append_comment(f"{self.label.data}:", self.comment) + + +@irdl_op_definition +class CmpRegOp(ARMInstruction): + """ + Compare (register) subtracts an optionally-shifted register value from a register value. + It updates the condition flags based on the result, and discards the result. + https://developer.arm.com/documentation/ddi0597/2024-12/Base-Instructions/CMP--register---Compare--register--?lang=en + """ + + name = "arm.cmp" + s1 = operand_def(IntRegisterType) + s2 = operand_def(IntRegisterType) + + assembly_format = "$s1 `,` $s2 attr-dict `:` `(` type($s1) `,` type($s2) `)`" + + def __init__( + self, + s1: Operation | SSAValue, + s2: Operation | SSAValue, + *, + comment: str | StringAttr | None = None, + ): + if isinstance(comment, str): + comment = StringAttr(comment) + + super().__init__( + operands=(s1, s2), + attributes={ + "comment": comment, + }, + ) + + def assembly_line_args(self): + return (self.s1, self.s2) diff --git a/xdsl/dialects/experimental/fir.py b/xdsl/dialects/experimental/fir.py index b1f9037cc1..fc053a6b73 100644 --- a/xdsl/dialects/experimental/fir.py +++ b/xdsl/dialects/experimental/fir.py @@ -522,6 +522,7 @@ class AllocaOp(IRDLOperation): an optional name. The allocation may have a dynamic repetition count for allocating a sequence of locations for the specified type. + ``` %c = ... : i64 %x = fir.alloca i32 %y = fir.alloca !fir.array<8 x i64> @@ -530,6 +531,7 @@ class AllocaOp(IRDLOperation): %i = ... : i16 %j = ... : i32 %w = fir.alloca !fir.type (%i, %j : i16, i32) + ``` Note that in the case of '%z', a contiguous block of memory is allocated and its size is a runtime multiple of a 32-bit REAL value. diff --git a/xdsl/dialects/linalg.py b/xdsl/dialects/linalg.py index 3e06938a92..065280c3be 100644 --- a/xdsl/dialects/linalg.py +++ b/xdsl/dialects/linalg.py @@ -935,6 +935,8 @@ def hidden_region(args: tuple[BlockArgument, ...]) -> None: [ AffineMapAttr(AffineMap.from_callable(lambda i, _, k: (i, k))), AffineMapAttr(AffineMap.from_callable(lambda _, j, k: (k, j))), + AffineMapAttr(AffineMap(3, 0, ())), + AffineMapAttr(AffineMap(3, 0, ())), AffineMapAttr(AffineMap.from_callable(lambda i, j, _: (i, j))), ] ) diff --git a/xdsl/dialects/experimental/math.py b/xdsl/dialects/math.py similarity index 89% rename from xdsl/dialects/experimental/math.py rename to xdsl/dialects/math.py index 7a5342c293..a2c103da19 100644 --- a/xdsl/dialects/experimental/math.py +++ b/xdsl/dialects/math.py @@ -1,3 +1,11 @@ +""" +The math dialect is intended to hold mathematical operations on integer and floating +types beyond simple arithmetics. + + +See https://mlir.llvm.org/docs/Dialects/MathOps/ +""" + from __future__ import annotations from xdsl.dialects.arith import FastMathFlagsAttr @@ -11,7 +19,7 @@ result_def, traits_def, ) -from xdsl.traits import Pure +from xdsl.traits import Pure, SameOperandsAndResultType @irdl_op_definition @@ -32,13 +40,13 @@ class AbsFOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None ): operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes={"fastmath": fastmath}, operands=[operand], result_types=[operand.type], @@ -62,11 +70,11 @@ class AbsIOp(IRDLOperation): operand = operand_def(IntegerType) result = result_def(IntegerType) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__(self, operand: Operation | SSAValue): operand = SSAValue.get(operand) - return super().__init__(operands=[operand], result_types=[operand.type]) + super().__init__(operands=[operand], result_types=[operand.type]) @irdl_op_definition @@ -98,7 +106,7 @@ class Atan2Op(IRDLOperation): rhs = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, @@ -107,7 +115,7 @@ def __init__( fastmath: FastMathFlagsAttr | None = None, ): attributes = {"fastmath": fastmath} - return super().__init__( + super().__init__( attributes=attributes, operands=[lhs, rhs], result_types=[SSAValue.get(lhs).type], @@ -135,13 +143,13 @@ class AtanOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None ): operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes={"fastmath": fastmath}, operands=[operand], result_types=[operand.type], @@ -168,7 +176,7 @@ class CbrtOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -176,7 +184,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -202,13 +210,13 @@ class CeilOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None ): operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes={"fastmath": fastmath}, operands=[operand], result_types=[operand.type], @@ -238,7 +246,7 @@ class CopySignOp(IRDLOperation): rhs = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, @@ -248,7 +256,7 @@ def __init__( ): attributes = {"fastmath": fastmath} - return super().__init__( + super().__init__( attributes=attributes, operands=[lhs, rhs], result_types=[SSAValue.get(lhs).type], @@ -276,7 +284,7 @@ class CosOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -284,7 +292,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -305,11 +313,11 @@ class CountLeadingZerosOp(IRDLOperation): operand = operand_def(IntegerType) result = result_def(IntegerType) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__(self, operand: Operation | SSAValue): operand = SSAValue.get(operand) - return super().__init__(operands=[operand], result_types=[operand.type]) + super().__init__(operands=[operand], result_types=[operand.type]) @irdl_op_definition @@ -328,11 +336,11 @@ class CountTrailingZerosOp(IRDLOperation): operand = operand_def(IntegerType) result = result_def(IntegerType) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__(self, operand: Operation | SSAValue): operand = SSAValue.get(operand) - return super().__init__(operands=[operand], result_types=[operand.type]) + super().__init__(operands=[operand], result_types=[operand.type]) @irdl_op_definition @@ -351,11 +359,11 @@ class CtPopOp(IRDLOperation): operand = operand_def(IntegerType) result = result_def(IntegerType) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__(self, operand: Operation | SSAValue): operand = SSAValue.get(operand) - return super().__init__(operands=[operand], result_types=[operand.type]) + super().__init__(operands=[operand], result_types=[operand.type]) @irdl_op_definition @@ -379,7 +387,7 @@ class ErfOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -387,7 +395,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -413,7 +421,7 @@ class Exp2Op(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -421,7 +429,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -449,7 +457,7 @@ class ExpM1Op(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -457,7 +465,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -483,7 +491,7 @@ class ExpOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -491,7 +499,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -526,7 +534,7 @@ class FPowIOp(IRDLOperation): rhs = operand_def(IntegerType) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, @@ -536,7 +544,7 @@ def __init__( ): attributes = {"fastmath": fastmath} - return super().__init__( + super().__init__( attributes=attributes, operands=[lhs, rhs], result_types=[SSAValue.get(lhs).type], @@ -564,7 +572,7 @@ class FloorOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -572,7 +580,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -605,7 +613,7 @@ class FmaOp(IRDLOperation): c = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, @@ -616,7 +624,7 @@ def __init__( ): attributes = {"fastmath": fastmath} - return super().__init__( + super().__init__( attributes=attributes, operands=[a, b, c], result_types=[SSAValue.get(a).type], @@ -643,12 +651,12 @@ class IPowIOp(IRDLOperation): rhs = operand_def(IntegerType) result = result_def(IntegerType) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__(self, lhs: Operation | SSAValue, rhs: Operation | SSAValue): lhs = SSAValue.get(lhs) rhs = SSAValue.get(rhs) - return super().__init__(operands=[lhs, rhs], result_types=[lhs.type]) + super().__init__(operands=[lhs, rhs], result_types=[lhs.type]) @irdl_op_definition @@ -669,7 +677,7 @@ class Log10Op(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -677,7 +685,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -702,7 +710,7 @@ class Log1pOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -710,7 +718,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -733,7 +741,7 @@ class Log2Op(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -741,7 +749,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -764,7 +772,7 @@ class LogOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -772,7 +780,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -799,7 +807,7 @@ class PowFOp(IRDLOperation): rhs = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, @@ -809,7 +817,7 @@ def __init__( ): attributes = {"fastmath": fastmath} - return super().__init__( + super().__init__( attributes=attributes, operands=[lhs, rhs], result_types=[SSAValue.get(lhs).type], @@ -840,7 +848,7 @@ class RoundEvenOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -848,7 +856,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -877,7 +885,7 @@ class RoundOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -885,7 +893,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -907,7 +915,7 @@ class RsqrtOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -915,7 +923,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -941,7 +949,7 @@ class SinOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -949,7 +957,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -971,7 +979,7 @@ class SqrtOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -979,7 +987,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -1002,7 +1010,7 @@ class TanOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -1010,7 +1018,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -1033,7 +1041,7 @@ class TanhOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -1041,7 +1049,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) @@ -1069,7 +1077,7 @@ class TruncOp(IRDLOperation): operand = operand_def(AnyFloatConstr) result = result_def(AnyFloatConstr) - traits = traits_def(Pure()) + traits = traits_def(Pure(), SameOperandsAndResultType()) def __init__( self, operand: Operation | SSAValue, fastmath: FastMathFlagsAttr | None = None @@ -1077,7 +1085,7 @@ def __init__( attributes = {"fastmath": fastmath} operand = SSAValue.get(operand) - return super().__init__( + super().__init__( attributes=attributes, operands=[operand], result_types=[operand.type] ) diff --git a/xdsl/dialects/riscv.py b/xdsl/dialects/riscv.py index b6daa9c79e..7f9efaf437 100644 --- a/xdsl/dialects/riscv.py +++ b/xdsl/dialects/riscv.py @@ -1704,7 +1704,9 @@ class AddOp(RdRsRsOperation[IntRegisterType, IntRegisterType, IntRegisterType]): Adds the registers rs1 and rs2 and stores the result in rd. Arithmetic overflow is ignored and the result is simply the low XLEN bits of the result. + ``` x[rd] = x[rs1] + x[rs2] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#add """ @@ -1946,7 +1948,7 @@ class JalrOp(RdRsImmJumpOperation): """ Jump to address and place return address in rd. - ``` + ```C t = pc+4 pc = (x[rs1] + sext(offset)) & ~1 x[rd] = t @@ -1979,7 +1981,9 @@ class BeqOp(RsRsOffIntegerOperation): """ Take the branch if registers rs1 and rs2 are equal. + ```C if (x[rs1] == x[rs2]) pc += sext(offset) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#beq """ @@ -1992,7 +1996,9 @@ class BneOp(RsRsOffIntegerOperation): """ Take the branch if registers rs1 and rs2 are not equal. + ```C if (x[rs1] != x[rs2]) pc += sext(offset) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#bne """ @@ -2005,7 +2011,9 @@ class BltOp(RsRsOffIntegerOperation): """ Take the branch if registers rs1 is less than rs2, using signed comparison. + ```C if (x[rs1] =s x[rs2]) pc += sext(offset) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#bge """ @@ -2031,7 +2041,9 @@ class BltuOp(RsRsOffIntegerOperation): """ Take the branch if registers rs1 is less than rs2, using unsigned comparison. + ```C if (x[rs1] =u x[rs2]) pc += sext(offset) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#bgeu """ @@ -2063,7 +2077,9 @@ class LbOp(RdRsImmIntegerOperation): Loads a 8-bit value from memory and sign-extends this to XLEN bits before storing it in register rd. + ```C x[rd] = sext(M[x[rs1] + sext(offset)][7:0]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#lb """ @@ -2077,7 +2093,9 @@ class LbuOp(RdRsImmIntegerOperation): Loads a 8-bit value from memory and zero-extends this to XLEN bits before storing it in register rd. + ```C x[rd] = M[x[rs1] + sext(offset)][7:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#lbu """ @@ -2091,7 +2109,9 @@ class LhOp(RdRsImmIntegerOperation): Loads a 16-bit value from memory and sign-extends this to XLEN bits before storing it in register rd. + ```C x[rd] = sext(M[x[rs1] + sext(offset)][15:0]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#lh """ @@ -2105,7 +2125,9 @@ class LhuOp(RdRsImmIntegerOperation): Loads a 16-bit value from memory and zero-extends this to XLEN bits before storing it in register rd. + ```C x[rd] = M[x[rs1] + sext(offset)][15:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#lhu """ @@ -2129,7 +2151,9 @@ class LwOp(RdRsImmIntegerOperation): Loads a 32-bit value from memory and sign-extends this to XLEN bits before storing it in register rd. + ```C x[rd] = sext(M[x[rs1] + sext(offset)][31:0]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#lw """ @@ -2153,7 +2177,9 @@ class SbOp(RsRsImmIntegerOperation): """ Store 8-bit, values from the low bits of register rs2 to memory. + ```C M[x[rs1] + sext(offset)] = x[rs2][7:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#sb """ @@ -2166,7 +2192,9 @@ class ShOp(RsRsImmIntegerOperation): """ Store 16-bit, values from the low bits of register rs2 to memory. + ```C M[x[rs1] + sext(offset)] = x[rs2][15:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#sh @@ -2190,7 +2218,9 @@ class SwOp(RsRsImmIntegerOperation): """ Store 32-bit, values from the low bits of register rs2 to memory. + ```C M[x[rs1] + sext(offset)] = x[rs2][31:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvi.html#sw """ @@ -3193,7 +3223,9 @@ class FMAddSOp(RdRsRsRsFloatOperation): """ Perform single-precision fused multiply addition. + ```C f[rd] = f[rs1]×f[rs2]+f[rs3] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmadd-s """ @@ -3206,7 +3238,9 @@ class FMSubSOp(RdRsRsRsFloatOperation): """ Perform single-precision fused multiply substraction. + ```C f[rd] = f[rs1]×f[rs2]+f[rs3] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmsub-s """ @@ -3219,7 +3253,9 @@ class FNMSubSOp(RdRsRsRsFloatOperation): """ Perform single-precision fused multiply substraction. + ```C f[rd] = -f[rs1]×f[rs2]+f[rs3] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fnmsub-s """ @@ -3232,7 +3268,9 @@ class FNMAddSOp(RdRsRsRsFloatOperation): """ Perform single-precision fused multiply addition. + ```C f[rd] = -f[rs1]×f[rs2]-f[rs3] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fnmadd-s """ @@ -3245,7 +3283,9 @@ class FAddSOp(RdRsRsFloatOperationWithFastMath): """ Perform single-precision floating-point addition. + ```C f[rd] = f[rs1]+f[rs2] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fadd-s """ @@ -3260,7 +3300,9 @@ class FSubSOp(RdRsRsFloatOperationWithFastMath): """ Perform single-precision floating-point substraction. + ```C f[rd] = f[rs1]-f[rs2] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fsub-s """ @@ -3273,7 +3315,9 @@ class FMulSOp(RdRsRsFloatOperationWithFastMath): """ Perform single-precision floating-point multiplication. + ```C f[rd] = f[rs1]×f[rs2] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmul-s """ @@ -3286,7 +3330,9 @@ class FDivSOp(RdRsRsFloatOperationWithFastMath): """ Perform single-precision floating-point division. + ```C f[rd] = f[rs1] / f[rs2] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fdiv-s """ @@ -3299,7 +3345,9 @@ class FSqrtSOp(RdRsOperation[FloatRegisterType, FloatRegisterType]): """ Perform single-precision floating-point square root. + ```C f[rd] = sqrt(f[rs1]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fsqrt-s """ @@ -3315,7 +3363,9 @@ class FSgnJSOp( Produce a result that takes all bits except the sign bit from rs1. The result’s sign bit is rs2’s sign bit. + ```C f[rd] = {f[rs2][31], f[rs1][30:0]} + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fsgnj.s """ @@ -3331,8 +3381,9 @@ class FSgnJNSOp( Produce a result that takes all bits except the sign bit from rs1. The result’s sign bit is opposite of rs2’s sign bit. - + ```C f[rd] = {~f[rs2][31], f[rs1][30:0]} + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fsgnjn.s """ @@ -3348,7 +3399,9 @@ class FSgnJXSOp( Produce a result that takes all bits except the sign bit from rs1. The result’s sign bit is XOR of sign bit of rs1 and rs2. + ```C f[rd] = {f[rs1][31] ^ f[rs2][31], f[rs1][30:0]} + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fsgnjx.s """ @@ -3361,7 +3414,9 @@ class FMinSOp(RdRsRsFloatOperationWithFastMath): """ Write the smaller of single precision data in rs1 and rs2 to rd. + ```C f[rd] = min(f[rs1], f[rs2]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmin-s """ @@ -3374,7 +3429,9 @@ class FMaxSOp(RdRsRsFloatOperationWithFastMath): """ Write the larger of single precision data in rs1 and rs2 to rd. + ```C f[rd] = max(f[rs1], f[rs2]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmax-s """ @@ -3387,7 +3444,9 @@ class FCvtWSOp(RdRsOperation[IntRegisterType, FloatRegisterType]): """ Convert a floating-point number in floating-point register rs1 to a signed 32-bit in integer register rd. + ```C x[rd] = sext(s32_{f32}(f[rs1])) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fcvt.w.s """ @@ -3400,7 +3459,9 @@ class FCvtWuSOp(RdRsOperation[IntRegisterType, FloatRegisterType]): """ Convert a floating-point number in floating-point register rs1 to a signed 32-bit in unsigned integer register rd. + ```C x[rd] = sext(u32_{f32}(f[rs1])) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fcvt.wu.s """ @@ -3413,7 +3474,9 @@ class FMvXWOp(RdRsOperation[IntRegisterType, FloatRegisterType]): """ Move the single-precision value in floating-point register rs1 represented in IEEE 754-2008 encoding to the lower 32 bits of integer register rd. + ```C x[rd] = sext(f[rs1][31:0]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmv.x.w """ @@ -3487,7 +3550,9 @@ class FCvtSWOp(RdRsOperation[FloatRegisterType, IntRegisterType]): """ Converts a 32-bit signed integer, in integer register rs1 into a floating-point number in floating-point register rd. + ```C f[rd] = f32_{s32}(x[rs1]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fcvt.s.w """ @@ -3500,7 +3565,9 @@ class FCvtSWuOp(RdRsOperation[FloatRegisterType, IntRegisterType]): """ Converts a 32-bit unsigned integer, in integer register rs1 into a floating-point number in floating-point register rd. + ```C f[rd] = f32_{u32}(x[rs1]) + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fcvt.s.wu """ @@ -3513,7 +3580,9 @@ class FMvWXOp(RdRsOperation[FloatRegisterType, IntRegisterType]): """ Move the single-precision value encoded in IEEE 754-2008 standard encoding from the lower 32 bits of integer register rs1 to the floating-point register rd. + ```C f[rd] = x[rs1][31:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fmv.w.x @@ -3537,7 +3606,9 @@ class FLwOp(RdRsImmFloatOperation): """ Load a single-precision value from memory into floating-point register rd. + ```C f[rd] = M[x[rs1] + sext(offset)][31:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#flw """ @@ -3771,7 +3842,9 @@ class FLdOp(RdRsImmFloatOperation): """ Load a double-precision value from memory into floating-point register rd. + ```C f[rd] = M[x[rs1] + sext(offset)][63:0] + ``` https://msyksphinz-self.github.io/riscv-isadoc/html/rvfd.html#fld """ diff --git a/xdsl/dialects/riscv_snitch.py b/xdsl/dialects/riscv_snitch.py index 07920ac13d..2f831d9446 100644 --- a/xdsl/dialects/riscv_snitch.py +++ b/xdsl/dialects/riscv_snitch.py @@ -756,8 +756,10 @@ class VFCpkASSOp( Packs two scalar f32 values from rs1 and rs2 and packs the result as two adjacent entries into the vectorial 2xf32 rd operand, such as: + ```C f[rd][lo] = f[rs1] f[rd][hi] = f[rs2] + ``` """ name = "riscv_snitch.vfcpka.s.s" @@ -772,8 +774,10 @@ class VFMulSOp(riscv.RdRsRsFloatOperationWithFastMath): rs1 and rs2 and stores the results in the corresponding f32 lanes into the vectorial 2xf32 rd operand, such as: + ```C f[rd][lo] = f[rs1][lo] * f[rs2][lo] f[rd][hi] = f[rs1][hi] * f[rs2][hi] + ``` """ name = "riscv_snitch.vfmul.s" @@ -788,8 +792,10 @@ class VFAddSOp(riscv.RdRsRsFloatOperationWithFastMath): rs1 and rs2 and stores the results in the corresponding f32 lanes into the vectorial 2xf32 rd operand, such as: + ```C f[rd][lo] = f[rs1][lo] + f[rs2][lo] f[rd][hi] = f[rs1][hi] + f[rs2][hi] + ``` """ name = "riscv_snitch.vfadd.s" @@ -804,10 +810,12 @@ class VFAddHOp(riscv.RdRsRsFloatOperationWithFastMath): rs1 and rs2 and stores the results in the corresponding f16 lanes into the vectorial 4xf16 rd operand, such as: + ```C f[rd][0] = f[rs1][0] + f[rs2][0] f[rd][1] = f[rs1][1] + f[rs2][1] f[rd][2] = f[rs1][2] + f[rs2][2] f[rd][3] = f[rs1][3] + f[rs2][3] + ``` """ name = "riscv_snitch.vfadd.h" @@ -822,8 +830,10 @@ class VFMaxSOp(riscv.RdRsRsFloatOperationWithFastMath): rs1 and rs2 and stores the results in the corresponding f32 lanes into the vectorial 2xf32 rd operand, such as: + ```C f[rd][lo] = max(f[rs1][lo], f[rs2][lo]) f[rd][hi] = max(f[rs1][hi], f[rs2][hi]) + ``` """ name = "riscv_snitch.vfmax.s" @@ -946,8 +956,10 @@ class VFMacSOp(RdRsRsAccumulatingFloatOperationWithFastMath): rs1 and rs2 and accumulates the results in the corresponding f32 lanes into the vectorial 2xf32 rd operand, such as: + ```C f[rd][lo] = f[rs1][lo] * f[rs2][lo] + f[rd][lo] f[rd][hi] = f[rs1][hi] * f[rs2][hi] + f[rd][hi] + ``` """ name = "riscv_snitch.vfmac.s" @@ -961,7 +973,9 @@ class VFSumSOp(RdRsAccumulatingFloatOperation): Performs sum of f32 values from rs and accumulates the result in the lower f32 value of the rd operand: + ```C f[rd][lo] = f[rs][hi] + f[rs][lo] + f[rd][lo] + ``` """ name = "riscv_snitch.vfsum.s" diff --git a/xdsl/dialects/x86/ops.py b/xdsl/dialects/x86/ops.py index f9b7ed8576..cf526b8d8a 100644 --- a/xdsl/dialects/x86/ops.py +++ b/xdsl/dialects/x86/ops.py @@ -223,7 +223,9 @@ def assembly_line_args(self) -> tuple[AssemblyInstructionArg | None, ...]: class RR_AddOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ Adds the registers r1 and r2 and stores the result in r1. + ```C x[r1] = x[r1] + x[r2] + ``` https://www.felixcloutier.com/x86/add """ @@ -234,7 +236,9 @@ class RR_AddOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_SubOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ subtracts r2 from r1 and stores the result in r1. + ```C x[r1] = x[r1] - x[r2] + ``` https://www.felixcloutier.com/x86/sub """ @@ -245,7 +249,9 @@ class RR_SubOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_ImulOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ Multiplies the registers r1 and r2 and stores the result in r1. + ```C x[r1] = x[r1] * x[r2] + ``` https://www.felixcloutier.com/x86/imul """ @@ -256,7 +262,9 @@ class RR_ImulOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_AndOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise and of r1 and r2, stored in r1 + ```C x[r1] = x[r1] & x[r2] + ``` https://www.felixcloutier.com/x86/and """ @@ -267,7 +275,9 @@ class RR_AndOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_OrOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise or of r1 and r2, stored in r1 + ```C x[r1] = x[r1] | x[r2] + ``` https://www.felixcloutier.com/x86/or """ @@ -278,7 +288,9 @@ class RR_OrOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_XorOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise xor of r1 and r2, stored in r1 + ```C x[r1] = x[r1] ^ x[r2] + ``` https://www.felixcloutier.com/x86/xor """ @@ -289,7 +301,9 @@ class RR_XorOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): class RR_MovOp(R_RR_Operation[GeneralRegisterType, GeneralRegisterType]): """ Copies the value of r1 into r2. + ```C x[r1] = x[r2] + ``` https://www.felixcloutier..com/x86/mov """ @@ -402,7 +416,9 @@ def assembly_line_args(self) -> tuple[AssemblyInstructionArg | None, ...]: class R_NegOp(R_R_Operation[GeneralRegisterType]): """ Negates r1 and stores the result in r1. + ```C x[r1] = -x[r1] + ``` https://www.felixcloutier.com/x86/neg """ @@ -413,7 +429,9 @@ class R_NegOp(R_R_Operation[GeneralRegisterType]): class R_NotOp(R_R_Operation[GeneralRegisterType]): """ bitwise not of r1, stored in r1 + ```C x[r1] = ~x[r1] + ``` https://www.felixcloutier.com/x86/not """ @@ -424,7 +442,9 @@ class R_NotOp(R_R_Operation[GeneralRegisterType]): class R_IncOp(R_R_Operation[GeneralRegisterType]): """ Increments r1 by 1 and stores the result in r1. + ```C x[r1] = x[r1] + 1 + ``` https://www.felixcloutier.com/x86/inc """ @@ -435,7 +455,9 @@ class R_IncOp(R_R_Operation[GeneralRegisterType]): class R_DecOp(R_R_Operation[GeneralRegisterType]): """ Decrements r1 by 1 and stores the result in r1. + ```C x[r1] = x[r1] - 1 + ``` https://www.felixcloutier.com/x86/dec """ @@ -487,7 +509,9 @@ def assembly_line_args(self) -> tuple[AssemblyInstructionArg | None, ...]: class R_ImulOp(IRDLOperation, X86Instruction): """ The source operand is multiplied by the value in the RAX register and the product is stored in the RDX:RAX registers. + ```C x[RDX:RAX] = x[RAX] * r1 + ``` https://www.felixcloutier.com/x86/imul """ @@ -583,7 +607,9 @@ def custom_print_attributes(self, printer: Printer) -> Set[str]: class RM_AddOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ Adds the value from the memory location pointed to by r2 to r1 and stores the result in r1. + ```C x[r1] = x[r1] + [x[r2]] + ``` https://www.felixcloutier.com/x86/add """ @@ -594,7 +620,9 @@ class RM_AddOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_SubOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ Subtracts the value from the memory location pointed to by r2 from r1 and stores the result in r1. + ```C x[r1] = x[r1] - [x[r2]] + ``` https://www.felixcloutier.com/x86/sub """ @@ -605,7 +633,9 @@ class RM_SubOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_ImulOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ Multiplies the value from the memory location pointed to by r2 with r1 and stores the result in r1. + ```C x[r1] = x[r1] * [x[r2]] + ``` https://www.felixcloutier.com/x86/imul """ @@ -616,7 +646,9 @@ class RM_ImulOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_AndOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise and of r1 and [r2], stored in r1 + ```C x[r1] = x[r1] & [x[r2]] + ``` https://www.felixcloutier.com/x86/and """ @@ -627,7 +659,9 @@ class RM_AndOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_OrOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise or of r1 and [r2], stored in r1 + ```C x[r1] = x[r1] | [x[r2]] + ``` https://www.felixcloutier.com/x86/or """ @@ -638,7 +672,9 @@ class RM_OrOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_XorOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ bitwise xor of r1 and [r2], stored in r1 + ```C x[r1] = x[r1] ^ [x[r2]] + ``` https://www.felixcloutier.com/x86/xor """ @@ -649,7 +685,9 @@ class RM_XorOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_MovOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ Copies the value from the memory location pointed to by r2 into r1. + ```C x[r1] = [x[r2]] + ``` https://www.felixcloutier.com/x86/mov """ @@ -660,7 +698,9 @@ class RM_MovOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): class RM_leaOp(R_RM_Operation[GeneralRegisterType, GeneralRegisterType]): """ Loads the effective address of the memory location pointed to by r2 into r1. + ```C x[r1] = &x[r2] + ``` https://www.felixcloutier.com/x86/lea """ @@ -724,7 +764,9 @@ def custom_print_attributes(self, printer: Printer) -> Set[str]: class RI_AddOp(R_RI_Operation[GeneralRegisterType]): """ Adds the immediate value to r1 and stores the result in r1. + ```C x[r1] = x[r1] + immediate + ``` https://www.felixcloutier.com/x86/add """ @@ -735,7 +777,9 @@ class RI_AddOp(R_RI_Operation[GeneralRegisterType]): class RI_SubOp(R_RI_Operation[GeneralRegisterType]): """ Subtracts the immediate value from r1 and stores the result in r1. + ```C x[r1] = x[r1] - immediate + ``` https://www.felixcloutier.com/x86/sub """ @@ -746,7 +790,9 @@ class RI_SubOp(R_RI_Operation[GeneralRegisterType]): class RI_AndOp(R_RI_Operation[GeneralRegisterType]): """ bitwise and of r1 and immediate, stored in r1 + ```C x[r1] = x[r1] & immediate + ``` https://www.felixcloutier.com/x86/and """ @@ -757,7 +803,9 @@ class RI_AndOp(R_RI_Operation[GeneralRegisterType]): class RI_OrOp(R_RI_Operation[GeneralRegisterType]): """ bitwise or of r1 and immediate, stored in r1 + ```C x[r1] = x[r1] | immediate + ``` https://www.felixcloutier.com/x86/or """ @@ -768,7 +816,9 @@ class RI_OrOp(R_RI_Operation[GeneralRegisterType]): class RI_XorOp(R_RI_Operation[GeneralRegisterType]): """ bitwise xor of r1 and immediate, stored in r1 + ```C x[r1] = x[r1] ^ immediate + ``` https://www.felixcloutier.com/x86/xor """ @@ -779,7 +829,9 @@ class RI_XorOp(R_RI_Operation[GeneralRegisterType]): class RI_MovOp(R_RI_Operation[GeneralRegisterType]): """ Copies the immediate value into r1. + ```C x[r1] = immediate + ``` https://www.felixcloutier.com/x86/mov """ @@ -842,7 +894,9 @@ def custom_print_attributes(self, printer: Printer) -> Set[str]: class MR_AddOp(M_MR_Operation[GeneralRegisterType, GeneralRegisterType]): """ Adds the value from r2 to the memory location pointed to by r1. + ```C [x[r1]] = [x[r1]] + x[r2] + ``` https://www.felixcloutier.com/x86/add """ @@ -993,7 +1047,9 @@ class MI_SubOp(M_MI_Operation[GeneralRegisterType]): class MI_AndOp(M_MI_Operation[GeneralRegisterType]): """ bitwise and of immediate and [r1], stored in [r1] + ```C [x[r1]] = [x[r1]] & immediate + ``` https://www.felixcloutier.com/x86/and """ @@ -1004,7 +1060,9 @@ class MI_AndOp(M_MI_Operation[GeneralRegisterType]): class MI_OrOp(M_MI_Operation[GeneralRegisterType]): """ bitwise or of immediate and [r1], stored in [r1] + ```C [x[r1]] = [x[r1]] | immediate + ``` https://www.felixcloutier.com/x86/or """ @@ -1015,7 +1073,9 @@ class MI_OrOp(M_MI_Operation[GeneralRegisterType]): class MI_XorOp(M_MI_Operation[GeneralRegisterType]): """ bitwise xor of immediate and [r1], stored in [r1] + ```C [x[r1]] = [x[r1]] ^ immediate + ``` https://www.felixcloutier.com/x86/xor """ @@ -1293,7 +1353,8 @@ def custom_print_attributes(self, printer: Printer) -> Set[str]: class M_M_Operation(Generic[R1InvT], IRDLOperation, X86Instruction, ABC): """ - A base class for x86 operations with a memory reference that's both a source and a destination + A base class for x86 operations with a memory reference that's both a source and a + destination """ source = operand_def(R1InvT) @@ -1345,7 +1406,9 @@ def custom_print_attributes(self, printer: Printer) -> Set[str]: class M_NegOp(M_M_Operation[GeneralRegisterType]): """ Negates the value at the memory location pointed to by r1. + ```C [x[r1]] = -[x[r1]] + ``` https://www.felixcloutier.com/x86/neg """ @@ -1356,7 +1419,9 @@ class M_NegOp(M_M_Operation[GeneralRegisterType]): class M_NotOp(M_M_Operation[GeneralRegisterType]): """ bitwise not of [r1], stored in [r1] + ```C [x[r1]] = ~[x[r1]] + ``` https://www.felixcloutier.com/x86/not """ diff --git a/xdsl/ir/core.py b/xdsl/ir/core.py index 6ad8c61c38..7a31bb06bf 100644 --- a/xdsl/ir/core.py +++ b/xdsl/ir/core.py @@ -287,7 +287,7 @@ def _verify(self): def verify(self) -> None: """ Check that the attribute parameters satisfy the expected invariants. - Raise an exception otherwise. + Raise a VerifyException otherwise. """ pass diff --git a/xdsl/pattern_rewriter.py b/xdsl/pattern_rewriter.py index ec10ff20c5..a0b14ba17b 100644 --- a/xdsl/pattern_rewriter.py +++ b/xdsl/pattern_rewriter.py @@ -23,7 +23,7 @@ SSAValue, ) from xdsl.irdl import GenericAttrConstraint, base -from xdsl.rewriter import InsertPoint, Rewriter +from xdsl.rewriter import BlockInsertPoint, InsertPoint, Rewriter from xdsl.utils.hints import isa from xdsl.utils.isattr import isattr @@ -351,25 +351,38 @@ def move_region_contents_to_new_regions(self, region: Region) -> Region: self.has_done_action = True return Rewriter.move_region_contents_to_new_regions(region) + def inline_region(self, region: Region, insertion_point: BlockInsertPoint) -> None: + """Move the region blocks to the specified insertion point.""" + self.has_done_action = True + Rewriter.inline_region(region, insertion_point) + + @deprecated( + "Please use `inline_region(region, BlockInsertPoint.before(target))` instead" + ) def inline_region_before(self, region: Region, target: Block) -> None: """Move the region blocks to an existing region.""" - self.has_done_action = True - Rewriter.inline_region_before(region, target) + self.inline_region(region, BlockInsertPoint.before(target)) + @deprecated( + "Please use `inline_region(region, BlockInsertPoint.after(target))` instead" + ) def inline_region_after(self, region: Region, target: Block) -> None: """Move the region blocks to an existing region.""" - self.has_done_action = True - Rewriter.inline_region_after(region, target) + self.inline_region(region, BlockInsertPoint.after(target)) + @deprecated( + "Please use `inline_region(region, BlockInsertPoint.at_start(target))` instead" + ) def inline_region_at_start(self, region: Region, target: Region) -> None: """Move the region blocks to an existing region.""" - self.has_done_action = True - Rewriter.inline_region_at_start(region, target) + self.inline_region(region, BlockInsertPoint.at_start(target)) + @deprecated( + "Please use `inline_region(region, BlockInsertPoint.at_end(target))` instead" + ) def inline_region_at_end(self, region: Region, target: Region) -> None: """Move the region blocks to an existing region.""" - self.has_done_action = True - Rewriter.inline_region_at_end(region, target) + self.inline_region(region, BlockInsertPoint.at_end(target)) class RewritePattern(ABC): diff --git a/xdsl/rewriter.py b/xdsl/rewriter.py index b8726a782b..e280aef608 100644 --- a/xdsl/rewriter.py +++ b/xdsl/rewriter.py @@ -1,8 +1,10 @@ from __future__ import annotations -from collections.abc import Sequence +from collections.abc import Iterable, Sequence from dataclasses import dataclass, field +from typing_extensions import deprecated + from xdsl.ir import Block, Operation, Region, SSAValue @@ -58,6 +60,56 @@ def at_end(block: Block) -> InsertPoint: return InsertPoint(block) +@dataclass(frozen=True) +class BlockInsertPoint: + """ + An insert point for a block. + It is either a point before a block, or after a block. + """ + + region: Region + """The region where the insertion point is in.""" + + insert_before: Block | None = field(default=None) + """ + The insertion point is right before this block. + If the block is None, the insertion point is at the end of the region. + """ + + def __post_init__(self) -> None: + # Check that the insertion point is valid. + # An insertion point can only be invalid if `insert_before` is a `Block`, + # and its parent is not `region`. + if self.insert_before is not None: + if self.insert_before.parent is not self.region: + raise ValueError("Insertion point must be in the builder's `region`") + + @staticmethod + def before(block: Block) -> BlockInsertPoint: + """Gets the insertion point before a block.""" + if (region := block.parent) is None: + raise ValueError("Block insertion point must have a parent region") + return BlockInsertPoint(region, block) + + @staticmethod + def after(block: Block) -> BlockInsertPoint: + """Gets the insertion point after a block.""" + region = block.parent + if region is None: + raise ValueError("Block insertion point must have a parent region") + return BlockInsertPoint(region, block.next_block) + + @staticmethod + def at_start(region: Region) -> BlockInsertPoint: + """Gets the insertion point at the start of a region.""" + return BlockInsertPoint(region, region.first_block) + + @staticmethod + def at_end(region: Region) -> BlockInsertPoint: + """Gets the insertion point at the end of a region.""" + return BlockInsertPoint(region) + + class Rewriter: @staticmethod def erase_op(op: Operation, safe_erase: bool = True): @@ -177,6 +229,20 @@ def inline_block( parent_region.detach_block(source) source.erase() + @staticmethod + def insert_block(block: Block | Iterable[Block], insert_point: BlockInsertPoint): + """ + Insert one or multiple blocks at a given location. + The blocks to insert should be detached from any region. + The insertion point should not be contained in the block to insert. + """ + region = insert_point.region + if insert_point.insert_before is not None: + region.insert_block_before(block, insert_point.insert_before) + else: + region.add_block(block) + + @deprecated("Use `insert_block(block, BlockInsertPoint.after(target))` instead") @staticmethod def insert_block_after(block: Block | list[Block], target: Block): """ @@ -184,15 +250,9 @@ def insert_block_after(block: Block | list[Block], target: Block): The blocks to insert should be detached from any region. The target block should not be contained in the block to insert. """ - if target.parent is None: - raise Exception("Cannot move a block after a toplevel op") - region = target.parent - block_list = block if isinstance(block, list) else [block] - if len(block_list) == 0: - return - pos = region.get_block_index(target) - region.insert_block(block_list, pos + 1) + Rewriter.insert_block(block, BlockInsertPoint.after(target)) + @deprecated("Use `insert_block(block, BlockInsertPoint.before(target))` instead") @staticmethod def insert_block_before(block: Block | list[Block], target: Block): """ @@ -200,12 +260,7 @@ def insert_block_before(block: Block | list[Block], target: Block): The blocks to insert should be detached from any region. The target block should not be contained in the block to insert. """ - if target.parent is None: - raise Exception("Cannot move a block after a toplevel op") - region = target.parent - block_list = block if isinstance(block, list) else [block] - pos = region.get_block_index(target) - region.insert_block(block_list, pos) + Rewriter.insert_block(block, BlockInsertPoint.before(target)) @staticmethod def insert_op( @@ -225,31 +280,36 @@ def move_region_contents_to_new_regions(region: Region) -> Region: region.move_blocks(new_region) return new_region + @staticmethod + def inline_region(region: Region, insertion_point: BlockInsertPoint) -> None: + """Move the region blocks to a given location.""" + if insertion_point.insert_before is not None: + region.move_blocks_before(insertion_point.insert_before) + else: + region.move_blocks(insertion_point.region) + + @deprecated("Use `inline_region(region, BlockInsertPoint.before(target))` instead") @staticmethod def inline_region_before(region: Region, target: Block) -> None: """Move the region blocks to an existing region, before `target`.""" - region.move_blocks_before(target) + Rewriter.inline_region(region, BlockInsertPoint.before(target)) + @deprecated("Use `inline_region(region, BlockInsertPoint.after(target))` instead") @staticmethod def inline_region_after(region: Region, target: Block) -> None: """Move the region blocks to an existing region, after `target`.""" - if target.next_block is not None: - Rewriter.inline_region_before(region, target.next_block) - else: - parent_region = target.parent - if parent_region is None: - raise ValueError("Cannot inline region before a block with no parent") - region.move_blocks(region) + Rewriter.inline_region(region, BlockInsertPoint.after(target)) + @deprecated( + "Use `inline_region(region, BlockInsertPoint.at_start(target))` instead" + ) @staticmethod def inline_region_at_start(region: Region, target: Region) -> None: """Move the region blocks to the start of an existing region.""" - if target.first_block is not None: - Rewriter.inline_region_before(region, target.first_block) - else: - Rewriter.inline_region_at_end(region, target) + Rewriter.inline_region(region, BlockInsertPoint.at_start(target)) + @deprecated("Use `inline_region(region, BlockInsertPoint.at_end(target))` instead") @staticmethod def inline_region_at_end(region: Region, target: Region) -> None: """Move the region blocks to the end of an existing region.""" - region.move_blocks(target) + Rewriter.inline_region(region, BlockInsertPoint.at_end(target)) diff --git a/xdsl/traits.py b/xdsl/traits.py index 23eca97fcd..a1717059c1 100644 --- a/xdsl/traits.py +++ b/xdsl/traits.py @@ -729,3 +729,56 @@ def get_insn(self, op: Operation) -> str: Return the insn representation of the operation for printing. """ raise NotImplementedError() + + +@dataclass(frozen=True) +class SameOperandsAndResultType(OpTrait): + """Constrain the operation to have the same operands and result type.""" + + def verify(self, op: Operation) -> None: + from xdsl.utils.type import ( + get_element_type_or_self, + get_encoding, + have_compatible_shape, + ) + + if len(op.results) < 1 or len(op.operands) < 1: + raise VerifyException( + f"'{op.name}' requires at least one result or operand" + ) + + result_type0 = get_element_type_or_self(op.result_types[0]) + + encoding = get_encoding(op.result_types[0]) + + for result_type in op.result_types[1:]: + result_type_elem = get_element_type_or_self(result_type) + if result_type0 != result_type_elem or not have_compatible_shape( + op.result_types[0], result_type + ): + raise VerifyException( + f"'{op.name} requires the same type for all operands and results" + ) + + element_encoding = get_encoding(result_type) + + if encoding != element_encoding: + raise VerifyException( + f"'{op.name} requires the same encoding for all operands and results" + ) + + for operand_type in op.operand_types: + operand_type_elem = get_element_type_or_self(operand_type) + if result_type0 != operand_type_elem or not have_compatible_shape( + op.result_types[0], operand_type + ): + raise VerifyException( + f"'{op.name} requires the same type for all operands and results" + ) + + element_encoding = get_encoding(operand_type) + + if encoding != element_encoding: + raise VerifyException( + f"'{op.name} requires the same encoding for all operands and results" + ) diff --git a/xdsl/transforms/convert_scf_to_cf.py b/xdsl/transforms/convert_scf_to_cf.py index d1c07e683b..977c756fd1 100644 --- a/xdsl/transforms/convert_scf_to_cf.py +++ b/xdsl/transforms/convert_scf_to_cf.py @@ -16,7 +16,7 @@ RewritePattern, op_type_rewrite_pattern, ) -from xdsl.rewriter import InsertPoint +from xdsl.rewriter import BlockInsertPoint, InsertPoint from xdsl.traits import IsTerminator @@ -60,7 +60,7 @@ def match_and_rewrite(self, if_op: IfOp, rewriter: PatternRewriter, /): ) rewriter.erase_op(then_terminator) - rewriter.inline_region_before(then_region, continue_block) + rewriter.inline_region(then_region, BlockInsertPoint.before(continue_block)) # Move blocks from the "else" region (if present) to the region containing # 'scf.if', place it before the continuation block and branch to it. It @@ -78,7 +78,7 @@ def match_and_rewrite(self, if_op: IfOp, rewriter: PatternRewriter, /): ) rewriter.erase_op(else_terminator) - rewriter.inline_region_before(else_region, continue_block) + rewriter.inline_region(else_region, BlockInsertPoint.before(continue_block)) else: else_block = continue_block @@ -116,7 +116,7 @@ def match_and_rewrite(self, for_op: ForOp, rewriter: PatternRewriter): first_body_block = condition_block.split_before(first_op) last_body_block = for_op.body.last_block assert last_body_block is not None - rewriter.inline_region_before(for_op.body, end_block) + rewriter.inline_region(for_op.body, BlockInsertPoint.before(end_block)) iv = condition_block.args[0] # Append the induction variable stepping logic to the last body block and @@ -169,7 +169,7 @@ def _convert_region( rewriter.replace_op(yield_op, BranchOp(continue_block, *yield_op.operands)) # Inline the region - rewriter.inline_region_before(region, continue_block) + rewriter.inline_region(region, BlockInsertPoint.before(continue_block)) return block @op_type_rewrite_pattern diff --git a/xdsl/transforms/convert_stencil_to_csl_stencil.py b/xdsl/transforms/convert_stencil_to_csl_stencil.py index 3cbcb4fe7a..85a8f938f8 100644 --- a/xdsl/transforms/convert_stencil_to_csl_stencil.py +++ b/xdsl/transforms/convert_stencil_to_csl_stencil.py @@ -366,18 +366,20 @@ class ConvertApplyOpPattern(RewritePattern): """ Fuses a `csl_stencil.prefetch` and a `stencil.apply` to build a `csl_stencil.apply`. - If there are several candidate prefetch ops, the one with the largest result buffer size is selected. - The selection is greedy, and could in the future be expanded into a more global selection optimising for minimal - prefetch overhead across multiple apply ops. - - args: - num_chunks - number of chunks into which communication and computation should be split. - Effectively, the number of times `csl_stencil.apply.receive_chunk` will be executed and the - tensor sizes it handles. Higher values may increase compute overhead but reduce size of - communication buffers when lowered. + If there are several candidate prefetch ops, the one with the largest result buffer + size is selected. + The selection is greedy, and could in the future be expanded into a more global + selection optimising for minimal prefetch overhead across multiple apply ops. """ num_chunks: int = 1 + """ + Number of chunks into which communication and computation should be split. + Effectively, the number of times `csl_stencil.apply.receive_chunk` will be executed + and the tensor sizes it handles. + Higher values may increase compute overhead but reduce size of communication buffers + when lowered. + """ @op_type_rewrite_pattern def match_and_rewrite(self, op: stencil.ApplyOp, rewriter: PatternRewriter, /): diff --git a/xdsl/transforms/experimental/replace_incompatible_fpga.py b/xdsl/transforms/experimental/replace_incompatible_fpga.py index a88e56822f..749c89db97 100644 --- a/xdsl/transforms/experimental/replace_incompatible_fpga.py +++ b/xdsl/transforms/experimental/replace_incompatible_fpga.py @@ -4,8 +4,8 @@ from xdsl.dialects import builtin from xdsl.dialects.arith import MaximumfOp from xdsl.dialects.builtin import f64 -from xdsl.dialects.experimental.math import AbsFOp, CopySignOp from xdsl.dialects.func import CallOp, FuncOp +from xdsl.dialects.math import AbsFOp, CopySignOp from xdsl.passes import ModulePass from xdsl.pattern_rewriter import ( GreedyRewritePatternApplier, diff --git a/xdsl/transforms/lower_snitch.py b/xdsl/transforms/lower_snitch.py index f027ae834a..0c6ff1a14c 100644 --- a/xdsl/transforms/lower_snitch.py +++ b/xdsl/transforms/lower_snitch.py @@ -113,7 +113,7 @@ def write_ssr_config_ops( This value is then passed to riscv.scfgw to perform the actual setting. Reference implementation in the snitch runtime library: - ``` c + ```C inline void write_ssr_cfg(uint32_t reg, uint32_t dm, uint32_t value) { asm volatile("scfgwi %[value], %[dm] | %[reg]<<5\n" ::[value] "r"(value), [ dm ] "i"(dm), [ reg ] "i"(reg)); diff --git a/xdsl/transforms/printf_to_putchar.py b/xdsl/transforms/printf_to_putchar.py index 05b196050c..a9fc1dccf6 100644 --- a/xdsl/transforms/printf_to_putchar.py +++ b/xdsl/transforms/printf_to_putchar.py @@ -1,8 +1,7 @@ from xdsl.builder import ImplicitBuilder from xdsl.context import MLContext -from xdsl.dialects import arith, func, scf +from xdsl.dialects import arith, func, math, scf from xdsl.dialects.builtin import IndexType, IntegerType, ModuleOp, i32 -from xdsl.dialects.experimental import math from xdsl.dialects.printf import PrintCharOp, PrintIntOp from xdsl.ir import Block, SSAValue from xdsl.passes import ModulePass diff --git a/xdsl/utils/type.py b/xdsl/utils/type.py new file mode 100644 index 0000000000..55cbda853b --- /dev/null +++ b/xdsl/utils/type.py @@ -0,0 +1,53 @@ +""" +Type utilities. +""" + +from typing import Any, cast + +from xdsl.dialects.builtin import ( + DYNAMIC_INDEX, + ContainerType, + NoneAttr, + ShapedType, + TensorType, +) +from xdsl.ir import Attribute + + +def get_element_type_or_self(maybe_shaped_type: Attribute) -> Attribute: + if isinstance(maybe_shaped_type, ContainerType): + container_type = cast(ContainerType[Any], maybe_shaped_type) + return container_type.get_element_type() + return maybe_shaped_type + + +def get_encoding(maybe_shaped_type: Attribute) -> Attribute: + if isinstance(maybe_shaped_type, TensorType): + return maybe_shaped_type.encoding + return NoneAttr() + + +def have_compatible_shape(lhs_type: Attribute, rhs_type: Attribute) -> bool: + is_lhs_container = isinstance(lhs_type, ContainerType) + is_rhs_container = isinstance(rhs_type, ContainerType) + + # both are scalars + if not is_lhs_container and not is_rhs_container: + return True + + # one is scalar and the other shaped + if is_lhs_container != is_rhs_container: + return False + + # at least one is unranked + if not isinstance(lhs_type, ShapedType) or not isinstance(rhs_type, ShapedType): + return True + + # both ranked, so check ranks + if lhs_type.get_num_dims() != rhs_type.get_num_dims(): + return False + + return all( + dim1 == DYNAMIC_INDEX or dim2 == DYNAMIC_INDEX or dim1 == dim2 + for dim1, dim2 in zip(lhs_type.get_shape(), rhs_type.get_shape()) + )