diff --git a/README.md b/README.md index 659d4631..2d8194ea 100644 --- a/README.md +++ b/README.md @@ -151,6 +151,47 @@ history checks are performed: Currently there are not ways for features to opt out of specific history checks. To opt out of all history checking for a specific run, use `--no-history-check`. +## Cross-language features + +A feature with `"crossLanguage": true` in its `config.json` has a conventional +`driver/` Go program and ordinary `feature.` participants. Run these +features with their own subcommand: + +```sh +go run . run-cross-language tracing/encoded_headers +``` + +The runner discovers participants from the files, prepares each participating SDK +once, and supplies the driver with prepared harness commands, a server, namespace, +and unique task-queue prefix through `FEATURE_CROSS_LANGUAGE`. The +`harness/go/crosslanguage` package reads this manifest and invokes harnesses in +`client` or `worker` roles. Workers announce readiness before clients are run. +The driver chooses scenarios, pairs, and assertions; the runner does not generate +a language matrix. A nonzero driver exit fails the feature in the normal summary. + +Use repeated `--sdk-version language=version-or-local-checkout` options to select +SDKs independently. For example: + +```sh +go run . run-cross-language --sdk-version cs=1.22.0 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +Use repeated `--sdk-language` options to prepare only selected participants, without +imposing pair policy on the runner. For the focused original regression: + +```sh +ENCODED_HEADERS_PAIRS=cs:ts go run . run-cross-language --sdk-language cs --sdk-language ts --sdk-version cs=1.22.0 --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +Go, Java, Python, Ruby, Rust, .NET and TypeScript harnesses expose separate roles. +See the feature's README for which roles its participants support and its +feature-specific scenario filters. Cross-language features own their +history assertions and do not use the single-language history comparison/generation +mechanism. This subcommand exposes SDK selection, server/namespace/TLS options, +and temporary-build retention, but not history-generation or prepared-directory flags. +The existing `run` and `prepare` subcommands continue to require `--lang` and select +only single-language features. + ## Writing Features Developers can write workflows and activities that represent a SDK "feature". These are organized into directories under diff --git a/build.gradle b/build.gradle index bfc4737f..7bc4ab86 100644 --- a/build.gradle +++ b/build.gradle @@ -33,6 +33,9 @@ dependencies { implementation 'com.jayway.jsonpath:json-path:2.6.0' implementation 'info.picocli:picocli:4.6.2' implementation 'io.temporal:temporal-sdk:latest.release' + implementation 'io.temporal:temporal-opentracing:latest.release' + implementation 'io.opentelemetry:opentelemetry-sdk:1.49.0' + implementation 'io.opentelemetry:opentelemetry-opentracing-shim:1.49.0' implementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' implementation 'org.reflections:reflections:0.10.2' } diff --git a/cmd/cmd.go b/cmd/cmd.go index dfa42b73..2a872e6b 100644 --- a/cmd/cmd.go +++ b/cmd/cmd.go @@ -28,6 +28,7 @@ func NewApp() *cli.App { Commands: []*cli.Command{ prepareCmd(), runCmd(), + runCrossLanguageCmd(), buildImageCmd(), publishImageCmd(), latestSdkVersionCmd(), diff --git a/cmd/prepare.go b/cmd/prepare.go index 1551ddd2..7f5910c3 100644 --- a/cmd/prepare.go +++ b/cmd/prepare.go @@ -26,9 +26,10 @@ func prepareCmd() *cli.Command { // PrepareConfig is configuration for NewPreparer. type PrepareConfig struct { - DirName string - Lang string - Version string + DirName string + Lang string + Version string + crossLanguage bool } func (p *PrepareConfig) flags() []cli.Flag { diff --git a/cmd/run.go b/cmd/run.go index 6b849538..c7c9dfe2 100644 --- a/cmd/run.go +++ b/cmd/run.go @@ -155,9 +155,13 @@ type Runner struct { log log.Logger config RunConfig // Root of the features repo - rootDir string - createTime time.Time - program sdkbuild.Program + rootDir string + createTime time.Time + program sdkbuild.Program + crossPrograms map[string]sdkbuild.Program + crossLanguage bool + crossVersions map[string]string + crossLanguages []string } type runBatch struct { @@ -366,6 +370,10 @@ func (r *Runner) Run(ctx context.Context, patterns []string) error { } } } + return r.runFeatures(ctx, features, patterns) +} + +func (r *Runner) runFeatures(ctx context.Context, features []*RunFeature, patterns []string) error { features = r.filterFeaturesForExternalServer(features, patterns) if len(features) == 0 { return fmt.Errorf("no features matched") @@ -481,6 +489,10 @@ func (r *Runner) runBatch(ctx context.Context, batch runBatch) error { defer proxyServer.Close() } + if r.crossLanguage { + return r.runCrossLanguageBatch(ctx, config, batch) + } + l, err := net.Listen("tcp", summaryListenAddr) if err != nil { return err @@ -959,6 +971,9 @@ func (r *Runner) destroyTempDir() { if r.program != nil { _ = os.RemoveAll(r.program.Dir()) } + for _, program := range r.crossPrograms { + _ = os.RemoveAll(program.Dir()) + } } func normalizeLangName(lang string) (string, error) { diff --git a/cmd/run_cross_language.go b/cmd/run_cross_language.go new file mode 100644 index 00000000..8d6cf7e6 --- /dev/null +++ b/cmd/run_cross_language.go @@ -0,0 +1,225 @@ +package cmd + +import ( + "context" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "slices" + "strings" + "time" + + hcmd "github.com/temporalio/features/harness/go/cmd" + "github.com/temporalio/features/harness/go/crosslanguage" + "github.com/temporalio/features/sdkbuild" + "github.com/urfave/cli/v2" +) + +type CrossLanguageRunConfig struct { + RunConfig + SDKVersions cli.StringSlice + SDKLanguages cli.StringSlice +} + +func runCrossLanguageCmd() *cli.Command { + var config CrossLanguageRunConfig + return &cli.Command{ + Name: "run-cross-language", + Usage: "Run crossLanguage features using their custom drivers", + Flags: append([]cli.Flag{ + &cli.StringSliceFlag{ + Name: "sdk-version", Destination: &config.SDKVersions, + Usage: "SDK selection, e.g. cs=1.22.0 or ts=/path/to/sdk", + }, + &cli.StringSliceFlag{ + Name: "sdk-language", Destination: &config.SDKLanguages, + Usage: "Prepare only these participants (repeatable; default: all discovered languages)", + }, + &cli.BoolFlag{ + Name: "retain-temp-dir", Destination: &config.RetainTempDir, + Usage: "Do not delete temporary SDK and driver builds", + }, + }, config.dockerRunFlags()...), + Action: func(ctx *cli.Context) error { + versions, err := config.sdkVersions() + if err != nil { + return err + } + runner := NewRunner(config.RunConfig) + runner.crossLanguage, runner.crossVersions = true, versions + for _, language := range config.SDKLanguages.Value() { + lang, err := normalizeLangName(language) + if err != nil { + return err + } + runner.crossLanguages = append(runner.crossLanguages, lang) + } + features, err := runner.GlobCrossLanguageFeatures(ctx.Args().Slice()) + if err != nil { + return err + } + return runner.runFeatures(ctx.Context, features, ctx.Args().Slice()) + }, + } +} + +func (config CrossLanguageRunConfig) sdkVersions() (map[string]string, error) { + versions := map[string]string{} + for _, selection := range config.SDKVersions.Value() { + lang, version, ok := strings.Cut(selection, "=") + lang, err := normalizeLangName(lang) + if !ok || err != nil || version == "" { + return nil, fmt.Errorf("invalid --sdk-version %q: expected language=version-or-path", selection) + } + if _, exists := versions[lang]; exists { + return nil, fmt.Errorf("duplicate --sdk-version for %s", lang) + } + versions[lang] = version + } + return versions, nil +} + +func (r *Runner) runCrossLanguageBatch(ctx context.Context, config RunConfig, batch runBatch) error { + restoreEnv := setNamespaceCapabilitiesEnv(config.NamespaceCapabilitiesJSON) + defer restoreEnv() + var summary Summary + var failed bool + for _, feature := range batch.Run.Features { + err := r.runCrossLanguageFeature(ctx, config, feature, r.crossVersions) + entry := SummaryEntry{Name: feature.SummaryName(), Outcome: FeaturePassed} + if err != nil { + entry.Outcome, entry.Message = "FAILED", err.Error() + failed = true + } + summary = append(summary, entry) + } + label := batch.VariantName + if label == "" { + label = "default" + } + r.logFeatureSummary(label, summary) + if failed { + return fmt.Errorf("cross-language feature failed") + } + return nil +} + +func (r *Runner) runCrossLanguageFeature( + ctx context.Context, config RunConfig, feature hcmd.RunFeature, versions map[string]string, +) error { + ctx, cancel := context.WithTimeout(ctx, 10*time.Minute) + defer cancel() + dir := filepath.Join(r.rootDir, "features", filepath.FromSlash(feature.Dir)) + files, err := filepath.Glob(filepath.Join(dir, "feature.*")) + if err != nil { + return err + } + manifest := crosslanguage.Manifest{ + Feature: feature.Dir, TaskQueue: feature.TaskQueue, + Programs: map[string]crosslanguage.Program{}, + } + for _, file := range files { + lang := strings.TrimPrefix(filepath.Ext(file), ".") + if _, err := normalizeLangName(lang); err != nil { + continue + } + if len(r.crossLanguages) != 0 && !slices.Contains(r.crossLanguages, lang) { + continue + } + program, err := r.crossLanguageProgram(ctx, lang, versions[lang]) + if err != nil { + return fmt.Errorf("prepare %s: %w", lang, err) + } + args := []string{"--server", config.Server, "--namespace", config.Namespace} + for _, option := range [][2]string{ + {"--client-cert-path", config.ClientCertPath}, {"--client-key-path", config.ClientKeyPath}, + {"--ca-cert-path", config.CACertPath}, {"--tls-server-name", config.TLSServerName}, + {"--http-proxy-url", config.HTTPProxyURL}, + } { + if option[1] != "" { + args = append(args, option[:]...) + } + } + if lang == "ts" { + args = append([]string{"./tslib/harness/ts/main.js"}, args...) + } else if lang == "go" { + args = append([]string{"run"}, args...) + } else if lang == "py" { + args = append([]string{"harness.python.main"}, args...) + } + command, err := program.NewCommand(ctx, args...) + if err != nil { + return err + } + manifest.Programs[lang] = crosslanguage.Program{Dir: command.Dir, Args: command.Args} + } + if len(manifest.Programs) == 0 { + return fmt.Errorf("%s has no feature. participants", feature.Dir) + } + buildDir, err := os.MkdirTemp(r.rootDir, "program-cross-driver-") + if err != nil { + return err + } + if !config.RetainTempDir { + defer os.RemoveAll(buildDir) + } + binary := filepath.Join(buildDir, "driver") + build := exec.CommandContext(ctx, "go", "build", "-o", binary, ".") + build.Dir = filepath.Join(dir, "driver") + build.Stdout, build.Stderr = os.Stdout, os.Stderr + if err := build.Run(); err != nil { + return fmt.Errorf("build %s/driver: %w", feature.Dir, err) + } + data, err := json.Marshal(manifest) + if err != nil { + return err + } + command := exec.CommandContext(ctx, binary) + command.Dir = dir + command.Env = append(os.Environ(), crosslanguage.ManifestEnv+"="+string(data)) + command.Stdout, command.Stderr = os.Stdout, os.Stderr + command.Cancel = func() error { return command.Process.Signal(os.Interrupt) } + command.WaitDelay = 10 * time.Second + if err := command.Run(); err != nil { + return fmt.Errorf("%s driver: %w", feature.Dir, err) + } + return nil +} + +func (r *Runner) crossLanguageProgram(ctx context.Context, lang, version string) (sdkbuild.Program, error) { + if program := r.crossPrograms[lang]; program != nil { + return program, nil + } + p := NewPreparer(PrepareConfig{Lang: lang, Version: version, crossLanguage: true}) + p.rootDir = r.rootDir + var program sdkbuild.Program + var err error + switch lang { + case "cs": + program, err = p.BuildDotNetProgram(ctx) + case "ts": + program, err = p.BuildTypeScriptProgram(ctx) + case "go": + program, err = p.BuildGoProgram(ctx) + case "py": + program, err = p.BuildPythonProgram(ctx) + case "java": + program, err = p.BuildJavaProgram(ctx, true) + case "rb": + program, err = p.BuildRubyProgram(ctx) + case "rs": + program, err = p.BuildRustProgram(ctx) + default: + return nil, fmt.Errorf("cross-language harness roles are not implemented for %s yet", lang) + } + if err != nil { + return nil, err + } + if r.crossPrograms == nil { + r.crossPrograms = map[string]sdkbuild.Program{} + } + r.crossPrograms[lang] = program + return program, nil +} diff --git a/cmd/run_cross_language_test.go b/cmd/run_cross_language_test.go new file mode 100644 index 00000000..6822ad14 --- /dev/null +++ b/cmd/run_cross_language_test.go @@ -0,0 +1,126 @@ +package cmd + +import ( + "context" + "os" + "os/exec" + "path/filepath" + "testing" + + hcmd "github.com/temporalio/features/harness/go/cmd" + "github.com/temporalio/features/sdkbuild" + "github.com/urfave/cli/v2" +) + +func TestCrossLanguageFeatureDiscovery(t *testing.T) { + root := t.TempDir() + for path, contents := range map[string]string{ + "features/tracing/encoded/config.json": `{"crossLanguage":true}`, + "features/tracing/encoded/feature.cs": "", + "features/tracing/encoded/feature.ts": "", + "features/tracing/plain/feature.ts": "", + "features/tracing/plain/config.json": `{}`, + } { + path = filepath.Join(root, path) + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(path, []byte(contents), 0644); err != nil { + t.Fatal(err) + } + } + for _, test := range []struct { + lang, pattern, want string + }{ + {"", "", "tracing/encoded"}, + {"", "features/tracing/encoded", "tracing/encoded"}, + {"", "tracing/encoded/config.json", "tracing/encoded"}, + {"ts", "", "tracing/plain"}, + {"cs", "", ""}, + {"ts", "tracing/encoded", ""}, + } { + runner := NewRunner(RunConfig{PrepareConfig: PrepareConfig{Lang: test.lang}}) + runner.rootDir = root + var patterns []string + if test.pattern != "" { + patterns = []string{test.pattern} + } + var features []*RunFeature + var err error + if test.lang == "" { + features, err = runner.GlobCrossLanguageFeatures(patterns) + } else { + features, err = runner.GlobFeatures(patterns) + } + if err != nil { + t.Fatal(err) + } + if test.want == "" { + if len(features) != 0 { + t.Fatalf("lang=%q pattern=%q: unwanted features %v", test.lang, test.pattern, features) + } + } else if len(features) != 1 || features[0].Dir != test.want { + t.Fatalf("lang=%q pattern=%q: got %v, want %s", test.lang, test.pattern, features, test.want) + } + } +} + +func TestCrossLanguageSDKSelections(t *testing.T) { + for _, selections := range [][]string{{"ts"}, {"ts="}, {"unknown=1"}, {"ts=1", "typescript=2"}} { + config := CrossLanguageRunConfig{SDKVersions: *cli.NewStringSlice(selections...)} + if _, err := config.sdkVersions(); err == nil { + t.Fatalf("accepted invalid SDK selections %v", selections) + } + } + config := CrossLanguageRunConfig{SDKVersions: *cli.NewStringSlice("dotnet=1.21.1", "ts=/local/sdk")} + versions, err := config.sdkVersions() + if err != nil || versions["cs"] != "1.21.1" || versions["ts"] != "/local/sdk" { + t.Fatalf("unexpected selections %v, %v", versions, err) + } +} + +type preparedCrossLanguageProgram struct{ dir string } + +func (p preparedCrossLanguageProgram) Dir() string { return p.dir } +func (p preparedCrossLanguageProgram) NewCommand(ctx context.Context, args ...string) (*exec.Cmd, error) { + command := exec.CommandContext(ctx, "unused-harness", args...) + command.Dir = p.dir + return command, nil +} + +func TestCrossLanguageDriverExitControlsFeatureOutcome(t *testing.T) { + for _, exit := range []string{"0", "7"} { + t.Run(exit, func(t *testing.T) { + root := t.TempDir() + for path, contents := range map[string]string{ + "go.mod": "module driver-test\n\ngo 1.26.0\n", + "features/sample/feature.ts": "", + "features/sample/driver/main.go": `package main +import ("os"; "strings") +func main() { + if !strings.Contains(os.Getenv("FEATURE_CROSS_LANGUAGE"), "\"Feature\":\"sample\"") { os.Exit(8) } + os.Exit(` + exit + `) +}`, + } { + path = filepath.Join(root, path) + if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(path, []byte(contents), 0644); err != nil { + t.Fatal(err) + } + } + runner := NewRunner(RunConfig{}) + runner.rootDir = root + runner.crossPrograms = map[string]sdkbuild.Program{ + "ts": preparedCrossLanguageProgram{root}, + } + err := runner.runCrossLanguageBatch(t.Context(), RunConfig{}, runBatch{ + Run: &hcmd.Run{Features: []hcmd.RunFeature{{Dir: "sample", TaskQueue: "queue"}}}, + }) + if (err != nil) != (exit != "0") { + t.Fatalf("driver exit=%s: unexpected result %v", exit, err) + } + }) + } +} diff --git a/cmd/run_feature.go b/cmd/run_feature.go index 10a773d4..5d39c7a8 100644 --- a/cmd/run_feature.go +++ b/cmd/run_feature.go @@ -19,12 +19,27 @@ type RunFeature struct { // GlobFeatures collects all features for this runner using the given patterns // or all features if no patterns given. func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { + return r.globFeatures(patterns, false) +} + +func (r *Runner) GlobCrossLanguageFeatures(patterns []string) ([]*RunFeature, error) { + return r.globFeatures(patterns, true) +} + +func (r *Runner) globFeatures(patterns []string, crossLanguage bool) ([]*RunFeature, error) { // Collect all feature dirs that have a lang entry var features []*RunFeature featuresDir := filepath.Join(r.rootDir, "features") - err := filepath.WalkDir(featuresDir, func(path string, _ fs.DirEntry, _ error) error { + err := filepath.WalkDir(featuresDir, func(path string, _ fs.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } // Only files that are feature + ext matter - if filepath.Base(path) != "feature."+r.config.Lang { + name := "feature." + r.config.Lang + if crossLanguage { + name = "config.json" + } + if filepath.Base(path) != name { return nil } @@ -35,6 +50,13 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { return err } dir = filepath.ToSlash(dir) + feature := &RunFeature{Dir: dir} + if err := feature.Config.LoadFromDir(filepath.Dir(path)); err != nil { + return fmt.Errorf("failed reading config from %v: %w", path, err) + } + if feature.Config.CrossLanguage != crossLanguage { + return nil + } // If no patterns present, all match. Otherwise, check dir or file on each. if len(patterns) > 0 { @@ -43,7 +65,7 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { pattern = strings.TrimPrefix(pattern, "features/") match, err := filepath.Match(pattern, dir) if !match && err == nil { - match, err = filepath.Match(pattern, dir+"/feature."+r.config.Lang) + match, err = filepath.Match(pattern, dir+"/"+name) } if err != nil { return fmt.Errorf("invalid pattern %q: %w", pattern, err) @@ -57,12 +79,6 @@ func (r *Runner) GlobFeatures(patterns []string) ([]*RunFeature, error) { } } - // Load config - feature := &RunFeature{Dir: dir} - if err := feature.Config.LoadFromDir(filepath.Dir(path)); err != nil { - return fmt.Errorf("failed reading config from %v: %w", path, err) - } - // If there's a min version, check we're within it if r.config.Lang == "go" && r.config.Version != "" && feature.Config.Go.MinVersion != "" { if semver.Compare(r.config.Version, feature.Config.Go.MinVersion) < 0 { diff --git a/cmd/run_go.go b/cmd/run_go.go index ee13c67c..c2e85529 100644 --- a/cmd/run_go.go +++ b/cmd/run_go.go @@ -3,6 +3,8 @@ package cmd import ( "context" "fmt" + "path/filepath" + "strings" "github.com/temporalio/features/harness/go/cmd" "github.com/temporalio/features/sdkbuild" @@ -13,7 +15,7 @@ import ( // root directory. func (p *Preparer) BuildGoProgram(ctx context.Context) (sdkbuild.Program, error) { p.log.Info("Building Go project", "DirName", p.config.DirName) - prog, err := sdkbuild.BuildGoProgram(ctx, sdkbuild.BuildGoProgramOptions{ + options := sdkbuild.BuildGoProgramOptions{ BaseDir: p.rootDir, DirName: p.config.DirName, Version: p.config.Version, @@ -39,7 +41,36 @@ func main() { cmd.Execute() }`, GoBuildTags: cmd.GoBuildTags(p.config.Version), - }) + } + if p.config.crossLanguage { + runner := NewRunner(RunConfig{}) + runner.rootDir = p.rootDir + features, err := runner.GlobCrossLanguageFeatures(nil) + if err != nil { + return nil, err + } + options.GoMainContents = `package main +import ( +"github.com/temporalio/features/harness/go/cmd" +"github.com/temporalio/features/harness/go/harness" +` + var registrations []string + for i, feature := range features { + if matches, _ := filepath.Glob(filepath.Join(p.rootDir, "features", feature.Dir, "feature.go")); len(matches) != 0 { + options.GoMainContents += fmt.Sprintf("f%d \"github.com/temporalio/features/features/%s\"\n", i, feature.Dir) + registrations = append(registrations, fmt.Sprintf("f%d.Feature", i)) + } + } + options.GoMainContents += ")\nfunc main() { harness.MustRegisterFeatures(" + strings.Join(registrations, ",") + "); cmd.Execute() }\n" + if strings.ContainsAny(p.config.Version, `/\`) { + sdkPath, err := filepath.Abs(p.config.Version) + if err != nil { + return nil, err + } + options.GoModContents += "\nreplace go.temporal.io/sdk/contrib/opentelemetry => " + filepath.ToSlash(filepath.Join(sdkPath, "contrib", "opentelemetry")) + "\n" + } + } + prog, err := sdkbuild.BuildGoProgram(ctx, options) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) } diff --git a/cmd/run_java.go b/cmd/run_java.go index af4e6b35..46fab07a 100644 --- a/cmd/run_java.go +++ b/cmd/run_java.go @@ -14,6 +14,10 @@ import ( // root directory. func (p *Preparer) BuildJavaProgram(ctx context.Context, build bool) (sdkbuild.Program, error) { p.log.Info("Building Java project", "DirName", p.config.DirName) + var modules []string + if p.config.crossLanguage { + modules = []string{"temporal-opentracing"} + } prog, err := sdkbuild.BuildJavaProgram(ctx, sdkbuild.BuildJavaProgramOptions{ BaseDir: p.rootDir, DirName: p.config.DirName, @@ -21,6 +25,7 @@ func (p *Preparer) BuildJavaProgram(ctx context.Context, build bool) (sdkbuild.P HarnessDependency: "io.temporal:features:0.1.0", MainClass: "io.temporal.sdkfeatures.Main", Build: build, + SDKModules: modules, }) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) diff --git a/cmd/run_ruby.go b/cmd/run_ruby.go index 99c2f2cf..ab070e67 100644 --- a/cmd/run_ruby.go +++ b/cmd/run_ruby.go @@ -41,11 +41,16 @@ func (p *Preparer) BuildRubyProgram(ctx context.Context) (sdkbuild.Program, erro } } + var dependencies []sdkbuild.RubyDependency + if p.config.crossLanguage { + dependencies = []sdkbuild.RubyDependency{{Name: "opentelemetry-sdk"}} + } prog, err := sdkbuild.BuildRubyProgram(ctx, sdkbuild.BuildRubyProgramOptions{ - BaseDir: p.rootDir, - SourceDir: rubyDir, - DirName: p.config.DirName, - Version: version, + BaseDir: p.rootDir, + SourceDir: rubyDir, + DirName: p.config.DirName, + Version: version, + MoreDependencies: dependencies, }) if err != nil { return nil, fmt.Errorf("failed preparing: %w", err) diff --git a/cmd/run_rust.go b/cmd/run_rust.go index 698dc78b..83547406 100644 --- a/cmd/run_rust.go +++ b/cmd/run_rust.go @@ -13,10 +13,11 @@ import ( func (p *Preparer) BuildRustProgram(ctx context.Context) (sdkbuild.Program, error) { p.log.Info("Building Rust project", "DirName", p.config.DirName) program, err := sdkbuild.BuildRustProgram(ctx, sdkbuild.BuildRustProgramOptions{ - BaseDir: p.rootDir, - DirName: p.config.DirName, - Version: p.config.Version, - PackageDir: filepath.Join(p.rootDir, "harness", "rust"), + BaseDir: p.rootDir, + DirName: p.config.DirName, + Version: p.config.Version, + PackageDir: filepath.Join(p.rootDir, "harness", "rust"), + CrossLanguage: p.config.crossLanguage, }) if err != nil { return nil, fmt.Errorf("failed preparing Rust: %w", err) diff --git a/cmd/run_typescript.go b/cmd/run_typescript.go index 967e98ed..9c80f530 100644 --- a/cmd/run_typescript.go +++ b/cmd/run_typescript.go @@ -6,6 +6,7 @@ import ( "fmt" "os" "path/filepath" + "strings" "github.com/temporalio/features/harness/go/cmd" "github.com/temporalio/features/sdkbuild" @@ -32,10 +33,43 @@ func (p *Preparer) BuildTypeScriptProgram(ctx context.Context) (sdkbuild.Program } } + var dependencies map[string]string + var excludes []string + if p.config.crossLanguage { + tracingVersion := strings.TrimPrefix(version, "v") + if strings.ContainsAny(version, `/\`) { + path, err := filepath.Abs(filepath.Join(version, "contrib", "interceptors-opentelemetry")) + if err != nil { + return nil, err + } + tracingVersion = "link:" + path + } + dependencies = map[string]string{ + "@temporalio/interceptors-opentelemetry": tracingVersion, + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", + } + } else { + // Cross-language participants may depend on newer SDK APIs than the ordinary + // features selected for a historical single-language run. + runner := NewRunner(RunConfig{}) + runner.rootDir = p.rootDir + features, err := runner.GlobCrossLanguageFeatures(nil) + if err != nil { + return nil, err + } + for _, feature := range features { + excludes = append(excludes, "../features/"+feature.Dir) + } + } prog, err := sdkbuild.BuildTypeScriptProgram(ctx, sdkbuild.BuildTypeScriptProgramOptions{ - BaseDir: p.rootDir, - DirName: p.config.DirName, - Version: version, + BaseDir: p.rootDir, + DirName: p.config.DirName, + Version: version, + MoreDependencies: dependencies, + AdditionalExcludes: excludes, TSConfigPaths: map[string][]string{ "@temporalio/harness": {"./tslib/harness/ts/harness.js", "../harness/ts/harness.ts"}, }, diff --git a/dotnet.csproj b/dotnet.csproj index 9d4f4baa..83e380bd 100644 --- a/dotnet.csproj +++ b/dotnet.csproj @@ -39,10 +39,12 @@ + + diff --git a/features/go.mod b/features/go.mod index 04f61c93..c6a1d50a 100644 --- a/features/go.mod +++ b/features/go.mod @@ -12,12 +12,15 @@ require ( github.com/temporalio/features/harness/go v0.0.0-00010101000000-000000000000 github.com/uber-go/tally/v4 v4.1.1 github.com/urfave/cli/v2 v2.3.0 + go.opentelemetry.io/otel v1.44.0 + go.opentelemetry.io/otel/sdk v1.44.0 go.temporal.io/api v1.64.3 go.temporal.io/sdk v1.51.0 go.temporal.io/sdk/contrib/aws/s3driver v0.1.1 go.temporal.io/sdk/contrib/aws/s3driver/awssdkv2 v0.1.1 go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0 go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0 + go.temporal.io/sdk/contrib/opentelemetry v0.8.1 go.temporal.io/sdk/contrib/sysinfo v0.1.0 go.temporal.io/sdk/contrib/tally v0.2.0 golang.org/x/mod v0.38.0 @@ -97,9 +100,7 @@ require ( go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.62.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect go.opentelemetry.io/otel/trace v1.44.0 // indirect go.uber.org/atomic v1.9.0 // indirect diff --git a/features/go.sum b/features/go.sum index 2144604c..ae413d7d 100644 --- a/features/go.sum +++ b/features/go.sum @@ -378,6 +378,8 @@ go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0 h1:pWclkV4CA6bAQ4gasJzIgNffJdRTb go.temporal.io/sdk/contrib/gcp/gcsdriver v0.1.0/go.mod h1:4rjw/25qkAjku1odNdeVVyEyfczGPv132km2gEP4QKk= go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0 h1:mT0Cfqjr+pwbKMch60dVd2Fcidx6XXScF/eJSbfLy/w= go.temporal.io/sdk/contrib/gcp/gcsdriver/gcssdk v0.1.0/go.mod h1:eg5XhF762ultvKxIaLxM8Bu22kEFg84bJev/0sXypm8= +go.temporal.io/sdk/contrib/opentelemetry v0.8.1 h1:wmQnxBWUsQQN6QihaEuUmsn8ZK6d+2G9oQF5bN4ObiY= +go.temporal.io/sdk/contrib/opentelemetry v0.8.1/go.mod h1:NnJgL/EwJIaWZVx4Vmb/qMh18a0fTu00VG/ojQ7tHPY= go.temporal.io/sdk/contrib/sysinfo v0.1.0 h1:jqP6BFZ/n+BoTt/OnlD+llufgSJSoxlq+aAIZCxnBdI= go.temporal.io/sdk/contrib/sysinfo v0.1.0/go.mod h1:1i61HTH1W1M331FprZF3SHeLFhZQSmb/YEbFsPhI654= go.temporal.io/sdk/contrib/tally v0.2.0 h1:XnTJIQcjOv+WuCJ1u8Ve2nq+s2H4i/fys34MnWDRrOo= diff --git a/features/tracing/encoded_headers/README.md b/features/tracing/encoded_headers/README.md new file mode 100644 index 00000000..e75e5c43 --- /dev/null +++ b/features/tracing/encoded_headers/README.md @@ -0,0 +1,114 @@ +# Encoded tracing headers across languages + +Exercises real SDK tracing integrations across workflow starts, including the +original [.NET → TypeScript regression](https://github.com/temporalio/sdk-typescript/issues/514#issuecomment-6259375934). +No interceptor decodes headers on an SDK's behalf. Every client checks that: + +- History contains a codec-encoded `_tracer-data` header with W3C `traceparent` + retaining the caller's trace identity. +- The workflow completes and round-trips its input and result through the codec. +- The real workflow tracing span retains that identity (silently dropping an + unreadable header is not a pass). +- No Workflow Task failed, even if a subsequent attempt succeeded. + +All participants wrap the entire serialized protobuf `Payload` with XOR `0x5a` +and set `metadata.encoding=binary/encrypted`. This deterministic test codec is +**not encryption**. Every codec rejects double encoding. User-provided Payload +headers must already include any required codec encoding; this feature does not +install a converter-wide wrapper or manually rewrite tracing headers. + +## Participants + +| SDK | Encoded tracing client | Worker | Real integration/configuration | +| --- | --- | --- | --- | +| .NET (`cs`) | Yes | Yes | `TracingInterceptor`, configured client codec | +| Go (`go`) | Yes | Yes | OpenTelemetry interceptor with producer-specific `TracerOptions.EncodeHeaders: true`; client codec | +| Java (`java`) | Yes | Yes | OpenTracing interceptors with the OpenTelemetry shim/W3C propagator and producer-specific `setEncodeHeaders(true)`; client codec | +| Python (`py`) | Yes | Yes | `TracingInterceptor`, client `HeaderCodecBehavior.CODEC` and codec | +| Ruby (`rb`) | Yes | Yes | OpenTelemetry tracing interceptor and client codec; worker codec thread pool | +| Rust (`rs`) | Yes | Yes | OpenTelemetry plugin with `encode_client_headers(true)` and existing worker activation codec traversal | +| TypeScript (`ts`) | Yes | Yes | OpenTelemetry plugin with `encodeClientHeaders: true`, worker `codecHeaders: true`, and payload codecs | +| PHP (`php`) | No | No | No SDK tracing integration in the inspected checkout; no participant is fabricated | + +Rust and TypeScript encode only the tracing carrier produced by their plugins; +user-provided client Payload headers are unchanged. These +producer opt-ins are independent of worker processing: Rust workers already decode +activation headers, while TypeScript workers use `codecHeaders`. +PHP would first need a real tracing integration and a codec/header policy. + +## Release availability + +The following versions were checked on November 13, 2026. Merged changes are not +necessarily published SDK releases. + +| SDK | Published version | Availability for this feature | +| --- | --- | --- | +| .NET | 1.22.0 | Available | +| Python | 1.36.0 | Available | +| Ruby | 1.11.0 | Available | +| Rust | 1.2.0 | Available; the harness pins this release | +| Go | SDK 1.51.0; OpenTelemetry module 0.8.1 | Blocked: the SDK contains the change, but the separately versioned OpenTelemetry module does not expose `EncodeHeaders` yet | +| Java | 1.40.0 | Blocked: the merged `setEncodeHeaders` option is not published yet | +| TypeScript | 1.25.0 | Blocked: the merged `codecHeaders` and `encodeClientHeaders` options are not published yet | + +Keep this feature PR in draft until the last three releases are available. Update +the Go OpenTelemetry dependency in `features/go.mod` and the TypeScript packages +in `package.json` when they are published; Java selects `latest.release`. +The default seven-language matrix remains enabled and must pass before landing. +Unreleased participants are not silently skipped or counted as successful. + +## Running + +By default, the runner discovers and prepares all participant files once. The +feature driver runs every supported client/worker pair among the prepared SDKs, +including same-language controls. Each pair gets its own queue and a 45-second +deadline; failures are labeled and aggregated while later pairs continue. Workers +are stopped and reaped on success, failure and cancellation. No tracing backend +is required. + +Run the currently available releases without any local SDK checkouts: + +```sh +go run . run-cross-language \ + --sdk-language cs --sdk-language py --sdk-language rb --sdk-language rs \ + --sdk-version cs=1.22.0 --sdk-version py=1.36.0 \ + --sdk-version rb=1.11.0 --sdk-version rs=1.2.0 tracing/encoded_headers +``` + +This runs all 16 client/worker combinations among those four SDKs. + +The original .NET → TypeScript case remains independently runnable against a +checkout containing the merged TypeScript fix: + +```sh +ENCODED_HEADERS_PAIRS=cs:ts go run . run-cross-language \ + --sdk-language cs --sdk-language ts --sdk-version cs=1.22.0 \ + --sdk-version ts=/path/to/sdk-typescript tracing/encoded_headers +``` + +With `ts=1.25.0` this is a **failing regression test**, not an expected-failure +success: tracing extraction raises `Unknown encoding: binary/encrypted`. + +Use `--sdk-version go=/path/to/sdk-go` and +`--sdk-version java=/path/to/sdk-java` to validate their merged but unreleased +tracing integrations. +Local Go selection also substitutes its independently versioned OpenTelemetry +module; local Java selection substitutes its OpenTracing module. Older releases +without the opt-ins cannot run these producer participants and fail rather than +silently testing unencoded headers. + +Use `ENCODED_HEADERS_PAIRS` only when focusing on particular scenarios: + +```sh +ENCODED_HEADERS_PAIRS=py:rs go run . run-cross-language --sdk-language py --sdk-language rs --sdk-version py=1.36.0 --sdk-version rs=1.2.0 tracing/encoded_headers +``` + +The filter is a comma-separated list of `client:worker` language codes. Requested +unsupported roles or unprepared participants are errors; they never disappear +from the run or count as passes. `--sdk-language` only limits preparation; all +pair/scenario policy stays in this feature's driver. Ruby preparation requires +the Ruby version specified by the harness gemspec; Rust requires the package's +pinned compiler/protoc and builds its `cross-language` Cargo feature. + +Single-language history comparison/replay is intentionally not used: the client +participant checks the actual other-language workflow history. diff --git a/features/tracing/encoded_headers/config.json b/features/tracing/encoded_headers/config.json new file mode 100644 index 00000000..8e492f94 --- /dev/null +++ b/features/tracing/encoded_headers/config.json @@ -0,0 +1,3 @@ +{ + "crossLanguage": true +} diff --git a/features/tracing/encoded_headers/driver/main.go b/features/tracing/encoded_headers/driver/main.go new file mode 100644 index 00000000..4e5bfc24 --- /dev/null +++ b/features/tracing/encoded_headers/driver/main.go @@ -0,0 +1,102 @@ +package main + +import ( + "context" + "errors" + "fmt" + "os" + "os/signal" + "slices" + "strings" + "time" + + "github.com/temporalio/features/harness/go/crosslanguage" +) + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func run() error { + ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) + defer cancel() + participants, err := crosslanguage.FromEnv() + if err != nil { + return err + } + pairs, err := selectPairs(participants, os.Getenv("ENCODED_HEADERS_PAIRS")) + if err != nil { + return err + } + var failures []error + for _, pair := range pairs { + if ctx.Err() != nil { + return errors.Join(append(failures, ctx.Err())...) + } + fmt.Printf("Testing encoded tracing headers: %s client → %s worker\n", pair[0], pair[1]) + err := runPair(ctx, participants, pair) + if err != nil { + err = fmt.Errorf("%s → %s: %w", pair[0], pair[1], err) + fmt.Fprintln(os.Stderr, err) + failures = append(failures, err) + } else { + fmt.Printf("PASS %s → %s\n", pair[0], pair[1]) + } + } + return errors.Join(failures...) +} + +var clients = []string{"cs", "go", "java", "py", "rb", "rs", "ts"} +var workers = []string{"cs", "go", "java", "py", "rb", "rs", "ts"} + +func selectPairs(manifest *crosslanguage.Manifest, filter string) ([][2]string, error) { + var pairs [][2]string + if filter != "" { + for _, selection := range strings.Split(filter, ",") { + client, worker, ok := strings.Cut(selection, ":") + if !ok || !slices.Contains(clients, client) || !slices.Contains(workers, worker) { + return nil, fmt.Errorf("invalid ENCODED_HEADERS_PAIRS pair %q: clients=%v workers=%v; PHP has no tracing integration", selection, clients, workers) + } + if _, ok := manifest.Programs[client]; !ok { + return nil, fmt.Errorf("client %s is not prepared; include --sdk-language %s", client, client) + } + if _, ok := manifest.Programs[worker]; !ok { + return nil, fmt.Errorf("worker %s is not prepared; include --sdk-language %s", worker, worker) + } + pair := [2]string{client, worker} + if !slices.Contains(pairs, pair) { + pairs = append(pairs, pair) + } + } + } else { + for _, client := range clients { + if _, ok := manifest.Programs[client]; !ok { + continue + } + for _, worker := range workers { + if _, ok := manifest.Programs[worker]; ok { + pairs = append(pairs, [2]string{client, worker}) + } + } + } + } + if len(pairs) == 0 { + return nil, fmt.Errorf("no supported client/worker pairs among prepared participants") + } + return pairs, nil +} + +func runPair(ctx context.Context, participants *crosslanguage.Manifest, pair [2]string) error { + ctx, cancel := context.WithTimeout(ctx, 45*time.Second) + defer cancel() + queue := participants.TaskQueue + "-" + pair[0] + "-" + pair[1] + stop, err := participants.StartWorker(ctx, pair[1], queue) + if err != nil { + return err + } + defer stop() + return participants.RunClient(ctx, pair[0], queue) +} diff --git a/features/tracing/encoded_headers/driver/main_test.go b/features/tracing/encoded_headers/driver/main_test.go new file mode 100644 index 00000000..7ccb737c --- /dev/null +++ b/features/tracing/encoded_headers/driver/main_test.go @@ -0,0 +1,30 @@ +package main + +import ( + "strings" + "testing" + + "github.com/temporalio/features/harness/go/crosslanguage" +) + +func TestPairSelection(t *testing.T) { + manifest := &crosslanguage.Manifest{Programs: map[string]crosslanguage.Program{ + "cs": {}, "ts": {}, "go": {}, + }} + pairs, err := selectPairs(manifest, "") + if err != nil || len(pairs) != 9 { + t.Fatalf("expected cs/go/ts clients × cs/go/ts workers: %v %v", pairs, err) + } + pairs, err = selectPairs(manifest, "cs:ts,cs:ts") + if err != nil || len(pairs) != 1 || pairs[0] != [2]string{"cs", "ts"} { + t.Fatalf("unexpected focused selection: %v %v", pairs, err) + } + for filter, message := range map[string]string{ + "go:java": "not prepared", "rs:ts": "not prepared", + "cs:php": "no tracing integration", + } { + if _, err := selectPairs(manifest, filter); err == nil || !strings.Contains(err.Error(), message) { + t.Fatalf("%s: expected %q, got %v", filter, message, err) + } + } +} diff --git a/features/tracing/encoded_headers/feature.cs b/features/tracing/encoded_headers/feature.cs new file mode 100644 index 00000000..54976970 --- /dev/null +++ b/features/tracing/encoded_headers/feature.cs @@ -0,0 +1,120 @@ +namespace tracing.encoded_headers; + +using System.Diagnostics; +using System.Text.Json; +using Google.Protobuf; +using OpenTelemetry.Context.Propagation; +using Temporalio.Api.Common.V1; +using Temporalio.Client; +using Temporalio.Converters; +using Temporalio.Extensions.OpenTelemetry; +using Temporalio.Features.Harness; +using Temporalio.Worker; +using Temporalio.Workflows; + +public class Feature : IFeature +{ + private static readonly ActivityListener Listener; + + static Feature() + { + var clientSourceName = TracingInterceptor.ClientSource.Name; + var workflowSourceName = TracingInterceptor.WorkflowsSource.Name; + Listener = new() + { + ShouldListenTo = source => source.Name == "header-codec-feature" || + source.Name == clientSourceName || source.Name == workflowSourceName, + Sample = (ref ActivityCreationOptions _) => ActivitySamplingResult.AllDataAndRecorded, + }; + ActivitySource.AddActivityListener(Listener); + } + + public void ConfigureClient(Runner runner, TemporalClientConnectOptions options) + { + options.DataConverter = DataConverter.Default with { PayloadCodec = new WrappingCodec() }; + options.Interceptors = new[] + { + new TracingInterceptor(new() { Propagator = new TraceContextPropagator() }), + }; + } + + public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) => + options.AddWorkflow(); + + public async Task ExecuteAsync(Runner runner) + { + using var source = new ActivitySource("header-codec-feature"); + using var parent = source.StartActivity("dotnet-caller")!; + var options = runner.NewWorkflowOptions(); + options.ExecutionTimeout = TimeSpan.FromSeconds(15); + var handle = await runner.Client.StartWorkflowAsync("workflow", new object?[] { "hello" }, options); + try + { + var history = await handle.FetchHistoryAsync(); + var header = history.Events.First().WorkflowExecutionStartedEventAttributes.Header.Fields["_tracer-data"]; + Assert.Equal(WrappingCodec.EncodingName, header.Metadata["encoding"].ToStringUtf8()); + var decoded = (await new WrappingCodec().DecodeAsync(new[] { header })).Single(); + var carrier = JsonSerializer.Deserialize>(decoded.Data.ToStringUtf8())!; + Assert.Equal(parent.TraceId.ToHexString(), carrier["traceparent"].Split('-')[1]); + + var result = await handle.GetResultAsync>().WaitAsync(TimeSpan.FromSeconds(30)); + Assert.Equal("hello", result["message"]); + Assert.Equal(parent.TraceId.ToHexString(), result["traceId"]); + history = await handle.FetchHistoryAsync(); + Assert.DoesNotContain(history.Events, evt => evt.WorkflowTaskFailedEventAttributes != null); + return null; + } + catch + { + // Preserve the extraction error in diagnostics instead of reporting only an execution timeout. + foreach (var evt in (await handle.FetchHistoryAsync()).Events) + { + if (evt.WorkflowTaskFailedEventAttributes is { } failed) + { + runner.Logger.LogError("Workflow Task failed: {Failure}", failed.Failure); + } + } + throw; + } + } + + [Workflow("workflow")] + public class WorkflowImpl + { + [WorkflowRun] + public Task> RunAsync(string message) + { + var activity = WorkflowDiagnosticActivity.Current ?? + throw new InvalidOperationException("No active workflow tracing span"); + Assert.NotEqual(default, activity.Context.TraceId); + return Task.FromResult(new Dictionary + { + ["message"] = message, + ["traceId"] = activity.Context.TraceId.ToHexString(), + }); + } + } + + sealed class WrappingCodec : IPayloadCodec + { + public const string EncodingName = "binary/encrypted"; + + public Task> EncodeAsync(IReadOnlyCollection payloads) => + Task.FromResult>(payloads.Select(payload => + { + Assert.NotEqual(EncodingName, payload.Metadata["encoding"].ToStringUtf8()); + return new Payload + { + Metadata = { ["encoding"] = ByteString.CopyFromUtf8(EncodingName) }, + Data = ByteString.CopyFrom(payload.ToByteArray().Select(b => (byte)(b ^ 0x5a)).ToArray()), + }; + }).ToArray()); + + public Task> DecodeAsync(IReadOnlyCollection payloads) => + Task.FromResult>(payloads.Select(payload => + { + Assert.Equal(EncodingName, payload.Metadata["encoding"].ToStringUtf8()); + return Payload.Parser.ParseFrom(payload.Data.Select(b => (byte)(b ^ 0x5a)).ToArray()); + }).ToArray()); + } +} diff --git a/features/tracing/encoded_headers/feature.go b/features/tracing/encoded_headers/feature.go new file mode 100644 index 00000000..feb7527a --- /dev/null +++ b/features/tracing/encoded_headers/feature.go @@ -0,0 +1,141 @@ +package encoded_headers + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + "github.com/temporalio/features/harness/go/harness" + "go.opentelemetry.io/otel/propagation" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + commonpb "go.temporal.io/api/common/v1" + enumspb "go.temporal.io/api/enums/v1" + "go.temporal.io/sdk/client" + "go.temporal.io/sdk/contrib/opentelemetry" + "go.temporal.io/sdk/converter" + "go.temporal.io/sdk/interceptor" + "go.temporal.io/sdk/workflow" + "google.golang.org/protobuf/proto" +) + +const encoding = "binary/encrypted" + +type wrappingCodec struct{} + +func (wrappingCodec) Encode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) { + result := make([]*commonpb.Payload, len(payloads)) + for i, payload := range payloads { + if string(payload.Metadata["encoding"]) == encoding { + return nil, fmt.Errorf("payload encoded twice") + } + data, err := proto.Marshal(payload) + if err != nil { + return nil, err + } + for j := range data { + data[j] ^= 0x5a + } + result[i] = &commonpb.Payload{Metadata: map[string][]byte{"encoding": []byte(encoding)}, Data: data} + } + return result, nil +} + +func (wrappingCodec) Decode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) { + result := make([]*commonpb.Payload, len(payloads)) + for i, payload := range payloads { + if string(payload.Metadata["encoding"]) != encoding { + return nil, fmt.Errorf("expected encoded payload, got %q", payload.Metadata["encoding"]) + } + data := append([]byte(nil), payload.Data...) + for j := range data { + data[j] ^= 0x5a + } + result[i] = new(commonpb.Payload) + if err := proto.Unmarshal(data, result[i]); err != nil { + return nil, err + } + } + return result, nil +} + +var provider = sdktrace.NewTracerProvider() +var tracer = provider.Tracer("encoded-headers-feature") + +var Feature = harness.Feature{ + Workflows: harness.WorkflowWithOptions{Workflow: Workflow, Options: workflow.RegisterOptions{Name: "workflow"}}, + ClientOptions: client.Options{ + DataConverter: converter.NewCodecDataConverter(converter.GetDefaultDataConverter(), wrappingCodec{}), + Interceptors: []interceptor.ClientInterceptor{newTracingInterceptor()}, + }, + Execute: execute, +} + +func newTracingInterceptor() interceptor.Interceptor { + tracing, err := opentelemetry.NewTracingInterceptor(opentelemetry.TracerOptions{ + Tracer: tracer, EncodeHeaders: true, TextMapPropagator: propagation.TraceContext{}, + }) + if err != nil { + panic(err) + } + return tracing +} + +func Workflow(ctx workflow.Context, message string) (map[string]string, error) { + span, ok := opentelemetry.SpanFromWorkflowContext(ctx) + if !ok || !span.SpanContext().IsValid() { + return nil, fmt.Errorf("no active workflow tracing span") + } + return map[string]string{"message": message, "traceId": span.SpanContext().TraceID().String()}, nil +} + +func execute(ctx context.Context, r *harness.Runner) (client.WorkflowRun, error) { + ctx, parent := tracer.Start(ctx, "go-caller") + defer parent.End() + run, err := r.Client.ExecuteWorkflow(ctx, client.StartWorkflowOptions{ + TaskQueue: r.TaskQueue, WorkflowExecutionTimeout: 15 * time.Second, + }, "workflow", "hello") + if err != nil { + return nil, err + } + var result map[string]string + resultErr := run.Get(ctx, &result) + history := r.Client.GetWorkflowHistory(ctx, run.GetID(), run.GetRunID(), false, enumspb.HISTORY_EVENT_FILTER_TYPE_ALL_EVENT) + found := false + for history.HasNext() { + event, err := history.Next() + if err != nil { + return nil, err + } + if failed := event.GetWorkflowTaskFailedEventAttributes(); failed != nil { + return nil, fmt.Errorf("workflow task failed: %v", failed.Failure) + } + if started := event.GetWorkflowExecutionStartedEventAttributes(); started != nil { + header := started.Header.GetFields()["_tracer-data"] + if header == nil { + return nil, fmt.Errorf("missing tracing header") + } + decoded, err := (wrappingCodec{}).Decode([]*commonpb.Payload{header}) + if err != nil { + return nil, err + } + var carrier map[string]string + if err := json.Unmarshal(decoded[0].Data, &carrier); err != nil { + return nil, err + } + parts := strings.Split(carrier["traceparent"], "-") + if len(parts) != 4 || parts[1] != parent.SpanContext().TraceID().String() { + return nil, fmt.Errorf("history traceparent mismatch: %v", carrier) + } + found = true + } + } + if resultErr != nil { + return nil, resultErr + } + if !found || result["message"] != "hello" || result["traceId"] != parent.SpanContext().TraceID().String() { + return nil, fmt.Errorf("trace identity/input round-trip failed: history=%t result=%v", found, result) + } + return nil, nil +} diff --git a/features/tracing/encoded_headers/feature.java b/features/tracing/encoded_headers/feature.java new file mode 100644 index 00000000..66675856 --- /dev/null +++ b/features/tracing/encoded_headers/feature.java @@ -0,0 +1,158 @@ +package tracing.encoded_headers; + +import static org.junit.jupiter.api.Assertions.*; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.protobuf.ByteString; +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.Scope; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.opentracingshim.OpenTracingShim; +import io.opentelemetry.sdk.OpenTelemetrySdk; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.temporal.api.common.v1.Payload; +import io.temporal.client.WorkflowClientOptions; +import io.temporal.common.converter.CodecDataConverter; +import io.temporal.common.converter.DefaultDataConverter; +import io.temporal.opentracing.OpenTracingClientInterceptor; +import io.temporal.opentracing.OpenTracingOptions; +import io.temporal.opentracing.OpenTracingWorkerInterceptor; +import io.temporal.payload.codec.PayloadCodec; +import io.temporal.sdkfeatures.Feature; +import io.temporal.sdkfeatures.Run; +import io.temporal.sdkfeatures.Runner; +import io.temporal.worker.WorkerFactoryOptions; +import io.temporal.workflow.WorkflowInterface; +import io.temporal.workflow.WorkflowMethod; +import java.util.*; + +@WorkflowInterface +public interface feature extends Feature { + @WorkflowMethod(name = "workflow") + Map workflow(String message); + + class Impl implements feature { + static final OpenTelemetry telemetry = + OpenTelemetrySdk.builder() + .setTracerProvider(SdkTracerProvider.builder().build()) + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .build(); + static final io.opentracing.Tracer tracer = OpenTracingShim.createTracerShim(telemetry); + final OpenTracingOptions options = tracingOptions(); + + static OpenTracingOptions tracingOptions() { + var builder = OpenTracingOptions.newBuilder().setTracer(tracer); + try { + // Older releases can still compile the ordinary suite; a selected participant must opt in. + builder.getClass().getMethod("setEncodeHeaders", boolean.class).invoke(builder, true); + } catch (ReflectiveOperationException e) { + throw new IllegalStateException( + "Java tracing requires producer-specific setEncodeHeaders(true)", e); + } + return builder.build(); + } + + @Override + public void workflowClientOptions(WorkflowClientOptions.Builder builder) { + builder.setDataConverter( + new CodecDataConverter( + DefaultDataConverter.newDefaultInstance(), List.of(new WrappingCodec()))); + builder.setInterceptors(new OpenTracingClientInterceptor(options)); + } + + @Override + public void workerFactoryOptions(WorkerFactoryOptions.Builder builder) { + builder.setWorkerInterceptors(new OpenTracingWorkerInterceptor(options)); + } + + @Override + public Map workflow(String message) { + var span = Span.current().getSpanContext(); + assertTrue(span.isValid(), "No active workflow tracing span"); + return Map.of("message", message, "traceId", span.getTraceId()); + } + + @Override + public Run execute(Runner runner) throws Exception { + var parent = + telemetry.getTracer("encoded-headers-feature").spanBuilder("java-caller").startSpan(); + try (Scope ignored = parent.makeCurrent()) { + var run = + runner.executeSingleWorkflow( + io.temporal.client.WorkflowOptions.newBuilder() + .setTaskQueue(runner.config.taskQueue) + .setWorkflowExecutionTimeout(java.time.Duration.ofSeconds(15)) + .build(), + "hello"); + Map result; + try { + result = runner.waitForRunResult(run, Map.class); + } finally { + for (var event : runner.getWorkflowHistory(run).getEventsList()) { + assertFalse(event.hasWorkflowTaskFailedEventAttributes(), event.toString()); + } + } + var header = + runner + .getWorkflowHistory(run) + .getEvents(0) + .getWorkflowExecutionStartedEventAttributes() + .getHeader() + .getFieldsOrThrow("_tracer-data"); + var decoded = new WrappingCodec().decode(List.of(header)).get(0); + Map carrier = + new ObjectMapper() + .readValue( + decoded.getData().toByteArray(), new TypeReference>() {}); + assertEquals( + parent.getSpanContext().getTraceId(), carrier.get("traceparent").split("-")[1]); + assertEquals( + Map.of("message", "hello", "traceId", parent.getSpanContext().getTraceId()), result); + return null; + } finally { + parent.end(); + } + } + } + + class WrappingCodec implements PayloadCodec { + static final ByteString ENCODING = ByteString.copyFromUtf8("binary/encrypted"); + + static byte[] xor(byte[] data) { + for (int i = 0; i < data.length; i++) data[i] ^= 0x5a; + return data; + } + + @Override + public List encode(List payloads) { + var result = new ArrayList(); + for (var payload : payloads) { + assertNotEquals( + ENCODING, payload.getMetadataMap().get("encoding"), "Payload encoded twice"); + result.add( + Payload.newBuilder() + .putMetadata("encoding", ENCODING) + .setData(ByteString.copyFrom(xor(payload.toByteArray()))) + .build()); + } + return result; + } + + @Override + public List decode(List payloads) { + var result = new ArrayList(); + for (var payload : payloads) { + assertEquals(ENCODING, payload.getMetadataMap().get("encoding")); + try { + result.add(Payload.parseFrom(xor(payload.getData().toByteArray()))); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw new IllegalArgumentException("Invalid wrapped payload", e); + } + } + return result; + } + } +} diff --git a/features/tracing/encoded_headers/feature.py b/features/tracing/encoded_headers/feature.py new file mode 100644 index 00000000..1b11481e --- /dev/null +++ b/features/tracing/encoded_headers/feature.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import dataclasses +import json +import uuid +from datetime import timedelta +from typing import Sequence + +from temporalio import workflow + +with workflow.unsafe.imports_passed_through(): + from opentelemetry import trace + from opentelemetry.propagate import set_global_textmap + from opentelemetry.sdk.trace import TracerProvider + from opentelemetry.trace.propagation.tracecontext import ( + TraceContextTextMapPropagator, + ) + from temporalio.api.common.v1 import Payload + from temporalio.common import HeaderCodecBehavior + from temporalio.contrib.opentelemetry import TracingInterceptor + from temporalio.converter import DataConverter, PayloadCodec + + from harness.python.feature import Runner, register_feature + + +class WrappingCodec(PayloadCodec): + async def encode(self, payloads: Sequence[Payload]) -> list[Payload]: + result = [] + for payload in payloads: + assert payload.metadata["encoding"] != b"binary/encrypted", ( + "Payload encoded twice" + ) + result.append( + Payload( + metadata={"encoding": b"binary/encrypted"}, + data=bytes(b ^ 0x5A for b in payload.SerializeToString()), + ) + ) + return result + + async def decode(self, payloads: Sequence[Payload]) -> list[Payload]: + result = [] + for payload in payloads: + assert payload.metadata["encoding"] == b"binary/encrypted" + result.append(Payload.FromString(bytes(b ^ 0x5A for b in payload.data))) + return result + + +@workflow.defn(name="workflow") +class Workflow: + @workflow.run + async def run(self, message: str) -> dict[str, str]: + span = trace.get_current_span().get_span_context() + assert span.is_valid, "No active workflow tracing span" + return {"message": message, "traceId": f"{span.trace_id:032x}"} + + +async def start(runner: Runner): + with trace.get_tracer("encoded-headers-feature").start_as_current_span( + "python-caller" + ) as parent: + trace_id = f"{parent.get_span_context().trace_id:032x}" + handle = await runner.client.start_workflow( + "workflow", + "hello", + id=str(uuid.uuid4()), + task_queue=runner.task_queue, + execution_timeout=timedelta(seconds=15), + ) + try: + result = await handle.result() + finally: + history = await handle.fetch_history() + for event in history.events: + assert not event.HasField("workflow_task_failed_event_attributes"), ( + event + ) + header = history.events[ + 0 + ].workflow_execution_started_event_attributes.header.fields["_tracer-data"] + decoded = (await WrappingCodec().decode([header]))[0] + carrier = json.loads(decoded.data) + assert carrier["traceparent"].split("-")[1] == trace_id + assert result == {"message": "hello", "traceId": trace_id}, result + return handle + + +if not workflow.unsafe.in_sandbox(): + trace.set_tracer_provider(TracerProvider()) + set_global_textmap(TraceContextTextMapPropagator()) + register_feature( + workflows=[Workflow], + start=start, + data_converter=dataclasses.replace( + DataConverter.default, payload_codec=WrappingCodec() + ), + additional_client_config={ + "interceptors": [TracingInterceptor()], + "header_codec_behavior": HeaderCodecBehavior.CODEC, + }, + ) diff --git a/features/tracing/encoded_headers/feature.rb b/features/tracing/encoded_headers/feature.rb new file mode 100644 index 00000000..0ff6c0d5 --- /dev/null +++ b/features/tracing/encoded_headers/feature.rb @@ -0,0 +1,79 @@ +# frozen_string_literal: true + +require 'json' +require 'securerandom' +require 'opentelemetry/sdk' +require 'temporalio/contrib/open_telemetry' +require 'temporalio/converters/data_converter' +require 'temporalio/converters/payload_codec' +require 'temporalio/workflow' + +module EncodedHeaders + class WrappingCodec < Temporalio::Converters::PayloadCodec + def encode(payloads) + payloads.map do |payload| + raise 'Payload encoded twice' if payload.metadata['encoding'] == 'binary/encrypted' + + Temporalio::Api::Common::V1::Payload.new( + metadata: { 'encoding' => 'binary/encrypted' }, + data: Temporalio::Api::Common::V1::Payload.encode(payload).bytes.map { |b| b ^ 0x5a }.pack('C*') + ) + end + end + + def decode(payloads) + payloads.map do |payload| + raise 'Expected encoded payload' unless payload.metadata['encoding'] == 'binary/encrypted' + + Temporalio::Api::Common::V1::Payload.decode(payload.data.bytes.map { |b| b ^ 0x5a }.pack('C*')) + end + end + end + + class Workflow < Temporalio::Workflow::Definition + workflow_name 'workflow' + + def execute(message) + span = Temporalio::Contrib::OpenTelemetry::Workflow.completed_span('feature-result') + raise 'No active workflow tracing span' unless span&.context&.valid? + + { 'message' => message, 'traceId' => span.context.hex_trace_id } + end + end + + PROVIDER = OpenTelemetry::SDK::Trace::TracerProvider.new + TRACER = PROVIDER.tracer('encoded-headers-feature') + + def self.start(client, task_queue, _feature) + TRACER.in_span('ruby-caller') do |parent| + trace_id = parent.context.hex_trace_id + handle = client.start_workflow( + 'workflow', 'hello', id: SecureRandom.uuid, task_queue: task_queue, execution_timeout: 15 + ) + begin + result = handle.result + ensure + history = handle.fetch_history + history.events.each do |event| + raise "Workflow task failed: #{event.workflow_task_failed_event_attributes}" if event.workflow_task_failed_event_attributes + end + end + header = history.events.first.workflow_execution_started_event_attributes.header.fields['_tracer-data'] + carrier = JSON.parse(WrappingCodec.new.decode([header]).first.data) + raise "History trace identity mismatch: #{carrier}" unless carrier['traceparent'].split('-')[1] == trace_id + raise "Input/trace round-trip mismatch: #{result}" unless result == { 'message' => 'hello', 'traceId' => trace_id } + + handle + end + end +end + +Harness.register_feature( + workflows: [EncodedHeaders::Workflow], + start: EncodedHeaders.method(:start), + worker_options: { workflow_payload_codec_thread_pool: Temporalio::Worker::ThreadPool.default }, + client_options: { + data_converter: Temporalio::Converters::DataConverter.new(payload_codec: EncodedHeaders::WrappingCodec.new), + interceptors: [Temporalio::Contrib::OpenTelemetry::TracingInterceptor.new(EncodedHeaders::TRACER)] + } +) diff --git a/features/tracing/encoded_headers/feature.rs b/features/tracing/encoded_headers/feature.rs new file mode 100644 index 00000000..34424dc5 --- /dev/null +++ b/features/tracing/encoded_headers/feature.rs @@ -0,0 +1,207 @@ +use crate::harness::{Feature, FeatureContext, FeatureFuture, FeatureOutcome}; +use anyhow::{Result, ensure}; +use futures::{FutureExt, future::BoxFuture}; +use opentelemetry::{ + Context, + trace::{FutureExt as _, TraceContextExt, Tracer, TracerProvider}, +}; +use prost::Message; +use std::{collections::HashMap, time::Duration}; +use temporalio_client::{Client, ClientOptions, WorkflowGetResultOptions}; +use temporalio_common::{ + data_converters::{ + DataConverter, DefaultFailureConverter, PayloadCodec, PayloadConversionError, + PayloadConverter, SerializationContextData, + }, + protos::temporal::api::{common::v1::Payload, history::v1::history_event::Attributes}, +}; +use temporalio_macros::{workflow, workflow_methods}; +use temporalio_sdk::{ + WorkerOptions, WorkflowContext, WorkflowResult, opentelemetry::OpenTelemetryPlugin, +}; + +const ENCODING: &[u8] = b"binary/encrypted"; + +#[derive(Debug)] +struct WrappingCodec; + +impl PayloadCodec for WrappingCodec { + fn encode( + &self, + _: &SerializationContextData, + payloads: Vec, + ) -> BoxFuture<'static, Result, PayloadConversionError>> { + async move { + payloads + .into_iter() + .map(|payload| { + if payload.metadata.get("encoding").map(Vec::as_slice) == Some(ENCODING) { + return Err(PayloadConversionError::EncodingError( + "Payload encoded twice".into(), + )); + } + Ok(Payload { + metadata: HashMap::from([("encoding".to_owned(), ENCODING.to_vec())]), + data: payload + .encode_to_vec() + .into_iter() + .map(|b| b ^ 0x5a) + .collect(), + ..Default::default() + }) + }) + .collect() + } + .boxed() + } + + fn decode( + &self, + _: &SerializationContextData, + payloads: Vec, + ) -> BoxFuture<'static, Result, PayloadConversionError>> { + async move { + payloads + .into_iter() + .map(|payload| { + if payload.metadata.get("encoding").map(Vec::as_slice) != Some(ENCODING) { + return Err(PayloadConversionError::EncodingError( + "Expected encoded payload".into(), + )); + } + let data: Vec = payload.data.into_iter().map(|b| b ^ 0x5a).collect(); + Payload::decode(data.as_slice()) + .map_err(|e| PayloadConversionError::EncodingError(e.into())) + }) + .collect() + } + .boxed() + } +} + +#[workflow] +#[derive(Default)] +pub struct Workflow; + +#[workflow_methods] +impl Workflow { + #[run(name = "workflow")] + pub async fn run( + _ctx: &mut WorkflowContext, + message: String, + ) -> WorkflowResult> { + let context = Context::current(); + let span = context.span(); + assert!( + span.span_context().is_valid(), + "No active workflow tracing span" + ); + Ok(HashMap::from([ + ("message".to_owned(), message), + ( + "traceId".to_owned(), + span.span_context().trace_id().to_string(), + ), + ])) + } +} + +struct EncodedHeaders { + provider: opentelemetry_sdk::trace::SdkTracerProvider, +} + +impl Feature for EncodedHeaders { + fn configure_client(&self, client: Client) -> Result { + let options = ClientOptions::new(client.options().namespace.clone()) + .data_converter(DataConverter::new( + PayloadConverter::default(), + DefaultFailureConverter::default(), + WrappingCodec, + )) + .plugin( + OpenTelemetryPlugin::builder() + .tracer(self.provider.tracer("encoded-headers-feature")) + .encode_client_headers(true) + .build(), + ) + .build(); + Ok(Client::new(client.connection().clone(), options)?) + } + + fn worker_options(&self, ctx: &FeatureContext) -> Result> { + Ok(Some( + WorkerOptions::new(ctx.task_queue.clone()) + .register_workflow::()? + .build(), + )) + } + + fn execute<'a>(&'a self, ctx: &'a FeatureContext) -> FeatureFuture<'a> { + Box::pin(async move { + let tracer = self.provider.tracer("encoded-headers-feature"); + let parent = Context::new().with_span(tracer.start("rust-caller")); + let trace_id = parent.span().span_context().trace_id().to_string(); + let result = async { + let mut options = ctx.start_options(); + options.execution_timeout = Some(Duration::from_secs(15)); + let handle = ctx + .client + .start_workflow(Workflow::run, "hello".to_owned(), options) + .await?; + let result = handle.get_result(WorkflowGetResultOptions::default()).await; + let events = handle + .fetch_history(Default::default()) + .into_events() + .await?; + for event in &events { + ensure!( + !matches!( + event.attributes, + Some(Attributes::WorkflowTaskFailedEventAttributes(_)) + ), + "Workflow Task failed: {event:?}" + ); + } + let Some(Attributes::WorkflowExecutionStartedEventAttributes(started)) = + events.first().and_then(|event| event.attributes.as_ref()) + else { + anyhow::bail!("Missing workflow start event"); + }; + let header = &started.header.as_ref().unwrap().fields["_tracer-data"]; + let decoded = WrappingCodec + .decode( + &SerializationContextData::Workflow( + temporalio_common::data_converters::WorkflowSerializationContext::new(), + ), + vec![header.clone()], + ) + .await?; + let carrier: HashMap = serde_json::from_slice(&decoded[0].data)?; + ensure!( + carrier["traceparent"].split('-').nth(1) == Some(trace_id.as_str()), + "History trace identity mismatch" + ); + ensure!( + result? + == HashMap::from([ + ("message".to_owned(), "hello".to_owned()), + ("traceId".to_owned(), trace_id), + ]), + "Workflow input/result or trace identity mismatch" + ); + Ok(FeatureOutcome::Passed) + } + .with_context(parent.clone()) + .await; + parent.span().end(); + result + }) + } +} + +pub fn feature() -> Box { + let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder() + .with_id_generator(temporalio_sdk::opentelemetry::WorkflowIdGenerator::default()) + .build(); + Box::new(EncodedHeaders { provider }) +} diff --git a/features/tracing/encoded_headers/feature.ts b/features/tracing/encoded_headers/feature.ts new file mode 100644 index 00000000..261c04fd --- /dev/null +++ b/features/tracing/encoded_headers/feature.ts @@ -0,0 +1,89 @@ +import * as assert from 'node:assert/strict'; +import { Resource } from '@opentelemetry/resources'; +import { InMemorySpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'; +import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'; +import { Feature } from '@temporalio/harness'; +import { defaultPayloadConverter, Payload, PayloadCodec } from '@temporalio/common'; +import { temporal } from '@temporalio/proto'; +import { OpenTelemetryPlugin } from '@temporalio/interceptors-opentelemetry'; +import { workflow } from './workflow'; + +const encoding = 'binary/encrypted'; +const payloadProto = temporal.api.common.v1.Payload; +const xor = (data: Uint8Array): Uint8Array => data.map((byte) => byte ^ 0x5a); + +class WrappingCodec implements PayloadCodec { + async encode(payloads: Payload[]): Promise { + return payloads.map((payload) => { + if (Buffer.from(payload.metadata?.encoding ?? []).toString() === encoding) { + throw new Error('Payload encoded twice'); + } + return { + metadata: { encoding: Buffer.from(encoding) }, + data: xor(payloadProto.encode(payload).finish()), + }; + }); + } + + async decode(payloads: Payload[]): Promise { + return payloads.map((payload) => { + if (Buffer.from(payload.metadata?.encoding ?? []).toString() !== encoding) { + throw new Error('Expected an encoded payload'); + } + return payloadProto.decode(xor(payload.data!)); + }); + } +} + +const resource = new Resource({ 'service.name': 'encoded-headers-feature' }); +const spanProcessor = new SimpleSpanProcessor(new InMemorySpanExporter()); +const provider = new NodeTracerProvider({ resource, spanProcessors: [spanProcessor] }); +provider.register(); +const tracer = provider.getTracer('encoded-headers-feature'); +const tracingOptions = { resource, spanProcessor, tracer, encodeClientHeaders: true }; +const tracingPlugin = new OpenTelemetryPlugin(tracingOptions); + +const workerOptions = { + codecHeaders: true, + plugins: [tracingPlugin], +}; + +export const feature = new Feature({ + workflow, + workflowsPath: require.resolve('./workflow'), + dataConverter: { payloadCodecs: [new WrappingCodec()] }, + clientOptions: { plugins: [tracingPlugin] }, + workerOptions, + execute: async (runner) => + tracer.startActiveSpan('ts-caller', async (parent) => { + try { + const handle = await runner.client.workflow.start(workflow, { + taskQueue: runner.options.taskQueue, + workflowId: `${runner.options.taskQueue}-workflow`, + workflowExecutionTimeout: '15s', + args: ['hello'], + }); + try { + const result = await handle.result(); + const events = (await handle.fetchHistory()).events!; + const header = events[0]!.workflowExecutionStartedEventAttributes!.header!.fields!['_tracer-data']!; + const [decoded] = await new WrappingCodec().decode([header]); + const carrier = defaultPayloadConverter.fromPayload<{ traceparent: string }>(decoded!); + assert.equal(carrier.traceparent.split('-')[1], parent.spanContext().traceId); + assert.deepEqual(result, { message: 'hello', traceId: parent.spanContext().traceId }); + assert.ok(events.every((event) => !event.workflowTaskFailedEventAttributes)); + return handle; + } catch (error) { + const events = (await handle.fetchHistory()).events!; + for (const event of events) { + if (event.workflowTaskFailedEventAttributes) { + console.error('Workflow Task failed:', event.workflowTaskFailedEventAttributes.failure); + } + } + throw error; + } + } finally { + parent.end(); + } + }), +}); diff --git a/features/tracing/encoded_headers/workflow.ts b/features/tracing/encoded_headers/workflow.ts new file mode 100644 index 00000000..116c81b7 --- /dev/null +++ b/features/tracing/encoded_headers/workflow.ts @@ -0,0 +1,7 @@ +import { context, trace } from '@opentelemetry/api'; + +export async function workflow(message: string): Promise<{ message: string; traceId: string }> { + const span = trace.getSpan(context.active()); + if (!span) throw new Error('No active workflow tracing span'); + return { message, traceId: span.spanContext().traceId }; +} diff --git a/harness/dotnet/Temporalio.Features.Harness/App.cs b/harness/dotnet/Temporalio.Features.Harness/App.cs index c897197a..277f4b10 100644 --- a/harness/dotnet/Temporalio.Features.Harness/App.cs +++ b/harness/dotnet/Temporalio.Features.Harness/App.cs @@ -39,6 +39,11 @@ public static class App name: "--tls-server-name", description: "TLS server name to use for verification"); + private static readonly Option roleOption = new( + name: "--role", + getDefaultValue: () => "all", + description: "Run all, client, or worker portions of a feature"); + private static readonly Argument< List<(string Dir, string TaskQueue, string? NexusEndpoint)>> featuresArgument = new( name: "features", @@ -72,6 +77,7 @@ private static Command CreateCommand() cmd.AddOption(caCertPathOption); cmd.AddOption(httpProxyUrlOption); cmd.AddOption(tlsServerNameOption); + cmd.AddOption(roleOption); cmd.AddArgument(featuresArgument); cmd.SetHandler(RunCommandAsync); return cmd; @@ -79,6 +85,11 @@ private static Command CreateCommand() private static async Task RunCommandAsync(InvocationContext ctx) { + var role = ctx.ParseResult.GetValueForOption(roleOption)!; + if (role is not ("all" or "client" or "worker")) + { + throw new ArgumentException("--role must be all, client, or worker"); + } // Create logger factory using var loggerFactory = LoggerFactory.Create(builder => builder.AddSimpleConsole( options => @@ -135,7 +146,7 @@ private static async Task RunCommandAsync(InvocationContext ctx) feature, loggerFactory, ctx.ParseResult.GetValueForOption(httpProxyUrlOption) - ).RunAsync(ctx.GetCancellationToken()); + ).RunAsync(ctx.GetCancellationToken(), role); } catch (TestSkippedException e) { diff --git a/harness/dotnet/Temporalio.Features.Harness/Runner.cs b/harness/dotnet/Temporalio.Features.Harness/Runner.cs index c27bd176..50249315 100644 --- a/harness/dotnet/Temporalio.Features.Harness/Runner.cs +++ b/harness/dotnet/Temporalio.Features.Harness/Runner.cs @@ -82,28 +82,40 @@ internal Runner( /// Run the feature with the given cancellation token. /// /// + /// Run both portions, only the client, or only the worker. /// - public async Task RunAsync(CancellationToken cancellationToken) + public async Task RunAsync(CancellationToken cancellationToken, string role = "all") { Logger.LogInformation("Executing feature {Feature}", PreparedFeature.Dir); runCancelToken = cancellationToken; client = await TemporalClient.ConnectAsync(ClientOptions); Feature.ConfigureWorker(this, WorkerOptions); - StartWorker(); - + if (role != "client") + { + StartWorker(); + } var featureFailed = false; try { + if (role == "worker") + { + Console.WriteLine("FEATURE_WORKER_READY"); + await Task.Delay(Timeout.Infinite, cancellationToken); + return; + } var run = await Feature.ExecuteAsync(this); if (run == null) { Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir); return; } - Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir); await Feature.CheckResultAsync(this, run); - await Feature.CheckHistoryAsync(this, run); + if (role == "all") + { + // A client-only run may target another SDK's workflow implementation. + await Feature.CheckHistoryAsync(this, run); + } } catch { diff --git a/harness/go/cmd/run.go b/harness/go/cmd/run.go index baef4e77..0d9a75b5 100644 --- a/harness/go/cmd/run.go +++ b/harness/go/cmd/run.go @@ -31,6 +31,9 @@ func runCmd() *cli.Command { Usage: "run a test or set of tests for Go", Flags: config.flags(), Action: func(ctx *cli.Context) error { + if config.Role != "" && config.Role != "client" && config.Role != "worker" { + return fmt.Errorf("role must be client or worker") + } var run Run if err := run.FromArgs(ctx.Args().Slice()); err != nil { return err @@ -101,6 +104,7 @@ func (r RunFeature) SummaryName() string { // RunFeatureConfig is config from config.json. type RunFeatureConfig struct { + CrossLanguage bool `json:"crossLanguage"` NoWorkflow bool `json:"noWorkflow"` NeedsNexusEndpoint bool `json:"needsNexusEndpoint"` Go RunFeatureConfigGo `json:"go"` @@ -130,6 +134,7 @@ type RunFeatureConfigGo struct { // RunConfig is configuration for NewRunner. type RunConfig struct { + Role string Server string Namespace string ClientCertPath string @@ -142,6 +147,9 @@ type RunConfig struct { func (r *RunConfig) flags() []cli.Flag { return []cli.Flag{ + &cli.StringFlag{ + Name: "role", Destination: &r.Role, + }, &cli.StringFlag{ Name: "server", Usage: "The host:port of the server (default is to create ephemeral in-memory server)", @@ -227,11 +235,15 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { if len(run.Features) == 0 { return fmt.Errorf("no features to run") } - summary, err := openSummary(r.config.SummaryURI) - if err != nil { - return err + var summary io.WriteCloser + if r.config.Role == "" { + var err error + summary, err = openSummary(r.config.SummaryURI) + if err != nil { + return err + } + defer summary.Close() } - defer summary.Close() var failureCount int failureSummary := "" allFeatures := harness.RegisteredFeatures() @@ -257,8 +269,10 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { Outcome: FeaturePassed, } defer func() { - bytes, _ := json.Marshal(sumEntry) - fmt.Fprintln(summary, string(bytes)) + if summary != nil { + bytes, _ := json.Marshal(sumEntry) + fmt.Fprintln(summary, string(bytes)) + } }() if feature.SkipReason != "" { @@ -273,6 +287,7 @@ func (r *Runner) Run(ctx context.Context, run *Run) error { } runnerConfig := harness.RunnerConfig{ + Role: r.config.Role, ServerHostPort: r.config.Server, Namespace: r.config.Namespace, ClientCertPath: r.config.ClientCertPath, diff --git a/harness/go/crosslanguage/driver.go b/harness/go/crosslanguage/driver.go new file mode 100644 index 00000000..890a7378 --- /dev/null +++ b/harness/go/crosslanguage/driver.go @@ -0,0 +1,116 @@ +// Package crosslanguage lets feature drivers invoke prepared language harnesses. +package crosslanguage + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "os" + "os/exec" +) + +const ManifestEnv = "FEATURE_CROSS_LANGUAGE" +const WorkerReady = "FEATURE_WORKER_READY" + +type Program struct { + Dir string + Args []string +} + +type Manifest struct { + Feature string + TaskQueue string + Programs map[string]Program +} + +func FromEnv() (*Manifest, error) { + var manifest Manifest + if err := json.Unmarshal([]byte(os.Getenv(ManifestEnv)), &manifest); err != nil { + return nil, fmt.Errorf("read runner manifest: %w", err) + } + return &manifest, nil +} + +func (m *Manifest) command(ctx context.Context, lang, role, queue string) (*exec.Cmd, error) { + program, ok := m.Programs[lang] + if !ok || len(program.Args) == 0 { + return nil, fmt.Errorf("feature has no prepared %s participant", lang) + } + args := append(append([]string{}, program.Args[1:]...), "--role", role, m.Feature+":"+queue) + cmd := exec.CommandContext(ctx, program.Args[0], args...) + cmd.Dir = program.Dir + cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr + return cmd, nil +} + +func (m *Manifest) RunClient(ctx context.Context, lang, queue string) error { + cmd, err := m.command(ctx, lang, "client", queue) + if err != nil { + return err + } + if err := cmd.Run(); err != nil { + return fmt.Errorf("%s client: %w", lang, err) + } + return nil +} + +// StartWorker waits for harness readiness. The returned function stops and reaps +// the process; drivers should defer it before executing any client scenarios. +func (m *Manifest) StartWorker(ctx context.Context, lang, queue string) (func(), error) { + ctx, cancel := context.WithCancel(ctx) + cmd, err := m.command(ctx, lang, "worker", queue) + if err != nil { + cancel() + return nil, err + } + cmd.Stdout = nil + stdout, err := cmd.StdoutPipe() + if err != nil { + cancel() + return nil, err + } + if err := cmd.Start(); err != nil { + cancel() + return nil, err + } + ready, done := make(chan struct{}), make(chan struct{}) + var runErr error + go func() { + scanner := bufio.NewScanner(stdout) + scanner.Buffer(make([]byte, 4096), 1024*1024) + announced := false + for scanner.Scan() { + line := scanner.Text() + if line == WorkerReady && !announced { + close(ready) + announced = true + } else { + fmt.Println(line) + } + } + if scanner.Err() != nil { + // A stopped reader can leave the worker blocked writing to its full pipe. + cancel() + } + runErr = cmd.Wait() + if scanner.Err() != nil { + runErr = fmt.Errorf("read worker output: %w", scanner.Err()) + } + close(done) + }() + stop := func() { + cancel() + <-done + } + select { + case <-ready: + return stop, nil + case <-done: + stop() + return nil, fmt.Errorf("%s worker exited before readiness: %v", lang, runErr) + case <-ctx.Done(): + stop() + return nil, ctx.Err() + } +} diff --git a/harness/go/crosslanguage/driver_test.go b/harness/go/crosslanguage/driver_test.go new file mode 100644 index 00000000..8330ded2 --- /dev/null +++ b/harness/go/crosslanguage/driver_test.go @@ -0,0 +1,88 @@ +package crosslanguage + +import ( + "context" + "fmt" + "os" + "os/signal" + "strings" + "testing" + "time" +) + +func helperManifest(t *testing.T, behavior string) Manifest { + t.Helper() + t.Setenv("CROSS_LANGUAGE_TEST_PROCESS", behavior) + return Manifest{ + Feature: "tracing/headers", + Programs: map[string]Program{ + "test": {Args: []string{os.Args[0], "-test.run=^TestHarnessProcess$", "--"}}, + }, + } +} + +func TestWorkerReadinessAndCleanup(t *testing.T) { + manifest := helperManifest(t, "ready") + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + defer cancel() + stop, err := manifest.StartWorker(ctx, "test", "queue") + if err != nil { + t.Fatal(err) + } + stop() +} + +func TestWorkerExitsBeforeReadiness(t *testing.T) { + manifest := helperManifest(t, "exit") + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + defer cancel() + if _, err := manifest.StartWorker(ctx, "test", "queue"); err == nil || + !strings.Contains(err.Error(), "before readiness") { + t.Fatalf("expected readiness failure, got %v", err) + } +} + +func TestWorkerCanceledBeforeReadiness(t *testing.T) { + manifest := helperManifest(t, "wait") + ctx, cancel := context.WithCancel(t.Context()) + cancel() + if _, err := manifest.StartWorker(ctx, "test", "queue"); err == nil { + t.Fatal("canceled worker unexpectedly started") + } +} + +func TestClientRoleAndFailure(t *testing.T) { + for _, behavior := range []string{"client", "exit"} { + manifest := helperManifest(t, behavior) + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + err := manifest.RunClient(ctx, "test", "queue") + cancel() + if (err != nil) != (behavior == "exit") { + t.Fatalf("behavior=%s: unexpected result %v", behavior, err) + } + } +} + +func TestHarnessProcess(t *testing.T) { + behavior := os.Getenv("CROSS_LANGUAGE_TEST_PROCESS") + if behavior == "" { + return + } + switch behavior { + case "client": + args := strings.Join(os.Args, " ") + if !strings.Contains(args, "--role client tracing/headers:queue") { + os.Exit(2) + } + case "ready", "wait": + ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) + defer cancel() + if behavior == "ready" { + fmt.Println(WorkerReady) + fmt.Println(WorkerReady) + } + <-ctx.Done() + case "exit": + os.Exit(3) + } +} diff --git a/harness/go/harness/runner.go b/harness/go/harness/runner.go index 83eb4f68..19282f5d 100644 --- a/harness/go/harness/runner.go +++ b/harness/go/harness/runner.go @@ -49,6 +49,7 @@ type Runner struct { // RunnerConfig is configuration for NewRunner. type RunnerConfig struct { + Role string ServerHostPort string Namespace string TaskQueue string @@ -110,9 +111,10 @@ func NewRunner(config RunnerConfig, feature *PreparedFeature) (*Runner, error) { if !r.Feature.DisableWorkflowPanicPolicyOverride { r.Feature.WorkerOptions.WorkflowPanicPolicy = worker.FailWorkflow } - err = r.StartWorker() - if err != nil { - return nil, err + if config.Role != "client" { + if err = r.StartWorker(); err != nil { + return nil, err + } } success = true @@ -123,6 +125,12 @@ func NewRunner(config RunnerConfig, feature *PreparedFeature) (*Runner, error) { func (r *Runner) Run(ctx context.Context) error { defer r.Close() + if r.Role == "worker" { + fmt.Println("FEATURE_WORKER_READY") + <-ctx.Done() + return ctx.Err() + } + // Do normal run r.Log.Debug("Executing feature", "Feature", r.Feature.Dir) var run client.WorkflowRun diff --git a/harness/java/io/temporal/sdkfeatures/Main.java b/harness/java/io/temporal/sdkfeatures/Main.java index f7ff70e3..4f5dba9e 100644 --- a/harness/java/io/temporal/sdkfeatures/Main.java +++ b/harness/java/io/temporal/sdkfeatures/Main.java @@ -75,9 +75,12 @@ BufferedWriter createSummaryServerWriter() { private static final Logger log = LoggerFactory.getLogger(Main.class); - @Option(names = "--summary-uri", description = "The URL of the summary server", required = true) + @Option(names = "--summary-uri", description = "The URL of the summary server") private String summaryUri; + @Option(names = "--role", description = "Cross-language harness role") + private String role; + @Option(names = "--server", description = "The host:port of the server", required = true) private String server; @@ -104,6 +107,12 @@ BufferedWriter createSummaryServerWriter() { @Override public void run() { + if (role != null && !role.equals("client") && !role.equals("worker")) { + throw new IllegalArgumentException("role must be client or worker"); + } + if (role == null && summaryUri == null) { + throw new IllegalArgumentException("Missing --summary-uri"); + } // Load TLS certs if specified SslContext sslContext = null; if (StringUtils.isNotEmpty(clientCertPath)) { @@ -146,7 +155,8 @@ public void run() { throw new RuntimeException("Client cert path must be specified since key path is"); } - try (BufferedWriter writer = createSummaryServerWriter()) { + try (BufferedWriter writer = + role == null ? createSummaryServerWriter() : new BufferedWriter(Writer.nullWriter())) { ObjectMapper mapper = new ObjectMapper(); // Run each @@ -157,7 +167,7 @@ public void run() { var pieces = featureWithTaskQueue.split(":", 3); // Find feature var feature = - Arrays.stream(PreparedFeature.ALL) + Arrays.stream(role == null ? PreparedFeature.ALL : crossLanguageFeature(pieces[0])) .filter(p -> p.dir.equals(pieces[0])) .findAny() .orElseThrow( @@ -175,6 +185,7 @@ public void run() { config.sslContext = sslContext; config.tlsServerName = tlsServerName; config.taskQueue = pieces[1]; + config.role = role; if (pieces.length == 3) { config.nexusEndpoint = pieces[2]; } @@ -213,4 +224,14 @@ public void run() { public static void main(String... args) { System.exit(new CommandLine(new Main()).execute(args)); } + + @SuppressWarnings("unchecked") + private PreparedFeature[] crossLanguageFeature(String dir) { + try { + return PreparedFeature.prepareFeatures( + (Class) Class.forName(dir.replace('/', '.') + ".feature$Impl")); + } catch (ClassNotFoundException e) { + throw new IllegalArgumentException("No Java participant for " + dir, e); + } + } } diff --git a/harness/java/io/temporal/sdkfeatures/Runner.java b/harness/java/io/temporal/sdkfeatures/Runner.java index fee9056a..e3952892 100644 --- a/harness/java/io/temporal/sdkfeatures/Runner.java +++ b/harness/java/io/temporal/sdkfeatures/Runner.java @@ -38,6 +38,7 @@ public class Runner implements Closeable { private static final Logger log = LoggerFactory.getLogger(Main.class); public static class Config { + public String role; public String serverHostPort; public String namespace; public String taskQueue; @@ -91,7 +92,9 @@ public static class Config { client = WorkflowClient.newInstance(service, clientBuild.build()); // Build worker - restartWorker(); + if (!"client".equals(config.role)) { + restartWorker(); + } } catch (Throwable e) { service.shutdownNow(); throw e; @@ -132,6 +135,11 @@ public void restartWorker() { } void run() throws Exception { + if ("worker".equals(config.role)) { + System.out.println("FEATURE_WORKER_READY"); + new java.util.concurrent.CountDownLatch(1).await(); + return; + } log.info("Executing feature {}", featureInfo.dir); var run = feature.execute(this); if (run == null) { @@ -322,7 +330,9 @@ public Map loadPastHistories() throws Excep public void close() { try { - workerFactory.shutdownNow(); + if (workerFactory != null) { + workerFactory.shutdownNow(); + } } catch (Throwable e) { try { service.shutdownNow(); diff --git a/harness/python/feature.py b/harness/python/feature.py index 25826250..0ed58ec5 100644 --- a/harness/python/feature.py +++ b/harness/python/feature.py @@ -130,6 +130,7 @@ def __init__( feature: Feature, tls_config: Optional[TLSConfig], http_proxy_url: Optional[str], + role: Optional[str] = None, ) -> None: self.address = address self.namespace = namespace @@ -143,6 +144,7 @@ def __init__( self.tls_config = tls_config self.http_proxy_url = http_proxy_url self.client: Client + self.role = role async def run(self) -> None: logger.info("Executing feature %s", self.feature.rel_dir) @@ -157,8 +159,13 @@ async def run(self) -> None: ) # Run worker - self.start_worker() + if self.role != "client": + self.start_worker() try: + if self.role == "worker": + print("FEATURE_WORKER_READY", flush=True) + await self._worker_task + return # Start and get handle handle: WorkflowHandle if self.feature.start: diff --git a/harness/python/main.py b/harness/python/main.py index d27122de..ccd4d744 100644 --- a/harness/python/main.py +++ b/harness/python/main.py @@ -25,6 +25,7 @@ async def run(): "--ca-cert-path", help="Path to a CA certificate for server verification" ) parser.add_argument("--log-level", help="Log level", default="WARNING") + parser.add_argument("--role", choices=["client", "worker"]) parser.add_argument("--http-proxy-url", help="HTTP proxy URL") parser.add_argument( "--tls-server-name", help="TLS server name to use for verification (optional)" @@ -94,6 +95,7 @@ async def run(): feature=features[rel_dir], tls_config=tls_config, http_proxy_url=args.http_proxy_url if args.http_proxy_url else None, + role=args.role, ).run() except Exception: logger.exception("Feature %s failed", rel_dir) diff --git a/harness/ruby/lib/harness.rb b/harness/ruby/lib/harness.rb index cdc9ead3..6a90f52a 100644 --- a/harness/ruby/lib/harness.rb +++ b/harness/ruby/lib/harness.rb @@ -7,7 +7,9 @@ module Harness :expect_run_result, :expect_activity_error, :start_callback, - :check_result_callback + :check_result_callback, + :client_options, + :worker_options ) @features = {} @@ -22,7 +24,9 @@ def self.register_feature( expect_run_result: nil, expect_activity_error: nil, start: nil, - check_result: nil + check_result: nil, + client_options: {}, + worker_options: {} ) rel_dir = caller_feature_dir(caller_locations(1, 1).first.path) @features[rel_dir] = Feature.new( @@ -31,7 +35,9 @@ def self.register_feature( expect_run_result: expect_run_result, expect_activity_error: expect_activity_error, start_callback: start, - check_result_callback: check_result + check_result_callback: check_result, + client_options: client_options, + worker_options: worker_options ) end diff --git a/harness/ruby/runner.rb b/harness/ruby/runner.rb index b824a7da..f086ed88 100644 --- a/harness/ruby/runner.rb +++ b/harness/ruby/runner.rb @@ -67,6 +67,7 @@ def parse_args(argv) opts.on('--tls-server-name NAME', 'TLS server name override') { |v| @tls_server_name = v } opts.on('--http-proxy-url URL', 'HTTP proxy URL') { |v| @http_proxy_url = v } opts.on('--summary-uri URI', 'Where to stream the test summary JSONL') { |v| @summary_uri = v } + opts.on('--role ROLE', %w[client worker], 'Cross-language harness role') { |v| @role = v } end @features_arg = parser.parse(argv) @@ -97,8 +98,8 @@ def write_summary_entry(summary_io, entry) summary_io.flush end - def connect_client - connect_options = {} + def connect_client(feature) + connect_options = feature.client_options.dup if @client_cert_path raise ArgumentError, 'Client cert specified, but not client key!' unless @client_key_path @@ -131,7 +132,7 @@ def run_feature(rel_dir, task_queue) feature = Harness.features[rel_dir] raise "Feature #{rel_dir} not registered after loading" unless feature - client = connect_client + client = connect_client(feature) execute_feature(client, feature, rel_dir, task_queue) end @@ -143,16 +144,28 @@ def load_feature_file(rel_dir) end def execute_feature(client, feature, rel_dir, task_queue) + if @role == 'client' + handle = start_workflow(client, feature, rel_dir, task_queue) + check_result(client, handle, feature) + return + end worker = Temporalio::Worker.new( client: client, task_queue: task_queue, activities: feature.activities, - workflows: feature.workflows + workflows: feature.workflows, + **feature.worker_options ) worker.run do - handle = start_workflow(client, feature, rel_dir, task_queue) - check_result(client, handle, feature) + if @role == 'worker' + puts 'FEATURE_WORKER_READY' + $stdout.flush + Queue.new.pop + else + handle = start_workflow(client, feature, rel_dir, task_queue) + check_result(client, handle, feature) + end end end diff --git a/harness/rust/Cargo.lock b/harness/rust/Cargo.lock index 40052ea6..bc53b098 100644 --- a/harness/rust/Cargo.lock +++ b/harness/rust/Cargo.lock @@ -102,6 +102,12 @@ dependencies = [ "syn 3.0.9", ] +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + [[package]] name = "bytes" version = "1.12.1" @@ -132,7 +138,7 @@ checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" dependencies = [ "cfg-if", "cpufeatures", - "rand_core", + "rand_core 0.10.1", ] [[package]] @@ -300,9 +306,9 @@ dependencies = [ [[package]] name = "dirs" -version = "6.0.0" +version = "7.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +checksum = "8d57d423b3c82e89b9a24ca3091fee61f456a26edbd28d26c65906f4bc1dcd8f" dependencies = [ "dirs-sys", ] @@ -592,6 +598,18 @@ dependencies = [ "wasi", ] +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + [[package]] name = "getrandom" version = "0.4.3" @@ -600,8 +618,8 @@ checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" dependencies = [ "cfg-if", "libc", - "r-efi", - "rand_core", + "r-efi 6.0.0", + "rand_core 0.10.1", ] [[package]] @@ -900,6 +918,17 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "js-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dc09d2154098bbf4ef54eab6b117a3c24cbbffe94046b16ee6d6d4510584d3a" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + [[package]] name = "lazy_static" version = "1.5.1" @@ -956,9 +985,9 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" [[package]] name = "lru" -version = "0.18.5" +version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" +checksum = "4a9f71e3591c7ec44d3e563e87bf14ddc2bada8519dca046e5b0e560cd004e2d" dependencies = [ "hashbrown 0.17.1", ] @@ -1089,6 +1118,36 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" +[[package]] +name = "opentelemetry" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0142c63252a9e054e68a4c61a5778f7b14f576274d593f8ce883d191a099682" +dependencies = [ + "futures-core", + "futures-sink", + "js-sys", + "pin-project-lite", + "thiserror", + "tracing", +] + +[[package]] +name = "opentelemetry_sdk" +version = "0.32.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b59f80e1ac4d5ff7a2db8fb6c80badb7f0f3f858211fba08dd9aaec750894f9" +dependencies = [ + "futures-channel", + "futures-executor", + "futures-util", + "opentelemetry", + "percent-encoding", + "portable-atomic", + "rand 0.9.5", + "thiserror", +] + [[package]] name = "option-ext" version = "0.2.0" @@ -1216,6 +1275,15 @@ dependencies = [ "zerovec", ] +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + [[package]] name = "predicates" version = "3.1.4" @@ -1413,12 +1481,28 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "r-efi" version = "6.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" +[[package]] +name = "rand" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" +dependencies = [ + "rand_chacha", + "rand_core 0.9.5", +] + [[package]] name = "rand" version = "0.10.3" @@ -1427,7 +1511,26 @@ checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" dependencies = [ "chacha20", "getrandom 0.4.3", - "rand_core", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", ] [[package]] @@ -1442,7 +1545,7 @@ version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a" dependencies = [ - "rand_core", + "rand_core 0.10.1", ] [[package]] @@ -1615,7 +1718,10 @@ dependencies = [ "anyhow", "clap", "futures", + "opentelemetry", + "opentelemetry_sdk", "percent-encoding", + "prost", "serde", "serde_json", "temporalio-client", @@ -1864,9 +1970,9 @@ dependencies = [ [[package]] name = "temporalio-client" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adee203bb632dd144574252f2519f6efee35c92b2a1dc99fc2a5345e5416a38d" +checksum = "f1d529c517ee4e71a4e1d9f773b392292639eefd0593c48377d124a8939a6309" dependencies = [ "anyhow", "async-trait", @@ -1883,7 +1989,7 @@ dependencies = [ "hyper", "hyper-util", "parking_lot", - "rand", + "rand 0.10.3", "serde_json", "temporalio-common", "thiserror", @@ -1898,9 +2004,9 @@ dependencies = [ [[package]] name = "temporalio-common" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdd8fe7008ab4539ad7e0649a55a34f237f60df7c30a03a69d75074262f1bb0" +checksum = "59744ea925fedf708b26baff7b059fc43f76d902d09fbbdbbd7668700e4fdfcd" dependencies = [ "anyhow", "async-trait", @@ -1936,9 +2042,9 @@ dependencies = [ [[package]] name = "temporalio-common-wasm" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "846575798b9f35125766dd40e632779de4407e6492011bacaba828337c0f3093" +checksum = "e067590d09c549cf22cd28f90cc64530743caf85a4f31bb7728b90011174bd77" dependencies = [ "anyhow", "async-trait", @@ -1963,20 +2069,20 @@ dependencies = [ [[package]] name = "temporalio-macros" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3f48f3a6ad84e1fc91323bb9aabff10a6ea6aca737eef9726f07e68f580f8c8" +checksum = "652321f14dfcc7b408166cba43c37bb61e0f239e550e6e296d004d38d33e2b14" dependencies = [ "proc-macro2", "quote", - "syn 2.0.119", + "syn 3.0.9", ] [[package]] name = "temporalio-protos" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdb4880e7150c234f60319c3b0994468f0b10f8a24c5620e4befc9d329f2ef67" +checksum = "b92fa39136fb7ea5b87d8981e3429779432b98994d1fcca36ad58925708706f9" dependencies = [ "anyhow", "base64 0.23.1", @@ -1996,9 +2102,9 @@ dependencies = [ [[package]] name = "temporalio-sdk" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59d223b6382f6f90b56d811266dd8f0ce56fa06fabf793056d2eb605fadbb266" +checksum = "7ded17a02f1a53b49b00cd9aeb5876188cb5ec7bf18f51051700946107b63039" dependencies = [ "anyhow", "async-trait", @@ -2006,6 +2112,8 @@ dependencies = [ "derive_more", "futures-util", "gethostname", + "opentelemetry", + "opentelemetry_sdk", "parking_lot", "prost", "prost-wkt-types", @@ -2025,9 +2133,9 @@ dependencies = [ [[package]] name = "temporalio-sdk-core" -version = "0.10.0" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53644dd3810c1cc5be51501c9284a03dbb6359cf68566222ae48e35a2fc7d04d" +checksum = "d808be0baca3e6d889ef8a728448840e51106f9a260276f93ffffe99b957d15d" dependencies = [ "anyhow", "async-trait", @@ -2049,7 +2157,7 @@ dependencies = [ "pin-project", "prost", "prost-wkt-types", - "rand", + "rand 0.10.3", "serde", "serde_json", "siphasher", @@ -2070,9 +2178,9 @@ dependencies = [ [[package]] name = "temporalio-workflow" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36202ab42aac8760c693f3aeb90da88f4edfa0d963b33b062d6a035dc2baa90a" +checksum = "3e8686c6e4dd3cd1e1c4c83196fffcb4a45600a88828bb4917ae57cb127fa336" dependencies = [ "anyhow", "bon", @@ -2081,7 +2189,7 @@ dependencies = [ "futures-util", "prost", "prost-wkt-types", - "rand", + "rand 0.10.3", "rand_pcg", "serde", "siphasher", @@ -2089,7 +2197,7 @@ dependencies = [ "temporalio-macros", "thiserror", "uuid", - "wit-bindgen", + "wit-bindgen 0.62.0", ] [[package]] @@ -2536,11 +2644,64 @@ version = "0.11.1+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" +[[package]] +name = "wasip2" +version = "1.0.4+wasi-0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487" +dependencies = [ + "wit-bindgen 0.57.1", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c" +dependencies = [ + "cfg-if", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e931a02a39abdbf66966fc35902b5ed58344750a70885bed4ebb3d8eaf28ed9" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ca4b54280e455bd831e33a6b8e734baf432fe63fbc35c42ac14ce67a043a53a" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.9", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b1f9c3798725016c6ee5f2f57869ec0831e8bbc0ab0310a86e787e97f41389e" +dependencies = [ + "unicode-ident", +] + [[package]] name = "wasm-encoder" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f64765e43c000fae008a48db8b288e175e237fc9ce20a26586836878c1bee89f" +checksum = "b1d0246511d901aacf25d2dc9111f0054947de5e093fe662099e709ff7530dc3" dependencies = [ "leb128fmt", "wasmparser", @@ -2548,9 +2709,9 @@ dependencies = [ [[package]] name = "wasm-metadata" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47e10808eb27efde692f1b1706089fe19296728bf872291f5b4e0d50fba88f2f" +checksum = "4e7bf119eb01f4a246864c10bd87c8f26c566350abb25aa4d5273c415bbab338" dependencies = [ "anyhow", "indexmap", @@ -2560,9 +2721,9 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe9269dd817e0e7021bf534ccd9761bc2d64778b6708e41228b8439d75eaa0b1" +checksum = "0f7c12eac7bb587801590f6a67ff0bc84d0748513864b71108e4b311cc3df694" dependencies = [ "bitflags", "hashbrown 0.17.1", @@ -2792,9 +2953,15 @@ checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81" [[package]] name = "wit-bindgen" -version = "0.61.1" +version = "0.57.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e473fd0095479f9689ac7d2a52c427cc96bb2b973ace50238dfcc1ab1cd52d93" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "wit-bindgen" +version = "0.62.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53cb4b5556c3a791e86838ea287782bdafa704d55b0e68b5b81a3a16b9ea5f4b" dependencies = [ "bitflags", "wit-bindgen-rust-macro", @@ -2802,9 +2969,9 @@ dependencies = [ [[package]] name = "wit-bindgen-core" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87445680dfe6d6b5369e884bd63c03a3335268e855365b2fc3f7bcdce96a630e" +checksum = "72ad22a37ecbc0e1fdca34d2b670ba41368cb0920735643e00fdf39a16ee5431" dependencies = [ "anyhow", "heck", @@ -2813,15 +2980,15 @@ dependencies = [ [[package]] name = "wit-bindgen-rust" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72f2fe494de0d898216caf0fd0ae76af75753fcb3ff4f465b46131537cf24cf8" +checksum = "84ba5213d4332c260a0d4e69e34b0f7e4b85ddae10b6ebfbac00d9c185ba628a" dependencies = [ "anyhow", "heck", "indexmap", - "prettyplease 0.2.37", - "syn 2.0.119", + "prettyplease 0.3.0", + "syn 3.0.9", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -2829,24 +2996,24 @@ dependencies = [ [[package]] name = "wit-bindgen-rust-macro" -version = "0.61.1" +version = "0.62.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59283a01aec94f60f92ada22ffe182a5cea8acfce43be3be688de8d52df55312" +checksum = "8f19d63da8e478a370ef8192d90ccb517965b7747d6b46cd2d831dd0ef4d2541" dependencies = [ "anyhow", - "prettyplease 0.2.37", + "prettyplease 0.3.0", "proc-macro2", "quote", - "syn 2.0.119", + "syn 3.0.9", "wit-bindgen-core", "wit-bindgen-rust", ] [[package]] name = "wit-component" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0fca88950af0c1f42bc77e17315e48798b8d68340171b6d204f62bc19a878a6" +checksum = "092f783dee3253265fcde131475055f8c275ac0176a9c0396db1dc7b5544bfb4" dependencies = [ "anyhow", "bitflags", @@ -2863,9 +3030,9 @@ dependencies = [ [[package]] name = "wit-parser" -version = "0.258.3" +version = "0.259.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72a2127663dcf3ee16614fb0e3c33d5c6c66fec9dad317a8b0fdd3869487a533" +checksum = "6390f4f02493ce678d509c859cf1698e38929fb75c8012a6ee2f7d6b6cb66cd7" dependencies = [ "anyhow", "hashbrown 0.17.1", @@ -2909,6 +3076,26 @@ dependencies = [ "synstructure", ] +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "zerofrom" version = "0.1.8" diff --git a/harness/rust/Cargo.toml b/harness/rust/Cargo.toml index 789df51c..dac0cc7e 100644 --- a/harness/rust/Cargo.toml +++ b/harness/rust/Cargo.toml @@ -6,6 +6,12 @@ publish = false [workspace] +[features] +cross-language = ["temporalio-sdk/experimental", "temporalio-sdk/opentelemetry", "dep:opentelemetry", "dep:opentelemetry_sdk", "dep:prost"] + +[build-dependencies] +serde_json = "1" + [[bin]] name = "program" path = "src/main.rs" @@ -14,11 +20,11 @@ path = "src/main.rs" protoc-version = "36.1" [dependencies] -temporalio-sdk = "=1.1.0" -temporalio-client = "=1.1.0" -temporalio-workflow = "=1.1.0" -temporalio-macros = "=1.1.0" -temporalio-common = "=1.1.0" +temporalio-sdk = "=1.2.0" +temporalio-client = "=1.2.0" +temporalio-workflow = "=1.2.0" +temporalio-macros = "=1.2.0" +temporalio-common = "=1.2.0" anyhow = "1" clap = { version = "4", default-features = false, features = ["derive", "std", "error-context"] } futures = "0.3" @@ -29,3 +35,6 @@ tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "net", tokio-util = { version = "0.7", features = ["rt"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] } url = "2" +opentelemetry = { version = "0.32", optional = true } +opentelemetry_sdk = { version = "0.32", optional = true } +prost = { version = "0.14", optional = true } diff --git a/harness/rust/build.rs b/harness/rust/build.rs index 16e3f57d..1adad2a1 100644 --- a/harness/rust/build.rs +++ b/harness/rust/build.rs @@ -33,6 +33,14 @@ fn main() { let mut registry = String::new(); let mut entries = String::new(); for (index, source) in sources.into_iter().enumerate() { + let config = source.parent().unwrap().join("config.json"); + let cross_language = fs::read_to_string(config) + .ok() + .and_then(|text| serde_json::from_str::(&text).ok()) + .is_some_and(|config| config["crossLanguage"] == true); + if cross_language != env::var_os("CARGO_FEATURE_CROSS_LANGUAGE").is_some() { + continue; + } let key = source .parent() .unwrap() diff --git a/harness/rust/src/harness.rs b/harness/rust/src/harness.rs index 5369d95b..85471388 100644 --- a/harness/rust/src/harness.rs +++ b/harness/rust/src/harness.rs @@ -204,14 +204,23 @@ async fn run_feature( cancelled: &CancellationToken, ) -> Result { let worker_options = feature.worker_options(ctx)?; + let has_worker = worker_options.is_some(); let driver = async { + if options.role.as_deref() == Some("worker") { + ensure!(has_worker, "feature has no worker"); + println!("FEATURE_WORKER_READY"); + cancelled.cancelled().await; + return Ok(FeatureOutcome::Passed); + } tokio::select! { result = tokio::time::timeout(FEATURE_TIMEOUT, catch(feature.execute(ctx))) => result.context("feature execution timed out")?, _ = cancelled.cancelled() => bail!("execution cancelled"), } }; - let outcome = if let Some(mut worker_options) = worker_options { + let outcome = if let Some(mut worker_options) = + worker_options.filter(|_| options.role.as_deref() != Some("client")) + { // Give outstanding activities a finite grace period before SDK cancellation. if worker_options.graceful_shutdown_period.is_none() { worker_options.graceful_shutdown_period = Some(Duration::from_secs(5)); @@ -222,7 +231,10 @@ async fn run_feature( } else { driver.await? }; - if matches!(outcome, FeatureOutcome::Skipped(_)) || options.no_history_check { + if matches!(outcome, FeatureOutcome::Skipped(_)) + || options.no_history_check + || options.role.is_some() + { return Ok(outcome); } if let Some(replay_options) = feature.replay_options(ctx)? { diff --git a/harness/rust/src/options.rs b/harness/rust/src/options.rs index 1e904d3d..304eb18e 100644 --- a/harness/rust/src/options.rs +++ b/harness/rust/src/options.rs @@ -35,6 +35,8 @@ impl FromStr for Selection { #[derive(Parser)] #[command(disable_help_flag = true)] pub(crate) struct Options { + #[arg(long, value_parser = ["worker", "client"])] + pub role: Option, #[arg(long, value_parser = clap::builder::NonEmptyStringValueParser::new())] server: String, #[arg(long, value_parser = clap::builder::NonEmptyStringValueParser::new())] diff --git a/harness/ts/harness.ts b/harness/ts/harness.ts index 9c83ebf0..816e7e23 100644 --- a/harness/ts/harness.ts +++ b/harness/ts/harness.ts @@ -10,6 +10,7 @@ import { WorkflowStartOptions, TLSConfig, ConnectionOptions, + ClientOptions, } from '@temporalio/client'; import * as proto from '@temporalio/proto'; import { DataConverter, UntypedActivities, Workflow, WorkflowResultType } from '@temporalio/common'; @@ -27,6 +28,9 @@ export { getConnection, getClient, Context } from './activity-interceptors'; export type { ReplaceNested }; export interface FeatureOptions { + /** Additional client configuration, including client-side tracing plugins. */ + clientOptions?: Partial; + /** * Workflow to execute. This defaults to `import(workflowsPath).workflow` if * unset. @@ -119,6 +123,7 @@ export class FeatureSource { } export interface RunnerOptions { + role?: 'all' | 'client' | 'worker'; address: string; namespace: string; proxyUrl?: string; @@ -141,6 +146,7 @@ export class Runner { connection, namespace: options.namespace, dataConverter: feature.options.dataConverter, + ...feature.options.clientOptions, }); // Create a connection for the Worker @@ -179,9 +185,9 @@ export class Runner { }, ...feature.options.workerOptions, }; - const worker = await Worker.create(workerOpts); + const worker = options.role === 'client' ? undefined : await Worker.create(workerOpts); const workerRunPromise = (async () => { - await worker.run(); + if (worker) await worker.run(); })(); return new Runner( source, @@ -205,12 +211,19 @@ export class Runner { readonly connectionOpts: ConnectionOptions, readonly nativeConnection: NativeConnection, readonly nativeConnectionOpts: NativeConnectionOptions, - private _worker: Worker, + private _worker: Worker | undefined, readonly workerOpts: WorkerOptions, private _workerRunPromise: Promise, ) {} async run(): Promise { + if (this.options.role === 'worker') { + console.log('FEATURE_WORKER_READY'); + return await this._workerRunPromise; + } + if (this.options.role === 'client') { + return await this.runWorkflow(); + } if (this.feature.options.alternateRun) { return await this.feature.options.alternateRun(this); } else { @@ -253,6 +266,7 @@ export class Runner { } get worker(): Worker { + if (!this._worker) throw new IllegalStateError('Worker not started in client-only mode'); return this._worker; } @@ -263,7 +277,7 @@ export class Runner { async restartWorker(): Promise { this._worker = await Worker.create(this.workerOpts); this._workerRunPromise = (async () => { - await this._worker.run(); + await this.worker.run(); })(); } @@ -289,7 +303,7 @@ export class Runner { async close(): Promise { try { - this._worker.shutdown(); + this._worker?.shutdown(); } catch (err) { if (!(err instanceof IllegalStateError && err.message.includes('Not running'))) { throw err; diff --git a/harness/ts/main.ts b/harness/ts/main.ts index 15685046..72ace8f6 100644 --- a/harness/ts/main.ts +++ b/harness/ts/main.ts @@ -16,6 +16,7 @@ async function run() { .option('--ca-cert-path ', 'Path to a CA certificate for server verification') .option('--http-proxy-url ', 'HTTP proxy URL') .option('--tls-server-name ', 'TLS server name to use for verification') + .option('--role ', 'Run all, client, or worker portions of a feature', 'all') .argument('', 'Features as dir + ":" + task queue'); const opts = program.parse(process.argv).opts<{ @@ -26,9 +27,13 @@ async function run() { caCertPath: string; httpProxyUrl: string; tlsServerName: string; + role: 'all' | 'client' | 'worker'; featureAndTaskQueues: string[]; }>(); opts.featureAndTaskQueues = program.args; + if (!['all', 'client', 'worker'].includes(opts.role)) { + throw new Error('--role must be all, client, or worker'); + } console.log('Running TypeScript SDK version ' + pkg.version, 'against', opts.server); @@ -87,6 +92,7 @@ async function run() { proxyUrl: opts.httpProxyUrl, taskQueue, tlsConfig, + role: opts.role, }); await runner.run(); } catch (err) { diff --git a/package-lock.json b/package-lock.json index b8fd2229..c94ac82c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,6 +9,10 @@ "@aws-sdk/client-s3": "^3.0.0", "@google-cloud/storage": "^7.0.0", "@grpc/grpc-js": "^1.12.4", + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", @@ -17,6 +21,7 @@ "@temporalio/external-storage-gcs-google-sdk": "^1.25.0", "@temporalio/external-storage-s3": "^1.25.0", "@temporalio/external-storage-s3-aws-sdk": "^1.25.0", + "@temporalio/interceptors-opentelemetry": "^1.25.0", "@temporalio/plugin": "^1.25.0", "@temporalio/proto": "^1.25.0", "@temporalio/worker": "^1.25.0", @@ -1284,6 +1289,137 @@ "node": ">=12.4.0" } }, + "node_modules/@opentelemetry/api": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", + "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@opentelemetry/context-async-hooks": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz", + "integrity": "sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/core": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz", + "integrity": "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/propagator-b3": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz", + "integrity": "sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/propagator-jaeger": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz", + "integrity": "sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==", + "deprecated": "Package no longer supported. See https://github.com/open-telemetry/opentelemetry-js/pull/7077", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/resources": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz", + "integrity": "sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/sdk-trace-base": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz", + "integrity": "sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==", + "deprecated": "Use @opentelemetry/sdk-trace package", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/resources": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/sdk-trace-node": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz", + "integrity": "sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==", + "deprecated": "Use @opentelemetry/sdk-trace package", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/context-async-hooks": "1.30.1", + "@opentelemetry/core": "1.30.1", + "@opentelemetry/propagator-b3": "1.30.1", + "@opentelemetry/propagator-jaeger": "1.30.1", + "@opentelemetry/sdk-trace-base": "1.30.1", + "semver": "^7.5.2" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/semantic-conventions": { + "version": "1.28.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz", + "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + } + }, "node_modules/@protobuf-ts/protoc": { "version": "2.11.1", "resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.11.1.tgz", @@ -1815,6 +1951,31 @@ "protobufjs": "^8.7.1" } }, + "node_modules/@temporalio/interceptors-opentelemetry": { + "version": "1.25.0", + "resolved": "https://registry.npmjs.org/@temporalio/interceptors-opentelemetry/-/interceptors-opentelemetry-1.25.0.tgz", + "integrity": "sha512-6nROrw3uOJvGi5njtjlA/szZBCEGKQHSpWg/kJ5NqGjNmAM6KLWe7XQcJGH5s8aIGtUlq0k6sAQFAH38ATKTEg==", + "license": "MIT", + "dependencies": { + "@opentelemetry/api": "^1.9.0", + "@opentelemetry/core": "^1.25.1", + "@opentelemetry/resources": "^1.25.1", + "@opentelemetry/sdk-trace-base": "^1.25.1", + "@temporalio/plugin": "1.25.0" + }, + "engines": { + "node": ">= 20.3.0" + }, + "peerDependencies": { + "@temporalio/common": "1.25.0", + "@temporalio/workflow": "1.25.0" + }, + "peerDependenciesMeta": { + "@temporalio/workflow": { + "optional": true + } + } + }, "node_modules/@temporalio/nexus": { "version": "1.25.0", "resolved": "https://registry.npmjs.org/@temporalio/nexus/-/nexus-1.25.0.tgz", @@ -6345,7 +6506,6 @@ "version": "7.7.4", "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, "license": "ISC", "bin": { "semver": "bin/semver.js" diff --git a/package.json b/package.json index c4def422..a600ad5e 100644 --- a/package.json +++ b/package.json @@ -11,10 +11,15 @@ "@aws-sdk/client-s3": "^3.0.0", "@google-cloud/storage": "^7.0.0", "@grpc/grpc-js": "^1.12.4", + "@opentelemetry/api": "1.9.0", + "@opentelemetry/resources": "^1.30.1", + "@opentelemetry/sdk-trace-base": "^1.30.1", + "@opentelemetry/sdk-trace-node": "^1.30.1", "@protobuf-ts/protoc": "^2.8.1", "@temporalio/activity": "^1.25.0", "@temporalio/client": "^1.25.0", "@temporalio/common": "^1.25.0", + "@temporalio/interceptors-opentelemetry": "^1.25.0", "@temporalio/external-storage-gcs": "^1.25.0", "@temporalio/external-storage-gcs-google-sdk": "^1.25.0", "@temporalio/external-storage-s3": "^1.25.0", diff --git a/pyproject.toml b/pyproject.toml index ee16d732..475452ac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,7 +5,10 @@ description = "Temporal SDK Features" authors = [{ name = "Temporal Technologies Inc", email = "sdk@temporal.io" }] requires-python = ">=3.11" license = "MIT" -dependencies = ["temporalio"] +dependencies = [ + "temporalio", + "opentelemetry-sdk", +] [dependency-groups] dev = [ diff --git a/sdkbuild/java.go b/sdkbuild/java.go index ed46b9b0..abb85d8c 100644 --- a/sdkbuild/java.go +++ b/sdkbuild/java.go @@ -31,6 +31,8 @@ type BuildJavaProgramOptions struct { // NewCommand then runs directly. Otherwise NewCommand compiles and runs it // with gradle run. Build bool + // Additional SDK artifacts that must come from the selected SDK checkout/version. + SDKModules []string // If present, this directory is expected to exist beneath base dir. Otherwise // a temporary dir is created. DirName string @@ -115,6 +117,11 @@ dependencies { application { mainClass = '` + options.MainClass + `' }` + if options.Version != "" && !isPathDep { + for _, module := range append([]string{"temporal-sdk"}, options.SDKModules...) { + buildGradle += "\nconfigurations.configureEach { resolutionStrategy.force 'io.temporal:" + module + ":" + strings.TrimPrefix(options.Version, "v") + "' }\n" + } + } if err := os.WriteFile(filepath.Join(dir, "build.gradle"), []byte(buildGradle), 0644); err != nil { return nil, fmt.Errorf("failed writing build.gradle: %w", err) } @@ -130,6 +137,11 @@ application { includeBuild('` + asAbsPath + `') { dependencySubstitution { substitute module('io.temporal:temporal-sdk') using project(':temporal-sdk') +` + for _, module := range options.SDKModules { + settingsGradle += " substitute module('io.temporal:" + module + "') using project(':" + module + "')\n" + } + settingsGradle += ` } } ` diff --git a/sdkbuild/python.go b/sdkbuild/python.go index d76e3507..ea15f125 100644 --- a/sdkbuild/python.go +++ b/sdkbuild/python.go @@ -201,11 +201,17 @@ func PythonProgramFromDir(dir string) (*PythonProgram, error) { // Dir is the directory to run in. func (p *PythonProgram) Dir() string { return p.dir } -// NewCommand makes a new uv command. The first argument needs to be the +// NewCommand runs the prepared interpreter directly so cancellation owns the +// Python process, rather than leaving it behind an exited package-manager wrapper. +// The first argument needs to be the // name of the module. func (p *PythonProgram) NewCommand(ctx context.Context, args ...string) (*exec.Cmd, error) { - args = append([]string{"run", "python", "-m"}, args...) - cmd := exec.CommandContext(ctx, "uv", args...) + python := filepath.Join(p.dir, ".venv", "bin", "python") + if runtime.GOOS == "windows" { + python = filepath.Join(p.dir, ".venv", "Scripts", "python.exe") + } + args = append([]string{"-m"}, args...) + cmd := exec.CommandContext(ctx, python, args...) cmd.Dir = p.dir setupCommandIO(cmd, nil, nil) return cmd, nil diff --git a/sdkbuild/rust.go b/sdkbuild/rust.go index dd60a4b0..3020e1c4 100644 --- a/sdkbuild/rust.go +++ b/sdkbuild/rust.go @@ -26,7 +26,8 @@ type BuildRustProgramOptions struct { DirName string // Version selects an exact published SDK version, defaulting to Cargo.toml. // A value containing a slash or backslash selects a local SDK workspace. - Version string + Version string + CrossLanguage bool // If present, custom writers that will capture stdout/stderr. Stdout io.Writer Stderr io.Writer @@ -142,6 +143,9 @@ func BuildRustProgram(ctx context.Context, options BuildRustProgramOptions) (*Ru } } args := []string{"build", "--release", "--bin", "program", "--target-dir", target} + if options.CrossLanguage { + args = append(args, "--features", "cross-language") + } if locked { args = append(args, "--locked") } diff --git a/sdkbuild/typescript.go b/sdkbuild/typescript.go index 614e90d4..8c32bb4c 100644 --- a/sdkbuild/typescript.go +++ b/sdkbuild/typescript.go @@ -33,6 +33,8 @@ type BuildTypeScriptProgramOptions struct { Includes []string // If present, overrides the default "exclude" array in tsconfig.json. Excludes []string + // Additional exclusions appended to the default or overridden exclude array. + AdditionalExcludes []string // If present, add additional dependencies -> version string to package.json. MoreDependencies map[string]string // If present, custom writers that will capture stdout/stderr. @@ -194,6 +196,7 @@ func BuildTypeScriptProgram(ctx context.Context, options BuildTypeScriptProgramO if len(options.Excludes) > 0 { excludes = options.Excludes } + excludes = append(excludes, options.AdditionalExcludes...) quotedIncludes := make([]string, len(includes)) for i, include := range includes { quotedIncludes[i] = strconv.Quote(include) diff --git a/uv.lock b/uv.lock index 4a362915..3f3c6562 100644 --- a/uv.lock +++ b/uv.lock @@ -1,19 +1,89 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] [options] -exclude-newer = "2026-10-27T23:13:31.870537Z" +exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values. exclude-newer-span = "P2W" [options.exclude-newer-package] +nexus-rpc = false temporalio = false +[[package]] +name = "ast-serialize" +version = "0.13.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/d5/5dc1ee8a80c3b20a0b63c61b43ba6bc53517faecd1def47bcd752d22268e/ast_serialize-0.13.1.tar.gz", hash = "sha256:401cc84e8888d4d76f2c8d296fa006ed1a5ff993b6aff90dd777c03973efd025", size = 955137, upload-time = "2026-10-17T00:04:17.183Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/a8/fbd136b9f70c59e75f59a8e974c84102976f1201828b4f886480ba956936/ast_serialize-0.13.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3e129d44b0cffbea24a7f40117ce49e30993c3d119e584d4817ebd6f87246456", size = 897306, upload-time = "2026-10-17T00:02:52.479Z" }, + { url = "https://files.pythonhosted.org/packages/50/3f/2ad51e9823a790e7a70fd781e9595ab3abeace27f3aefcaa1939457efd72/ast_serialize-0.13.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:523d45bab16ddaf1399c04c4fe81bbf180f81e33c2f7bcbe76be56b0f7311ab4", size = 1236082, upload-time = "2026-10-17T00:02:54.82Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5c/8e959db5cc2237f9d4c560a8e2253c98f9746883fb4774651e4cda458901/ast_serialize-0.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:638333fb8ae72c62753f9e794fda20290883ddc65b0d85e26e08f8bb227567ad", size = 1221242, upload-time = "2026-10-17T00:02:56.395Z" }, + { url = "https://files.pythonhosted.org/packages/d6/05/ab1c56c3b7adcac88764bba609502d6b4989e449b2dd60eb478e1d20e369/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc34c670747d85d4232834665e247009413eaebe47c69eaf60a5c439aaecaed9", size = 1282105, upload-time = "2026-10-17T00:02:58.275Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f4/41981fcd2ddffe0760e5326be9dcbd2eda9478a8430a637e5123bd8fcb26/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c8ebd419811c435812d242fb2a173e57dfede198c9ac9a0a584666ebc9b9331", size = 1287905, upload-time = "2026-10-17T00:03:00.068Z" }, + { url = "https://files.pythonhosted.org/packages/6a/43/b783addc5681153707121991b7b47892f7e9c8ba58a0d03b71a3b023ba47/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8899c038b1c15ae8b98e379057fb3ef398ceb0b21d1737a8156dd5a0923b7e51", size = 1541806, upload-time = "2026-10-17T00:03:01.503Z" }, + { url = "https://files.pythonhosted.org/packages/47/10/969db095038ee15270f65ad20d1129c5e4da605bf7e93b70ae640f1c8a9f/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e14c4de98f965647a74e6eaf37e20207124e45451ccd36e84a6f6ebab45e0372", size = 1309946, upload-time = "2026-10-17T00:03:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/06/dd/7c623d2fb0b868948952d1787e629a43b866f7d4caefd5445e20aefacec4/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3e8a3eff69af640db985360fef35073fb46956dfc3e5c614cf00920d2746dd", size = 1302773, upload-time = "2026-10-17T00:03:04.378Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c2/4d49469110a19a44fc6269f4fd59679bcf84df068f185f89b73bee4da19b/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:75d7750fe98f6f35a96c43aba8d98a2e623e22c778a0c17ab9ede92eb10f5d82", size = 1299579, upload-time = "2026-10-17T00:03:05.88Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/2d381f1f262dda15affc8ad643fba1619eb07e7d9f8bd904deffef183006/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e8ddd63e80fc280c2f790157386f27f9b9f6ccb9c4f8e803b863cbfb085769", size = 1355969, upload-time = "2026-10-17T00:03:07.321Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9c/2266794e6c25fa9ce51ce04a9bf4b7e330e3ac9351ba3fa14e487678acdb/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9221e09496fb942901993c1812ee87950cc0ecbb514c7c0f1f5fa6d78f701ed8", size = 1460227, upload-time = "2026-10-17T00:03:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d6/14deb28e5d8f328f626a0778ea2cf98fe908f2bbcccd804cb6f449ee1782/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:7a5c38bdb93669c596f94fb7204dd6ebe4fadb19058ac9a2faf2948c2a175f96", size = 1562691, upload-time = "2026-10-17T00:03:10.25Z" }, + { url = "https://files.pythonhosted.org/packages/f5/19/7a28c0e5ba54f0d3e054f847a2a549b748cb179ab433321a8dc1b39e398d/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:acf4e9f055d75058ab01536da330648746f2f82b7697a85230547f2d5ebe895c", size = 1558669, upload-time = "2026-10-17T00:03:11.799Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/f9e2690eab58217f1d395a964a78efa7eaf813a1e38be8dfd9a8d45d0840/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87427913c325adc811e81e7c9a757b061f47ef1e29114ac479aa0953a2687a98", size = 1665071, upload-time = "2026-10-17T00:03:13.284Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/ef5b159a0d7161b404f05e7ec21cf7735ee7edc10c000cd2cbbc7bb6b69a/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:ad88921f95b92bc144d9ad059a0e16f8c1ae69f5239f2d3c6536fd2774f73dfe", size = 1473364, upload-time = "2026-10-17T00:03:14.563Z" }, + { url = "https://files.pythonhosted.org/packages/1d/87/6e8ac4a865124a12cc4f915bf1bcfac3bba426cd5f58d3712a873ee61012/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f8b17e2921e56621bcb46792bd3e0b82ca3b85de78d5936e7b8174ba1758b0aa", size = 1500566, upload-time = "2026-10-17T00:03:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1e/29155f1621433008013ad5c940a03d41a676be0680c41527040472d37583/ast_serialize-0.13.1-cp314-cp314t-win32.whl", hash = "sha256:2f9a9ce8b0994f757b941f7f7fe384a6666b4162b941ebc5c248081baea18e47", size = 1128674, upload-time = "2026-10-17T00:03:17.481Z" }, + { url = "https://files.pythonhosted.org/packages/bb/64/2506da65143ea138de5822e9173e0b72320a2f70e23bd723f044033175f1/ast_serialize-0.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5d99910e6b9a9b9360bcca2ae99aee36cc912ce058df2a57d1c33099b6cb2593", size = 1163306, upload-time = "2026-10-17T00:03:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/6d/8f/c7cb22638899b0cf15908809c270560e46395e65604bc59e4b623ab9f405/ast_serialize-0.13.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a789cbe14d0a0e9ec9b32a456e5abc81ad8799479c3cfd88a29e3442262aebe6", size = 1133775, upload-time = "2026-10-17T00:03:20.377Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e2/b0c140fe50fa39dd249e382f7733af6f816c90021fe7959a0b026f86237f/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:23d768369b89d551077dc173da6892fad00443338417523b6732f4e8ba4a7ed5", size = 1236160, upload-time = "2026-10-17T00:03:21.945Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/a8a2ca21e3943555b48221f8fba546877a7ad39efaf6505506524967d7c4/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:68f8829d114dab6c9db4a8bbb8d0e342958faee1b5e15a29022678df639960f8", size = 1222214, upload-time = "2026-10-17T00:03:23.462Z" }, + { url = "https://files.pythonhosted.org/packages/15/19/2f58f2ba64e4799b39de85c140aef09a03aa6ea53be75dd292a9d9b9d8ae/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e385b17d5bde892a6184003a9aff3518387908b73f8f5ea539313c07c8c0ede", size = 1282979, upload-time = "2026-10-17T00:03:24.695Z" }, + { url = "https://files.pythonhosted.org/packages/b1/af/ca6087fe84210c1ccd43e3182917bb70649fa1e69745a90c1d59ba08fea8/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:02686b281ec9b8e9614f6f0db27e12e4cac515f336c5d05b678bc9eb73ff2af5", size = 1288596, upload-time = "2026-10-17T00:03:26.04Z" }, + { url = "https://files.pythonhosted.org/packages/b0/2c/4ef964c763329a0347125e745ec0451ba4fbaceec9efe2ac729b7cd55f17/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8ab2c2585b2e22e48cd4aff2136fce4eab4ced569b85f150ef9a5a5d6f34d49", size = 1545540, upload-time = "2026-10-17T00:03:27.52Z" }, + { url = "https://files.pythonhosted.org/packages/bb/85/aa961dbb75813cfa94de0ce9a16a9510c226b95f604c405421e727f44bb0/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c652d9f5d52d8b81eff3ff2c95c9dd0f281de45f6ad5d3fa95527550c396454a", size = 1309374, upload-time = "2026-10-17T00:03:29.091Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e6/f2b67c327d9f9533e41791804403ccc2dc457821195a2e51f0b587a90b90/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121e1d08d58b75c15491cc3003609cbad71ac2b0016043c36d30a6b2032b6605", size = 1303466, upload-time = "2026-10-17T00:03:30.451Z" }, + { url = "https://files.pythonhosted.org/packages/73/1d/33f18b81d1bb1f5d682943ea92fda8130a6593627f12f6201668d40824fd/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:30cf89b6a6844542d116c758725d13de5b97b9410a51ee577715f761270d0c1c", size = 1300576, upload-time = "2026-10-17T00:03:32.102Z" }, + { url = "https://files.pythonhosted.org/packages/25/cb/64914144925f1a4abdd9217e717b122255c38fc5ebe4342f92052f3bacbc/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:732aaae9e498c973fc63fd7f308009b57c4afa6ff59d0b674d894e57d0bca01a", size = 1355960, upload-time = "2026-10-17T00:03:33.676Z" }, + { url = "https://files.pythonhosted.org/packages/ee/80/bd29379fab2bce19adc0bf9177002b11b23dfe8d8fecf409998b458b4624/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:d9c1a920b2aa0c1e016bed7721689717034ca0dba64ac3a3ff243b003d4e8dd8", size = 1459779, upload-time = "2026-10-17T00:03:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/83/89/012dbe733de05ffdf8e40ca0f9fa5d417cb16ec93a74463c57c001914198/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:847cad4c22953823f5e76d0b126c6f9da670cfa45b1df41b9324e22189d77611", size = 1563399, upload-time = "2026-10-17T00:03:37.285Z" }, + { url = "https://files.pythonhosted.org/packages/69/37/ee4bcb0358bee38744eb0f18560446572d095fe3bf6b63d6f739d08a839c/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:aca07de3ca8e3d9f2b716c3c31f4f384fe4bd2d03e09912417cff7a3e08036f7", size = 1558808, upload-time = "2026-10-17T00:03:38.711Z" }, + { url = "https://files.pythonhosted.org/packages/54/1c/ff44c5355251d61ef22934c4430bb31a61de4781d25a992154aac9b8c82a/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:5db12d843d931b9d1f1519ce66b9cbfe72d8563b75c1204d255322254d1964dd", size = 1666324, upload-time = "2026-10-17T00:03:40.376Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bb/6da4bfc8aa3403e6447607131bf3463acaf954d990c6c8b6787c1902ddfe/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:fb8021f4dc3296de18737e3b8b34994411da725374d74a0b9eb32a738f2a23d0", size = 1474089, upload-time = "2026-10-17T00:03:41.715Z" }, + { url = "https://files.pythonhosted.org/packages/21/97/897e33bef2eefd880e6350e375cc66bc5bcd00a139be480fd655f5b3f095/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:0d764913374ba21df8cd618045b371ed104ce55c6276de7c59e554a4f5ba26fd", size = 1501542, upload-time = "2026-10-17T00:03:43.08Z" }, + { url = "https://files.pythonhosted.org/packages/8d/4c/821211ac83870c27e4412381b7c7838336456b40575bf840e4680b2018d9/ast_serialize-0.13.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:2bad302ae2427454ef9dab71bd5c3ad67188860c39d36daee38f72031edb39c4", size = 1126118, upload-time = "2026-10-17T00:03:44.616Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/2b2d5e6c4fa352874a80618e742ffd32d249dee6c119f4233b51afc6b8f4/ast_serialize-0.13.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:032b09d86c785c3984e975378b7861f2a68ac44e22ba7b07b93a536b2524eeb8", size = 1163766, upload-time = "2026-10-17T00:03:45.986Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/d610cfcdabaa44fd62a54ca1fc57a7dba120643798b089a14914973562de/ast_serialize-0.13.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:929eda0c419e622ab49df3a4c45f81c57dcc10874bbad55d0470a4a03324dac3", size = 1134043, upload-time = "2026-10-17T00:03:48.453Z" }, + { url = "https://files.pythonhosted.org/packages/f0/89/0e30f9eddf7d44ccf9d25979030754fd0457af61fa4279acb8c293a04f97/ast_serialize-0.13.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bf53a3ba1cbe45399fc1e4ccd684b8f2a11cca450f89706b79122f478534c6f5", size = 897546, upload-time = "2026-10-17T00:03:50.093Z" }, + { url = "https://files.pythonhosted.org/packages/81/92/d705be88ff452b9ba0088b554a0cbd308fd01879da092b33fd2ad7d1aa60/ast_serialize-0.13.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:4bcf1d5f4eefecaa325a34ecf079b2741189e7d0821523f92cb343a389a67489", size = 1242416, upload-time = "2026-10-17T00:03:51.521Z" }, + { url = "https://files.pythonhosted.org/packages/60/c2/98370845a7f35cb8a25782e78284b48e01bf3128339881d48d613f304f8f/ast_serialize-0.13.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1b158f1c9e3a0d386913924c57995d6df78224868a4d0f215bdd41587c97b34a", size = 1229729, upload-time = "2026-10-17T00:03:52.825Z" }, + { url = "https://files.pythonhosted.org/packages/d8/8b/2d7ffed76addd9d3fcf37fb171400942735c8912264c763561a85407f6a8/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a6201b69ce42e919f2fd9a559138d5410b5d8afff7c3a6b1f500b0481ff7d8", size = 1292255, upload-time = "2026-10-17T00:03:54.148Z" }, + { url = "https://files.pythonhosted.org/packages/6b/2a/bb9e0e719d89cc950fadfcfcc9cb4bc7640419c4228c852f031ab8abf440/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eb0be64c9b8f1ed26637eef345abe75ea90351c92c85a8aec7838b3af971011", size = 1298501, upload-time = "2026-10-17T00:03:55.559Z" }, + { url = "https://files.pythonhosted.org/packages/7a/32/13ce07dce48226f5bd9cfd8f708ec101a8be05aa430cda4918ce31ce8c82/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f2427bddfca208e84de700044fadf9aef2769a70bae740a1bdabb89ee9e1117", size = 1553758, upload-time = "2026-10-17T00:03:56.952Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fb/9b51d186db0c20ca28cbaaefd50f03b573c89327b9a2627820cbce22196b/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88df960e67184a71874e5b2ee014f87d1254a0dbc1f903c7bd7b1ab7733ecaef", size = 1318258, upload-time = "2026-10-17T00:03:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fa/da311559dd3dae9af5825cf21660775a929b970f72e3786af3f2cd667944/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f99786e0d62082a5b121b3437f3167562133711df22128de1e9886f57f0b226", size = 1313260, upload-time = "2026-10-17T00:04:00.194Z" }, + { url = "https://files.pythonhosted.org/packages/2b/11/97a4b9e5b4776d72f47fcd9a09a497bbf68ec8c1ae074307a2c51e410d85/ast_serialize-0.13.1-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:a01b515b25a03184eff4acef25b981ae007916379682e908fc8785b342a0bf3e", size = 1309992, upload-time = "2026-10-17T00:04:01.575Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c4/62f85121a80cd451ef04f550cf0f7ea0ad9ff46cc4e9a5b9ae439b6527b1/ast_serialize-0.13.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:29422d7bcd9e7f39411571c36cec45ce8a7a9b3ad4b2e7aa64497c15a9e397f6", size = 1362715, upload-time = "2026-10-17T00:04:02.881Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/c5f4a545f72a7681e3295bab6e3600ee0862ec4391bed961fe9f735b67e0/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ffb0f548a7dc126067fdfb7b2325ab5dfcdeecc29faf5e0f0461c96d6ebfa3d", size = 1469931, upload-time = "2026-10-17T00:04:04.181Z" }, + { url = "https://files.pythonhosted.org/packages/38/a9/65aed4f8fa7a001a7cfdc03e68e844517ab041ba6fb614b7d78a1d6ac056/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:2876444a5f87a7c76f371af3c07c2fda563a08bc8af52568df812e8aba4bf568", size = 1570945, upload-time = "2026-10-17T00:04:05.778Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/44b2da991cede79bfbf52089f33a5f0168945466b3d9cd38b5dcf08e7130/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:885a62ec6481ce58ab24c6357360d7a82023b62dd7e5e7ceccf59e9662a3272b", size = 1569978, upload-time = "2026-10-17T00:04:07.347Z" }, + { url = "https://files.pythonhosted.org/packages/46/e4/109b2a5beca700237767d5add920c2f8e1ba9bd5799b0faf143d0e9cf4ef/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:2015fd0165e463aac3b1aadc6a1fa1e5820c14ca950821f4fe02f8a3f6a388d6", size = 1676082, upload-time = "2026-10-17T00:04:08.7Z" }, + { url = "https://files.pythonhosted.org/packages/73/e0/7df70f6dbb11b5762da5416318f08316a1c51348e0d69ec79ca5f98f836a/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:eb41e1906502ac80d24ff343f45008552a3f5b5158607959fe6a07dbfc6eb037", size = 1483207, upload-time = "2026-10-17T00:04:10.162Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bc/523aa1c08bd69b5654621beb3dc1a9035715a4a63762fb8d219d6fb3eb81/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ca9acc67f796aa2554fa3037dccc022a4b08b38b2ad153edfac9c9bb7cb1f3c6", size = 1512140, upload-time = "2026-10-17T00:04:11.589Z" }, + { url = "https://files.pythonhosted.org/packages/66/83/6607060659998f00afdea0d8375c1e6e2b7d515ab905090d9a5a02f48851/ast_serialize-0.13.1-cp39-abi3-win32.whl", hash = "sha256:4f98da562e5901d69c7dd30885594c5438f859edf354e9ac7517d188fb026c3a", size = 1131889, upload-time = "2026-10-17T00:04:12.953Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6f/bafd6490fe7b355627fabe95f4417e3d02da93102c8552550eb9a0774e1e/ast_serialize-0.13.1-cp39-abi3-win_amd64.whl", hash = "sha256:ddf7cbc9c8abf70102c4a088efe154bb86bfb825b0a10e556d2b15972cf99bd7", size = 1171153, upload-time = "2026-10-17T00:04:14.362Z" }, + { url = "https://files.pythonhosted.org/packages/11/25/4235f4b375a67a37ac595bf478a5407a744eaf7b64113c1c3a5432b8d954/ast_serialize-0.13.1-cp39-abi3-win_arm64.whl", hash = "sha256:48f11d96c9ec71119612f8e79a8c55c12f2b136716d68347433c561d27a25f43", size = 1139035, upload-time = "2026-10-17T00:04:15.767Z" }, +] + [[package]] name = "features" version = "0.1.0" source = { editable = "." } dependencies = [ + { name = "opentelemetry-sdk" }, { name = "temporalio" }, ] @@ -24,7 +94,10 @@ dev = [ ] [package.metadata] -requires-dist = [{ name = "temporalio" }] +requires-dist = [ + { name = "opentelemetry-sdk" }, + { name = "temporalio" }, +] [package.metadata.requires-dev] dev = [ @@ -34,114 +107,178 @@ dev = [ [[package]] name = "librt" -version = "0.8.1" +version = "0.16.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/56/9c/b4b0c54d84da4a94b37bd44151e46d5e583c9534c7e02250b961b1b6d8a8/librt-0.8.1.tar.gz", hash = "sha256:be46a14693955b3bd96014ccbdb8339ee8c9346fbe11c1b78901b55125f14c73", size = 177471, upload-time = "2026-02-17T16:13:06.101Z" } +sdist = { url = "https://files.pythonhosted.org/packages/04/f5/9dc696772d241814bacac7880bac32f2930b5a6ebc1f85317b83161a011c/librt-0.16.0.tar.gz", hash = "sha256:ac38d6d8d66bf3d744148dbbc0b8e193e195a51e364ed55e224631f5721891fc", size = 219839, upload-time = "2026-09-29T00:55:32.891Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/01/0e748af5e4fee180cf7cd12bd12b0513ad23b045dccb2a83191bde82d168/librt-0.8.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:681dc2451d6d846794a828c16c22dc452d924e9f700a485b7ecb887a30aad1fd", size = 65315, upload-time = "2026-02-17T16:11:25.152Z" }, - { url = "https://files.pythonhosted.org/packages/9d/4d/7184806efda571887c798d573ca4134c80ac8642dcdd32f12c31b939c595/librt-0.8.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3b4350b13cc0e6f5bec8fa7caf29a8fb8cdc051a3bae45cfbfd7ce64f009965", size = 68021, upload-time = "2026-02-17T16:11:26.129Z" }, - { url = "https://files.pythonhosted.org/packages/ae/88/c3c52d2a5d5101f28d3dc89298444626e7874aa904eed498464c2af17627/librt-0.8.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ac1e7817fd0ed3d14fd7c5df91daed84c48e4c2a11ee99c0547f9f62fdae13da", size = 194500, upload-time = "2026-02-17T16:11:27.177Z" }, - { url = "https://files.pythonhosted.org/packages/d6/5d/6fb0a25b6a8906e85b2c3b87bee1d6ed31510be7605b06772f9374ca5cb3/librt-0.8.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:747328be0c5b7075cde86a0e09d7a9196029800ba75a1689332348e998fb85c0", size = 205622, upload-time = "2026-02-17T16:11:28.242Z" }, - { url = "https://files.pythonhosted.org/packages/b2/a6/8006ae81227105476a45691f5831499e4d936b1c049b0c1feb17c11b02d1/librt-0.8.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0af2bd2bc204fa27f3d6711d0f360e6b8c684a035206257a81673ab924aa11e", size = 218304, upload-time = "2026-02-17T16:11:29.344Z" }, - { url = "https://files.pythonhosted.org/packages/ee/19/60e07886ad16670aae57ef44dada41912c90906a6fe9f2b9abac21374748/librt-0.8.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d480de377f5b687b6b1bc0c0407426da556e2a757633cc7e4d2e1a057aa688f3", size = 211493, upload-time = "2026-02-17T16:11:30.445Z" }, - { url = "https://files.pythonhosted.org/packages/9c/cf/f666c89d0e861d05600438213feeb818c7514d3315bae3648b1fc145d2b6/librt-0.8.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d0ee06b5b5291f609ddb37b9750985b27bc567791bc87c76a569b3feed8481ac", size = 219129, upload-time = "2026-02-17T16:11:32.021Z" }, - { url = "https://files.pythonhosted.org/packages/8f/ef/f1bea01e40b4a879364c031476c82a0dc69ce068daad67ab96302fed2d45/librt-0.8.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9e2c6f77b9ad48ce5603b83b7da9ee3e36b3ab425353f695cba13200c5d96596", size = 213113, upload-time = "2026-02-17T16:11:33.192Z" }, - { url = "https://files.pythonhosted.org/packages/9b/80/cdab544370cc6bc1b72ea369525f547a59e6938ef6863a11ab3cd24759af/librt-0.8.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:439352ba9373f11cb8e1933da194dcc6206daf779ff8df0ed69c5e39113e6a99", size = 212269, upload-time = "2026-02-17T16:11:34.373Z" }, - { url = "https://files.pythonhosted.org/packages/9d/9c/48d6ed8dac595654f15eceab2035131c136d1ae9a1e3548e777bb6dbb95d/librt-0.8.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:82210adabbc331dbb65d7868b105185464ef13f56f7f76688565ad79f648b0fe", size = 234673, upload-time = "2026-02-17T16:11:36.063Z" }, - { url = "https://files.pythonhosted.org/packages/16/01/35b68b1db517f27a01be4467593292eb5315def8900afad29fabf56304ba/librt-0.8.1-cp311-cp311-win32.whl", hash = "sha256:52c224e14614b750c0a6d97368e16804a98c684657c7518752c356834fff83bb", size = 54597, upload-time = "2026-02-17T16:11:37.544Z" }, - { url = "https://files.pythonhosted.org/packages/71/02/796fe8f02822235966693f257bf2c79f40e11337337a657a8cfebba5febc/librt-0.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:c00e5c884f528c9932d278d5c9cbbea38a6b81eb62c02e06ae53751a83a4d52b", size = 61733, upload-time = "2026-02-17T16:11:38.691Z" }, - { url = "https://files.pythonhosted.org/packages/28/ad/232e13d61f879a42a4e7117d65e4984bb28371a34bb6fb9ca54ec2c8f54e/librt-0.8.1-cp311-cp311-win_arm64.whl", hash = "sha256:f7cdf7f26c2286ffb02e46d7bac56c94655540b26347673bea15fa52a6af17e9", size = 52273, upload-time = "2026-02-17T16:11:40.308Z" }, - { url = "https://files.pythonhosted.org/packages/95/21/d39b0a87ac52fc98f621fb6f8060efb017a767ebbbac2f99fbcbc9ddc0d7/librt-0.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a28f2612ab566b17f3698b0da021ff9960610301607c9a5e8eaca62f5e1c350a", size = 66516, upload-time = "2026-02-17T16:11:41.604Z" }, - { url = "https://files.pythonhosted.org/packages/69/f1/46375e71441c43e8ae335905e069f1c54febee63a146278bcee8782c84fd/librt-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:60a78b694c9aee2a0f1aaeaa7d101cf713e92e8423a941d2897f4fa37908dab9", size = 68634, upload-time = "2026-02-17T16:11:43.268Z" }, - { url = "https://files.pythonhosted.org/packages/0a/33/c510de7f93bf1fa19e13423a606d8189a02624a800710f6e6a0a0f0784b3/librt-0.8.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:758509ea3f1eba2a57558e7e98f4659d0ea7670bff49673b0dde18a3c7e6c0eb", size = 198941, upload-time = "2026-02-17T16:11:44.28Z" }, - { url = "https://files.pythonhosted.org/packages/dd/36/e725903416409a533d92398e88ce665476f275081d0d7d42f9c4951999e5/librt-0.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:039b9f2c506bd0ab0f8725aa5ba339c6f0cd19d3b514b50d134789809c24285d", size = 209991, upload-time = "2026-02-17T16:11:45.462Z" }, - { url = "https://files.pythonhosted.org/packages/30/7a/8d908a152e1875c9f8eac96c97a480df425e657cdb47854b9efaa4998889/librt-0.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bb54f1205a3a6ab41a6fd71dfcdcbd278670d3a90ca502a30d9da583105b6f7", size = 224476, upload-time = "2026-02-17T16:11:46.542Z" }, - { url = "https://files.pythonhosted.org/packages/a8/b8/a22c34f2c485b8903a06f3fe3315341fe6876ef3599792344669db98fcff/librt-0.8.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:05bd41cdee35b0c59c259f870f6da532a2c5ca57db95b5f23689fcb5c9e42440", size = 217518, upload-time = "2026-02-17T16:11:47.746Z" }, - { url = "https://files.pythonhosted.org/packages/79/6f/5c6fea00357e4f82ba44f81dbfb027921f1ab10e320d4a64e1c408d035d9/librt-0.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adfab487facf03f0d0857b8710cf82d0704a309d8ffc33b03d9302b4c64e91a9", size = 225116, upload-time = "2026-02-17T16:11:49.298Z" }, - { url = "https://files.pythonhosted.org/packages/f2/a0/95ced4e7b1267fe1e2720a111685bcddf0e781f7e9e0ce59d751c44dcfe5/librt-0.8.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:153188fe98a72f206042be10a2c6026139852805215ed9539186312d50a8e972", size = 217751, upload-time = "2026-02-17T16:11:50.49Z" }, - { url = "https://files.pythonhosted.org/packages/93/c2/0517281cb4d4101c27ab59472924e67f55e375bc46bedae94ac6dc6e1902/librt-0.8.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dd3c41254ee98604b08bd5b3af5bf0a89740d4ee0711de95b65166bf44091921", size = 218378, upload-time = "2026-02-17T16:11:51.783Z" }, - { url = "https://files.pythonhosted.org/packages/43/e8/37b3ac108e8976888e559a7b227d0ceac03c384cfd3e7a1c2ee248dbae79/librt-0.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e0d138c7ae532908cbb342162b2611dbd4d90c941cd25ab82084aaf71d2c0bd0", size = 241199, upload-time = "2026-02-17T16:11:53.561Z" }, - { url = "https://files.pythonhosted.org/packages/4b/5b/35812d041c53967fedf551a39399271bbe4257e681236a2cf1a69c8e7fa1/librt-0.8.1-cp312-cp312-win32.whl", hash = "sha256:43353b943613c5d9c49a25aaffdba46f888ec354e71e3529a00cca3f04d66a7a", size = 54917, upload-time = "2026-02-17T16:11:54.758Z" }, - { url = "https://files.pythonhosted.org/packages/de/d1/fa5d5331b862b9775aaf2a100f5ef86854e5d4407f71bddf102f4421e034/librt-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff8baf1f8d3f4b6b7257fcb75a501f2a5499d0dda57645baa09d4d0d34b19444", size = 62017, upload-time = "2026-02-17T16:11:55.748Z" }, - { url = "https://files.pythonhosted.org/packages/c7/7c/c614252f9acda59b01a66e2ddfd243ed1c7e1deab0293332dfbccf862808/librt-0.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f2ae3725904f7377e11cc37722d5d401e8b3d5851fb9273d7f4fe04f6b3d37d", size = 52441, upload-time = "2026-02-17T16:11:56.801Z" }, - { url = "https://files.pythonhosted.org/packages/c5/3c/f614c8e4eaac7cbf2bbdf9528790b21d89e277ee20d57dc6e559c626105f/librt-0.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e6bad1cd94f6764e1e21950542f818a09316645337fd5ab9a7acc45d99a8f35", size = 66529, upload-time = "2026-02-17T16:11:57.809Z" }, - { url = "https://files.pythonhosted.org/packages/ab/96/5836544a45100ae411eda07d29e3d99448e5258b6e9c8059deb92945f5c2/librt-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cf450f498c30af55551ba4f66b9123b7185362ec8b625a773b3d39aa1a717583", size = 68669, upload-time = "2026-02-17T16:11:58.843Z" }, - { url = "https://files.pythonhosted.org/packages/06/53/f0b992b57af6d5531bf4677d75c44f095f2366a1741fb695ee462ae04b05/librt-0.8.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:eca45e982fa074090057132e30585a7e8674e9e885d402eae85633e9f449ce6c", size = 199279, upload-time = "2026-02-17T16:11:59.862Z" }, - { url = "https://files.pythonhosted.org/packages/f3/ad/4848cc16e268d14280d8168aee4f31cea92bbd2b79ce33d3e166f2b4e4fc/librt-0.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c3811485fccfda840861905b8c70bba5ec094e02825598bb9d4ca3936857a04", size = 210288, upload-time = "2026-02-17T16:12:00.954Z" }, - { url = "https://files.pythonhosted.org/packages/52/05/27fdc2e95de26273d83b96742d8d3b7345f2ea2bdbd2405cc504644f2096/librt-0.8.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e4af413908f77294605e28cfd98063f54b2c790561383971d2f52d113d9c363", size = 224809, upload-time = "2026-02-17T16:12:02.108Z" }, - { url = "https://files.pythonhosted.org/packages/7a/d0/78200a45ba3240cb042bc597d6f2accba9193a2c57d0356268cbbe2d0925/librt-0.8.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5212a5bd7fae98dae95710032902edcd2ec4dc994e883294f75c857b83f9aba0", size = 218075, upload-time = "2026-02-17T16:12:03.631Z" }, - { url = "https://files.pythonhosted.org/packages/af/72/a210839fa74c90474897124c064ffca07f8d4b347b6574d309686aae7ca6/librt-0.8.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e692aa2d1d604e6ca12d35e51fdc36f4cda6345e28e36374579f7ef3611b3012", size = 225486, upload-time = "2026-02-17T16:12:04.725Z" }, - { url = "https://files.pythonhosted.org/packages/a3/c1/a03cc63722339ddbf087485f253493e2b013039f5b707e8e6016141130fa/librt-0.8.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4be2a5c926b9770c9e08e717f05737a269b9d0ebc5d2f0060f0fe3fe9ce47acb", size = 218219, upload-time = "2026-02-17T16:12:05.828Z" }, - { url = "https://files.pythonhosted.org/packages/58/f5/fff6108af0acf941c6f274a946aea0e484bd10cd2dc37610287ce49388c5/librt-0.8.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fd1a720332ea335ceb544cf0a03f81df92abd4bb887679fd1e460976b0e6214b", size = 218750, upload-time = "2026-02-17T16:12:07.09Z" }, - { url = "https://files.pythonhosted.org/packages/71/67/5a387bfef30ec1e4b4f30562c8586566faf87e47d696768c19feb49e3646/librt-0.8.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2af9e01e0ef80d95ae3c720be101227edae5f2fe7e3dc63d8857fadfc5a1d", size = 241624, upload-time = "2026-02-17T16:12:08.43Z" }, - { url = "https://files.pythonhosted.org/packages/d4/be/24f8502db11d405232ac1162eb98069ca49c3306c1d75c6ccc61d9af8789/librt-0.8.1-cp313-cp313-win32.whl", hash = "sha256:086a32dbb71336627e78cc1d6ee305a68d038ef7d4c39aaff41ae8c9aa46e91a", size = 54969, upload-time = "2026-02-17T16:12:09.633Z" }, - { url = "https://files.pythonhosted.org/packages/5c/73/c9fdf6cb2a529c1a092ce769a12d88c8cca991194dfe641b6af12fa964d2/librt-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:e11769a1dbda4da7b00a76cfffa67aa47cfa66921d2724539eee4b9ede780b79", size = 62000, upload-time = "2026-02-17T16:12:10.632Z" }, - { url = "https://files.pythonhosted.org/packages/d3/97/68f80ca3ac4924f250cdfa6e20142a803e5e50fca96ef5148c52ee8c10ea/librt-0.8.1-cp313-cp313-win_arm64.whl", hash = "sha256:924817ab3141aca17893386ee13261f1d100d1ef410d70afe4389f2359fea4f0", size = 52495, upload-time = "2026-02-17T16:12:11.633Z" }, - { url = "https://files.pythonhosted.org/packages/c9/6a/907ef6800f7bca71b525a05f1839b21f708c09043b1c6aa77b6b827b3996/librt-0.8.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6cfa7fe54fd4d1f47130017351a959fe5804bda7a0bc7e07a2cdbc3fdd28d34f", size = 66081, upload-time = "2026-02-17T16:12:12.766Z" }, - { url = "https://files.pythonhosted.org/packages/1b/18/25e991cd5640c9fb0f8d91b18797b29066b792f17bf8493da183bf5caabe/librt-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:228c2409c079f8c11fb2e5d7b277077f694cb93443eb760e00b3b83cb8b3176c", size = 68309, upload-time = "2026-02-17T16:12:13.756Z" }, - { url = "https://files.pythonhosted.org/packages/a4/36/46820d03f058cfb5a9de5940640ba03165ed8aded69e0733c417bb04df34/librt-0.8.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7aae78ab5e3206181780e56912d1b9bb9f90a7249ce12f0e8bf531d0462dd0fc", size = 196804, upload-time = "2026-02-17T16:12:14.818Z" }, - { url = "https://files.pythonhosted.org/packages/59/18/5dd0d3b87b8ff9c061849fbdb347758d1f724b9a82241aa908e0ec54ccd0/librt-0.8.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:172d57ec04346b047ca6af181e1ea4858086c80bdf455f61994c4aa6fc3f866c", size = 206907, upload-time = "2026-02-17T16:12:16.513Z" }, - { url = "https://files.pythonhosted.org/packages/d1/96/ef04902aad1424fd7299b62d1890e803e6ab4018c3044dca5922319c4b97/librt-0.8.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b1977c4ea97ce5eb7755a78fae68d87e4102e4aaf54985e8b56806849cc06a3", size = 221217, upload-time = "2026-02-17T16:12:17.906Z" }, - { url = "https://files.pythonhosted.org/packages/6d/ff/7e01f2dda84a8f5d280637a2e5827210a8acca9a567a54507ef1c75b342d/librt-0.8.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:10c42e1f6fd06733ef65ae7bebce2872bcafd8d6e6b0a08fe0a05a23b044fb14", size = 214622, upload-time = "2026-02-17T16:12:19.108Z" }, - { url = "https://files.pythonhosted.org/packages/1e/8c/5b093d08a13946034fed57619742f790faf77058558b14ca36a6e331161e/librt-0.8.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4c8dfa264b9193c4ee19113c985c95f876fae5e51f731494fc4e0cf594990ba7", size = 221987, upload-time = "2026-02-17T16:12:20.331Z" }, - { url = "https://files.pythonhosted.org/packages/d3/cc/86b0b3b151d40920ad45a94ce0171dec1aebba8a9d72bb3fa00c73ab25dd/librt-0.8.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:01170b6729a438f0dedc4a26ed342e3dc4f02d1000b4b19f980e1877f0c297e6", size = 215132, upload-time = "2026-02-17T16:12:21.54Z" }, - { url = "https://files.pythonhosted.org/packages/fc/be/8588164a46edf1e69858d952654e216a9a91174688eeefb9efbb38a9c799/librt-0.8.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7b02679a0d783bdae30d443025b94465d8c3dc512f32f5b5031f93f57ac32071", size = 215195, upload-time = "2026-02-17T16:12:23.073Z" }, - { url = "https://files.pythonhosted.org/packages/f5/f2/0b9279bea735c734d69344ecfe056c1ba211694a72df10f568745c899c76/librt-0.8.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:190b109bb69592a3401fe1ffdea41a2e73370ace2ffdc4a0e8e2b39cdea81b78", size = 237946, upload-time = "2026-02-17T16:12:24.275Z" }, - { url = "https://files.pythonhosted.org/packages/e9/cc/5f2a34fbc8aeb35314a3641f9956fa9051a947424652fad9882be7a97949/librt-0.8.1-cp314-cp314-win32.whl", hash = "sha256:e70a57ecf89a0f64c24e37f38d3fe217a58169d2fe6ed6d70554964042474023", size = 50689, upload-time = "2026-02-17T16:12:25.766Z" }, - { url = "https://files.pythonhosted.org/packages/a0/76/cd4d010ab2147339ca2b93e959c3686e964edc6de66ddacc935c325883d7/librt-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:7e2f3edca35664499fbb36e4770650c4bd4a08abc1f4458eab9df4ec56389730", size = 57875, upload-time = "2026-02-17T16:12:27.465Z" }, - { url = "https://files.pythonhosted.org/packages/84/0f/2143cb3c3ca48bd3379dcd11817163ca50781927c4537345d608b5045998/librt-0.8.1-cp314-cp314-win_arm64.whl", hash = "sha256:0d2f82168e55ddefd27c01c654ce52379c0750ddc31ee86b4b266bcf4d65f2a3", size = 48058, upload-time = "2026-02-17T16:12:28.556Z" }, - { url = "https://files.pythonhosted.org/packages/d2/0e/9b23a87e37baf00311c3efe6b48d6b6c168c29902dfc3f04c338372fd7db/librt-0.8.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c74a2da57a094bd48d03fa5d196da83d2815678385d2978657499063709abe1", size = 68313, upload-time = "2026-02-17T16:12:29.659Z" }, - { url = "https://files.pythonhosted.org/packages/db/9a/859c41e5a4f1c84200a7d2b92f586aa27133c8243b6cac9926f6e54d01b9/librt-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a355d99c4c0d8e5b770313b8b247411ed40949ca44e33e46a4789b9293a907ee", size = 70994, upload-time = "2026-02-17T16:12:31.516Z" }, - { url = "https://files.pythonhosted.org/packages/4c/28/10605366ee599ed34223ac2bf66404c6fb59399f47108215d16d5ad751a8/librt-0.8.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2eb345e8b33fb748227409c9f1233d4df354d6e54091f0e8fc53acdb2ffedeb7", size = 220770, upload-time = "2026-02-17T16:12:33.294Z" }, - { url = "https://files.pythonhosted.org/packages/af/8d/16ed8fd452dafae9c48d17a6bc1ee3e818fd40ef718d149a8eff2c9f4ea2/librt-0.8.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9be2f15e53ce4e83cc08adc29b26fb5978db62ef2a366fbdf716c8a6c8901040", size = 235409, upload-time = "2026-02-17T16:12:35.443Z" }, - { url = "https://files.pythonhosted.org/packages/89/1b/7bdf3e49349c134b25db816e4a3db6b94a47ac69d7d46b1e682c2c4949be/librt-0.8.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:785ae29c1f5c6e7c2cde2c7c0e148147f4503da3abc5d44d482068da5322fd9e", size = 246473, upload-time = "2026-02-17T16:12:36.656Z" }, - { url = "https://files.pythonhosted.org/packages/4e/8a/91fab8e4fd2a24930a17188c7af5380eb27b203d72101c9cc000dbdfd95a/librt-0.8.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d3a7da44baf692f0c6aeb5b2a09c5e6fc7a703bca9ffa337ddd2e2da53f7732", size = 238866, upload-time = "2026-02-17T16:12:37.849Z" }, - { url = "https://files.pythonhosted.org/packages/b9/e0/c45a098843fc7c07e18a7f8a24ca8496aecbf7bdcd54980c6ca1aaa79a8e/librt-0.8.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5fc48998000cbc39ec0d5311312dda93ecf92b39aaf184c5e817d5d440b29624", size = 250248, upload-time = "2026-02-17T16:12:39.445Z" }, - { url = "https://files.pythonhosted.org/packages/82/30/07627de23036640c952cce0c1fe78972e77d7d2f8fd54fa5ef4554ff4a56/librt-0.8.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e96baa6820280077a78244b2e06e416480ed859bbd8e5d641cf5742919d8beb4", size = 240629, upload-time = "2026-02-17T16:12:40.889Z" }, - { url = "https://files.pythonhosted.org/packages/fb/c1/55bfe1ee3542eba055616f9098eaf6eddb966efb0ca0f44eaa4aba327307/librt-0.8.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31362dbfe297b23590530007062c32c6f6176f6099646bb2c95ab1b00a57c382", size = 239615, upload-time = "2026-02-17T16:12:42.446Z" }, - { url = "https://files.pythonhosted.org/packages/2b/39/191d3d28abc26c9099b19852e6c99f7f6d400b82fa5a4e80291bd3803e19/librt-0.8.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc3656283d11540ab0ea01978378e73e10002145117055e03722417aeab30994", size = 263001, upload-time = "2026-02-17T16:12:43.627Z" }, - { url = "https://files.pythonhosted.org/packages/b9/eb/7697f60fbe7042ab4e88f4ee6af496b7f222fffb0a4e3593ef1f29f81652/librt-0.8.1-cp314-cp314t-win32.whl", hash = "sha256:738f08021b3142c2918c03692608baed43bc51144c29e35807682f8070ee2a3a", size = 51328, upload-time = "2026-02-17T16:12:45.148Z" }, - { url = "https://files.pythonhosted.org/packages/7c/72/34bf2eb7a15414a23e5e70ecb9440c1d3179f393d9349338a91e2781c0fb/librt-0.8.1-cp314-cp314t-win_amd64.whl", hash = "sha256:89815a22daf9c51884fb5dbe4f1ef65ee6a146e0b6a8df05f753e2e4a9359bf4", size = 58722, upload-time = "2026-02-17T16:12:46.85Z" }, - { url = "https://files.pythonhosted.org/packages/b2/c8/d148e041732d631fc76036f8b30fae4e77b027a1e95b7a84bb522481a940/librt-0.8.1-cp314-cp314t-win_arm64.whl", hash = "sha256:bf512a71a23504ed08103a13c941f763db13fb11177beb3d9244c98c29fb4a61", size = 48755, upload-time = "2026-02-17T16:12:47.943Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0e/b04fd2d76b6a78a02286938251b2c119fb36ddece92c76cb4886ef7d44b8/librt-0.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fe4372c52d4849096c6cc1cda2817d293ec51440c890474ed59ef38d46556f18", size = 148058, upload-time = "2026-09-29T00:44:40.903Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fc/e1ed24aadb32d38603c0c07f579d739eb4d90e64e90d525b024e4a999b4d/librt-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c72c5295a84bd249526da9bdca38f2e176d15c31c13bb0063c5053f4ca023421", size = 153073, upload-time = "2026-09-29T00:44:42.165Z" }, + { url = "https://files.pythonhosted.org/packages/be/38/133ab655409420e0c34a9a9836a7f4e5ae75fba758d7fe177099130d58ba/librt-0.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be56ba9c884143495b517f23fe794ae367d58cd89ea0fdd6d437e3c024a87f9f", size = 493052, upload-time = "2026-09-29T00:44:44.043Z" }, + { url = "https://files.pythonhosted.org/packages/94/42/aaa663bc9421f5bf7bbbe9d3316d7219749698ec7688ac3b519770a89c04/librt-0.16.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:ef46c1a29ffb8c72e882e22618ec618778eacd0578fb22c6e7cf9c11d15f357b", size = 485506, upload-time = "2026-09-29T00:44:45.479Z" }, + { url = "https://files.pythonhosted.org/packages/7b/59/83a6eb5087ba8b45b083859e2085256963e06d4c2531944cdd962670bfb5/librt-0.16.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d3c94211ee0c4f8d649ec06b7c115c0ec4eadb873a0e3154ca15cef3f814b071", size = 498708, upload-time = "2026-09-29T00:44:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e4/15a8d62b2bc12935080ec7277e2e0b9b233047781eb784a51d3e25af669a/librt-0.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94aed6a8308818b91677957d1bd03188869cd7aeb23c5dba7912a6c0402f7602", size = 515981, upload-time = "2026-09-29T00:44:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/46/4f/287cc282ac5dd815204c0779e79401bb0a568c3a1335fb319bf0838fb566/librt-0.16.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:349c0bcb87ebd07481b6ff781e25cdc699723dbe2212e57dabb27f7a13b7b87d", size = 508670, upload-time = "2026-09-29T00:44:49.726Z" }, + { url = "https://files.pythonhosted.org/packages/bf/5b/ab7292add898ade0d2b5b75d32a923aae315861671aa5c39f5491309f7ae/librt-0.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:001bfd59a7d45b17e3e75f2a8c6405280b35e7b84471792778e718c4f368950e", size = 530393, upload-time = "2026-09-29T00:44:51.356Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9e/8e6bcf027d4bcbc16a4e864b3d158a1d3e5f55ffa53af0238020cad89271/librt-0.16.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:28e038895b998d7a0c7798922ce8a1dc157675df5cf1c9ef0aca809ed804b7a1", size = 534302, upload-time = "2026-09-29T00:44:52.893Z" }, + { url = "https://files.pythonhosted.org/packages/96/a4/8c5ab4f3b3a8e905ff8305d76976a2e666f52fe049edd398aed2402beb36/librt-0.16.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0dbe4096a7ecc00fa835d24510ad8545a4efef738dac96e0e63516783ccde905", size = 536150, upload-time = "2026-09-29T00:44:54.421Z" }, + { url = "https://files.pythonhosted.org/packages/ea/5e/7c4bc267e3cd4b8bd288de9f62d61fff203829c9cc649ea2aa12e9218cf0/librt-0.16.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5cd5b092441053364af968ea12084692cb9d4a22f3ce9524e377880bf028761e", size = 514316, upload-time = "2026-09-29T00:44:55.998Z" }, + { url = "https://files.pythonhosted.org/packages/e0/75/c8bc6b50f43c73819334233f5a3259c81216742cef56d2140c3dd377c3f0/librt-0.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ddeb3c9dedb461bb457c6c7d9aa7fbf35329da313d1a7543d00c8d0f3473c96", size = 557731, upload-time = "2026-09-29T00:44:57.581Z" }, + { url = "https://files.pythonhosted.org/packages/93/fb/e241f91bc8de6c7ac1c6a20ea6dd381bc52312b44d711ffcd97140db1e57/librt-0.16.0-cp311-cp311-win32.whl", hash = "sha256:e05108e0849966f53a8d2d3112a7af881d0efaa479bc735bba91108f9f2350a7", size = 104922, upload-time = "2026-09-29T00:44:59.078Z" }, + { url = "https://files.pythonhosted.org/packages/d1/38/c892383d2bb1a6a80b2ec8ede84970a265a792c56614a06282bf3008517c/librt-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:5f49cff01bd608ef7d97104cb035c75455e79c2d70bf4a506cf773338ac1860d", size = 125093, upload-time = "2026-09-29T00:49:01.621Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/8bbde1ed0b21480163617648f638fdaec9374cf5e9c846ebcee34ec02a42/librt-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:1d28ae980ae2218f9c5b95d191e947296f918c9bf0b400d467a9430275bbe678", size = 115910, upload-time = "2026-09-29T00:52:40.131Z" }, + { url = "https://files.pythonhosted.org/packages/ad/76/bbdaeb87b7c47b5c7343e90222b9bfa4e4a8a83f647e02933ad0129225b1/librt-0.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe52bf4641069e7978a14253b036cb9002def1926317e710f2e249f8a8c47742", size = 151028, upload-time = "2026-09-29T00:52:41.508Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0c/ab8ed3dab0085931aec4a792c7eaac8dc6c5ff4691fda3a5360d9d8a9cd2/librt-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5bcc2c4726ced915b00de0c9856a4eeabfb3fddb93e10e0b8f735b7709358b6d", size = 155283, upload-time = "2026-09-29T00:52:42.873Z" }, + { url = "https://files.pythonhosted.org/packages/eb/36/494e79d460c80c1f030661e8287c9eca5e1ad652dc2b2180b6cd42abce0a/librt-0.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff7baa55f8e7c69851419e50a666015d02a74198716fd45c0125a2112e0a389f", size = 503185, upload-time = "2026-09-29T00:52:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/9b/34/a8464038dd9db6e4381fa2b6eb73dc9a50888d77102c4c139304ac35cddc/librt-0.16.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b95d5d92ab83d39e760a52091bb1baba664f3a2351e39b1e16801e5747c2f0e9", size = 496738, upload-time = "2026-09-29T00:52:46.441Z" }, + { url = "https://files.pythonhosted.org/packages/6a/53/e0e5e334ef0c6ed27039d323819368b9ef6712be87d55ee2bf9799398afd/librt-0.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6d085d70bce51d43c5c7c36d63490770180d8779e71c49305c87b4213918de7", size = 513818, upload-time = "2026-09-29T00:52:48.068Z" }, + { url = "https://files.pythonhosted.org/packages/ad/f7/7ce72cbf19d0addd05090b339152fd0548a02562c2866a603e6e3b3da2df/librt-0.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36e53948e99bbe3ffea257124cfcae1cfb01831555c9a9c903c9f9a72db7fd07", size = 531952, upload-time = "2026-09-29T00:52:49.816Z" }, + { url = "https://files.pythonhosted.org/packages/83/22/0b1bcb6a8e723c8b4fd60dfc8ae8ec6461c54073fbc8685efeb8d900d407/librt-0.16.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:54d11f726aae9df5a6ffbbf0a03a52449bbac84a53ef03669cb41cdfd4ae41bf", size = 524465, upload-time = "2026-09-29T00:52:51.354Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/e9c23b8b9df1813da1be205deca9606beb7ddd033972246cd426d05374a0/librt-0.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4323193ac0cd025f85af531df8ba91bf24d1973b401697347a6282e8fd3fcf5e", size = 543191, upload-time = "2026-09-29T00:52:53.284Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e5/6a8b21b342c03ed7e230fa3afbfd2edc58e6e87ef1f0d11fa2b9a748c252/librt-0.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e42f8e098b9c5396fefa05fb1cc7e33b0e08fc51da106b5de4a45fd22aac6743", size = 546979, upload-time = "2026-09-29T00:52:54.932Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/b5129023eced1be01e01c22757f53be551d463b1bb7264f787927404c1d6/librt-0.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:39ec1d5a14e37baf1450a6cabf03fe552340808bf1ad9d71824ab90117716459", size = 555317, upload-time = "2026-09-29T00:52:56.869Z" }, + { url = "https://files.pythonhosted.org/packages/71/89/28bba5938c725fe91f06bf93f7fa6c6b150229df53a87b454b0d5c2a796e/librt-0.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d1aabe3925cbb4a08d15b7b20ba4011b53019da0c4173a25155139b7b1baed65", size = 535846, upload-time = "2026-09-29T00:52:58.475Z" }, + { url = "https://files.pythonhosted.org/packages/22/92/63773026614f888c5d4e370e395ce42ca604b89f70b3acdfedbf94851b80/librt-0.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:300c3ffdc459f4a779a8411ecb188e3ac0b1ff3a3a7b099642555dedae06c69b", size = 573700, upload-time = "2026-09-29T00:53:00.127Z" }, + { url = "https://files.pythonhosted.org/packages/66/8f/347d4677eefb57cd9f8e01d95a1dcee9a91b4e44e664173c32ff6f3752e5/librt-0.16.0-cp312-cp312-win32.whl", hash = "sha256:c17194318e4c0c0348b36f36c2ec7534436fe0a4c15582403162a4f08c80797a", size = 106158, upload-time = "2026-09-29T00:53:02.031Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2c/5193dc81127cd5ddfad031391b046bf32dda219b38463ab872407ca30646/librt-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:25a58a19ea8d83b68209f04912df765e9260635ef77646542ed4b4abe6bc7940", size = 126176, upload-time = "2026-09-29T00:53:03.445Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3d/9668a400c8dd81d162eba38b33fa49fa6205f1a64493570a13fbb815c3ee/librt-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7be7cf555bc30ec12622e9447299cc4a9b8ff307548b634794353db0c2065dc", size = 116572, upload-time = "2026-09-29T00:53:04.815Z" }, + { url = "https://files.pythonhosted.org/packages/46/cd/ae5e0e9dba45d1399aa04a5395bcc0bead40d9fa06dc903634a7b4d7473d/librt-0.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c5e6144e68b577f157519f2ba88ca20e3ed61c29b00e5cdfa76cd2d45acf059a", size = 151036, upload-time = "2026-09-29T00:53:06.284Z" }, + { url = "https://files.pythonhosted.org/packages/41/5a/48a16e323c5f9447a94cce7b59babf60fa04e62c3365ecf060c77ed8b320/librt-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:33f41443a1f4e1f099331b3d8120e409fbff84b9760bc1cc9ea496f37ddaa5cc", size = 155211, upload-time = "2026-09-29T00:53:07.72Z" }, + { url = "https://files.pythonhosted.org/packages/3f/29/0f59299eb4251a409b2e690ad4b7d9f8a676db829d7817ec961f32b44f7e/librt-0.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e510b7770bee609617a3374a96548eb114cae048023e3f049ee449e7ff2db32", size = 502587, upload-time = "2026-09-29T00:53:09.191Z" }, + { url = "https://files.pythonhosted.org/packages/de/ba/d6fb4ef8d1537c396079d72289f16be7cd35a366e5065c51253fea2760b6/librt-0.16.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:efc49c462d4516b8a58b00b490078fa64689fd1fe66970cc190131d7afb8027e", size = 496146, upload-time = "2026-09-29T00:53:11.016Z" }, + { url = "https://files.pythonhosted.org/packages/52/fc/8c50dd4d7cc97c0ee8f252c8a3104980f234391cf1519b554e8b9de08b60/librt-0.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:92caf82ebef5e12d21c72242b70d1e92536f1711cf2a727a4c276de4b4469087", size = 513336, upload-time = "2026-09-29T00:53:12.655Z" }, + { url = "https://files.pythonhosted.org/packages/a9/59/16c409c56f708eda2db9a0553662845d45e3871c77d70a240dae3f3bdc56/librt-0.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17bac7f7a16b328fff77e440287693eb017abde913595b5827ebccbc21ecd8a6", size = 531689, upload-time = "2026-09-29T00:53:14.39Z" }, + { url = "https://files.pythonhosted.org/packages/88/82/d34772a6c29d1446dcca6e64d74062efd508523ab351aa16625a4689d5cc/librt-0.16.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5b976054553670829985ed767feb78fb6bcede0175327c4844dd5c281c1be659", size = 524537, upload-time = "2026-09-29T00:53:16.064Z" }, + { url = "https://files.pythonhosted.org/packages/77/8f/24c5631313746131ccee53bc91fdc8374f9cf25e0082a1fee9c93bb98acc/librt-0.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0058f9d68721094105917254c72ac0569117bb7b13b9769cf45d26d89f9d21cd", size = 543231, upload-time = "2026-09-29T00:53:17.939Z" }, + { url = "https://files.pythonhosted.org/packages/f2/cb/5f8e0d41dbd8b499c2265e939c31acc9ba59845565bf99539ad1c06aebcf/librt-0.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:30b7beaf3f4487b7d8adef1f158b49067cb4d5a19fa7a3bf31a4e7a820e435c5", size = 546499, upload-time = "2026-09-29T00:53:19.666Z" }, + { url = "https://files.pythonhosted.org/packages/be/61/063052de441d1385f59cea4223f184bf9e5d125de1ae3239b490aa1e486e/librt-0.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:468df902df016a06eb0e40b0747dc8d14e47d7a38b18b63b1fb167d85cb94d63", size = 555261, upload-time = "2026-09-29T00:53:21.292Z" }, + { url = "https://files.pythonhosted.org/packages/14/11/a2ada0529372268d6401afa9d457a095b68cd7753532b6f7f33049a19b43/librt-0.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:aea7b1f2b125dad5de85f049136651bff256c883c65e6b9209b2da0a1ac3cdef", size = 536029, upload-time = "2026-09-29T00:53:23.07Z" }, + { url = "https://files.pythonhosted.org/packages/23/9d/5bb6d38853382986dca702fc7e06c8256d30f5fa0676d882773b744610dc/librt-0.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a8afb6557920860b7a3a596eb804cf37e09e7cf8a803db2478c202acc72d8c2e", size = 573748, upload-time = "2026-09-29T00:53:24.696Z" }, + { url = "https://files.pythonhosted.org/packages/99/f6/0025cde35ff7f607684dc775a2b2d732cce2561cec050a6ee1fb2e1fc6fe/librt-0.16.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:77c7a2b4fe2c1369e0d5aa1cade26740a7b14be32fbc9a5535d617d20065c39d", size = 79861, upload-time = "2026-09-29T00:53:26.089Z" }, + { url = "https://files.pythonhosted.org/packages/93/93/303b8592909bd583f83f02818ffbea3f7647ca1e22b1cd5465d04b8145fe/librt-0.16.0-cp313-cp313-win32.whl", hash = "sha256:02d89c813d5ff74b17df72d3a34819d132cd168e56b81bf755b809bd9e46b8c4", size = 106236, upload-time = "2026-09-29T00:53:27.43Z" }, + { url = "https://files.pythonhosted.org/packages/cf/24/80bbb463c60ed18e29cb26aba386ddb76609580e4e7160710e550587018c/librt-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:14ed6ebe3e4f85f326d7920011ad30ff49ed9334e62cf88caef9ba973d9e3a92", size = 126180, upload-time = "2026-09-29T00:53:28.7Z" }, + { url = "https://files.pythonhosted.org/packages/43/80/b1a6fbdd7da825cdd55c71aa81eb6cfa82c513c360774152eacb50b4a771/librt-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:83d4041a3d9b2fd053a8a4e1f22878b3e5833e2712956382d5c048d791454e91", size = 116557, upload-time = "2026-09-29T00:53:30.012Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/9e0cf7da129a93c3dc7f45bc3cd4a660f2aaa995aa8a6f95c2583ef41239/librt-0.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:931a0bb0fcac88f263e269e46eb30ba8e21402cd3c62ca40cb97034c0693fab1", size = 149844, upload-time = "2026-09-29T00:53:31.391Z" }, + { url = "https://files.pythonhosted.org/packages/8f/26/8a90d2a8f2b2e471bb486b7aec117b8ae622715ed6c39853aec48ea20073/librt-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1bc17e54e5305f8d40b7ca203671ff5a9e59c1d0f8ea0f625dcca53a3984de11", size = 154111, upload-time = "2026-09-29T00:53:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/35/ce/67abb46258da4d3e42ff5b141db6f38c59357bef84c7979f183b22f924f1/librt-0.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:877698bf6bca5721d8be345f2fe09778e40ecadea8b58c73075f2b1a53666bf2", size = 494234, upload-time = "2026-09-29T00:53:34.466Z" }, + { url = "https://files.pythonhosted.org/packages/12/f9/ea7162414a16f8f1bbd3b493ad6d22b926c5471916e078350bdbca8c4e5f/librt-0.16.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5981c011b306781ce561e18e14230a14524a3d8109b97553666c942c18f31a96", size = 491173, upload-time = "2026-09-29T00:53:36.124Z" }, + { url = "https://files.pythonhosted.org/packages/b1/09/9b3e869060dd33f9989b80ba4fea306f6db8cecefcdfe6d7346ef0603f65/librt-0.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:afced3dfc17cd805ecf7a3d77996a71cf5f2c75aa66eb0c21a9930f4fc992f86", size = 505547, upload-time = "2026-09-29T00:53:37.686Z" }, + { url = "https://files.pythonhosted.org/packages/50/07/79007d2165f649ea93e08c0962d1d62c70af9cde77965255095bf9d96f9a/librt-0.16.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca8052401c55d7511dda6760719fda7618067e83535d7d0010096d216c34b667", size = 523057, upload-time = "2026-09-29T00:53:39.301Z" }, + { url = "https://files.pythonhosted.org/packages/61/0c/8fbaff66d0ba376d8864653f5acce1569bae27e89648671f26f7eca67ab8/librt-0.16.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1e511762a074005bb0aa569166779834e75e438370226930d0ce1866d4b6a33b", size = 515158, upload-time = "2026-09-29T00:53:41.012Z" }, + { url = "https://files.pythonhosted.org/packages/df/2e/23ff0dece76f07a4124413a57682efa0bbeb5765ac0122bc0955513f82ca/librt-0.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1e8591bd8a5a628cd7f07954c6a1592359a878bf032957a8e9057a41d644311", size = 534183, upload-time = "2026-09-29T00:53:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/26/c4/e11dea21d9a29486eba78887380374189d472734fa32cc50cb37ca44d3d0/librt-0.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4aaefb4ba6c07e1aeebb2795c8958148f1d6f9af3b555b53d23d766edb6d67a", size = 540663, upload-time = "2026-09-29T00:53:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/75/e873ae158a8b7f5359be33e7fd6c1fbe02d9a78a3e89a77de6b0e837f476/librt-0.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:d92db7a0f6aee44f1baee94750457e8d2d1c6ccea41842de6268d34e8dc7eddd", size = 545908, upload-time = "2026-09-29T00:53:45.812Z" }, + { url = "https://files.pythonhosted.org/packages/ba/36/8939d3f6a93e11bd9592e6fe28d2b44f1c2dc4bed6e22e72359a91e18ffb/librt-0.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:378dfaffb38e59c24a87cde5713cd865d51ff7383fa12947f3907f306ea1ca55", size = 523302, upload-time = "2026-09-29T00:53:47.596Z" }, + { url = "https://files.pythonhosted.org/packages/71/14/35309f44a077f0f42ade0e2e7cd88c0cea760c661af205c01ea90d3c0e1f/librt-0.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3e0c39bdc85370422e8b637be76eb1fd07d30967551b03e62267dd156f553152", size = 565911, upload-time = "2026-09-29T00:53:49.278Z" }, + { url = "https://files.pythonhosted.org/packages/78/0c/df6255b94967f3159ebc46f08d8e783c12da6ee269ddb74b2efed63c640c/librt-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:1b384b90ab79a7bc30b566895809a636e0666f21f3cf12b54823d025b7e83839", size = 79119, upload-time = "2026-09-29T00:53:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/6b/44/d30d5a5461378c9d33f36736c6791c3b4c4ba4b1ffe0da7350aedcb2c9a0/librt-0.16.0-cp314-cp314-win32.whl", hash = "sha256:52327da75a94012e7f932f913d20d3876bed3c102be00e6c3e8600ff7bdd58a7", size = 100140, upload-time = "2026-09-29T00:53:52.205Z" }, + { url = "https://files.pythonhosted.org/packages/c2/98/769712f356a1e897df3581bb0c3100375d054a000de26099360ea65b5111/librt-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:3f0b8114c44b2ac06ff5dacd08e07e8e807ff4f46083f2a1602685122559be41", size = 120464, upload-time = "2026-09-29T00:53:53.495Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d3/ae2abccc8bdc8b063c1613a77686e17b74e9d3d60cfe6f12c63fa2821b9f/librt-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:8caf96a4ef8fb27d0ac0d1ad8337d26a240acd4a02fe4345d0a8f264753e8f99", size = 110889, upload-time = "2026-09-29T00:53:54.817Z" }, + { url = "https://files.pythonhosted.org/packages/e4/26/0737d4be058dd6376eade7dd8b380d4b869b6394cee929393a5a431c45bb/librt-0.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:953107e2f68d0f3512c48f898b0dbf0ce5cc52bba0f318d847c985dc555ee4cc", size = 159838, upload-time = "2026-09-29T00:53:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/01/96/9bc96531d7c620e9949af904470f02e3fa8f35129ab8e8f281c51eaa3788/librt-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad37d5b9abd49c9a655dcda7ea52a8a752884062ef1ee71ae17c2f2a0f81fe6a", size = 162018, upload-time = "2026-09-29T00:53:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fa/b0289dcb186eb3f97221ba00da5f4bd3ba7fa5e99752d48aa8d336615334/librt-0.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c4aa329c17bd1aaea4f6e89335d8ccd494b3a5830b6654462273e50e11023f0", size = 703983, upload-time = "2026-09-29T00:53:59.024Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ab/05ebbbde7530fc5eeb58fbd1581522a9f64f132fa703c4c595eed6e14760/librt-0.16.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0ead24d2562a49473dddd9efef8581f020007eb0054389c3ee3ffad38b1ca4c9", size = 683847, upload-time = "2026-09-29T00:54:00.671Z" }, + { url = "https://files.pythonhosted.org/packages/a3/75/f52aeecd4dbadbddf80725ba7de126d8bd5d0eb66247eae17a81ed90dd4d/librt-0.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02118f56a9c36ddd07dfd9b919d9ecc117ba20a90987d56aa4c429fa34509188", size = 698045, upload-time = "2026-09-29T00:54:02.247Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/fa277a835cd6eb42380591ceb85f48c5b4d2b2d7e2cb9869e1e17d24d237/librt-0.16.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4e29522c62e28595ff7e324c6834ade51127707f0e255b18d1c1cf03d39c1048", size = 724640, upload-time = "2026-09-29T00:54:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/25/e4/2cf64354f3fde8ebd591b3b48f96510bee24ac5f7d1e567adbbe210abdbd/librt-0.16.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ff4b2367926b69c6215635902cccb04048e73094e9862900d27cb2c6bbff143", size = 731748, upload-time = "2026-09-29T00:54:05.741Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c9/c180af3e94e01aa529fa93d7733fec2abc47f222345400cf21d5481d5f8a/librt-0.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c6f1b27bf1632a7e016af9f145f82be95e1edd7721a646505c21059257cb5a04", size = 754960, upload-time = "2026-09-29T00:54:07.38Z" }, + { url = "https://files.pythonhosted.org/packages/95/d6/01073aa78c58f356b10d9c57b3fe9abb143df338142bcd316df417b89db0/librt-0.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5696d7f52e7b37217cb3a8f92c744fe835942602fdd4c1a8bc4741d3bfdce15e", size = 747000, upload-time = "2026-09-29T00:54:09.06Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d8/1de3783908658d697a8cfc00582f61299ffba7796d7260c112e4700b1109/librt-0.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:6072e92dd876ff6ceeb6cf371e35e51f479349837391341f479b08df4564242b", size = 749569, upload-time = "2026-09-29T00:54:10.702Z" }, + { url = "https://files.pythonhosted.org/packages/b7/32/e817f66c96d6caa8bb8435ff93c4c220624d59efc506be59ab98fcd01d0c/librt-0.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:39ca4f2f2fe05de8e63493da592d84311adabe5bef52b193851981da9816b302", size = 729483, upload-time = "2026-09-29T00:54:12.25Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c9/23992ccd2b9d22798fdd0f61353183a47414e651da782ad83eb680f50833/librt-0.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9807485a908f00355820f18e91e045ffdcdc5adb68aaec40a1e2b88c5f7bba1", size = 776584, upload-time = "2026-09-29T00:54:13.837Z" }, + { url = "https://files.pythonhosted.org/packages/67/3b/e8af957f08e6e2e8e566b099e43d2748418aa565df6ee1d9d3331209fdfe/librt-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:94be5cb7bca4df6201f4183e9e4fa2086c655283d20b38cd84500a69057575a7", size = 104402, upload-time = "2026-09-29T00:54:15.568Z" }, + { url = "https://files.pythonhosted.org/packages/ca/1c/946e6443d7cd32347a086043395e421e52fd603c9163d2ec970ceab8eed6/librt-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d46ca272b251d033dd4527b0dec5f261a28a52bd5fa0f99c117b0a1f8588cc2d", size = 126227, upload-time = "2026-09-29T00:54:17.165Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a3/bc4f9959d3c62bcbf9e5fd3470a8bbd8bf33224ed4c25d7fba173201b8ac/librt-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b9d6d4b14e92d876f8026b54c20c445f36425214c1081dc76f74e40db386b82b", size = 116493, upload-time = "2026-09-29T00:54:18.567Z" }, + { url = "https://files.pythonhosted.org/packages/b6/4b/10fdb42dfab4c1533e1570e686b18e86ff4328b406361b39fb3016667638/librt-0.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:6fe436af2eaf630474f491af5d032cbe45f93fcff5c3b9fe4ab194a7255b20ff", size = 149829, upload-time = "2026-09-29T00:54:19.933Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/a90ca13f1d3d91af1680000a4038536907018fbd51764767287a05d28b8b/librt-0.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:8ff5d26c529336be9bd7ae04483235d77778ee7d6444a95353102b542601ce81", size = 154522, upload-time = "2026-09-29T00:54:21.306Z" }, + { url = "https://files.pythonhosted.org/packages/5c/dd/bcf364eacfa070bb1fc88d503111ae7177914197ba1fa717c748926e7930/librt-0.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:909d8e3c1faee44cb762b1c519ff8613dcc5ceae5c99987a00917b5a31fd1d6a", size = 497593, upload-time = "2026-09-29T00:54:22.798Z" }, + { url = "https://files.pythonhosted.org/packages/18/c1/2c4e81e347bdabfe8346bfc6dc37ae5e154d61c88e30848ec0606025a5e0/librt-0.16.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:6d4a64283ee61824b5790de882bc68e2d9d7a5143537cb7a966f7354f71646d4", size = 480459, upload-time = "2026-09-29T00:54:24.364Z" }, + { url = "https://files.pythonhosted.org/packages/ab/d7/fef2a3cb8400701be496f6e459876f650b3451f407e30cb243de571ae615/librt-0.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5810ba811297fdf37a1531a57667cb8ace0842013ca8606bf9eb7c24cf4be154", size = 507814, upload-time = "2026-09-29T00:54:25.997Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6f/53762927a32e9dc9eb1d1c1f3528da281290c86d96929a8af652f671266e/librt-0.16.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e56aaf8c167548dc8e5d6f3bd0f48dcdd299a23c73be3f744aab79d99e9c7f5d", size = 525114, upload-time = "2026-09-29T00:54:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/6c/67/0b9d031f303c4e8c691a9a8ef9d272f13b530c11cc563b819df621b6a348/librt-0.16.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8f36c58e33b304b525c6c9c5076399c6ebf1109e17b9051a05a407b091b9215b", size = 520465, upload-time = "2026-09-29T00:54:29.331Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/2056a3a85864e882eb17a203a10ddb26fa748bc9718ec67e79059ab46cae/librt-0.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:242e00b3d4fa37c3d3c1ca5f5c9adb7d909ddb1eac9c41f2787320d00caa0af2", size = 537257, upload-time = "2026-09-29T00:54:30.915Z" }, + { url = "https://files.pythonhosted.org/packages/54/57/e0d79790c163cbc0909e209a6f62e30bb713b647f905a176cdc64848fd4d/librt-0.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:0253721561787b8df8443eb347b7a6461015354e5bdd37ee38a41fef220d2bb0", size = 527442, upload-time = "2026-09-29T00:54:32.478Z" }, + { url = "https://files.pythonhosted.org/packages/aa/50/1c0c95aba7af51f4752ea34fbf2eb79b36e7cae3a72536248e8c735de735/librt-0.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3e483a8d69ede8067db70c0e83007423b6925de6fd53afed01d66160f2e9398c", size = 548139, upload-time = "2026-09-29T00:54:34.183Z" }, + { url = "https://files.pythonhosted.org/packages/98/91/a8a43dd5138d4f55f88846b8f0c85454a4fad69952cebfcff9948f831290/librt-0.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:69ba927445cfaaffb4081003ef5224c55a5c2ab67ef956f416ef744916e44121", size = 529708, upload-time = "2026-09-29T00:54:35.761Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/d5226881ab2b7c20d9d587b37bdd4a0ec8775a96d00ca87ac9f385587db4/librt-0.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d6a365f2ab45a984d0e00eee0dd17f599ceab8cadab6ea07b6111c8132fc0e42", size = 567781, upload-time = "2026-09-29T00:54:37.409Z" }, + { url = "https://files.pythonhosted.org/packages/bb/bf/2345ba57a626e8c78c4ddcc724636a8df5a593fe46c1ee76bbf477e32b0d/librt-0.16.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:f01f3805f2dae4781c0c34b440e31740d082950bdaf89a6f601ad589a28af57a", size = 79177, upload-time = "2026-09-29T00:54:38.792Z" }, + { url = "https://files.pythonhosted.org/packages/1e/40/99e77936cc9207f629b077bf7cbc5e2f0827cddd7c29792f04ef881bd2c3/librt-0.16.0-cp315-cp315-win32.whl", hash = "sha256:b0e3e721c75d2e79a76d4422c79d7ba705fe1bbafec907037fe7a657a480a0e3", size = 100127, upload-time = "2026-09-29T00:54:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/56/1e/801fe26bc622061b9dfd010e166d94142cb774b733217e6d98d1c0cf2638/librt-0.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:bc02954b1295de798bbdb0b4e2d8a28c2117de8b5c73dcbeb27dc32572dfb971", size = 120480, upload-time = "2026-09-29T00:54:41.722Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a9/d533983055bd36e112627384c2c038845d1df882540b8bcefb566475640b/librt-0.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:c5db585d43449a5f54303d4b2774e45e1babd975cfe1630a3d708c0b80c3e560", size = 110915, upload-time = "2026-09-29T00:54:43.052Z" }, + { url = "https://files.pythonhosted.org/packages/55/fe/d62238fa9c653b0e0613290349467cb65711b5800e8e474f45e942a0ad95/librt-0.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f06c689cb14afd9b612727553a5ec5a40febf113ca41c4413a2b0b334285884b", size = 159714, upload-time = "2026-09-29T00:54:44.497Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ac/f31efe7818700be72ba4f9af8a80fa67c39808c8d26dacc55dc1f6f35172/librt-0.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:13b4e8aba90b0b1c82474e9844aa9ffe7ad3faa484350e1da64cb8188d903134", size = 162086, upload-time = "2026-09-29T00:54:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/d9/16/4d7487bf86a9d7e8e18f37ba5538789233ea693637379b75701bd35ec9de/librt-0.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a269c46ae327d8e6f8c1f85f7516cb52c0fa48127565a1105a4f4a05ff2a0b4", size = 712727, upload-time = "2026-09-29T00:54:47.486Z" }, + { url = "https://files.pythonhosted.org/packages/77/74/50cd550ccc1a517b9ed62347625c01ddf8c4afad66490312677c011458f6/librt-0.16.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a33e0dae1f8592146a4764d54ce842b278732d21a84e17c3bbe6b1bc158a2248", size = 681106, upload-time = "2026-09-29T00:54:49.126Z" }, + { url = "https://files.pythonhosted.org/packages/df/5d/7293f712975ee6fdd2251411fd9ef1c62bc99c7b83ecbe62dbc999b1fab7/librt-0.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47ada6ea32636492c61aa8ad27ae3b9404bfe7a97e3ba946d1984236cc741da0", size = 705921, upload-time = "2026-09-29T00:54:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/67/f7/8aab946f11d59d1bece9ffc65d994b200c789a8ca5a95c17e17e609f912a/librt-0.16.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43bd6e642d8a248c114327f98dd25ac5a7cb5aa168ef02f0559b91874df16b8", size = 731786, upload-time = "2026-09-29T00:54:52.584Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/1c42ab31e7cb8384ebf6d3af607213c495222474f4940443ae7639ab7685/librt-0.16.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c3d1bb7841a816ace6449bb26d3f9560dbfa20e71c568d23f0f62bf1e68f50b1", size = 744964, upload-time = "2026-09-29T00:54:54.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2e/4b19982d933d2dfced671e840b219e4c1cd3f507df6e6dabb51bbd4e3850/librt-0.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3931f7a3db322e7f44e02a280e3949326ce9579ad388ee8d691dc7c76da9fb70", size = 765305, upload-time = "2026-09-29T00:54:55.815Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1b/e872583de2dcb3ac7746e7a2321aeeb168274f3952a87dc66e05ddb29faf/librt-0.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:f4462528b6000afe8f16907b5c7c2553abf1df005ba5140e6eb394541c3624c3", size = 744959, upload-time = "2026-09-29T00:54:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/10/de/a18c6bcfb297af2674233e90b3c3661c3a0af0f1434a0c966d2ef708a835/librt-0.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:80039ba9b6a7d5f1a0175a4cca6bbefead87bd854c80abad1cb30afe47a830db", size = 758138, upload-time = "2026-09-29T00:54:59.484Z" }, + { url = "https://files.pythonhosted.org/packages/22/1c/0df1d732539c297bb1a093e1fe3204d2faf76a9022cf4e1d1c2fce059790/librt-0.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:7a1d272724b581bb6bc769dfdafed6da2ecc9886ba2450311de55a4ac2e1e9cd", size = 744268, upload-time = "2026-09-29T00:55:01.179Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f7/ccaf31331f20c91a5bd9bd48ffc3f743f9c81bb5720cc7b2a720ca204f0a/librt-0.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:fbe4fb8c5445f7496d7f7f6bb0807875d09d47e6771ffa175fb2df2895fb86ba", size = 785783, upload-time = "2026-09-29T00:55:02.938Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ea/7421d9e6db894cd6cd788b604b3394a163ded6b942052b6f96c23ccf08e1/librt-0.16.0-cp315-cp315t-win32.whl", hash = "sha256:375bfe6b572a8f6cfc398709356046173bf27e64c4c5edaf5f7062f051fb4bf9", size = 104355, upload-time = "2026-09-29T00:55:04.533Z" }, + { url = "https://files.pythonhosted.org/packages/85/6d/7c31a506eb847bc58aeb2402d58e17605e821f68ab5df5e66fe274a6df41/librt-0.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:bd3150023d3dc2bc70f3784e59ffa1140d56ddba3d8125b3d6f9f85221279bfc", size = 126134, upload-time = "2026-09-29T00:55:06.017Z" }, + { url = "https://files.pythonhosted.org/packages/36/69/7a5d10ac409c4da0355e054a14371871da9b5557fcc42772cd00181c6cce/librt-0.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:8ceafb70f2a4f0826f11031942e59c0728fd98da112dc346d4352bde1e486866", size = 116391, upload-time = "2026-09-29T00:55:07.484Z" }, ] [[package]] name = "mypy" -version = "1.19.1" +version = "2.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "ast-serialize" }, { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, { name = "mypy-extensions" }, { name = "pathspec" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/3c/78ecece71ee4b5445389a4ccd11627cfb9c69e4de554d11060171f376305/mypy-2.4.1.tar.gz", hash = "sha256:63b590965691e540a335fa74dadf31a7069142f6b72e234689bbd244edf55623", size = 4066728, upload-time = "2026-10-28T19:23:13.286Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/47/6b3ebabd5474d9cdc170d1342fbf9dddc1b0ec13ec90bf9004ee6f391c31/mypy-1.19.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d8dfc6ab58ca7dda47d9237349157500468e404b17213d44fc1cb77bce532288", size = 13028539, upload-time = "2025-12-15T05:03:44.129Z" }, - { url = "https://files.pythonhosted.org/packages/5c/a6/ac7c7a88a3c9c54334f53a941b765e6ec6c4ebd65d3fe8cdcfbe0d0fd7db/mypy-1.19.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e3f276d8493c3c97930e354b2595a44a21348b320d859fb4a2b9f66da9ed27ab", size = 12083163, upload-time = "2025-12-15T05:03:37.679Z" }, - { url = "https://files.pythonhosted.org/packages/67/af/3afa9cf880aa4a2c803798ac24f1d11ef72a0c8079689fac5cfd815e2830/mypy-1.19.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2abb24cf3f17864770d18d673c85235ba52456b36a06b6afc1e07c1fdcd3d0e6", size = 12687629, upload-time = "2025-12-15T05:02:31.526Z" }, - { url = "https://files.pythonhosted.org/packages/2d/46/20f8a7114a56484ab268b0ab372461cb3a8f7deed31ea96b83a4e4cfcfca/mypy-1.19.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a009ffa5a621762d0c926a078c2d639104becab69e79538a494bcccb62cc0331", size = 13436933, upload-time = "2025-12-15T05:03:15.606Z" }, - { url = "https://files.pythonhosted.org/packages/5b/f8/33b291ea85050a21f15da910002460f1f445f8007adb29230f0adea279cb/mypy-1.19.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f7cee03c9a2e2ee26ec07479f38ea9c884e301d42c6d43a19d20fb014e3ba925", size = 13661754, upload-time = "2025-12-15T05:02:26.731Z" }, - { url = "https://files.pythonhosted.org/packages/fd/a3/47cbd4e85bec4335a9cd80cf67dbc02be21b5d4c9c23ad6b95d6c5196bac/mypy-1.19.1-cp311-cp311-win_amd64.whl", hash = "sha256:4b84a7a18f41e167f7995200a1d07a4a6810e89d29859df936f1c3923d263042", size = 10055772, upload-time = "2025-12-15T05:03:26.179Z" }, - { url = "https://files.pythonhosted.org/packages/06/8a/19bfae96f6615aa8a0604915512e0289b1fad33d5909bf7244f02935d33a/mypy-1.19.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8174a03289288c1f6c46d55cef02379b478bfbc8e358e02047487cad44c6ca1", size = 13206053, upload-time = "2025-12-15T05:03:46.622Z" }, - { url = "https://files.pythonhosted.org/packages/a5/34/3e63879ab041602154ba2a9f99817bb0c85c4df19a23a1443c8986e4d565/mypy-1.19.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffcebe56eb09ff0c0885e750036a095e23793ba6c2e894e7e63f6d89ad51f22e", size = 12219134, upload-time = "2025-12-15T05:03:24.367Z" }, - { url = "https://files.pythonhosted.org/packages/89/cc/2db6f0e95366b630364e09845672dbee0cbf0bbe753a204b29a944967cd9/mypy-1.19.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b64d987153888790bcdb03a6473d321820597ab8dd9243b27a92153c4fa50fd2", size = 12731616, upload-time = "2025-12-15T05:02:44.725Z" }, - { url = "https://files.pythonhosted.org/packages/00/be/dd56c1fd4807bc1eba1cf18b2a850d0de7bacb55e158755eb79f77c41f8e/mypy-1.19.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c35d298c2c4bba75feb2195655dfea8124d855dfd7343bf8b8c055421eaf0cf8", size = 13620847, upload-time = "2025-12-15T05:03:39.633Z" }, - { url = "https://files.pythonhosted.org/packages/6d/42/332951aae42b79329f743bf1da088cd75d8d4d9acc18fbcbd84f26c1af4e/mypy-1.19.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:34c81968774648ab5ac09c29a375fdede03ba253f8f8287847bd480782f73a6a", size = 13834976, upload-time = "2025-12-15T05:03:08.786Z" }, - { url = "https://files.pythonhosted.org/packages/6f/63/e7493e5f90e1e085c562bb06e2eb32cae27c5057b9653348d38b47daaecc/mypy-1.19.1-cp312-cp312-win_amd64.whl", hash = "sha256:b10e7c2cd7870ba4ad9b2d8a6102eb5ffc1f16ca35e3de6bfa390c1113029d13", size = 10118104, upload-time = "2025-12-15T05:03:10.834Z" }, - { url = "https://files.pythonhosted.org/packages/de/9f/a6abae693f7a0c697dbb435aac52e958dc8da44e92e08ba88d2e42326176/mypy-1.19.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e3157c7594ff2ef1634ee058aafc56a82db665c9438fd41b390f3bde1ab12250", size = 13201927, upload-time = "2025-12-15T05:02:29.138Z" }, - { url = "https://files.pythonhosted.org/packages/9a/a4/45c35ccf6e1c65afc23a069f50e2c66f46bd3798cbe0d680c12d12935caa/mypy-1.19.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdb12f69bcc02700c2b47e070238f42cb87f18c0bc1fc4cdb4fb2bc5fd7a3b8b", size = 12206730, upload-time = "2025-12-15T05:03:01.325Z" }, - { url = "https://files.pythonhosted.org/packages/05/bb/cdcf89678e26b187650512620eec8368fded4cfd99cfcb431e4cdfd19dec/mypy-1.19.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f859fb09d9583a985be9a493d5cfc5515b56b08f7447759a0c5deaf68d80506e", size = 12724581, upload-time = "2025-12-15T05:03:20.087Z" }, - { url = "https://files.pythonhosted.org/packages/d1/32/dd260d52babf67bad8e6770f8e1102021877ce0edea106e72df5626bb0ec/mypy-1.19.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9a6538e0415310aad77cb94004ca6482330fece18036b5f360b62c45814c4ef", size = 13616252, upload-time = "2025-12-15T05:02:49.036Z" }, - { url = "https://files.pythonhosted.org/packages/71/d0/5e60a9d2e3bd48432ae2b454b7ef2b62a960ab51292b1eda2a95edd78198/mypy-1.19.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:da4869fc5e7f62a88f3fe0b5c919d1d9f7ea3cef92d3689de2823fd27e40aa75", size = 13840848, upload-time = "2025-12-15T05:02:55.95Z" }, - { url = "https://files.pythonhosted.org/packages/98/76/d32051fa65ecf6cc8c6610956473abdc9b4c43301107476ac03559507843/mypy-1.19.1-cp313-cp313-win_amd64.whl", hash = "sha256:016f2246209095e8eda7538944daa1d60e1e8134d98983b9fc1e92c1fc0cb8dd", size = 10135510, upload-time = "2025-12-15T05:02:58.438Z" }, - { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" }, - { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" }, - { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" }, - { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" }, - { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" }, - { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" }, - { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8b/2bc7f489528db504221ad7eff6b3f83979ee57d066103c72a85d09046a30/mypy-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:79a1e79199e980fb41f219cb3d4746d25c64b0b623840d3ed57df1cdc13a6502", size = 14321495, upload-time = "2026-10-28T19:21:16.612Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/b2f037b4982dce33645296e4394b031ade60f697f468761fa3ea8e2f8ece/mypy-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e18d0da3898b3bcd16192f15a206e7b8b8dd0f4a0b3e51aa5bd5c2afe749e2c", size = 14467468, upload-time = "2026-10-28T19:22:10.629Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5a/379f9bfa18bf3f8d43668fbd9ae4f2922dd027a559c461ca9d41cde1d32e/mypy-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b69a15fc2e75858d6b15e91ed3a0dcff1a533265183b64734138791fe0f49aa5", size = 15421496, upload-time = "2026-10-28T19:22:48.005Z" }, + { url = "https://files.pythonhosted.org/packages/83/50/3bde18a2824ec296432cebe01752ccd0ab8a2ad784abe4390040d019b3bf/mypy-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:70971cc0bcb1d3f03d2eb68fa430a6481ccc03558dc001d9534d7e5fa274c392", size = 15670425, upload-time = "2026-10-28T19:21:57.026Z" }, + { url = "https://files.pythonhosted.org/packages/6a/36/8b722b88c325d317354de7d10d8fb9d4dc0f958433e873a91fc4ed21a06e/mypy-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:6f7225951a277dd0d6add900731d487174b7d24ac133c09d670ed63b4d8cb90d", size = 11300972, upload-time = "2026-10-28T19:21:48.724Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d6/fb2bab1245658d68af8abfe776362a780c621fe0f364f2c7b53039a945ee/mypy-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:be4c03f33c55500191df2ed4a9b5e7edbdd1fff067fe361a5a9b1b5d3262da6e", size = 10873349, upload-time = "2026-10-28T19:21:32.104Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1a/0be9dc6af5e0e04128f18a5e36b4ca44bfb0085857d37aa6a7de1ac2b0cb/mypy-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d63737426a048a27705a4eedb828669f4bc0873612a1b46b0b9fe892b2ebaaaf", size = 14381321, upload-time = "2026-10-28T19:21:54.223Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a6/7907e36711a8a8c703f961f076fab61793383694140bd1fd87589f3f68d4/mypy-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7344869cad05f073b8cae2826774fa0161e3eb2f5c685b76813574008d77d750", size = 14466373, upload-time = "2026-10-28T19:22:25.211Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b8/7313212b29de570c25c9859d7c8e4ef2251a6d34338a1e20031d94297721/mypy-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a20ff6cd2af7a670c64f089bfa5fbcebe8ff3bf896c5e6ac7c9862c7960e4494", size = 15553666, upload-time = "2026-10-28T19:22:36.511Z" }, + { url = "https://files.pythonhosted.org/packages/23/8f/92966b6082ff49da9142e1e527eb9af4359a9a61632a1cfc313da96b37fe/mypy-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9ed1195502cca32be5ef756b1693477f4991db2f2e34eaa90cc4ad6bea4f9531", size = 15802641, upload-time = "2026-10-28T19:21:13.421Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b4/874f6fd54b005020ad63e2cf7a59b178d16a771d478849b29b842cb0cf14/mypy-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c194c5d878130fca1ae662dfb1feb6274afbab0b40032c80147377e0ea803d5", size = 11383067, upload-time = "2026-10-28T19:22:03.516Z" }, + { url = "https://files.pythonhosted.org/packages/b0/41/5ae8e6528c2faa96e4a921a999d2c7ac7c565bee184b4282bf62ffa76b5d/mypy-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:71eda06e5bae51976ce869fda429159c9cec678bd02f25bb197f0265c8f991be", size = 10946882, upload-time = "2026-10-28T19:21:39.51Z" }, + { url = "https://files.pythonhosted.org/packages/6a/65/cd19bc06b67d2df4828220245fd98569ba40fac00c60ba48bef1817d8ac3/mypy-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f1613bfe6726169a5680ec3dad5fe1f6d96285c12aded51ad432eadedd39d45", size = 14214179, upload-time = "2026-10-28T19:22:27.49Z" }, + { url = "https://files.pythonhosted.org/packages/c9/db/4d54ca4f49a0113d0c956980272aefdc6eec5458f7a72b350785b9ef2249/mypy-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:680ba5d9f0e3fe0c746b3d14df15f2a718e4bc308a1145616a1ea691ce7c354b", size = 14376217, upload-time = "2026-10-28T19:21:08.019Z" }, + { url = "https://files.pythonhosted.org/packages/a2/45/089b4724b85f0f408941be5298f817ee89181c1ce031a73d60ebb150c2c7/mypy-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb70621535c22fd4b1a0450d37ed1d6c5eb39656a1cebfb189084c12de54ba7", size = 15467623, upload-time = "2026-10-28T19:21:21.555Z" }, + { url = "https://files.pythonhosted.org/packages/27/4c/15edbc64b0b1412bfe94c74192b3b56554ab642b85a31bb06cef6313101f/mypy-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4af5ad558033bf71a44a1be149ed61633522824f84c1b6bc2445d3fe2d2a5296", size = 15729867, upload-time = "2026-10-28T19:21:37.557Z" }, + { url = "https://files.pythonhosted.org/packages/76/5b/7d160fb685994b65b0ca86d352f3afb5424f96a9e6914719f7b861fb6701/mypy-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:acdd82cb3a2eb10720e87706a128d75785d005a8c47e36a4973221524f41fc56", size = 11390802, upload-time = "2026-10-28T19:22:18.081Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ea/453d27f8d531f57c5f14aa73094eaa48e3fb77f680bdede2045cb64fa58b/mypy-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:133886ef1a7a8cf673df55d865e41580c6c46aa9b8e31e1325dfe315c038f745", size = 10950427, upload-time = "2026-10-28T19:22:59.003Z" }, + { url = "https://files.pythonhosted.org/packages/7d/75/282d43d6fea7be984ac63e75ffd8eee146ba2f3b077bb1ca5bf3f973e0c4/mypy-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c45485061ba08f700acc12cfc8b177e6997e6bc353605babfc0abb081e079456", size = 14233251, upload-time = "2026-10-28T19:22:44.977Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a8/9021263cc7e761451c7d8131bdfab3c0a5c2d67aa2d694670019e1ab86a7/mypy-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727890a32f1858c09549eb55a8b234fe990d460450b28f03e8213ef925f1247c", size = 14394953, upload-time = "2026-10-28T19:21:29.492Z" }, + { url = "https://files.pythonhosted.org/packages/16/10/4192a5cea09ebbc41c534f57bd0d8f0fb42a8e810632cda6e37f072c59fd/mypy-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:beb254fec368c4e7f7f82a5f310c6470b893ec88a90b66426da971c6826b0453", size = 15442824, upload-time = "2026-10-28T19:22:42.068Z" }, + { url = "https://files.pythonhosted.org/packages/99/e6/d3b0a7474aa4f696594a47a218b6796d9c4346fc81ed288904278cddd9bd/mypy-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ec416d5d2ae689e681f5727e328723f18d8b5dc8c903a146b7851dc5727aad8a", size = 15717227, upload-time = "2026-10-28T19:22:54.026Z" }, + { url = "https://files.pythonhosted.org/packages/48/6a/2ec530dacd4f77ca50d0fa05b854098f2d75e5d18c587d2612b44f10d68c/mypy-2.4.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:0e95ad0bec03ced9a73b42514208abd24c789e67f0e1eba476e276dd7a2dea3a", size = 7898637, upload-time = "2026-10-28T19:21:41.709Z" }, + { url = "https://files.pythonhosted.org/packages/cc/56/de9d7bad12e3868d5f1f4279aed20b1b568b2c5e166f2d3a05b211dca0b1/mypy-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:51f742d4154824837ca6e92aa81f00eec222700a3c337bd258e5562a3880d75a", size = 11576656, upload-time = "2026-10-28T19:22:13.232Z" }, + { url = "https://files.pythonhosted.org/packages/b8/12/4fa9883b9b59e5c96ff62845ad019dc47786031c45d67eaccf452cffffd8/mypy-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:f44dd4c5ab22df21206dd926c98381ebdbf5bfd696df37dd38ded2d23143fcb6", size = 11174403, upload-time = "2026-10-28T19:23:01.346Z" }, + { url = "https://files.pythonhosted.org/packages/3f/f2/827e356fc4f74c60b8da42663336e035b49d948a3c11224b0fc7543086b1/mypy-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2875280687e64740e6ddcef43bd4c5852ad45ff34549740f6aea3f0373870b93", size = 15713427, upload-time = "2026-10-28T19:21:26.757Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/e58a4fcae1d238189eac758036c0921992a86e3e6209190efd96d61fc5d4/mypy-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ea0714d2bccaf6d010c970e1d3ba2c9c2add79d2030aad2ef03167d788948276", size = 15938481, upload-time = "2026-10-28T19:22:34.371Z" }, + { url = "https://files.pythonhosted.org/packages/a1/54/a20f881801b88900923f2be1541a4b438ad0f0883e03836641fdc3d7adf4/mypy-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c6ff0e7ea546943001a91639c9f0c64b60d239268fa5d29e4a6c87f82c2373", size = 17243006, upload-time = "2026-10-28T19:22:39.425Z" }, + { url = "https://files.pythonhosted.org/packages/de/1c/ff84a6133a6e89c390bff6b25d9bad6598e7891b205f4b30b496906d636d/mypy-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a5b5da107dc2c93fb0a22f7a45dbaea5dc131afc7056b5468d78e819f9a138e6", size = 17557728, upload-time = "2026-10-28T19:21:43.607Z" }, + { url = "https://files.pythonhosted.org/packages/15/4a/effa47d39b8fadf679c08e7c78559e523f9769a42a75662d2d15b2b9cdd6/mypy-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c3a4d0c47053cc90035dd3a2c321112b593ad42935d0cbfd747288e1564fa8ca", size = 12370826, upload-time = "2026-10-28T19:22:29.779Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/b214ececb1a97fbb61ab3dfd48ae3cffd92ae2c148af4c9dc94c6c56772b/mypy-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0c5bf267645351887b72903fd2f5fbddcf85234e0e6c4ad94e2fcfb4f0c3f971", size = 11851083, upload-time = "2026-10-28T19:23:11.288Z" }, + { url = "https://files.pythonhosted.org/packages/57/5b/e44a2edb0b25a9f1429de770e1d0238af23302671dd40c77ac5efeb0c559/mypy-2.4.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:db599d03e7d60d15f2e0a11665c18bc52a88699fcab990fdf8cecd5be8ac801c", size = 14243144, upload-time = "2026-10-28T19:21:10.975Z" }, + { url = "https://files.pythonhosted.org/packages/59/d4/5c99dc3a28e11d2f0fcbb02df63d2d3e574dedc0f9f69d50901df305a7a6/mypy-2.4.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6c7210e40dd423af7d65cbe428b5906d11dc60659337bdae4e5fdf02ce32ed7", size = 14409316, upload-time = "2026-10-28T19:22:15.515Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c9/3108b38f4c30eabd80194f5d9771a87e27196c5e0ddb5bf4b99c6ed1e97e/mypy-2.4.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2d4a51db92059eecc2c33b2a5194b28585ebfd917292c015fe87a77dbff6cd2", size = 15445573, upload-time = "2026-10-28T19:22:05.635Z" }, + { url = "https://files.pythonhosted.org/packages/dd/12/84a53eceaf11c46dfd7931fb6b8902d01fb33787d3a991e81c461458150b/mypy-2.4.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:01b7718552d017f88d1151f3cc9d6556d778a90bd58060a2c3d87d070f9099fb", size = 15732989, upload-time = "2026-10-28T19:23:06.512Z" }, + { url = "https://files.pythonhosted.org/packages/65/ba/bf017dc2abdf83b2f74e29c43834b7af67dc1f1b20202f02dae60b4781a0/mypy-2.4.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:3467b1d13000812ab85dc2a3834b9379ec77798ca1bcabe434e23fb21fead692", size = 7898932, upload-time = "2026-10-28T19:21:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/76/05/0c22b1f0390120a8592d31209cb6b9f932b6a0b426fe643e550de15139e3/mypy-2.4.1-cp315-cp315-win_amd64.whl", hash = "sha256:080cf64a60b90a73435542feecf4171904cc5710658165b40c6869115d4aa100", size = 11577577, upload-time = "2026-10-28T19:22:01.302Z" }, + { url = "https://files.pythonhosted.org/packages/73/fb/ac01e173629697ddac2f11e51efd10347d673f9a7311b03f4aba710ebccd/mypy-2.4.1-cp315-cp315-win_arm64.whl", hash = "sha256:f9118a3f50de264b614861bb11814833a742138ac3c8e2e49a860b6977fb2704", size = 11173540, upload-time = "2026-10-28T19:21:46.444Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e4/b9b9c8eb09e70927ee65b1456cfed35710b6e4ff0b07f364ceaf2202307c/mypy-2.4.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9d7dafd56179d296651df9e1844b91c9517c379398f017a2a435d077a28943c1", size = 15706623, upload-time = "2026-10-28T19:22:20.528Z" }, + { url = "https://files.pythonhosted.org/packages/26/74/1ceb1ca884add0565e618d013dd24333039100dc0fcc42661561f2e1cae5/mypy-2.4.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d923cec43316f0e6736b8298fd00abeaaf348a091c20e7296b3aebceecb63eca", size = 15944095, upload-time = "2026-10-28T19:21:04.779Z" }, + { url = "https://files.pythonhosted.org/packages/2b/68/27bcf9b4efa22733b6050485ae37845b94c9b8851abe4fc60632d905c32d/mypy-2.4.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6e081b466e88d4343adffe11aff0f02df34b5b9070b4b700053a0b7294c0be1", size = 17223065, upload-time = "2026-10-28T19:23:03.724Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a3/ed5724b317bf585c29f3c8be2792e97d45925d65a9c8af40ceeb267072e6/mypy-2.4.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:70196470ac300f444a302a738541101893c2c57804078b33690286a7899149e9", size = 17560589, upload-time = "2026-10-28T19:21:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/42/2f/005185e6ab4752fd6cc2d1a6d1421fe21979770afe2490c00c555f34a913/mypy-2.4.1-cp315-cp315t-win_amd64.whl", hash = "sha256:de95648e0a6d46fa9929b956ed2c87c5dc9933d4d59945e6390e9d753c74e7c1", size = 12353324, upload-time = "2026-10-28T19:22:51.481Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d6/20420cc9c780087139662534d128c2f3274361f8bb7e9cf0d5495a846ed5/mypy-2.4.1-cp315-cp315t-win_arm64.whl", hash = "sha256:ef8d5be90032261197ac388d945d8ff4f476c95880798a1911760af64ddfe71f", size = 11845599, upload-time = "2026-10-28T19:22:23.136Z" }, + { url = "https://files.pythonhosted.org/packages/21/5c/6e8010f8f2c4ad817364592d4b3883633417269b913fc9d5174fdeb7e565/mypy-2.4.1-py3-none-any.whl", hash = "sha256:1784648d6ec8c2b5465e3f26241b845a0b3cb4e56c993c64abe16989e7698999", size = 2801286, upload-time = "2026-10-28T19:21:19.516Z" }, ] [[package]] @@ -155,68 +292,107 @@ wheels = [ [[package]] name = "nexus-rpc" -version = "1.4.0" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/e5/25be948c92492cfc8ac24a524ad8828fe0cb9f71f46a974d7a37f0794a26/nexus_rpc-1.5.0.tar.gz", hash = "sha256:be2d6934414677bc9dd8e571fb5106c22b8769edc19562c3f49d9988edd24e1c", size = 97404, upload-time = "2026-10-28T17:12:21.82Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/e2/00541e7997f3dfb294f7be3dafea3307ea09b9d3fd332054fe4d30627efc/nexus_rpc-1.5.0-py3-none-any.whl", hash = "sha256:5d6e856972be812573948df02da2257344c407a8eaa99977b5d38be54448305a", size = 30406, upload-time = "2026-10-28T17:12:20.245Z" }, +] + +[[package]] +name = "opentelemetry-api" +version = "1.45.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/cf3a6b6448849656e1e5f4e2101f3988dc6789724050096aba1bc5ccf592/opentelemetry_api-1.45.2.tar.gz", hash = "sha256:d7b0008e21e5fd61cbe7a7f34ca3b6905a78ab677d9bc395e299359c75cda6b4", size = 73277, upload-time = "2026-10-29T17:29:37.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/2d/610db864d7513158cebb8f36cc88e67e73bd6c7aa1905ef18d89e1281c81/opentelemetry_api-1.45.2-py3-none-any.whl", hash = "sha256:2cbd737377e710ee740d261c94e93fa0f08e6d037c18f17513cc0a2d94479a34", size = 60335, upload-time = "2026-10-29T17:29:06.955Z" }, +] + +[[package]] +name = "opentelemetry-sdk" +version = "1.45.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7b/1a/74a21d4d6969fb8b432ac397e66112a8167a6deb267ea4559dbaf2fe91ef/opentelemetry_sdk-1.45.2.tar.gz", hash = "sha256:7eec4de13dd21ff3a1670dcb0e02079e692736f94d733dfdce5af461d884248d", size = 221705, upload-time = "2026-10-29T17:29:54.685Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/a5/9a3b793ef48245f2336a16beb2324c2397dbb3f987cd68942f77cca06156/opentelemetry_sdk-1.45.2-py3-none-any.whl", hash = "sha256:ff974ea70ee4f1d51e2ec152db37c2b626c7bf82bb3f7d86114fd8704e7199c6", size = 141756, upload-time = "2026-10-29T17:29:33.722Z" }, +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.66b2" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "opentelemetry-api" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/35/d5/cd1ffb202b76ebc1b33c1332a3416e55a39929006982adc2b1eb069aaa9b/nexus_rpc-1.4.0.tar.gz", hash = "sha256:3b8b373d4865671789cc43623e3dc0bcbf192562e40e13727e17f1c149050fba", size = 82367, upload-time = "2026-02-25T22:01:34.053Z" } +sdist = { url = "https://files.pythonhosted.org/packages/37/3f/50f95972b50e8e353f5b9342034c9cd17730f1956f009ce6a3fbbd89f9ce/opentelemetry_semantic_conventions-0.66b2.tar.gz", hash = "sha256:7da5f1a5dc4383eb66711d4d3d3e71824d9403ac1559fea021cc103c1a4c4976", size = 150246, upload-time = "2026-10-29T17:29:55.682Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/52/6327a5f4fda01207205038a106a99848a41c83e933cd23ea2cab3d2ebc6c/nexus_rpc-1.4.0-py3-none-any.whl", hash = "sha256:14c953d3519113f8ccec533a9efdb6b10c28afef75d11cdd6d422640c40b3a49", size = 29645, upload-time = "2026-02-25T22:01:33.122Z" }, + { url = "https://files.pythonhosted.org/packages/67/bd/6bf33ed31521c565931c037e9e81bac47c1acb000e850c6e24220e2a0c00/opentelemetry_semantic_conventions-0.66b2-py3-none-any.whl", hash = "sha256:4cbe61e5f9275d57ab31708446e7938ef4291ebbe6a7fca6f7a629c5acae87d8", size = 206280, upload-time = "2026-10-29T17:29:35.062Z" }, ] [[package]] name = "pathspec" -version = "1.0.4" +version = "1.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, ] [[package]] name = "protobuf" -version = "6.33.5" +version = "7.36.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/25/7c72c307aafc96fa87062aa6291d9f7c94836e43214d43722e86037aac02/protobuf-6.33.5.tar.gz", hash = "sha256:6ddcac2a081f8b7b9642c09406bc6a4290128fce5f471cddd165960bb9119e5c", size = 444465, upload-time = "2026-01-29T21:51:33.494Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/79/af92d0a8369732b027e6d6084251dd8e782c685c72da161bd4a2e00fbabb/protobuf-6.33.5-cp310-abi3-win32.whl", hash = "sha256:d71b040839446bac0f4d162e758bea99c8251161dae9d0983a3b88dee345153b", size = 425769, upload-time = "2026-01-29T21:51:21.751Z" }, - { url = "https://files.pythonhosted.org/packages/55/75/bb9bc917d10e9ee13dee8607eb9ab963b7cf8be607c46e7862c748aa2af7/protobuf-6.33.5-cp310-abi3-win_amd64.whl", hash = "sha256:3093804752167bcab3998bec9f1048baae6e29505adaf1afd14a37bddede533c", size = 437118, upload-time = "2026-01-29T21:51:24.022Z" }, - { url = "https://files.pythonhosted.org/packages/a2/6b/e48dfc1191bc5b52950246275bf4089773e91cb5ba3592621723cdddca62/protobuf-6.33.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:a5cb85982d95d906df1e2210e58f8e4f1e3cdc088e52c921a041f9c9a0386de5", size = 427766, upload-time = "2026-01-29T21:51:25.413Z" }, - { url = "https://files.pythonhosted.org/packages/4e/b1/c79468184310de09d75095ed1314b839eb2f72df71097db9d1404a1b2717/protobuf-6.33.5-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:9b71e0281f36f179d00cbcb119cb19dec4d14a81393e5ea220f64b286173e190", size = 324638, upload-time = "2026-01-29T21:51:26.423Z" }, - { url = "https://files.pythonhosted.org/packages/c5/f5/65d838092fd01c44d16037953fd4c2cc851e783de9b8f02b27ec4ffd906f/protobuf-6.33.5-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8afa18e1d6d20af15b417e728e9f60f3aa108ee76f23c3b2c07a2c3b546d3afd", size = 339411, upload-time = "2026-01-29T21:51:27.446Z" }, - { url = "https://files.pythonhosted.org/packages/9b/53/a9443aa3ca9ba8724fdfa02dd1887c1bcd8e89556b715cfbacca6b63dbec/protobuf-6.33.5-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:cbf16ba3350fb7b889fca858fb215967792dc125b35c7976ca4818bee3521cf0", size = 323465, upload-time = "2026-01-29T21:51:28.925Z" }, - { url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" }, + { url = "https://files.pythonhosted.org/packages/32/72/98342feb672507c8f3a69e34b4fa8961f608edba5c1a48a6f47156d92cb5/protobuf-7.36.2-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:cbc70b17ee27e28894c7fee8bb04be1abead49e936bc70eb60052531eee2079e", size = 456039, upload-time = "2026-09-17T20:07:51.542Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ea/91fdf7c2b8bbd49cde056f00a9df6773532987e1c00fe2830b895af95c7e/protobuf-7.36.2-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:e11e1f0180583a2af89db6a2ecd9e8dc40aa6d2988ca175bfd0e6d12ea72d74e", size = 344219, upload-time = "2026-09-17T20:07:52.914Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/5fd5f8ece73fad885c5a09aa849b32d70472f954ba3a92d3bb5974ea953b/protobuf-7.36.2-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:f4fee11ec330d238b34a05c9b675f693c20415d1c5bd7d5320cc2f8a798eb9cf", size = 357223, upload-time = "2026-09-17T20:07:53.985Z" }, + { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" }, + { url = "https://files.pythonhosted.org/packages/fc/1b/dcc64f358fcb51811b58ae40b3d28f820725f116d86487cc20bd4b130701/protobuf-7.36.2-cp310-abi3-win32.whl", hash = "sha256:912c1221170e16c08d1f086762f563dd61ff83c18b5fa6652952dfaded66f728", size = 442998, upload-time = "2026-09-17T20:07:55.826Z" }, + { url = "https://files.pythonhosted.org/packages/8a/55/b77bda4e5e5f5971fb51b07663694690e9afdb9402136c16a522bd621cad/protobuf-7.36.2-cp310-abi3-win_amd64.whl", hash = "sha256:a300819d441e078a5608c0d3c709796bb548136058fda017ae51d425b44fd353", size = 456514, upload-time = "2026-09-17T20:07:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" }, ] [[package]] name = "ruff" -version = "0.15.6" +version = "0.17.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/51/df/f8629c19c5318601d3121e230f74cbee7a3732339c52b21daa2b82ef9c7d/ruff-0.15.6.tar.gz", hash = "sha256:8394c7bb153a4e3811a4ecdacd4a8e6a4fa8097028119160dffecdcdf9b56ae4", size = 4597916, upload-time = "2026-03-12T23:05:47.51Z" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/2f/4e03a7e5ce99b517e98d3b4951f411de2b0fa8348d39cf446671adcce9a2/ruff-0.15.6-py3-none-linux_armv6l.whl", hash = "sha256:7c98c3b16407b2cf3d0f2b80c80187384bc92c6774d85fefa913ecd941256fff", size = 10508953, upload-time = "2026-03-12T23:05:17.246Z" }, - { url = "https://files.pythonhosted.org/packages/70/60/55bcdc3e9f80bcf39edf0cd272da6fa511a3d94d5a0dd9e0adf76ceebdb4/ruff-0.15.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ee7dcfaad8b282a284df4aa6ddc2741b3f4a18b0555d626805555a820ea181c3", size = 10942257, upload-time = "2026-03-12T23:05:23.076Z" }, - { url = "https://files.pythonhosted.org/packages/e7/f9/005c29bd1726c0f492bfa215e95154cf480574140cb5f867c797c18c790b/ruff-0.15.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3bd9967851a25f038fc8b9ae88a7fbd1b609f30349231dffaa37b6804923c4bb", size = 10322683, upload-time = "2026-03-12T23:05:33.738Z" }, - { url = "https://files.pythonhosted.org/packages/5f/74/2f861f5fd7cbb2146bddb5501450300ce41562da36d21868c69b7a828169/ruff-0.15.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13f4594b04e42cd24a41da653886b04d2ff87adbf57497ed4f728b0e8a4866f8", size = 10660986, upload-time = "2026-03-12T23:05:53.245Z" }, - { url = "https://files.pythonhosted.org/packages/c1/a1/309f2364a424eccb763cdafc49df843c282609f47fe53aa83f38272389e0/ruff-0.15.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e2ed8aea2f3fe57886d3f00ea5b8aae5bf68d5e195f487f037a955ff9fbaac9e", size = 10332177, upload-time = "2026-03-12T23:05:56.145Z" }, - { url = "https://files.pythonhosted.org/packages/30/41/7ebf1d32658b4bab20f8ac80972fb19cd4e2c6b78552be263a680edc55ac/ruff-0.15.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70789d3e7830b848b548aae96766431c0dc01a6c78c13381f423bf7076c66d15", size = 11170783, upload-time = "2026-03-12T23:06:01.742Z" }, - { url = "https://files.pythonhosted.org/packages/76/be/6d488f6adca047df82cd62c304638bcb00821c36bd4881cfca221561fdfc/ruff-0.15.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:542aaf1de3154cea088ced5a819ce872611256ffe2498e750bbae5247a8114e9", size = 12044201, upload-time = "2026-03-12T23:05:28.697Z" }, - { url = "https://files.pythonhosted.org/packages/71/68/e6f125df4af7e6d0b498f8d373274794bc5156b324e8ab4bf5c1b4fc0ec7/ruff-0.15.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c22e6f02c16cfac3888aa636e9eba857254d15bbacc9906c9689fdecb1953ab", size = 11421561, upload-time = "2026-03-12T23:05:31.236Z" }, - { url = "https://files.pythonhosted.org/packages/f1/9f/f85ef5fd01a52e0b472b26dc1b4bd228b8f6f0435975442ffa4741278703/ruff-0.15.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98893c4c0aadc8e448cfa315bd0cc343a5323d740fe5f28ef8a3f9e21b381f7e", size = 11310928, upload-time = "2026-03-12T23:05:45.288Z" }, - { url = "https://files.pythonhosted.org/packages/8c/26/b75f8c421f5654304b89471ed384ae8c7f42b4dff58fa6ce1626d7f2b59a/ruff-0.15.6-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:70d263770d234912374493e8cc1e7385c5d49376e41dfa51c5c3453169dc581c", size = 11235186, upload-time = "2026-03-12T23:05:50.677Z" }, - { url = "https://files.pythonhosted.org/packages/fc/d4/d5a6d065962ff7a68a86c9b4f5500f7d101a0792078de636526c0edd40da/ruff-0.15.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:55a1ad63c5a6e54b1f21b7514dfadc0c7fb40093fa22e95143cf3f64ebdcd512", size = 10635231, upload-time = "2026-03-12T23:05:37.044Z" }, - { url = "https://files.pythonhosted.org/packages/d6/56/7c3acf3d50910375349016cf33de24be021532042afbed87942858992491/ruff-0.15.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8dc473ba093c5ec238bb1e7429ee676dca24643c471e11fbaa8a857925b061c0", size = 10340357, upload-time = "2026-03-12T23:06:04.748Z" }, - { url = "https://files.pythonhosted.org/packages/06/54/6faa39e9c1033ff6a3b6e76b5df536931cd30caf64988e112bbf91ef5ce5/ruff-0.15.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:85b042377c2a5561131767974617006f99f7e13c63c111b998f29fc1e58a4cfb", size = 10860583, upload-time = "2026-03-12T23:05:58.978Z" }, - { url = "https://files.pythonhosted.org/packages/cb/1e/509a201b843b4dfb0b32acdedf68d951d3377988cae43949ba4c4133a96a/ruff-0.15.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:cef49e30bc5a86a6a92098a7fbf6e467a234d90b63305d6f3ec01225a9d092e0", size = 11410976, upload-time = "2026-03-12T23:05:39.955Z" }, - { url = "https://files.pythonhosted.org/packages/6c/25/3fc9114abf979a41673ce877c08016f8e660ad6cf508c3957f537d2e9fa9/ruff-0.15.6-py3-none-win32.whl", hash = "sha256:bbf67d39832404812a2d23020dda68fee7f18ce15654e96fb1d3ad21a5fe436c", size = 10616872, upload-time = "2026-03-12T23:05:42.451Z" }, - { url = "https://files.pythonhosted.org/packages/89/7a/09ece68445ceac348df06e08bf75db72d0e8427765b96c9c0ffabc1be1d9/ruff-0.15.6-py3-none-win_amd64.whl", hash = "sha256:aee25bc84c2f1007ecb5037dff75cef00414fdf17c23f07dc13e577883dca406", size = 11787271, upload-time = "2026-03-12T23:05:20.168Z" }, - { url = "https://files.pythonhosted.org/packages/7f/d0/578c47dd68152ddddddf31cd7fc67dc30b7cdf639a86275fda821b0d9d98/ruff-0.15.6-py3-none-win_arm64.whl", hash = "sha256:c34de3dd0b0ba203be50ae70f5910b17188556630e2178fd7d79fc030eb0d837", size = 11060497, upload-time = "2026-03-12T23:05:25.968Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" }, + { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" }, + { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" }, + { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" }, + { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" }, + { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" }, + { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" }, + { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" }, ] [[package]] name = "temporalio" -version = "1.27.2" +version = "1.36.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "nexus-rpc" }, @@ -224,29 +400,31 @@ dependencies = [ { name = "types-protobuf" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/62/2bc1a9ad29382a3a99f088907ef2024a94420cfef340be1b33026c632828/temporalio-1.27.2.tar.gz", hash = "sha256:633bf2379492f3db1e887d1e64fdac00d9c2ddc3e9382b831d5af68256912e92", size = 2503041, upload-time = "2026-05-14T02:17:57.565Z" } +sdist = { url = "https://files.pythonhosted.org/packages/60/82/e1cdd6b33af79e38d2e3db350821d62b6daf188bc905013852dd480929bd/temporalio-1.36.0.tar.gz", hash = "sha256:e65a9d30a0e3647cb92f2b19254447b5297e26f0f5edd323b27ee406367543e4", size = 2923753, upload-time = "2026-11-11T01:08:39.067Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/64/85/9da14f9fbdfae95435d29353bb1c55891581ad6b23c86ca56e72d83035ed/temporalio-1.27.2-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:860f706380faafec8f183f9194d0883c8033a4211c5d19c2c962c45b06cf99e9", size = 14602829, upload-time = "2026-05-14T02:17:45.624Z" }, - { url = "https://files.pythonhosted.org/packages/24/51/b7437991e71eea082dc53222da11f064974917cd59063ba57e13e5895fbc/temporalio-1.27.2-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:a8dc0c680e351f3132809861888d8326dbd5030dd4e570663597e7d4768d9502", size = 13997680, upload-time = "2026-05-14T02:17:53.968Z" }, - { url = "https://files.pythonhosted.org/packages/8c/5d/358065040e6f0cedbf669acd333622999eec737ff868ca7829d727b77746/temporalio-1.27.2-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:805f3de4d193dec52e040e41dbfc9ab44be0206d2e81142ceefaf7b7208058d1", size = 14252199, upload-time = "2026-05-14T02:17:36.972Z" }, - { url = "https://files.pythonhosted.org/packages/72/8a/85d2eab07c3e23fc1124203e76857c69ab9b22d8ccebad0835e294edb754/temporalio-1.27.2-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5bc996cb501b8a918f50037ccee6facb05bb70984acada4c2a3e01f5e7957a38", size = 14779945, upload-time = "2026-05-14T02:18:05.513Z" }, - { url = "https://files.pythonhosted.org/packages/67/81/c9b08609e2a92ecf62c97c59cabfa0608337c8d5cc9941eed5d9a7778840/temporalio-1.27.2-cp310-abi3-win_amd64.whl", hash = "sha256:62a84ae9a60c17932971e4ca3b0f3cd6f32f173b8183e759989376503fb95af6", size = 14981897, upload-time = "2026-05-14T02:17:27.333Z" }, + { url = "https://files.pythonhosted.org/packages/8c/82/3696a76e35452f1960764027b41bff6c52ad5f70cd9d968dd49dc0efdd5c/temporalio-1.36.0-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:042f00e7ad1935c017ca4e964af1c88a1d45ac21f73e455b3f81b2c55a0bcab5", size = 14091242, upload-time = "2026-11-11T01:08:18.938Z" }, + { url = "https://files.pythonhosted.org/packages/a0/79/908bc9218f248f45581f0d4dce338ba5ae2b9fd1b5d20f2dd00b67e54366/temporalio-1.36.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:f3218255207aa37313adc0ae46332089411cb6e240d82a415ba39f8da4de64bd", size = 13648068, upload-time = "2026-11-11T01:08:22.372Z" }, + { url = "https://files.pythonhosted.org/packages/66/b3/4d6dd7d57901e7038263775c84312f523a31bbeb3a5d45958f782f18e36a/temporalio-1.36.0-cp311-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:318f6b3f2315cf1c06c7896ab6c312791b6f9a426bab0a80c42a57af156acc20", size = 14050456, upload-time = "2026-11-11T01:08:25.454Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b6/0572b6211bcceda6b657c13e726ad2ce2959a5228d002d1bd327610de5af/temporalio-1.36.0-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed457244ed5185a3e4a2ecccd40bff1d11583380b9b80ecf314589463540f3f8", size = 14524738, upload-time = "2026-11-11T01:08:28.079Z" }, + { url = "https://files.pythonhosted.org/packages/1e/9a/ffb5f15773b87cb461f5eeb02f5b6ff493e77e08067e9e0f7da4f57e22da/temporalio-1.36.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d45faa8cb1cc047990e4d61c755e34a843d557e858667da9b175c550373607ab", size = 14132850, upload-time = "2026-11-11T01:08:30.474Z" }, + { url = "https://files.pythonhosted.org/packages/46/e2/d3fde3487dc3430e3c3291e90e52788f47183fc80c2c1dc08e0aa4eade86/temporalio-1.36.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8cf5dfe59a54d2ff1e8a9e3397457661bf560dcd3b9b9ddc07f7c6757f8a3dac", size = 14627513, upload-time = "2026-11-11T01:08:33.428Z" }, + { url = "https://files.pythonhosted.org/packages/76/d8/95ec26dcb35ef2dd35eae52e9e5223f148b21c05344d46ca29d746ebefe9/temporalio-1.36.0-cp311-abi3-win_amd64.whl", hash = "sha256:74940ad05bebf84e1c53a9f10a69addd10b819985286cd5e05c8b48340ded815", size = 15472448, upload-time = "2026-11-11T01:08:36.551Z" }, ] [[package]] name = "types-protobuf" -version = "6.32.1.20260221" +version = "7.35.1.20260906" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5f/e2/9aa4a3b2469508bd7b4e2ae11cbedaf419222a09a1b94daffcd5efca4023/types_protobuf-6.32.1.20260221.tar.gz", hash = "sha256:6d5fb060a616bfb076cbb61b4b3c3969f5fc8bec5810f9a2f7e648ee5cbcbf6e", size = 64408, upload-time = "2026-02-21T03:55:13.916Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/6c/e3e5b3e10bc328126a39637c138f9ebfd734bf14342b9f3540039b4ab995/types_protobuf-7.35.1.20260906.tar.gz", hash = "sha256:efd1a3862d4c967dad5512ef8d56b1530ac84f182c41735b94004756518c4998", size = 69895, upload-time = "2026-09-06T06:35:28.308Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2e/e8/1fd38926f9cf031188fbc5a96694203ea6f24b0e34bd64a225ec6f6291ba/types_protobuf-6.32.1.20260221-py3-none-any.whl", hash = "sha256:da7cdd947975964a93c30bfbcc2c6841ee646b318d3816b033adc2c4eb6448e4", size = 77956, upload-time = "2026-02-21T03:55:12.894Z" }, + { url = "https://files.pythonhosted.org/packages/44/4e/f63e826c68f77ef875506d72f225918800346545ee99847bc28f3394f18d/types_protobuf-7.35.1.20260906-py3-none-any.whl", hash = "sha256:5155e48569e0dabff303fdf578db96cd31ea9a4a63b18018a4ceac6b0ae17462", size = 86419, upload-time = "2026-09-06T06:35:27.247Z" }, ] [[package]] name = "typing-extensions" -version = "4.15.0" +version = "4.16.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, ]